load arguments and debug logic

.gitignore

@@ -149,3 +149,5 @@ cython_debug/
 # Local History for Visual Studio Code
 .history/
 
+
+config.yaml

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: Current File",
+            "type": "python",
+            "request": "launch",
+            "module": "onlyone",
+            "console": "integratedTerminal",
+            "args": ["--configFile","config.yaml"]
+        }
+    ]
+}

README.md

@@ -1,2 +1,4 @@
 # onlyone
 
+pip install yaml
+

config.example.yaml

@@ -0,0 +1,7 @@
+
+defaultProcess: a
+processes:
+- key: a
+  cmd: aaa
+- key: b
+  cmd: aaa

onlyone/__init__.py

@@ -5,87 +5,96 @@ from typing import List
 
 
 
-def b():
-    return 3+3
-
 log = logging.getLogger(__name__)
 
-def isrunning(process:str):
+def isrunning(cmd:str):
     for proc in psutil.process_iter():
-        if process.split(" ")[0] == proc.name().split(" ")[0]:
+        if cmd == " ".join(proc.cmdline()):
             return True
     return False
 
-def startprocess(process:str):
+def startprocess(cmd):
     try:
-        #raise Exception("aaa")
+        os.popen(cmd)
-        os.popen(process)
+        log.info("[onlyone][startprocess] -> processed started : " + cmd) 
-        log.info("[onlyone][startprocess] -> processed started : " + process) 
     except OSError as e:
         log.error("eror")
     except:
         log.error("eror")
     
 
-def __killprocesses(killprocesses:List, processesList: List):
+def __killprocesses(killcmds:List, sysprocesses: List):
     if killprocesses == None :
         return False
-    for proc in processesList:
+    for proc in sysprocesses:
-        if  any(element.split(" ")[0] == proc.name().split(" ")[0] for element in killprocesses):
+        if  any(" ".join(proc.cmdline()) == x for x in killcmds):
             proc.kill()
             log.info("[onlyone][__killprocesses] -> processed kiled : " + proc.name + "(" + proc.id  + ")")
     return False
 
 
-def killprocesses(killprocesses:List):
+def killprocesses(killcmds:List):
-    return __killprocesses(killprocesses, psutil.process_iter())
+    return __killprocesses(killcmds, psutil.process_iter())
     
 
-def __forceoneprocessinstance(process:str, processes:List):
+def __forceoneprocessinstance(cmd:str, processes:List):
     found = False
     for proc in processes:
-        if proc.name().split(" ")[0] == process.split(" ")[0]:
+        if " ".join(proc.cmdline()) == cmd:
             if found:
                 proc.kill()
                 log.info("[onlyone][__forceoneprocessinstance] -> processed kiled : " + proc.name + "(" + proc.id  + ")")
             else :
                 found = True
     if not found:
-        startprocess(process)
+        startprocess(cmd)
 
-def forceoneprocessinstance(processname:str):
+def forceoneprocessinstance(cmd:str):
-    return __forceoneprocessinstance(processname, psutil.process_iter())
+    return __forceoneprocessinstance(cmd, psutil.process_iter())
 
-def onlyone(process:str, killprocesses:list):
+def onlyone(cmd:str, killcmds:list):
     processes = psutil.process_iter()
-    __killprocesses(killprocesses, processes)
+    __killprocesses(killcmds, processes)
-    __forceoneprocessinstance(process, processes)
+    __forceoneprocessinstance(cmd, processes)
 
-def Manager():
+class Manager:
     def __init__(self):
-        self.processes=[]
+        self.__processes=[]
-        self._current=None
+        self.__current=None
-    
-    def addprocess(self, key, processname, initParams):
-        self.processes.append({
-            key:key,
-            processname:processname,
-            initParams:initParams
-        })
 
