Added process manager

Makefile

@@ -1,2 +1,2 @@
 all:
-	g++ -lrt -std=c++17 src/main.cpp src/usermanager.cpp -o ncsambawatcher
+	g++ -lrt -std=c++17 src/main.cpp src/usermanager.cpp src/guarder.cpp -o ncsambawatcher

configs/ncsambawatcher.service

@@ -0,0 +1,17 @@
+[Unit]
+Description=A service which scan Nextcloud folders
+After=network.target
+
+[Service]
+ExecStart=/usr/bin/ncsambawatcher
+Restart=always
+User=root
+Group=root
+WorkingDirectory=/usr/bin/
+Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=ncsambawatcher
+
+[Install]
+WantedBy=multi-user.target

init.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+make
+
+sudo cp ncsambawatcher /usr/bin/
+sudo chmod +x /usr/bin/ncsambawatcher
+
+sudo cp configs/ncsambawatcher.service /etc/systemd/system
+
+sudo systemctl daemon-reload
+sudo systemctl enable ncsambawatcher.service
+sudo systemctl start ncsambawatcher.service

src/guarder.cpp

@@ -0,0 +1 @@
+#include "guarder.h"

src/guarder.h

@@ -0,0 +1,52 @@
+#ifndef _GUARDER_H
+#define _GUARDER_H
+
+#include <sys/types.h>
+#include <sys/shm.h>
+#include <sys/ipc.h>
+
+class guarder{
+private:
+    const int shmid;
+
+    void setFlag(bool value)
+    {
+        bool *flag = static_cast<bool *>(shmat(shmid, nullptr, 0));
+        *flag = value;
+        shmdt(flag);
+    }
+
+public:
+    guarder() : shmid(shmget(IPC_PRIVATE, sizeof(bool), 0666 | IPC_CREAT))
+    {
+        setFlagOff();
+    }
+
+    guarder(guarder &g) : shmid(g.shmid) {}
+
+    void setFlagOff()
+    {
+        setFlag(false);
+    }
+
+    void setFlagOn()
+    {
+        setFlag(true);
+    }
+
+    bool isFlagOn()
+    {
+        bool *flag = static_cast<bool *>(shmat(shmid, nullptr, 0));
+        bool ret = *flag;
+        shmdt(flag);
+        return ret;
+    }
+
+    ~guarder()
+    {
+        shmctl(shmid, IPC_RMID, nullptr);
+    }
+
+};
+
+#endif // _GUARDER_H

src/main.cpp

@@ -1,71 +1,65 @@
 #include <iostream>
 #include <array>
 #include <string>
-#include <map>
 #include <vector>
 #include <unistd.h>
 #include <sys/types.h>
-#include <sys/shm.h>
-#include <sys/ipc.h>
 #include <syslog.h>
-#include <sys/stat.h>
 #include <fcntl.h>
 #include <signal.h>
-#include <stdbool.h>
 #include "locations.h"
 #include "usermanager.h"
+#include "guarder.h"
+#include "processManager.h"
 
 #define MAXNAMESIZE 255
 #define SCAN_DONE_SIG SIGRTMIN
-#define SCAN_CMD_USR "docker exec -ti --user www-data nextcloud /var/www/html/occ files:scan --path="
+#define SCAN_CMD_USR "docker exec --user www-data nextcloud /var/www/html/occ files:scan --path="
 
-void initRunningFlag(int shmid)
+int p1[2];
+guarder guard;
+userManager manager;
+
+void flushManagerToPipe()
 {
-    bool *init = static_cast<bool *>(shmat(shmid, nullptr, 0));
-    *init = false;
-    shmdt(init);
+    if (!guard.isFlagOn())
+    {
+        std::vector<std::string> users = manager.getFlaggedUsers();
+
+        for (std::vector<std::string>::iterator it = users.begin(); it != users.end(); ++it)
+        {
+            int size = it->size();
+            write(p1[1], &size, sizeof(int));
+            write(p1[1], it->data(), size * sizeof(char));
+        }
+
+        manager.unflagAllUsers();
+    }
 }
 
