Merge pull request #1 from WebPlatformForEmbedded/timer

pwielders · web-flow · commit 40ce6b8ab630 · 2019-01-21T13:41:57.000+01:00
Launcher with scheduling support is added
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,6 @@
+CMakeCache.txt
+Launcher.json
+Makefile
+cmake_install.cmake
+install_manifest.txt
+libWPEFrameworkLauncher.so
diff --git a/Launcher.cpp b/Launcher.cpp
@@ -68,6 +68,8 @@ SERVICE_REGISTRATION(Launcher, 1, 0);
 
 /* virtual */ const string Launcher::Initialize(PluginHost::IShell* service)
 {
+    Time relativeTime;
+    Time interval;
     string message;
     Config config;
 
@@ -79,34 +81,42 @@ SERVICE_REGISTRATION(Launcher, 1, 0);
 
     config.FromString(_service->ConfigLine());
 
-    _closeTime = (config.CloseTime.Value());
-    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());
+        relativeTime = Time(config.ScheduleTime.RelativeTime.Value());
+        if (relativeTime.IsValid() != true) {
+            SYSLOG(Trace::Warning, (_T("Time 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, (_T("Interval format is wrong")));
         }
     }
 
-    _observer.Register(&_notification);
+    _activity = Core::ProxyType<Job>::Create(&config, interval);
+    if (_activity.IsValid() == true) {
+        if (_activity->IsOperational() == false) {
+            // Well if we where able to parse the parameters (if needed) we are ready to start it..
+            _observer.Register(&_notification);
 
-    // Well if we where able to parse the parameters (if needed) we are ready to start it..
-    _process.Launch(options, &_pid);
+            if (relativeTime.IsValid() == true) {
+                Core::Time scheduledTime(Core::Time::Now());
+                uint64_t timeValueToTrigger = ((relativeTime.Hour() * 60 + relativeTime.Minute()) * 60 + relativeTime.Second()) * 1000;
+                scheduledTime.Add(timeValueToTrigger);
 
-    if (_pid == 0) {
-        _observer.Unregister(&_notification);
-        message = _T("Could not spawn the requested app/script [") + config.Command.Value() + ']';
+                PluginHost::WorkerPool::Instance().Schedule(scheduledTime, _activity);
+            }
+            else {
+                PluginHost::WorkerPool::Instance().Submit(_activity);
+            }
+        }
+        else {
+            message = _T("Could not parse the configuration for the job.");
+        }
     }
     else {
-        _memory = Core::Service<MemoryObserverImpl>::Create<Exchange::IMemory>(_pid);
+        message = _T("Could not create the job.");
     }
 
     return (message);
@@ -124,13 +134,13 @@ SERVICE_REGISTRATION(Launcher, 1, 0);
         _memory = nullptr;
     }
 
-    if (_process.IsActive() == true) {
+    if (_activity->Process().IsActive() == true) {
         // First try a gentle touch....
-        _process.Kill(false);
+        _activity->Process().Kill(false);
 
         // Wait for a maximum of 3 Seconds before we shoot the process!!
-        if (_process.WaitProcessCompleted(_closeTime * 1000) != Core::ERROR_NONE) {
-            _process.Kill(true);
+        if (_activity->Process().WaitProcessCompleted(_closeTime * 1000) != Core::ERROR_NONE) {
+            _activity->Process().Kill(true);
         }
     }
 
@@ -147,14 +157,20 @@ 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->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));
@@ -163,7 +179,6 @@ void Launcher::Update(const ProcessObserver::Info& info)
     }
 }
 
-
 } //namespace Plugin
 
 } // namespace WPEFramework
diff --git a/Launcher.h b/Launcher.h
@@ -292,16 +292,45 @@ class Launcher : public PluginHost::IPlugin {
             Core::JSON::String Value;
         };
 
+    public:
+        class Schedule : public Core::JSON::Container {
+        private:
+            Schedule& operator=(const Schedule&) = delete;
+
+        public:
+            Schedule()
+                : Core::JSON::Container()
+                , RelativeTime()
+                , Interval() {
+                Add(_T("relativetime"), &RelativeTime);
+                Add(_T("interval"), &Interval);
+            }
+            Schedule(const Schedule& copy)
+                : Core::JSON::Container()
+                , RelativeTime(copy.RelativeTime)
+                , Interval(copy.Interval) {
+                Add(_T("relativetime"), &RelativeTime);
+                Add(_T("interval"), &Interval);
+            }
+            ~Schedule() {
+            }
+        public:
+            Core::JSON::String RelativeTime;
+            Core::JSON::String Interval;
+        };
+
     public:
         Config()
             : Core::JSON::Container()
             , Command()
             , Parameters()
             , CloseTime(3)
