Merge pull request #5 from WebPlatformForEmbedded/timer

Memory Observer updated based on the Job creation and Job revocation added

Author: HaseenaSainul

Launcher.cpp

@@ -15,64 +15,6 @@ namespace Plugin {
 
 SERVICE_REGISTRATION(Launcher, 1, 0);
 
-    class MemoryObserverImpl : public Exchange::IMemory {
-    private:
-        MemoryObserverImpl();
-        MemoryObserverImpl(const MemoryObserverImpl&);
-        MemoryObserverImpl& operator=(const MemoryObserverImpl&);
-
-    public:
-        MemoryObserverImpl(const uint32_t id)
-            : _main(id == 0 ? Core::ProcessInfo().Id() : id)
-            , _observable(false)
-        {
-        }
-        ~MemoryObserverImpl()
-        {
-        }
-
-    public:
-        virtual void Observe(const uint32_t pid)
-        {
-            if (pid == 0) {
-                _observable = false;
-             }
-             else {
-                _main = Core::ProcessInfo(pid);
-                _observable = true;
-             }
-        }
-        virtual uint64_t Resident() const
-        {
-            return (_observable == false ? 0 : _main.Resident());
-        }
-        virtual uint64_t Allocated() const
-        {
-            return (_observable == false ? 0 : _main.Allocated());
-        }
-        virtual uint64_t Shared() const
-        {
-            return (_observable == false ? 0 : _main.Shared());
-        }
-        virtual uint8_t Processes() const
-        {
-            return (IsOperational() ? 1 : 0);
-        }
-        virtual const bool IsOperational() const
-        {
-            return (_observable == false) || (_main.IsActive());
-        }
-
-        BEGIN_INTERFACE_MAP(MemoryObserverImpl)
-        INTERFACE_ENTRY(Exchange::IMemory)
-        END_INTERFACE_MAP
-
-    private:
-        Core::ProcessInfo _main;
-        bool _observable;
-    };
-
-
 /* static */ Launcher::ProcessObserver Launcher::_observer;
 
 /* virtual */ const string Launcher::Initialize(PluginHost::IShell* service)
@@ -106,7 +48,10 @@ SERVICE_REGISTRATION(Launcher, 1, 0);
         }
     }
 
-    _activity = Core::ProxyType<Job>::Create(&config, interval);
+    _memory = Core::Service<MemoryObserverImpl>::Create<Exchange::IMemory>(0);
+    ASSERT(_memory != nullptr);
+
+    _activity = Core::ProxyType<Job>::Create(&config, interval, _memory);
     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..
@@ -136,15 +81,24 @@ SERVICE_REGISTRATION(Launcher, 1, 0);
             else {
                 PluginHost::WorkerPool::Instance().Submit(_activity);
             }
+
         }
         else {
+            _activity.Release();
             message = _T("Could not parse the configuration for the job.");
         }
     }
     else {
         message = _T("Could not create the job.");
     }
 
+    if (_activity.IsValid() == false) {
+        if (_memory != nullptr) {
+            _memory->Release();
+            _memory = nullptr;
+        }
+    }
+
     return (message);
 }
 
@@ -153,6 +107,8 @@ SERVICE_REGISTRATION(Launcher, 1, 0);
     ASSERT(_service == service);
     ASSERT(_memory != nullptr);
 
+    PluginHost::WorkerPool::Instance().Revoke(_activity);
+
     _observer.Unregister(&_notification);
 
     if (_memory != nullptr) {
@@ -188,7 +144,8 @@ void Launcher::Update(const ProcessObserver::Info& info)
         ASSERT(_service != nullptr);
 
         if (info.Event() == ProcessObserver::Info::EVENT_EXIT) {
-        
+
+            _memory->Observe(0);
             if ((info.ExitCode() & 0xFFFF) == 0) {
                 // Only do this if we do not need a retrigger on an intervall.
                 if (_activity->IsOperational() == false) {

Launcher.h

@@ -265,6 +265,63 @@ class Launcher : public PluginHost::IPlugin {
         Launcher& _parent;
     };
 
+    class MemoryObserverImpl : public Exchange::IMemory {
+    private:
+        MemoryObserverImpl();
+        MemoryObserverImpl(const MemoryObserverImpl&);
+        MemoryObserverImpl& operator=(const MemoryObserverImpl&);
+
+    public:
+        MemoryObserverImpl(const uint32_t id)
+            : _main(id == 0 ? Core::ProcessInfo().Id() : id)
+            , _observable(false)
+        {
+        }
+        ~MemoryObserverImpl()
+        {
+        }
+
+    public:
+        virtual void Observe(const uint32_t pid)
+        {
+            if (pid == 0) {
+                _observable = false;
+             }
+             else {
+                _main = Core::ProcessInfo(pid);
+                _observable = true;
+             }
+        }
+        virtual uint64_t Resident() const
+        {
+            return (_observable == false ? 0 : _main.Resident());
+        }
+        virtual uint64_t Allocated() const
+        {
+            return (_observable == false ? 0 : _main.Allocated());
+        }
+        virtual uint64_t Shared() const
+        {
+            return (_observable == false ? 0 : _main.Shared());
+        }
+        virtual uint8_t Processes() const
+        {
+            return (IsOperational() ? 1 : 0);
+        }
+        virtual const bool IsOperational() const
+        {
+            return (_observable == false) || (_main.IsActive());
+        }
+
+        BEGIN_INTERFACE_MAP(MemoryObserverImpl)
+        INTERFACE_ENTRY(Exchange::IMemory)
+        END_INTERFACE_MAP
+
+    private:
+        Core::ProcessInfo _main;
+        bool _observable;
+    };
+
 public:
     class Config : public Core::JSON::Container {
     private:
@@ -485,11 +542,12 @@ class Launcher : public PluginHost::IPlugin {
         Job& operator=(const Job&) = delete;
 
     public:
-        Job(Config* config, const Time& interval)
+        Job(Config* config, const Time& interval, Exchange::IMemory* memory)
             : _hasRun(false)
             , _pid(0)
             , _options(config->Command.Value().c_str())
             , _process(false)
+            , _memory(memory)
             , _interval(interval)
         {
             auto iter = config->Parameters.Elements();
@@ -528,8 +586,10 @@ class Launcher : public PluginHost::IPlugin {
              // Check if the process is not active, no need to reschedule the same job again.
             if (_process.IsActive() == false) {
 
-                Core::Time currentTime(Core::Time::Now());
                 _process.Launch(_options, &_pid);
+                if (_memory != nullptr) {
+                    _memory->Observe(_pid);
+                }
             }
 
             if (_interval.IsValid() == true) {
@@ -550,6 +610,7 @@ class Launcher : public PluginHost::IPlugin {
         uint32_t _pid;
         Core::Process::Options _options;
         Core::Process _process;
+        Exchange::IMemory* _memory;
         Time _interval;
     };