Large re-organization to split daggyd away from the core libdaggy.

This paves the way for implementing daggys and other utilities.

Squashed commit of the following:

commit 1f77239ab3c9e44d190eef94531a39501c8c4dfe
Author: Ian Roddis <gitlab@ie2r.com>
Date:   Mon Oct 18 16:25:02 2021 -0300

    Adding README, stdout support for daggyd logging

commit c2c237224e84a3be68aaa597ce98af1365e74a13
Author: Ian Roddis <gitlab@ie2r.com>
Date:   Mon Oct 18 16:10:29 2021 -0300

    removing old daggyd

commit cfea2baf61ca10c535801c5a391d2d525a1a2d04
Author: Ian Roddis <gitlab@ie2r.com>
Date:   Mon Oct 18 16:10:09 2021 -0300

    Moving tests into their sub-project folders

commit e41ca42069bea1db16dd76b6684a3f692fef6b15
Author: Ian Roddis <gitlab@ie2r.com>
Date:   Mon Oct 18 15:57:40 2021 -0300

    Splitting out daggyd from libdaggy

commit be97b146c1d2446f5c03cb78707e921f18c60bd8
Author: Ian Roddis <gitlab@ie2r.com>
Date:   Mon Oct 18 15:56:55 2021 -0300

    Splitting out daggyd from libdaggy

commit cb61e140e9d6d8832d61fb7037fd4c0ff6edad00
Author: Ian Roddis <gitlab@ie2r.com>
Date:   Mon Oct 18 15:49:47 2021 -0300

    moving daggy to libdaggy

libdaggy/include/daggy/executors/task/ForkingTaskExecutor.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <daggy/ThreadPool.hpp>
+
+#include "TaskExecutor.hpp"
+
+namespace daggy::executors::task {
+  class ForkingTaskExecutor : public TaskExecutor
+  {
+  public:
+    using Command = std::vector<std::string>;
+
+    explicit ForkingTaskExecutor(size_t nThreads);
+    ~ForkingTaskExecutor() override;
+
+    // Validates the job to ensure that all required values are set and are of
+    // the right type,
+    bool validateTaskParameters(const ConfigValues &job) override;
+
+    std::vector<ConfigValues> expandTaskParameters(
+        const ConfigValues &job, const ConfigValues &expansionValues) override;
+
+    // Runs the task
+    std::future<AttemptRecord> execute(DAGRunID runID,
+                                       const std::string &taskName,
+                                       const Task &task) override;
+
+    bool stop(DAGRunID runID, const std::string &taskName) override;
+
+  private:
+    ThreadPool tp_;
+    std::mutex taskControlsGuard_;
+    AttemptRecord runTask(const Task &task, std::atomic<bool> &running);
+    std::unordered_map<std::string, std::atomic<bool>> taskControls_;
+  };
+}  // namespace daggy::executors::task

libdaggy/include/daggy/executors/task/NoopTaskExecutor.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "TaskExecutor.hpp"
+
+namespace daggy::executors::task {
+  class NoopTaskExecutor : public TaskExecutor
+  {
+  public:
+    using Command = std::vector<std::string>;
+
+    // Validates the job to ensure that all required values are set and are of
+    // the right type,
+    bool validateTaskParameters(const ConfigValues &job) override;
+
+    std::vector<ConfigValues> expandTaskParameters(
+        const ConfigValues &job, const ConfigValues &expansionValues) override;
+
+    // Runs the task
+    std::future<AttemptRecord> execute(DAGRunID runID,
+                                       const std::string &taskName,
+                                       const Task &task) override;
+
+    bool stop(DAGRunID runID, const std::string &taskName) override;
+  };
+}  // namespace daggy::executors::task

libdaggy/include/daggy/executors/task/SlurmTaskExecutor.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "TaskExecutor.hpp"
+
+namespace daggy::executors::task {
+  class SlurmTaskExecutor : public TaskExecutor
+  {
+  public:
+    using Command = std::vector<std::string>;
+
+    SlurmTaskExecutor();
+    ~SlurmTaskExecutor() override;
+
+    // Validates the job to ensure that all required values are set and are of
+    // the right type,
+    bool validateTaskParameters(const ConfigValues &job) override;
+
+    std::vector<ConfigValues> expandTaskParameters(
+        const ConfigValues &job, const ConfigValues &expansionValues) override;
+
+    // Runs the task
+    std::future<AttemptRecord> execute(DAGRunID runID,
+                                       const std::string &taskName,
+                                       const Task &task) override;
+
+    bool stop(DAGRunID runID, const std::string &taskName) override;
+
+  private:
+    struct Job
+    {
+      std::promise<AttemptRecord> prom;
+      std::string stdoutFile;
+      std::string stderrFile;
+      DAGRunID runID;
+      std::string taskName;
+    };
+
+    std::mutex promiseGuard_;
+    std::unordered_map<size_t, Job> runningJobs_;
+    std::atomic<bool> running_;
+
+    // Monitors jobs and resolves promises
+    std::thread monitorWorker_;
+    void monitor();
+  };
+}  // namespace daggy::executors::task

libdaggy/include/daggy/executors/task/TaskExecutor.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <chrono>
+#include <daggy/Defines.hpp>
+#include <future>
+#include <string>
+#include <thread>
+#include <vector>
+
+/*
+   Executors run Tasks, returning a future with the results.
+   If there are many retries, logs are returned for each attempt.
+*/
+
+namespace daggy::executors::task {
+  class TaskExecutor
+  {
+  public:
+    virtual ~TaskExecutor() = default;
+
+    // Validates the job to ensure that all required values are set and are of
+    // the right type,
+    virtual bool validateTaskParameters(const ConfigValues &job) = 0;
+
+    // Will use the expansion values to return the fully expanded tasks.
+    virtual std::vector<ConfigValues> expandTaskParameters(
+        const ConfigValues &job, const ConfigValues &expansionValues) = 0;
+
+    // Blocking execution of a task
+    virtual std::future<AttemptRecord> execute(DAGRunID runID,
+                                               const std::string &taskName,
+                                               const Task &task) = 0;
+
+    // Kill a currently executing task. This will resolve the future.
+    virtual bool stop(DAGRunID runID, const std::string &taskName) = 0;
+  };
+}  // namespace daggy::executors::task