New work interface

src/historywork/RunCommandWork.cpp

@@ -9,36 +9,52 @@
 namespace stellar
 {
 
-RunCommandWork::RunCommandWork(Application& app, WorkParent& parent,
-                               std::string const& uniqueName, size_t maxRetries)
-    : Work(app, parent, uniqueName, maxRetries)
+RunCommandWork::RunCommandWork(Application& app, std::function<void()> callback,
+                               std::string const& name, size_t maxRetries)
+    : Work(app, callback, name, maxRetries)
 {
 }
 
-RunCommandWork::~RunCommandWork()
+BasicWork::State
+RunCommandWork::doWork()
 {
-    clearChildren();
-}
-
-void
-RunCommandWork::onStart()
-{
-    std::string cmd, outfile;
-    getCommand(cmd, outfile);
-    if (!cmd.empty())
+    if (mDone)
     {
-        auto exit = mApp.getProcessManager().runProcess(cmd, outfile);
-        exit.async_wait(callComplete());
+        return mEc ? BasicWork::WORK_FAILURE_RETRY : BasicWork::WORK_SUCCESS;
     }
     else
     {
-        scheduleSuccess();
+        std::string cmd, outfile;
+        std::tie(cmd, outfile) = getCommand();
+        if (!cmd.empty())
+        {
+            auto exit = mApp.getProcessManager().runProcess(cmd, outfile);
+
+            std::weak_ptr<RunCommandWork> weak(
+                std::static_pointer_cast<RunCommandWork>(shared_from_this()));
+            exit.async_wait([weak](asio::error_code ec) {
+                auto self = weak.lock();
+                if (self)
+                {
+                    self->mEc = ec;
+                    self->mDone = true;
+                    self->wakeUp();
+                }
+            });
+            return BasicWork::WORK_WAITING;
+        }
+        else
+        {
+            return BasicWork::WORK_SUCCESS;
+        }
     }
 }
 
 void
-RunCommandWork::onRun()
+RunCommandWork::onReset()
 {
-    // Do nothing: we ran the command in onStart().
+    mDone = false;
+    mEc = asio::error_code();
+    Work::onReset();
 }
 }

src/historywork/RunCommandWork.h

@@ -8,23 +8,28 @@
 
 namespace stellar
 {
+using RunCommandInfo = std::pair<std::string, std::string>;
 
-// This subclass exists for two reasons: first, to factor out a little code
-// around running commands, and second to ensure that command-running
-// happens from onStart rather than onRun, and that onRun is an empty
-// method; this way we only run a command _once_ (when it's first
-// scheduled) rather than repeatedly (racing with other copies of itself)
-// when rescheduled.
+/**
+ * This class helps run various commands, that require
+ * process spawning. This work is not scheduled while it's
+ * waiting for a process to exit, and wakes up when it's ready
+ * to be scheduled again.
+ */
 class RunCommandWork : public Work
 {
-    virtual void getCommand(std::string& cmdLine, std::string& outFile) = 0;
+    bool mDone{false};
+    asio::error_code mEc;
+    virtual RunCommandInfo getCommand() = 0;
 
   public:
-    RunCommandWork(Application& app, WorkParent& parent,
-                   std::string const& uniqueName,
-                   size_t maxRetries = Work::RETRY_A_FEW);
-    ~RunCommandWork();
-    void onStart() override;
-    void onRun() override;
+    RunCommandWork(Application& app, std::function<void()> callback,
+                   std::string const& name,
+                   size_t maxRetries = BasicWork::RETRY_A_FEW);
+    ~RunCommandWork() = default;
+
+  protected:
+    void onReset() override;
+    BasicWork::State doWork() override;
 };
 }