+    def load(self, dict:dict):
+        if(dict == None):return
+        if("processes" in dict):
+            for p in dict["processes"]:
+                if "key" in  p and "cmd" in p:
+                    self.addprocess(p["key"], p["cmd"])
+        if("defaultProcess" in dict):
+            self.current(dict["defaultProcess"])
+        
+    
+    def addprocess(self, key, cmd):
+        self.__processes.append({"key": key, "cmd":cmd})
+      
     def current(self):
-        return None if self == None else self._current.key
+        if self.__current == None:
+            return None
+        else:
+            return self.__current["key"]
 
     def current(self, key):
-        item =  any(element in key for element in self.processes)
+       
+        item = None
+        if key!=None:
+            for x in self.__processes:
+                if x["key"] == key:
+                    item =x        
         if item == None:
-            return None
+            killprocesses([x["cmd"] for x in self.__processes])
-        self._current=item
+            self._current = None
-        others = []
+            return
-        for item in self.processes:
+        
-            if item.key!=key:
+        onlyone(item["cmd"], [x for x in self.__processes if x["key"]!=item["key"]])
-                others.append(item.processname)
+        self._current = item["key"]
-        onlyone(item.processname, item.initParams, [element.processname for element in others])
 
    
        

onlyone/__main__.py

@@ -2,37 +2,34 @@ import logging
 import argparse
 from types import new_class
 from typing import List
-from __init__ import *
+import sys
+import onlyone
+import yaml
+import os
+
+
+
 
 
 logging.basicConfig(level="DEBUG")
 log = logging.getLogger(__name__)
 parser = argparse.ArgumentParser(description='onlyone')
-parser.add_argument('--init', type=str, required=False, help='init processes')
+parser.add_argument('--configFile', type=str, required=False, help='configfile')
-parser.add_argument('--kill', type=List, required=False, help='kill processes')
-parser.add_argument('--configfile', type=str, required=False, help='configfile')
-parser.add_argument('--mode', type=str, required=False, help='configfile')
 args = parser.parse_args()
 
-
+sys.stdout.write("arguments - " + str(sys.argv))
-
+log.info("Current Path:" + os.getcwd())
 if args.configfile:
-   manager = Manager()
+   manager = onlyone.Manager()
-   #manager.refreshrate(1000)
+   if os.path.isfile(args.configfile):
-   manager.addprocess("x", "aaaaa", None)
+       log.info("trying to read file : " +  args.configfile)
-   manager.current("x")
+       configTxt = open(args.configfile, "r").read()
-   #manager.oncurrent_changed(__oncurrent_changed)
+       log.info("config file content : " +  configTxt)
-   console.writeline("write !quit and enter to exit")
+       log.info("trying read yaml")
-else:
+       configDict = yaml.safe_load(configTxt)
-    if args.init:
+       manager.load(configDict)
-        log.debug("invoking onlyone.onlyone")
+
-        onlyone(args.init, args.kill)
+   else:
-        quit()
+       log.error("Current Path:" + os.getcwd())
-    if args.kill:
+       log.error("File dont exists:" + args.configfile)
-        log.debug("invoking onlyone.killprocesses")
-        killprocesses(args.kill)
-        quit()
-    log.debug("invoked without arguments")
 
-def __oncurrent_changed(self, sender):
-    t=""

onlyone/sample.yaml

@@ -1,34 +0,0 @@
-refresrate: 3000
-default: 
-fifo: 
-  name: "aaaaaa"
-mqtt:
-  broker: "aaaaaaaaaa"
-  clientid: "aaaaaaa"
-  topic: home/pi/onlyone
-  username: 
-  password:
-rest:
-  username: aaaa
-  password: aaa
-  port: 67777   
-processes: _
-  key: blue
-  process: smb
-  params: _
-    teste
-    teste
-    aaa
-  key: blue
-  process: smb
-  findexp: aaaaaa
-  params: _
-    teste
-    teste
-    aaa
-  key: blue
-  process: smb
-  params: _
-    teste
-    teste
-    aaa