-bool readRunningFlag(int shmid)
+void handler(int sig) 
 {
-    bool *init = static_cast<bool *>(shmat(shmid, nullptr, 0));
-    *init = false;
-    shmdt(init);
-    return *init;
+    if (sig == SCAN_DONE_SIG)
+    {
+        flushManagerToPipe();
+    }
 }
 
-void setRunningFlag(int shmid, bool data)
-{
-    bool *init = static_cast<bool *>(shmat(shmid, nullptr, 0));
-    *init = data;
-    shmdt(init);
-}
-
-void handler(int sig) {}
-
 int main()
 {
     openlog("ncsambawatcher", LOG_PID | LOG_CONS, LOG_USER);
-
-    int p1[2];
     pipe(p1);
-    sigset_t ss;
-    sigfillset(&ss);
-    sigdelset(&ss, SCAN_DONE_SIG);
-
-    int shmid = shmget(IPC_PRIVATE, sizeof(bool), 0666 | IPC_CREAT);
-    initRunningFlag(shmid);
 
     pid_t parent = getpid();
     pid_t child = fork();
 
     if (child > 0) // parent
     {
+        signal(SCAN_DONE_SIG, handler);
         close(p1[0]); // read
 
         FILE *logpipe = popen(LOGFILE, "r");
         std::array<char, 256> buffer;
-        userManager manager;
 
         while (fgets(buffer.data(), buffer.size(), logpipe) != nullptr)
         {
@@ -74,20 +68,14 @@ int main()
             if (line.find('|') == std::string::npos)
                 continue;
 
-
             std::vector<std::string> x = splitLogFile(line, '|');
             std::string user(x.at(USER_LOG_LOCATION));
             manager.addUser(user);
             manager.setUserFlagged(user);
 
-            std::vector<std::string> users = manager.getFlaggedUsers();
+            std::cout << "User find: " << user << std::endl;
 
-            for (std::vector<std::string>::iterator it = users.begin(); it != users.end(); ++it)
-            {
-                int size = it->size();
-                write(p1[1], &size, sizeof(int));
-                write(p1[1], it->data(), size * sizeof(char));
-            }
+            flushManagerToPipe();
         }
 
         fclose(logpipe);
@@ -99,6 +87,7 @@ int main()
 
         int size;
         char *buffer = nullptr;
+        processManager pm;
 
         while (read(p1[0], &size, sizeof(int)))
         {
@@ -107,21 +96,24 @@ int main()
 
             read(p1[0], buffer, size * sizeof(char));
             std::string name(buffer);
+            std::string cmd = std::string(SCAN_CMD_USR) + name;
 
-            system((std::string(SCAN_CMD_USR) + name).data());
+            std::cout << "Scan received for: " << name << std::endl;
+
+            pm.runTask(name, cmd);
+
+            kill(parent, SCAN_DONE_SIG);
 
             if (buffer != nullptr)
             {
                 delete[] buffer;
                 buffer = nullptr;
             }
-                
         }
 
         close(p1[0]); // read
     }
 
-    shmctl(shmid, IPC_RMID, nullptr);
     closelog();
 
     return EXIT_SUCCESS;

src/processManager.h

@@ -0,0 +1,41 @@
+#ifndef _PROCCESSMANAGER_H
+#define _PROCCESSMANAGER_H
+
+#include <map>
+#include <string>
+#include <unistd.h>
+#include <sys/types.h>
+#include "guarder.h"
+#include "usermanager.h"
+
+class processManager
+{
+private:
+    std::map<std::string, guarder> running;
+
+    bool getIdTag(std::string &id)
+    {
+        return running[id].isFlagOn();
+    }
+
+
+public:  
+
+    void runTask(std::string &id, std::string &cmdCommand)
+    {
+        if (!getIdTag(id))
+        {
+            running[id].setFlagOn();
+            pid_t child = fork();
+
+            if (child == 0) // child
+            {
+                system(cmdCommand.c_str());
+                running[id].setFlagOff();
+                exit(EXIT_SUCCESS);
+            }
+        }
+    }
+};
+
+#endif // _PROCCESSMANAGER_H