[OBJECT] Moving the "launch" into a stan-a-lone object with just enough locgic.

Author: pwielders

Launcher.cpp

@@ -68,6 +68,8 @@ SERVICE_REGISTRATION(Launcher, 1, 0);
 
 /* virtual */ const string Launcher::Initialize(PluginHost::IShell* service)
 {
+    Time time;
+    Time interval;
     string message;
     Config config;
 
@@ -79,52 +81,42 @@ SERVICE_REGISTRATION(Launcher, 1, 0);
 
     config.FromString(_service->ConfigLine());
 
-    _closeTime = (config.CloseTime.Value());
-
-    static Core::Process::Options options(config.Command.Value().c_str());
-    auto iter = config.Parameters.Elements();
+    if (config.ScheduleTime.IsSet() == true) {
 
-    while (iter.Next() == true) {
-        const Config::Parameter& element(iter.Current());
+        time = Time(config.ScheduleTime.Time.Value());
+        if (time.IsValid() != true) {
+            SYSLOG(Trace::Warning, "Interval format is wrong");
+        }
 
-        if ((element.Option.IsSet() == true) && (element.Option.Value().empty() == false)) {
-            if ((element.Value.IsSet() == true) && (element.Value.Value().empty() == false)) {
-                options.Set(element.Option.Value(), element.Value.Value());
-            }
-            else {
-                options.Set(element.Option.Value());
-            }
+        interval = Time(config.ScheduleTime.Interval.Value());
+        if (interval.IsValid() != true) {
+            SYSLOG(Trace::Warning, "Interval format is wrong");
         }
+        printf("%s:%s:%d %s %s\n", __FILE__, __func__, __LINE__, time.c_str(), interval.c_str());
     }
 
-    _options = &options;
+    _activity = Core::ProxyType<Job>::Create(&config, interval)
 
-    if (config.ScheduleTime.IsSet() == true) {
+    if (_activity.IsValid() == true) {
+        if (_activity->IsOperational() == true) {
+            // Well if we where able to parse the parameters (if needed) we are ready to start it..
+            _observer.Register(&_notification);
 
-        string time(config.ScheduleTime.Time.Value());
-        if (time.empty() == false) {
-            if (_time.Parse(time) != true) {
-                TRACE_L1("Time format is wrong");
+            if (_time.Valid() == true) {
+                Workerpool::Instance().Schedule(scheduledTime, _activity);
             }
-        }
-
-        string interval(config.ScheduleTime.Interval.Value());
-        if (interval.empty() == false) {
-            if (_interval.Parse(interval) != true) {
-                TRACE_L1("Interval format is wrong");
+            else {
+                Workerpool::Instance().Submit(_activity);
             }
         }
-        printf("%s:%s:%d %s %s\n", __FILE__, __func__, __LINE__, time.c_str(), interval.c_str());
+        else {
+            message = _T("Could not parse the configuration for the job.");
+        }
     }
-
-    _observer.Register(&_notification);
-
-    // Well if we where able to parse the parameters (if needed) we are ready to start it..
-    bool status = LaunchJob(_time);
-    if (status == false) {
-        _observer.Unregister(&_notification);
-        message = _T("Could not spawn the requested app/script [") + config.Command.Value() + ']';
+    else {
+        message = _T("Could not create the job.");
     }
+
     return (message);
 }
 
@@ -159,48 +151,24 @@ SERVICE_REGISTRATION(Launcher, 1, 0);
     return (string());
 }
 
-bool Launcher::ScheduleJob(Time time)
-{
-    Core::Time scheduledTime(Core::Time::Now());
-    uint64_t timeValueToTrigger = ((time.Hour() * 60 + time.Minute()) * 60 + time.Second()) * 1000;
-
-    scheduledTime.Add(timeValueToTrigger);
-    PluginHost::WorkerPool::Instance().Schedule(scheduledTime, _activity);
-}
-
-bool Launcher::LaunchJob(Time time)
-{
-    bool status = true;
-    if (time.Hour() == 0 && time.Minute() == 0 && time.Second() == 0) {
-        _process.Launch(*_options, &_pid);
-
-        if (_pid == 0) {
-            _observer.Unregister(&_notification);
-            status = false;
-        }
-        else {
-            _memory = Core::Service<MemoryObserverImpl>::Create<Exchange::IMemory>(_pid);
-            ScheduleJob(_interval);
-        }
-    }
-    else {
-       ScheduleJob(_time);
-    }
-    return status;
-}
-
 void Launcher::Update(const ProcessObserver::Info& info)
 {
     // This can potentially be called on a socket thread, so the deactivation (wich in turn kills this object) must be done
     // on a seperate thread. Also make sure this call-stack can be unwound before we are totally destructed.
-    if (_pid == info.Id()) {
+    if ((_activity.IsValid() == true) && (_activity->Process.Pid() == info.Id()) {
 
         ASSERT(_service != nullptr);
 
         if (info.Event() == ProcessObserver::Info::EVENT_EXIT) {
 
             if ((info.ExitCode() & 0xFFFF) == 0) {
-                PluginHost::WorkerPool::Instance().Submit(PluginHost::IShell::Job::Create(_service, PluginHost::IShell::DEACTIVATED, PluginHost::IShell::AUTOMATIC));
+                // Only do this if we do not need a retrigger on an intervall.
+                if (_activity->IsOperational() == false) {
+                    PluginHost::WorkerPool::Instance().Submit(PluginHost::IShell::Job::Create(_service, PluginHost::IShell::DEACTIVATED, PluginHost::IShell::AUTOMATIC));
+                }
+                else {
+                    TRACE(Trace::Information, (_T("The process has run, and completed succefully.")));
+                }
             }
             else {
                 PluginHost::WorkerPool::Instance().Submit(PluginHost::IShell::Job::Create(_service, PluginHost::IShell::DEACTIVATED, PluginHost::IShell::FAILURE));

Launcher.h

@@ -344,23 +344,41 @@ class Launcher : public PluginHost::IPlugin {
     };
 
     class Time {
-public:
+    public:
         Time()
-        : _hour(0)
-        , _minute(0)
-        , _second(0)
+        : _hour(~0)
+        , _minute(~0)
+        , _second(~0)
+        {
+        }
+        Time(const string& time) 
+        : _hour(~0) 
+        , _minute(~0)
+        , _second(~0)
+        {
+            Parse(time);
+        }
+        Time(const Time& copy) 
+        : _hour(copy._hour) 
+        , _minute(copy._minute)
+        , _second(copy._second)
         {
         }
-
         ~Time ()
         {
         }
 
-        uint8_t Hour() { return _hour; }
-        uint8_t Minute() { return _minute; }
-        uint8_t Second() { return _second; }
+    public:
+        bool IsValid () const { return (HasSeconds() || HasMinutes() || HasHours()); }
+        bool HasHours() const { return (_hour != static_cast<uint8_t>(~0)); }
+        bool HasMinutes() const { return (_hour != static_cast<uint8_t>(~0)); }
+        bool HasSeconds() const { return (_hour != static_cast<uint8_t>(~0)); }
+        uint8_t Hour() const { return _hour; }
+        uint8_t Minute() const { return _minute; }
+        uint8_t Second() const { return _second; }
 
-        bool Parse(string time) {
+    private:
+        bool Parse(const string& time) {
             bool status = true;
             printf("%s:%s:%d: time = %s\n", __FILE__, __func__, __LINE__, time.c_str());
 
@@ -441,32 +459,63 @@ class Launcher : public PluginHost::IPlugin {
     };
 
 private:
-    class PeriodicSync : public Core::IDispatchType<void> {
+    class Job: public Core::IDispatchType<void> {
     private:
-        PeriodicSync() = delete;
-        PeriodicSync(const PeriodicSync&) = delete;
-        PeriodicSync& operator=(const PeriodicSync&) = delete;
+        Job() = delete;
+        Job(const Job&) = delete;
+        Job& operator=(const Job&) = delete;
 
     public:
-        PeriodicSync(Launcher* launcher)
-            : _launcher(launcher)
+        Job(Config* config const Time& interval)
+            : _hasRun(false)
+            , _options(config->Command.Value().c_str())
         {
-            ASSERT(launcher != nullptr);
+            auto iter = config->Parameters.Elements();
+
+            while (iter.Next() == true) {
+                const Config::Parameter& element(iter.Current());
+
+                if ((element.Option.IsSet() == true) && (element.Option.Value().empty() == false)) {
+                    if ((element.Value.IsSet() == true) && (element.Value.Value().empty() == false)) {
+                        options.Set(element.Option.Value(), element.Value.Value());
+                    }
+                    else {
+                        options.Set(element.Option.Value());
+                    }
+                }
+            }
         }
-        ~PeriodicSync()
+        ~Job()
         {
         }
 
     public:
+        bool IsOperational() const {
+            return ((_hasRun == false) && (_interval.IsValid() == false));
+        }
+        Core::Process& Process() {
+            _return (_process);
+        }
         virtual void Dispatch() override
         {
+            _hasRun = true;
            Time time;
-            printf("%s:%s:%d: \n", __FILE__, __func__, __LINE__);
-            _launcher->LaunchJob(time);
+             // Check if the process is not active, no need to reschedule the same job againb.
+            if (_process.IsActive() == false) {
+                printf("%s:%s:%d: \n", __FILE__, __func__, __LINE__);
+                _process.Launch(_options);
+            }
+            if (_interval.IsValid() == true) {
+                // Reschedule our next launch point...
+                Workerpool::Instance().Schedule(this, CurrentTime + Interval);
+            }
         }
 
     private:
-        Launcher* _launcher;
+        bool _hasRun;
+        Core::Process::Options _options(config.Command.Value().c_str());
+        Core::Process _process;
+        Time _interval;
     };
 
 public:
@@ -484,7 +533,7 @@ class Launcher : public PluginHost::IPlugin {
         , _interval()
         , _options(nullptr)
         , _client(this)
-        , _activity(Core::ProxyType<PeriodicSync>::Create(_client))
+        , _activity()
     {
     }
 #ifdef __WIN32__
@@ -521,28 +570,18 @@ class Launcher : public PluginHost::IPlugin {
     // to this plugin. This Metadata can be used by the MetData plugin to publish this information to the ouside world.
     string Information() const override; 
 
-    bool LaunchJob(Time time);
-
 private:
     void Update(const ProcessObserver::Info& info);
-    bool ScheduleJob(Time time);
+    bool Execute();
 
 private:
     PluginHost::IShell* _service;
-    Core::Process _process;
     uint32_t _pid;
     uint8_t _closeTime;
     Core::Sink<Notification> _notification;
     Exchange::IMemory* _memory;
 
-    Time _time;
-    Time _interval;
-
     static ProcessObserver _observer;
-
-    Launcher* _client;
-    Core::Process::Options* _options;
-    Core::ProxyType<Core::IDispatchType<void> > _activity;
 };
 
 } //namespace Plugin