Added process manager

.gitea/workflows/ci.yml

@@ -1,79 +0,0 @@
-name: CI
-
-on:
-  push:
-    tags:
-      - '*'     # Triggers on all tags
-    branches:
-      - '**'    # Triggers on all branches
-
-defaults:
-  run:
-    shell: bash
-    working-directory: .
-
-jobs:
-  build:
-    runs-on: ubuntu
-    container:
-      image: node:20
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-
-      - name: Install tools
-        run: apt update && apt install -y build-essential
-
-      - name: Compile project
-        run: make
-
-      - name: Save build output
-        uses: actions/upload-artifact@v3
-        with:
-          name: ncsambawatcher
-          path: ./ncsambawatcher
-
-  release:
-    if: startsWith(github.ref, 'refs/tags/')
-    needs: build
-    runs-on: ubuntu
-    container:
-      image: node:20
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-      
-      - name: Install build tools
-        run: apt update && apt install -y zip
-
-      - name: Download compiled binary
-        uses: actions/download-artifact@v3
-        with:
-          name: ncsambawatcher
-
-      - name: Copy files
-        run: |
-          mkdir build
-          cp ncsambawatcher build/ncsambawatcher
-          cp configs/ncsambawatcher.config.default build/ncsambawatcher.config
-          cp configs/ncsambawatcher.service.default build/ncsambawatcher.service
-          cp init.sh build/init.sh
-
-      - name: Create release zip
-        run: |
-          cd build
-          ls -al
-          zip -rv ../ncsambawatcher.zip ./*
-          cd ../
-          ls -al
-
-      - name: Publish release
-        uses: akkuman/gitea-release-action@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.RELEASE_SECRET }}
-        with:
-          tag_name: ${{ github.ref_name }}
-          name: Release ${{ github.ref_name }}
-          files: ./ncsambawatcher.zip
-          token: ${{ secrets.RELEASE_SECRET }}
-          draft: true

.gitignore

@@ -90,6 +90,3 @@ settings.json
 watch.c
 ncwatchfile
 ncsambawatcher
-
-obj/
-build/

Makefile

@@ -1,31 +1,2 @@
-# Compiler and flags
+all:
-CXX := g++
+	g++ -lrt -std=c++17 src/main.cpp src/usermanager.cpp src/guarder.cpp -o ncsambawatcher
-CXXFLAGS := -std=c++17 -Wall -Wextra -O2
-
-# Directories
-SRC_DIR := src
-OBJ_DIR := obj
-BUILD_DIR := .
-TARGET := $(BUILD_DIR)/ncsambawatcher
-
-# Create list of source and object files
-SRCS := $(wildcard $(SRC_DIR)/*.cpp)
-OBJS := $(SRCS:$(SRC_DIR)/%.cpp=$(OBJ_DIR)/%.o)
-
-# Default target
-all: $(TARGET)
-
-# Link object files into final binary
-$(TARGET): $(OBJS)
-	$(CXX) $(CXXFLAGS) -o $@ $^
-
-# Compile .cpp to .o into obj/
-$(OBJ_DIR)/%.o: $(SRC_DIR)/%.cpp
-	@mkdir -p $(OBJ_DIR)
-	$(CXX) $(CXXFLAGS) -c $< -o $@
-
-# Clean build artifacts
-clean:
-	rm -f $(OBJ_DIR)/*.o $(TARGET)
-
-.PHONY: all clean

README.md

@@ -1,57 +1,3 @@
-# Nextcloud-Samba Sync
+# nextcloud-samba-sync
 
-## Pre installation
+A Nextcloud-Samba File scanner system
-
-- Install `samba` and `vfs-modules`
-```
-sudo apt update
-sudo apt install samba samba-vfs-modules
-```
-- Create shares. The example is in `configs` folder
-
-## Installation
-
-1. Download a `ncsambawatcher.zip` file from a release above 2.0
-2. Extract somewhere on your server (I recommend your user folder)
-3. Make sure the samba configuration file is correct (See `configs/smb.24.04.conf`)
-4. Configurate the `ncsambawatcher.config` file
-<table>
-    <thead>
-    <tr>
-        <td>Name</td>
-        <td>Required</td>
-        <td>Description</td>
-    </tr>
-</thead>
-    <tbody>
-        <tr>
-            <td><code>NEXTCLOUD_CONTAINER_NAME</code></td>
-            <td>Yes</td>
-            <td>The nextcloud's docker container name</td>
-        </tr>
-        <tr>
-            <td><code>NEXTCLOUD_USERS</code></td>
-            <td>No</td>
-            <td>Usernames separated with spaces</td>
-        </tr>
-        <tr>
-            <td><code>NEXTCLOUD_GROUPFOLDER_IDS</code></td>
-            <td>No</td>
-            <td>Groupfolder ids separated with spaces (only the number)</td>
-        </tr>
-    </tbody>
-    </table>
-
-Example 1: 
-```
-NEXTCLOUD_CONTAINER_NAME=nextcloud
-```
-Example 2: (See `configs/ncsambawatcher.config.default`)
-
-5. Run the `init.sh` script
-6. You're done :)
-
-## Notes
-
-- You don't need to add users and groupfolders to the configfile because the program add automaticly from the logfile
-- For a user (not groupfolder): The username and the samba share name **MUST BE THE SAME**

configs/ncsambawatcher.config.default

@@ -1,3 +0,0 @@
-NEXTCLOUD_CONTAINER_NAME=nextcloud
-NEXTCLOUD_USERS=username1 username2 username3
-NEXTCLOUD_GROUPFOLDER_IDS=1 2 3 4

configs/ncsambawatcher.service

@@ -1,14 +1,14 @@
 [Unit]
 Description=A service which scan Nextcloud folders
-After=network.target docker.service
+After=network.target
-Requires=docker.service
 
 [Service]
-ExecStart=/path/to/folder/ncsambawatcher
+ExecStart=/usr/bin/ncsambawatcher
-WorkingDirectory=/path/to/folder/
 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

configs/smb.24.04.conf

@@ -1,48 +0,0 @@
-[global]
-   vfs objects = full_audit
-   full_audit:prefix = %u|%I|%m|%S
-   full_audit:success = mkdirat unlinkat renameat write
-   full_audit:failure = none
-   full_audit:facility = local5
-   full_audit:priority = NOTICE
-
-# Example usershare
-[<username>] #CHANGEME
-   path = /path/to/nextcloud/data/<username>/files/ #CHANGEME
-   valid users = <username> #CHANGEME
-   force user = www-data
-   force group = www-data
-   create mask = 0755
-   force create mode = 0755
-   directory mask = 0755
-   force directory mode = 0755
-   guest ok = no
-   public = no
-   writable = yes
-   browsable = yes
-   hide dot files = no
-   inherit owner = yes
-   hide unreadable = no
-
-# Example groupfolder share
-[Sharename]
-   path = /path/to/nextcloud/data/__groupfolders/<groupfolder-id> #CHANGEME
-   valid users = usernames #CHANGEME
-   force user = www-data
-   force group = www-data
-   create mask = 0755
-   force create mode = 0755
-   directory mask = 0755
-   force directory mode = 0755
-   guest ok = no
-   public = no
-   writable = yes
-   browsable = yes
-   hide dot files = no
-   inherit owner = yes
-   hide unreadable = no
-   full_audit:prefix = %u|%I|%m|__groupfolders/<groupfolder-id> #CHANGEME
-
-# To disable logs for a specific share, add this line to that share
-[Sharename]
-   vfs objects = 

init.sh

@@ -1,9 +1,11 @@
 #!/bin/bash
 
-current_dir=$(pwd)
+make
-sed -i "s|/path/to/folder/|$current_dir/|g" ncsambawatcher.service
 
-sudo cp ./ncsambawatcher.service /etc/systemd/system
+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

src/configfilemanager.cpp

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

src/configfilemanager.h

@@ -1,68 +0,0 @@
-#ifndef _CONFIGFILEMANAGER_H
-#define _CONFIGFILEMANAGER_H
-
-#include <map>
-#include <string>
-#include <vector>
-#include <fstream>
-#include <iostream>
-#include <mutex>
-#include "definitions.h"
-
-class configfilemanager{
-private:
-    std::map<std::string, std::string> configs;
-    std::mutex mtx;
-
-
-public:
-    configfilemanager(std::string filepath = "./ncsambawatcher.config")
-    {
-        std::ifstream is(filepath);
-        if(!is.good())
-        {
-            std::cerr << "File not exits: " << filepath << std::endl;
-            exit(EXIT_FAILURE);
-        }
-        std::string tmp;
-
-        while(!is.eof())
-        {
-            std::getline(is, tmp);
-            std::cout << tmp << std::endl;
-            if (tmp.at(0) == '#') // ignore comments
-                continue;
-            
-            std::vector<std::string> splited = splitString(tmp, '=');
-            if (splited.size() != 2)
-            {
-                std::cerr << "Invalid line: " << tmp << std::endl;
-                continue;
-            }
-
-            configs.insert(std::make_pair(splited.at(0), splited.at(1)));           
-        }
-
-        if (configs.count("NEXTCLOUD_CONTAINER_NAME") == 0)
-        {
-            std::cerr << "The container's name not added" << std::endl;
-            exit(EXIT_FAILURE);
-        }
-
-        std::cout << "Config file loaded successfuly" << std::endl;
-    }
-
-    std::string at(const std::string &config)
-    {
-        std::lock_guard<std::mutex> lock(mtx);
-        return configs.at(config);
-    }
-
-    std::string at(const char* config)
-    {
-        return at(std::string(config));
-    }
-
-};
-
-#endif // _CONFIGFILEMANAGER_H

src/definitions.h

@@ -1,13 +0,0 @@
-#ifndef _LOCATIONS_H
-#define _LOCATIONS_H
-
-#define LOGFILE "journalctl -u smbd --since now -f"
-
-#define USER_LOG_LOCATION 3
-
-#define SCAN_CMD_USR "docker exec --user www-data %1% /var/www/html/occ files:scan --path="
-#define SCAN_CMD_GRP "docker exec --user www-data %1% /var/www/html/occ groupfolder:scan "
-
-std::vector<std::string> splitString(const std::string& input, char delimiter);
-
-#endif // _LOCATIONS_H

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/locations.h

@@ -0,0 +1,8 @@
+#ifndef _LOCATIONS_H
+#define _LOCATIONS_H
+
+#define LOGFILE "journalctl -u smbd --since now -f"
+
+#define USER_LOG_LOCATION 3
+
+#endif // _LOCATIONS_H

src/main.cpp

@@ -1,39 +1,63 @@
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/wait.h>
 #include <iostream>
-#include <thread>
-#include <vector>
-#include <set>
 #include <array>
 #include <string>
-#include <mutex>
+#include <vector>
-#include <condition_variable>
+#include <unistd.h>
-#include <cstdio>
+#include <sys/types.h>
-#include "definitions.h"
+#include <syslog.h>
+#include <fcntl.h>
+#include <signal.h>
+#include "locations.h"
 #include "usermanager.h"
-#include "configfilemanager.h"
+#include "guarder.h"
+#include "processManager.h"
 
-configfilemanager cfm;
+#define MAXNAMESIZE 255
+#define SCAN_DONE_SIG SIGRTMIN
+#define SCAN_CMD_USR "docker exec --user www-data nextcloud /var/www/html/occ files:scan --path="
+
+int p1[2];
+guarder guard;
 userManager manager;
-std::condition_variable cv;
-std::mutex mtx;
 
-std::vector<std::string> splitString(const std::string& str, char delimiter = '|')
+void flushManagerToPipe()
 {
-    std::vector<std::string> ret;
+    if (!guard.isFlagOn())
-    std::stringstream ss(str);
+    {
-    std::string token;
+        std::vector<std::string> users = manager.getFlaggedUsers();
 
-    while (std::getline(ss, token, delimiter)) {
+        for (std::vector<std::string>::iterator it = users.begin(); it != users.end(); ++it)
-        ret.push_back(token);
+        {
+            int size = it->size();
+            write(p1[1], &size, sizeof(int));
+            write(p1[1], it->data(), size * sizeof(char));
         }
 
-    return ret;
+        manager.unflagAllUsers();
+    }
 }
 
-void readingThreadFunc()
+void handler(int sig) 
 {
+    if (sig == SCAN_DONE_SIG)
+    {
+        flushManagerToPipe();
+    }
+}
+
+int main()
+{
+    openlog("ncsambawatcher", LOG_PID | LOG_CONS, LOG_USER);
+    pipe(p1);
+
+    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;
 
@@ -44,76 +68,53 @@ void readingThreadFunc()
             if (line.find('|') == std::string::npos)
                 continue;
 
-        std::vector<std::string> x = splitString(line, '|');
+            std::vector<std::string> x = splitLogFile(line, '|');
             std::string user(x.at(USER_LOG_LOCATION));
-
-        {
-            std::lock_guard<std::mutex> lock(mtx);
             manager.addUser(user);
             manager.setUserFlagged(user);
-        }
-
-        cv.notify_one();
 
             std::cout << "User find: " << user << std::endl;
+
+            flushManagerToPipe();
         }
-}
+
-
+        fclose(logpipe);
-void scannerThreadFunc()
+        close(p1[1]); // write
-{
+    }
-    std::unique_lock<std::mutex> lock(mtx);
+    else // child
-    std::vector<pid_t> childrens;
+    {
-    while (true)
+        close(p1[1]); // write
-    {
+
-        cv.wait(lock, []
+        int size;
-                { return manager.isAnybodyFlagged(); });
+        char *buffer = nullptr;
-
+        processManager pm;
-        std::set<std::string> scanUsers = manager.getFlaggedUsers();
+
-        manager.unflagAllUsers();
+        while (read(p1[0], &size, sizeof(int)))
-
+        {
-        lock.unlock();
+            if (buffer == nullptr)
-        childrens.clear();
+                buffer = new char[size];
-
+
-        for (const std::string& user : scanUsers)
+            read(p1[0], buffer, size * sizeof(char));
-        {
+            std::string name(buffer);
-            pid_t child = fork();
+            std::string cmd = std::string(SCAN_CMD_USR) + name;
-
+
-            if (child < 0)
+            std::cout << "Scan received for: " << name << std::endl;
-            {
+
-                std::cerr << "Fork failed for: " << user << std::endl;
+            pm.runTask(name, cmd);
-            }
+
-            else if (child == 0) // child
+            kill(parent, SCAN_DONE_SIG);
-            {
+
-                std::string cmd = userManager::getScanCommandFromUser(user, cfm);
+            if (buffer != nullptr)
-                execl("/bin/sh", "sh", "-c", cmd.c_str(), static_cast<char *>(nullptr));
+            {
-                std::cerr << "Scan failed" << std::endl;
+                delete[] buffer;
-                _exit(EXIT_FAILURE);
+                buffer = nullptr;
-            }
+            }
-            else // parent
+        }
-            {
+
-                childrens.push_back(child);
+        close(p1[0]); // read
-            }
+    }
-        }
+
-
+    closelog();
-        for (const pid_t& pid : childrens)
+
-        {
+    return EXIT_SUCCESS;
-            waitpid(pid, nullptr, 0);
-        }
-
-        lock.lock();
-    }
-}
-
-int main()
-{
-    manager.tryAddUsersFromConfig(cfm);
-    manager.tryAddGroupIDsFromConfig(cfm);
-    
-    std::thread readingThread(readingThreadFunc);
-    std::thread scannerThread(scannerThreadFunc);
-
-    readingThread.join();
-    scannerThread.join();
-
-    return 0;
 }

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

src/usermanager.cpp

@@ -1,28 +1,14 @@
 #include "usermanager.h"
 
-std::string userManager::getScanCommandFromUser(const std::string &user, configfilemanager &cfm)
+std::vector<std::string> splitLogFile(const std::string& input, char delimiter = '|')
 {
-    std::string contname = cfm.at("NEXTCLOUD_CONTAINER_NAME");
+    std::vector<std::string> ret;
-    std::string baseCommand;
+    std::stringstream ss(input);
-    std::string userCommand;
+    std::string token;
-    std::string placeholder("%1%");
 
-    if (user.find("__groupfolder") != std::string::npos)
+    while (std::getline(ss, token, delimiter)) {
-    {
+        ret.push_back(token);
-        baseCommand = SCAN_CMD_GRP;
-        userCommand = splitString(user, '/').back();
-    }
-    else
-    {
-        baseCommand = SCAN_CMD_USR;
-        userCommand = user;
     }
 
-    size_t pos = 0;
+    return ret;
-    while ((pos = baseCommand.find(placeholder, pos)) != std::string::npos) {
-        baseCommand.replace(pos, placeholder.length(), contname);
-        pos += contname.length(); // Move past the replacement
-    }
-
-    return baseCommand + userCommand;
 }

src/usermanager.h

@@ -4,63 +4,51 @@
 #include <string>
 #include <map>
 #include <vector>
-#include <set>
 #include <sstream>
-#include <mutex>
+#include "locations.h"
-#include <stdexcept>
+
-#include "definitions.h"
+std::vector<std::string> splitLogFile(const std::string& input, char delimiter);
-#include "configfilemanager.h"
 
 class userManager
 {
 private:
     std::map<std::string, bool> users;
-    std::mutex mtx;
 
 public:
     
-    static std::string getScanCommandFromUser(const std::string&, configfilemanager& cfm);
-
     void addUserFromLogLine(std::string &line)
     {
-        addUser(splitString(line, '|').at(USER_LOG_LOCATION));
+        addUser(splitLogFile(line, '|').at(USER_LOG_LOCATION));
     }
 
-    void addUser(const std::string &user)
+    void addUser(std::string &user)
     {
-        std::lock_guard<std::mutex> lock(mtx);
         if (users.count(user) == 0)
         {
             users[user] = false;
-            std::cout << "User added the list: " << user << std::endl;
         }
     }
 
-    void removeUser(const std::string &user)
+    void removeUser(std::string &user)
     {
-        std::lock_guard<std::mutex> lock(mtx);
         users.erase(user);
-        std::cout << "User removed the list: " << user << std::endl;
     }
 
-    bool isContains(const std::string &user)
+    bool isContains(std::string &user)
     {
-        std::lock_guard<std::mutex> lock(mtx);
         return users.count(user) == 1;
     }
 
-    void setUserFlagged(const std::string &user)
+    void setUserFlagged(std::string &user)
     {
-        std::lock_guard<std::mutex> lock(mtx);
         if (users.count(user) == 1)
         {
             users[user] = true;
         }
     }
 
-    void setUserUnflagged(const std::string &user)
+    void setUserUnflagged(std::string &user)
     {
-        std::lock_guard<std::mutex> lock(mtx);
         if (users.count(user) == 1)
         {
             users[user] = false;
@@ -69,90 +57,38 @@ public:
 
     void unflagAllUsers()
     {
-        std::lock_guard<std::mutex> lock(mtx);
         for (std::map<std::string, bool>::iterator it = users.begin(); it != users.end(); ++it)
         {
             it->second = false;
         }
     }
 
-    std::set<std::string> getUsers()
+    std::vector<std::string> getUsers()
     {
-        std::set<std::string> ret;
+        std::vector<std::string> ret;
-
-        std::lock_guard<std::mutex> lock(mtx);
 
         for (std::map<std::string, bool>::iterator it = users.begin(); it != users.end(); ++it)
         {
-            ret.insert(it->first);
+            ret.push_back(it->first);
         }
 
         return ret;
     }
 
-    std::set<std::string> getFlaggedUsers()
+    std::vector<std::string> getFlaggedUsers()
     {
-        std::set<std::string> ret;
+        std::vector<std::string> ret;
-
-        std::lock_guard<std::mutex> lock(mtx);
 
         for (std::map<std::string, bool>::iterator it = users.begin(); it != users.end(); ++it)
         {
             if (it->second)
             {
-                ret.insert(it->first);
+                ret.push_back(it->first);
             }
         }
 
         return ret;
     }
-
-    bool isAnybodyFlagged()
-    {
-        std::lock_guard<std::mutex> lock(mtx);
-    
-        for (std::map<std::string, bool>::iterator it = users.begin(); it != users.end(); ++it)
-        {
-            if (it->second)
-                return true;
-        }
-
-        return false;
-    }
-
-    void tryAddUsersFromConfig(configfilemanager &cfm)
-    {
-        try
-        {
-            std::vector<std::string> alluser = splitString(cfm.at("NEXTCLOUD_USERS"), ' ');
-
-            for (const std::string& user : alluser)
-            {
-                addUser(user);
-            }
-        }
-        catch (std::exception e)
-        {
-            std::cerr << "No user added from configuration file" << std::endl;
-        }
-    }
-
-    void tryAddGroupIDsFromConfig(configfilemanager &cfm)
-    {
-        try
-        {
-            std::vector<std::string> allids = splitString(cfm.at("NEXTCLOUD_GROUPFOLDER_IDS"), ' ');
-
-            for (const std::string& id : allids)
-            {
-                addUser("__groupfolder/" + id);
-            }
-        }
-        catch (std::exception e)
-        {
-            std::cerr << "No groupfolder added from configuration file" << std::endl;
-        }
-    }
 };
 
 #endif // _USERMAN_H