Merge pull request #11 from WebPlatformForEmbedded/haseena/process

HaseenaSainul · web-flow · commit 7f05bd7cb1c0 · 2019-02-12T19:43:07.000+05:30
Changes to handle termination of child process
diff --git a/Launcher.cpp b/Launcher.cpp
@@ -30,6 +30,7 @@ SERVICE_REGISTRATION(Launcher, 1, 0);
 
     // Setup skip URL for right offset.
     _service = service;
+    _deactivationInProgress = false;
 
     config.FromString(_service->ConfigLine());
 
@@ -58,10 +59,12 @@ SERVICE_REGISTRATION(Launcher, 1, 0);
     ASSERT(_memory != nullptr);
     ASSERT(_activity.IsValid() == true);
 
+    _deactivationInProgress = true;
+
     _memory->Observe(0);
-    _observer.Unregister(&_notification);
 
     _activity->Shutdown();
+    _observer.Unregister(&_notification);
     _activity.Release();
 
     _memory->Release();
@@ -84,21 +87,30 @@ 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 ( (_activity->Pid() == info.Id()) && (info.Event() == ProcessObserver::Info::EVENT_EXIT) ) { 
+    if (_activity->IsActive() == true) {
 
-        _memory->Observe(0);
-        uint32_t result = _activity->ExitCode();
+        _activity->Update(info);
 
-        if (result != Core::ERROR_NONE) {
-            SYSLOG(Trace::Fatal, (_T("FORCED Shutdown: %s by error: %d."), _service->Callsign().c_str(), result));
-            PluginHost::WorkerPool::Instance().Submit(PluginHost::IShell::Job::Create(_service, PluginHost::IShell::DEACTIVATED, PluginHost::IShell::FAILURE));
-        }
-        else if (_activity->Continuous() == false) {
-            TRACE(Trace::Information, (_T("Launcher [%s] has run succesfully, deactivation requested."), _service->Callsign().c_str()));
-            PluginHost::WorkerPool::Instance().Submit(PluginHost::IShell::Job::Create(_service, PluginHost::IShell::DEACTIVATED, PluginHost::IShell::AUTOMATIC));
-        }
-        else {
-            TRACE(Trace::Information, (_T("Launcher [%s] has run succesfully, scheduled for the next run."), _service->Callsign().c_str()));
+        if (_activity->IsActive() == false) {
+            uint32_t result = _activity->ExitCode();
+
+            if (result != Core::ERROR_NONE) {
+                if (_deactivationInProgress == false) {
+                    _deactivationInProgress = true;
+                    SYSLOG(Trace::Fatal, (_T("FORCED Shutdown: %s by error: %d."), _service->Callsign().c_str(), result));
+                    PluginHost::WorkerPool::Instance().Submit(PluginHost::IShell::Job::Create(_service, PluginHost::IShell::DEACTIVATED, PluginHost::IShell::FAILURE));
+                }
+            }
+            else if (_activity->Continuous() == false) {
+                if (_deactivationInProgress == false) {
+                    _deactivationInProgress = true;
+                    TRACE(Trace::Information, (_T("Launcher [%s] has run succesfully, deactivation requested."), _service->Callsign().c_str()));
+                    PluginHost::WorkerPool::Instance().Submit(PluginHost::IShell::Job::Create(_service, PluginHost::IShell::DEACTIVATED, PluginHost::IShell::AUTOMATIC));
+                }
+            }
+            else {
+                TRACE(Trace::Information, (_T("Launcher [%s] has run succesfully, scheduled for the next run."), _service->Callsign().c_str()));
+            }
         }
     }
 }
@@ -125,6 +137,7 @@ bool Launcher::ScheduleParameters(const Config& config, string& message, Core::T
         }
         else if ( (timeMode == ABSOLUTE_WITH_INTERVAL) && ((interval.IsValid() == false) || (interval.TimeInSeconds() == 0)) ) {
             message = _T("Requested mode is ABSOLUTE WITH INTERVAL but no interval (or 0 second interval) is given.");
+
         }
         else {
             // All signals green, we have valid input, calculate the ScheduleTime/Interval time
diff --git a/Launcher.h b/Launcher.h
@@ -3,6 +3,7 @@
 #include "Module.h"
 #include <interfaces/IMemory.h>
 #include <linux/cn_proc.h>
+#include <vector>
 
 namespace WPEFramework {
 namespace Plugin {
@@ -544,16 +545,19 @@ class Launcher : public PluginHost::IPlugin {
         Job(const Job&) = delete;
         Job& operator=(const Job&) = delete;
 
+        typedef std::vector<uint32_t> ProcessList;
+
     public:
         Job(Config* config, const Time& interval, Exchange::IMemory* memory)
             : _adminLock()
-            , _pid(0)
             , _options(config->Command.Value().c_str())
             , _process(false)
             , _memory(memory)
             , _interval(interval)
             , _closeTime(config->CloseTime.Value())
             , _shutdownPhase(0)
+            , _processListEmpty(1, 1)
+            , _shutdownCompleted(false)
         {
             auto iter = config->Parameters.Elements();
 
@@ -580,11 +584,58 @@ class Launcher : public PluginHost::IPlugin {
         uint32_t ExitCode() {
             return (_process.IsActive() == false ? _process.ExitCode() : Core::ERROR_NONE);
         }
+        bool IsActive() const {
+            return (_processList.size() > 0);
+        }
         bool Continuous() const {
             return (_interval.IsValid() == true);
         }
         uint32_t Pid() {
-            return _pid;
+            return (_processList.front());
+        }
+        void Update (const ProcessObserver::Info& info) {
+            switch (info.Event()) {
+            case ProcessObserver::Info::EVENT_FORK:
+            {
+                 _adminLock.Lock();
+
+                 ProcessList::iterator position (std::find(_processList.begin(), _processList.end(), info.Id()));
+                 if (position != _processList.end()) {
+                     _processList.push_back(info.ChildId());
+
+                     if (_shutdownPhase == 2) {
+                         ::kill(info.ChildId(), SIGKILL);
+                     }
+                 }
+
+                 _adminLock.Unlock();
+                 break;
+            }
+            case ProcessObserver::Info::EVENT_EXIT:
+            {
+                _adminLock.Lock();
+
+                ProcessList::iterator position (std::find(_processList.begin(), _processList.end(), info.Id()));
+                if (position != _processList.end()) {
+                    _processList.erase(position);
+                    if ( (info.Id() ==_processList.front()) && (_process.IsActive() == false) ) {
+                        _memory->Observe(0);
+                    }
+                    else {
+                        // TODO: Probably might need to add the read exit code here for any process that exits to prevent
+                        //       Zombie processes here..
+                    }
+                    if (_processList.size() == 0) {
+                        _processListEmpty.Unlock();
+                    }
+                }
+
+                _adminLock.Unlock();
+                break;
+            }
+            default:
+                break;
+            }
         }
         void Schedule (const Core::Time& time) {
             if (time <= Core::Time::Now()) {
@@ -600,18 +651,39 @@ class Launcher : public PluginHost::IPlugin {
             _adminLock.Unlock();
 
             PluginHost::WorkerPool::Instance().Revoke(Core::ProxyType<Core::IDispatch>(*this));
-
             if (_process.IsActive() == true) {
 
                 // First try a gentle touch....
                 _process.Kill(false);
 
                // Wait for a maximum configured wait time before we shoot the process!!
-               if (_process.WaitProcessCompleted(_closeTime * 1000) != Core::ERROR_NONE) {
-                   _process.Kill(true);
-                   _process.WaitProcessCompleted(1000);
-               }
+               _process.WaitProcessCompleted(_closeTime * 1000);
             }
+
+            // If there was a proper shutdown, all assoicated processes should have left. 
+            // If not, we will start doing it the rude way!!
+            if (_processList.size() != 0) {
+                _adminLock.Lock();
+                _shutdownPhase = 2;
+
+                TRACE_L1("Trying to force kill\n");
+                for (int i = 0; i < _processList.size(); i++) {
+                    ::kill(_processList[i], SIGKILL);
+                }
+ 
+                _adminLock.Unlock();
+                _process.WaitProcessCompleted(1000);
+            }
+
+            if (_processListEmpty.Lock(1000) != Core::ERROR_NONE) {
+                TRACE(Trace::Fatal, (_T("Could not kill all spawned processes for: %s."), _options.Command().c_str()));
+                _processList.clear();
+            }
+
+            _adminLock.Lock();
+            _processListEmpty.Unlock();            
+            _shutdownPhase = 0;
+            _adminLock.Unlock();
         }
 
     private:
@@ -621,14 +693,18 @@ class Launcher : public PluginHost::IPlugin {
             Core::Time nextRun (Core::Time::Now());
 
              // Check if the process is not active, no need to reschedule the same job again.
-            if (_process.IsActive() == false) {
+            if ( (_process.IsActive() == false) && (_shutdownCompleted.Lock(0) == Core::ERROR_NONE) ) {
+
+                ASSERT (_processList.size() == 0);
 
-                _process.Launch(_options, &_pid);
+                _processList.push_back(0);
+                _process.Launch(_options, &_processList.front());
 
-                TRACE(Trace::Information, (_T("Launched command: %s [%d]."), _options.Command().c_str(), _pid));
+                TRACE(Trace::Information, (_T("Launched command: %s [%d]."), _options.Command().c_str(), Pid()));
                 ASSERT (_memory != nullptr);
 
-                _memory->Observe(_pid);
+                _memory->Observe(Pid());
+                _shutdownCompleted.Unlock();
             }
 
             if (_interval.IsValid() == true) {
@@ -644,13 +720,15 @@ class Launcher : public PluginHost::IPlugin {
 
     private:
         Core::CriticalSection _adminLock;
-        uint32_t _pid;
         Core::Process::Options _options;
         Core::Process _process;
         Exchange::IMemory* _memory;
         Time _interval;
         uint8_t _closeTime;
         uint8_t _shutdownPhase;
+        ProcessList _processList;
+        Core::Event _processListEmpty;
+        Core::BinairySemaphore _shutdownCompleted;
     };
 
 public:
@@ -662,6 +740,7 @@ class Launcher : public PluginHost::IPlugin {
         , _memory(nullptr)
         , _notification(this)
         , _activity()
+        , _deactivationInProgress()
     {
     }
 #ifdef __WIN32__
@@ -707,6 +786,7 @@ class Launcher : public PluginHost::IPlugin {
     Exchange::IMemory* _memory;
     Core::Sink<Notification> _notification;
     Core::ProxyType<Job> _activity;
+    bool _deactivationInProgress;
 
     static ProcessObserver _observer;
 };
diff --git a/README.md b/README.md
@@ -77,7 +77,7 @@ Plugin to "Launch" linux applications and scripts
 
 Note:
 1. If field "mode" is empty or not set, it will treat the time as relative
-2. If relative time value is "00:00.00"/invalid format/not set, the launcher will ignore the given time and launch the application at the launcher activation time itself.
+2. If relative time value is "00:00.00"/not set, the launcher will ignore the given time and launch the application at the launcher activation time itself.
 3. If time format given is
   a. "XX", treat it as SS
   b. "XX.XX" treat it as MM.SS
@@ -100,7 +100,7 @@ Note:
    ```
 
 Note:
-1. If absolute time value is invalid format/not set, the launcher will ignore the given time and launch the application at the launcher activation time itself.
+1. If absolute time value is not set, the launcher will ignore the given time and launch the application at the launcher activation time itself.
 2. If time format given is
    a. "XX", treat it as SS, and schedule the application launch at next SSth time. i.e. if absolute time given is 25 and current time is 08:10:45, then the application will be
       launched at 08:11:25