+            , ScheduleTime()
         {
             Add(_T("command"), &Command);
             Add(_T("parameters"), &Parameters);
             Add(_T("closetime"), &CloseTime);
+            Add(_T("schedule"), &ScheduleTime);
         }
         ~Config()
         {
@@ -311,6 +340,193 @@ class Launcher : public PluginHost::IPlugin {
         Core::JSON::String Command;
         Core::JSON::ArrayType<Parameter> Parameters;
         Core::JSON::DecUInt8 CloseTime;
+        Schedule ScheduleTime;
+    };
+
+    class Time {
+    public:
+        Time()
+        : _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 ()
+        {
+        }
+
+    public:
+        bool IsValid () const { return (HasSeconds() || HasMinutes() || HasHours()); }
+        bool HasHours() const { return (_hour < 24); }
+        bool HasMinutes() const { return (_minute < 60); }
+        bool HasSeconds() const { return (_second < 60); }
+        uint8_t Hour() const { return _hour; }
+        uint8_t Minute() const { return _minute; }
+        uint8_t Second() const { return _second; }
+
+    private:
+        bool Parse(const string& time) {
+            bool status = true;
+            string t = time;
+
+            //Get hours
+            uint8_t hour;
+            string hValue = Split(t, ":");
+            status = IsValidTime(hValue, hour, 24);
+            if (status == true) {
+
+               //Get minutes
+                uint8_t minute;
+                string mValue = Split(t, ".");
+                status = IsValidTime(mValue, minute, 60);
+                if (status == true) {
+
+                    //Store seconds
+                    uint8_t second;
+                    string sValue = t;
+                    status = IsValidTime(sValue, second, 60);
+                    if (status  == true) {
+
+                        //Check all the time components are still valid
+                        if ((hour > 0 && second > 0) && (minute == 0)) {
+                            status = false;
+                            TRACE(Trace::Information, (_T("Invalid time format")));
+                        }
+                        else { //Update time components
+                            _hour = hour;
+                            _minute = minute;
+                            _second = second;
+                        }
+                    }
+                }
+            }
+            return status;
+        }
+
+private:
+        inline bool IsDigit(const string& str) {
+            return (str.find_first_not_of( "0123456789" ) == std::string::npos);
+        }
+
+        inline bool IsValidTime(const string& str, uint8_t& time, const uint8_t limit) {
+            bool status = true;
+            if (IsDigit(str)) {
+                int t = atoi(str.c_str());
+                if (t >= limit || t < 0) {
+                    status = false;
+                    TRACE(Trace::Information, (_T("Invalid time  %s"), str.c_str()));
+                }
+                else {
+                    time = t;
+                }
+            }
+            else {
+                status = false;
+                TRACE(Trace::Information, (_T("Invalid time %s"), str.c_str()));
+            }
+            return status;
+        }
+
+        inline string Split(string& str, const string delimiter) {
+            string word;
+            size_t position = str.find(delimiter, 0);
+            if (position != string::npos) {
+                word = str.substr(0, position);
+                str = str.substr(word.size() + 1, str.size());
+            }
+            return word;
+        }
+
+private:
+        uint8_t _hour;
+        uint8_t _minute;
+        uint8_t _second;
+    };
+
+public:
+    class Job: public Core::IDispatchType<void> {
+    private:
+        Job() = delete;
+        Job(const Job&) = delete;
+        Job& operator=(const Job&) = delete;
+
+    public:
+        Job(Config* config, const Time& interval)
+            : _hasRun(false)
+            , _pid(0)
+            , _options(config->Command.Value().c_str())
+            , _process(false)
+            , _interval(interval)
+        {
+            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());
+                    }
+                }
+            }
+        }
+        ~Job()
+        {
+        }
+
+    public:
+        bool IsOperational() const {
+
+            return ((_hasRun == true) && (_interval.IsValid() == true));
+        }
+        Core::Process& Process() {
+            return (_process);
+        }
+        uint32_t Pid() {
+            return _pid;
+        }
+        virtual void Dispatch() override
+        {
+            _hasRun = true;
+             // Check if the process is not active, no need to reschedule the same job again.
+            if (_process.IsActive() == false) {
+                _process.Launch(_options, &_pid);
+            }
+
+            if (_interval.IsValid() == true && ((_interval.Hour() != 0) || (_interval.Minute() != 0) || (_interval.Second() != 0))) {
+                // Reschedule our next launch point...
+                Core::Time scheduledTime(Core::Time::Now());
+                uint64_t intervalTime = ((_interval.Hour() * 60 + _interval.Minute()) * 60 + _interval.Second()) * 1000;
+                scheduledTime.Add(intervalTime);
+                PluginHost::WorkerPool::Instance().Schedule(scheduledTime,Core::ProxyType<Core::IDispatch>(*this));
+            }
+            else {
+                _hasRun = false;
+            }
+        }
+
+    private:
+        bool _hasRun;
+        uint32_t _pid;
+        Core::Process::Options _options;
+        Core::Process _process;
+        Time _interval;
     };
 
 public:
@@ -319,11 +535,10 @@ class Launcher : public PluginHost::IPlugin {
 #endif
     Launcher()
         : _service(nullptr)
-        , _process(false)
-        , _pid(0)
         , _closeTime(0)
         , _notification(this)
         , _memory(nullptr)
+        , _activity()
     {
     }
 #ifdef __WIN32__
@@ -362,16 +577,16 @@ class Launcher : public PluginHost::IPlugin {
 
 private:
     void Update(const ProcessObserver::Info& info);
+    bool Execute();
 
 private:
     PluginHost::IShell* _service;
-    Core::Process _process;
-    uint32_t _pid;
     uint8_t _closeTime;
     Core::Sink<Notification> _notification;
     Exchange::IMemory* _memory;
 
     static ProcessObserver _observer;
+    Core::ProxyType<Job> _activity;
 };
 
 } //namespace Plugin
diff --git a/README.md b/README.md
