Reimplement: Orchestrator::run()

This patch reimplements the running of the computed jobs.

The old implementation was structured as follows:

1. Compute a Tree of dependencies for the requested package
2. Make sets of this tree (see below)
3. For each set
    3.1. Run set in parallel by submitting each job in the set to the scheduler
    3.2. collect outputs and errors
    3.3. Record outputs and return errors (if any)

The complexity here was the computing of the JobSets but also the running of
each job in a set in parallel.
The code was non-trivial to understand.

But that's not even the biggest concern with this approch.
Consider the following tree of jobs:

        A
       / \
      B   E
     / \   \
    C   D   F
           / \
          G   H
               \
                I

Each node here represents a package, the edges represent dependencies on the
lower-hanging package.

This tree would result in 5 sets of jobs:

    [
        [ I ]
        [ G, H ]
        [ C, D, F ]
        [ B, E ]
        [ A ]
    ]

because each "layer" in the tree would be run in parallel.
It can be easily seen, that in the tree from above, the jobs for [ I, G, D, C ]
can be run in parallel easily, because they do not have dependencies.

The reimplementation also has another (crucial) benefit: The implementation does
not depend on a structure of artifact path names anymore.

Before, the artifacts needed to have a name as follows:

    <name of the package>-<version of the package>.<something>

which was extremely restrictive.

With the changes from this patch, the implementation does not depend on such
a format anymore.
Instead: Dependencies are associated with a job, by the output of jobs run
for dependent packages.

That means that, considering the above tree of packages:

    deps_of(B) = outputs_of(job_for(C)) + outputs_of(job_for(D))

in text:
    The dependencies of package B are the outputs of the job run for package C
    plus the outputs of the job run for package D.

With that change in place, the outputs of a job run for a package can yield
arbitrary file names and as long as the build script for the package can process
them, everything is fine.

The new algorithm, that solves that issue, is rather simple:

1. Hold a list of errors
2. Hold a list of artifacts that were built
3. Hold a list of jobs that were run
4. Iterate over all jobs, filtered by
    - If the job appears in the "already run jobs" list, ignore it
    - If a job has dependencies (on outputs of other jobs) that do not appear in
      the "already run jobs", ignore it (for now)
5. Run these jobs, and for each job:
    5.1. Take the job UUID and put it in the "already run jobs" list.
    5.2. Take the result of the job,
        5.2.1. if it is an error, put it in the "list of errors"
        5.2.2. if it is ok, put the artifact in the "list of artifacts"
6. if the list of errors is not empty, goto 9
7. if all jobs are in the "already run jobs" list, goto 9
8. goto 4
9. return all artifacts and all errors

Because this approach is fundamentally different than the previous approach, a
lot of things had to be rewritten:

- The `JobSet` type was complete removed

- There is a new type `crate::job:Tree` that gets built from the
  `crate::package::Tree`
  It is a mapping of a UUID (the job UUID) to a `JobDefinition`.
  The `JobDefinition` type is
    - A Job
    - A list of UUIDs of other jobs, where this job depends on the outputs
  It is therefore a mapping of `Job -> outputs(jobs_of(dependencies)`
  The `crate::job::Tree` type is now responsible for building a `Job` object for
  each `crate::package::Package` object from the `crate::package::Tree` object.

  Because the `crate::package::Tree` object contains all required packages for
  the complete built, the implementation of `crate::job::Tree::build_tree()`
  does not check sanity.
  It is assumed that the input tree to the function contains all mappings.

  Despite the name `crate::job::Tree` ("Tree"), the actual structure stored in
  the type is not a real tree.

- The `MergedStores::get_artifact_by_path()` function was adapted because in the
  previous implementation, it used `StagingStore::load_from_path()`, which tried
  to load the file from the filesystem and put it into the internal map, which
  failed if it was already there.
  The adaption checks if the artifact already exists in the internal map and
  returns that object instead.
  (For the release store accordingly)

- The interface of the `RunnableJob::build_from_job()` function was adapted, as
  this function does not need to access the `MergedStores` object anymore to
  load dependency-Artifacts from the filesystem.
  Instead, these Artifacts are passed to the function now.

- The Orchestrator code
    - Got a type alias `JobResult` which represents the result of a job run wich
      is either
        - A number of artifacts (for optimization reasons with their associated
          database artifact entry)
        - or an error with the job uuid that failed (again, for optimization
          reasons)
    - Got an implementation of the algorithm described above
    - Got a new implementation of run_job(), which
        - Fetches the pathes of dependency-artifacts from the database by using
          the job uuids from the JobDefinition object
        - Creates the RunnableJob object for that
        - Schedules the RunnableJob object in the scheduler
        - For each output artifact (database object representing it)
            - get the filesystem Artifact object for it

Signed-off-by: Matthias Beyer <matthias.beyer@atos.net>
Tested-by: Matthias Beyer <matthias.beyer@atos.net>

1 files changed, 0 insertions, 5 deletions

diff --git a/src/filestore/staging.rs b/src/filestore/staging.rs
index 995768c..b944d84 100644
--- a/src/filestore/staging.rs
+++ b/src/filestore/staging.rs
@@ -9,7 +9,6 @@
 //
 
 use std::fmt::Debug;
-use std::path::Path;
 
 use anyhow::anyhow;
 use anyhow::Context;
@@ -101,8 +100,4 @@ impl StagingStore {
     pub fn root_path(&self) -> &StoreRoot {
         self.0.root_path()
     }
-
-    pub fn path_exists_in_store_root(&self, path: &Path) -> bool {
-        self.0.path_exists_in_store_root(path)
-    }
 }