removed *.sh *.bat now the manager is pyros.py

removed .sh .bat now the manager is pyros.py
Jeremy
1 parent 124965dc
Showing 18 changed files with 609 additions and 25 deletions Show diff stats
install/install.py
pyrosrun.bat -> obsolete/pyrosrun.bat
pyrosrun.sh -> obsolete/pyrosrun.sh
src/scripts/celery_test.sh -> obsolete/scripts/celery_test.sh
src/scripts/delete_all_requests.sh -> obsolete/scripts/delete_all_requests.sh
src/scripts/kill_celery_workers.bat -> obsolete/scripts/kill_celery_workers.bat
src/scripts/kill_celery_workers.sh -> obsolete/scripts/kill_celery_workers.sh
src/scripts/kill_simulation.sh -> obsolete/scripts/kill_simulation.sh
src/scripts/start_celery_single_worker.sh -> obsolete/scripts/start_celery_single_worker.sh
src/scripts/start_celery_workers.bat -> obsolete/scripts/start_celery_workers.bat
src/scripts/start_celery_workers.sh -> obsolete/scripts/start_celery_workers.sh
src/scripts/test_all_usual.sh -> obsolete/scripts/test_all_usual.sh
simulators/scripts/kill_all.sh -> obsolete/sim_scripts/kill_all.sh
simulators/scripts/run_all.sh -> obsolete/sim_scripts/run_all.sh
simulators/scripts/simulator_launch.sh -> obsolete/sim_scripts/simulator_launch.sh
simulators/scripts/start_simulator_worker.sh -> obsolete/sim_scripts/start_simulator_worker.sh
pyros.py
simulators/user/userSimulator.py
@@ -146,22 +146,30 @@ class AInstaller(Utils):
     def setConfig(self, config):
         self.config = config
  
+    def addExecuted(self, src, message):
+        if (src in self.executed):
+            self.executed[src].append(str(message))
+        else:
+            self.executed[src] = [str(message)]
+        return 0
+
+    def addError(self, src, message):
+        if (src in self.errors):
+            self.errors[src].append(str(message))
+        else:
+            self.errors[src] = [str(message)]
+        return 0
+
     def execProcess(self, command):
         self.printFullTerm(Colors.BLUE, "Executing command [" + command + "]")
         process = subprocess.Popen(command, shell=True)
         process.wait()
         if process.returncode == 0:
             self.printFullTerm(Colors.GREEN, "Process executed successfully")
-            if (self.current_command in self.executed):
-                self.executed[self.current_command].append(command)
-            else:
-                self.executed[self.current_command] = [command]
+            self.addExecuted(self.current_command, command)
         else:
             self.printFullTerm(Colors.WARNING, "Process execution failed")
-            if (self.current_command in self.errors):
-                self.errors[self.current_command].append(command)
-            else:
-                self.errors[self.current_command] = [command]
+            self.addError(self.current_command, command)
         return process.returncode
  
     def execProcessFromVenv(self, command):
@@ -171,16 +179,10 @@ class AInstaller(Utils):
         process.wait()
         if process.returncode == 0:
             self.printFullTerm(Colors.GREEN, "Process executed successfully")
-            if (self.current_command in self.executed):
-                self.executed[self.current_command].append(str(' '.join(args[1:])))
-            else:
-                self.executed[self.current_command] = [str(' '.join(args[1:]))]
+            self.addExecuted(self.current_command, str(' '.join(args[1:])))
         else:
             self.printFullTerm(Colors.WARNING, "Process execution failed")
-            if (self.current_command in self.errors):
-                self.errors[self.current_command].append(str(' '.join(args[1:])))
-            else:
-                self.errors[self.current_command] = [str(' '.join(args[1:]))]
+            self.addError(self.current_command, str(' '.join(args[1:])))
         return process.returncode
  
     def askYesNoQuestion(self,  message, question_tag, default=True):
@@ -389,7 +391,7 @@ class Config:
             res = self.__parser.parse_args(), self.__parser.format_usage()
             return (res)
         except SystemExit as e:
-            print(e, file=sys.stderr)
+            # print(e, file=sys.stderr)
             sys.exit(1)
  
     def parseConf(self):
@@ -0,0 +1,576 @@
+import sys
+import os
+import subprocess
+import platform
+import fileinput
+import argparse
+import time
+
+DEBUG = False
+
+
+class Utils:
+    system = platform.system()
+    columns = 100
+    row = 1000
+    disp = True
+
+    def __init__(self):
+        if (platform.system() != 'Windows'):
+            try:
+                rows, columns = os.popen('stty size', 'r').read().split()
+                self.columns = int(columns)
+            except:
+                self.columns = 100
+                if DEBUG:
+                    print("Could not get terminal size")
+
+    def printFullTerm(self, color, string):
+        value = int(self.columns / 2 - len(string) / 2)
+        self.printColor(color, "-" * value, eol='')
+        self.printColor(color, string, eol='')
+        value += len(string)
+        self.printColor(color, "-" * (self.columns - value))
+        return 0
+
+    def changeDirectory(self, path):
+        if DEBUG:
+            print("Moving to : " + path)
+        os.chdir(path)
+        if DEBUG:
+            print("Current directory : " + str(os.getcwd()))
+        return 0
+
+    def replacePatternInFile(self, pattern, replace, file_path):
+        try:
+            with fileinput.FileInput(file_path, inplace=True, backup='.bak') as file:
+                for line in file:
+                    print(line.replace(pattern, replace), end='')
+        except:
+            return 1
+        return 0
+
+    def printColor(self, color, message, file=sys.stdout, eol=os.linesep, forced=False):
+        if (self.disp == False and forced == False):
+            return 0
+        if (self.system == 'Windows'):
+            print(message, file=file, end=eol)
+        else:
+            print(color + message + Colors.ENDC, file=file, end=eol)
+        return 0
+
+    def askQuestion(self, message, default = ""):
+        self.printColor(Colors.BLUE, message, forced=True)
+        self.printColor(Colors.BOLD, "Answer (default="+default+"): ", eol='', forced=True)
+        sys.stdout.flush()
+        ret = sys.stdin.readline().replace(os.linesep, '')
+        if ret == "":
+            return default
+        return ret
+
+    def sleep(self, t):
+        time.sleep(t)
+        return 0
+
+'''
+    Manager class : manager of your project
+'''
+
+
+class AManager(Utils):
+    path = os.path.realpath(__file__)
+    path_dir = os.getcwd()
+    path_dir_file = os.path.dirname(os.path.realpath(__file__))
+    python_path = sys.executable
+    python_version = sys.version_info
+
+    bin_dir = ""
+    celery = "celery"
+    venv_pip = "pip"
+    venv_bin = "python"
+    wait = True
+    current_command = ""
+    config = None
+    commandMatcher = {}
+    commandDescription = {}
+    commands = []
+    errors = {}
+    executed = {}
+
+    def __init__(self, param):
+        super(AManager, self).__init__()
+        self.wait = param.getWait()
+        self.commands = param.getCommandList()
+        self.disp = param.getPrint()
+        config = param.getConfig()
+        self.config = config
+
+        self.changeDirectory(self.path_dir_file)
+
+        if self.system == 'Windows':
+            self.bin_dir = "Scripts"
+            self.bin_name = "python.exe"
+            self.pip_name = "pip.exe"
+            self.celery = "celery.exe"
+        else:
+            self.bin_dir = "bin"
+            self.bin_name = "python"
+            self.pip_name = "pip"
+            self.celery = "celery"
+        self.venv_pip = self.path_dir_file + os.sep + config["path"] + os.sep + config["env"] + os.sep + self.bin_dir + os.sep + self.pip_name
+        self.venv_bin = self.path_dir_file + os.sep + config["path"] + os.sep + config["env"] + os.sep + self.bin_dir + os.sep + self.bin_name
+        self.venv_cel = self.path_dir_file + os.sep + config["path"] + os.sep + config["env"] + os.sep + self.bin_dir + os.sep + self.celery
+
+    def help(self):
+        print("This function must be implemented")
+        raise(NotImplementedError("Function not implemented"))
+
+    def addExecuted(self, src, message):
+        if (src in self.executed):
+            self.executed[src].append(str(message))
+        else:
+            self.executed[src] = [str(message)]
+        return 0
+
+    def addError(self, src, message):
+        if (src in self.errors):
+            self.errors[src].append(str(message))
+        else:
+            self.errors[src] = [str(message)]
+        return 0
+
+    def execProcess(self, command):
+        self.printFullTerm(Colors.BLUE, "Executing command [" + command + "]")
+        process = subprocess.Popen(command, shell=True)
+        process.wait()
+        if process.returncode == 0:
+            self.printFullTerm(Colors.GREEN, "Process executed successfully")
+            self.addExecuted(self.current_command, command)
+        else:
+            self.printFullTerm(Colors.WARNING, "Process execution failed")
+            self.addError(self.current_command, command)
+        return process.returncode
+
+    def execProcessFromVenv(self, command):
+        args = command.split()
+        self.printFullTerm(Colors.BLUE, "Executing command from venv [" + str(' '.join(args[1:])) + "]")
+        process = subprocess.Popen(args)
+        process.wait()
+        if process.returncode == 0:
+            self.printFullTerm(Colors.GREEN, "Process executed successfully")
+            self.addExecuted(self.current_command, str(' '.join(args[1:])))
+        else:
+            self.printFullTerm(Colors.WARNING, "Process execution failed")
+            self.addError(self.current_command, str(' '.join(args[1:])))
+        return process.returncode
+
+    def execProcessAsync(self, command):
+        self.printFullTerm(Colors.BLUE, "Executing command [" + command + "]")
+        subprocess.Popen(command, shell=True)
+        self.printFullTerm(Colors.GREEN, "Process launched successfully")
+        self.addExecuted(self.current_command, command)
+        return 0
+
+    def execProcessFromVenvAsync(self, command: str) -> int:
+        args = command.split()
+        self.printFullTerm(Colors.BLUE, "Executing command from venv [" + str(' '.join(args[1:])) + "]")
+        subprocess.Popen(args)
+        self.printFullTerm(Colors.GREEN, "Process launched successfully")
+        self.addExecuted(self.current_command, str(' '.join(args[1:])))
+        return 0
+
+    def end(self):
+        count = 0
+
+        self.printFullTerm(Colors.WARNING, "Summary")
+        self.printColor(Colors.GREEN, "Success : ")
+        for command, valid in self.executed.items():
+            if not valid:
+                self.printColor(Colors.BLUE, "\t- Command : " + command + " success !")
+            else:
+                self.printColor(Colors.WARNING, "\t- In commmand : " + command)
+                for exe in valid:
+                    self.printColor(Colors.GREEN, "\t\t - Command : " + exe + " success !")
+        self.printColor(Colors.FAIL, "Errors : ")
+        if not self.errors:
+            self.printColor(Colors.GREEN, "\tNone")
+        for command, items in self.errors.items():
+            count += 1
+            if (not items):
+                self.printColor(Colors.FAIL, "Command : " + command + " failed !")
+            else:
+                self.printColor(Colors.WARNING, "\t- In commmand : " + command)
+                for exe in items:
+                    self.printColor(Colors.FAIL, "\t\t - Command : " + exe)
+        return count
+
+    def exec(self):
+        if (not self.commands):
+            self.commandMatcher["help"]()
+            return 0
+        for command in self.commands:
+            self.current_command = command
+            if command in self.commandMatcher:
+                self.commandMatcher[command]()
+            else:
+                self.addError(str(command), "invalid command")
+        return self.end()
+
+    def logError(self, message):
+        self.printColor(Colors.FAIL, "Pyros : An error occurred [" + message + "]", file=sys.stderr)
+        return 0
+
+
+class Config:
+    __parser = argparse.ArgumentParser("Installer parser")
+    __content = {
+        "path": "private",
+        "env": "venv_py3_pyros"
+    }
+    __wait = True
+    __print = True
+    usage = ""
+    __command_list = []
+
+    def __init__(self):
+        self.__parser.add_argument("command", nargs='?', default="help", help="The command you want to execute (default=help)")
+        self.__parser.add_argument("--env", help="Your environment directory name default=venv")
+        self.__parser.add_argument("--path", help="Path to the virtual env (from the source file directory) (default=private)")
+        self.__parser.add_argument("--nowait", action='store_true', help="Don't wait the end of a program")
+        self.__parser.add_argument("--noprint", action='store_true', help="Won't print")
+        self.usage = self.__parser.format_usage()
+
+    def parse(self):
+        try:
+            res = self.__parser.parse_args(), self.__parser.format_usage()
+            return (res)
+        except SystemExit as e:
+            # print(e, file=sys.stderr)
+            sys.exit(1)
+
+    def parseConf(self):
+        res, usage = self.parse()
+        try:
+            if (res.env):
+                self.__content["env"] = res.env
+            if (res.path):
+                self.__content["path"] = res.path
+            if (res.nowait):
+                self.__wait = False
+            if (res.noprint):
+                self.__print = False
+            self.__command_list.append(res.command)
+            return 0
+        except Exception as e:
+            print(e, file=sys.stderr)
+            return 1
+
+    def getPath(self):
+        return self.__content["path"]
+
+    def getEnv(self):
+        return self.__content["env"]
+
+    def getWait(self):
+        return self.__wait
+
+    def getPrint(self):
+        return self.__print
+
+    def setPrint(self, value):
+        self.__print = value
+        return 0
+
+    def setWait(self, value):
+        self.__wait = value
+        return 0
+
+    def getCommandList(self):
+        return self.__command_list
+
+    def printUsage(self):
+        print(self.usage, file=sys.stderr)
+
+    def addConf(self, key, value):
+        if isinstance(key, str) and isinstance(value, str):
+            self.__content[key] = value
+            return 0
+        return 1
+
+    def setPath(self, path):
+        if (os.path.isdir(path)):
+            if (path == ""):
+                path = "."
+            self.__content["path"] = path
+            return 0
+        return 1
+
+    def setEnvName(self, name):
+        self.__content["env"] = name
+        return 0
+
+    def getConfig(self):
+        return self.__content
+
+
+'''
+    Color class
+'''
+
+
+class Colors:
+    HEADER = '\033[95m'
+    BLUE = '\033[94m'
+    GREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+    UNDERLINE = '\033[4m'
+
+
+'''
+    Pyros class
+'''
+
+
+class Pyros(AManager):
+    help_message = "python neo.py"
+    init_fixture = "initial_fixture.json"
+
+    def install(self):
+        if (self.system == "Windows"):
+            self.execProcess("python install/install.py install")
+        else:
+            self.execProcess("python3 install/install.py install")
+        return 0
+
+    def update(self):
+        if (self.system == "Windows"):
+            self.execProcess("python install/install.py update")
+        else:
+            self.execProcess("python3 install/install.py update")
+        return 0
+
+    def server(self):
+        self.changeDirectory("src")
+        self.execProcessFromVenvAsync(self.venv_bin + " manage.py runserver")
+        self.changeDirectory("..")
+        return 0
+
+    def clean(self):
+        return self.clean_logs()
+
+    def clean_logs(self):
+        return self.execProcess("rm logs/*.log")
+
+    def test(self):
+        self.changeDirectory("src")
+        self.execProcessFromVenvAsync(self.venv_bin + " manage.py test")
+        self.changeDirectory("..")
+        return 0
+
+    def migrate(self):
+        self.changeDirectory("src")
+        self.execProcessFromVenv(self.venv_bin + " manage.py migrate")
+        self.changeDirectory("..")
+        return 0
+
+    def makemigrations(self):
+        self.changeDirectory("src")
+        self.execProcessFromVenv(self.venv_bin + " manage.py makemigrations")
+        self.changeDirectory("..")
+        return 0
+
+    def help(self):
+        for command, message in self.commandDescription.items():
+            self.printColor(Colors.BLUE, "-> " + command + ": ", eol='')
+            self.printColor(Colors.GREEN, message)
+        return 0
+
+    def updatedb(self):
+        self.migrate()
+        self.makemigrations()
+        return 0
+
+    def unittest(self):
+        self.changeDirectory("src")
+        self.execProcessFromVenv(self.venv_bin + " manage.py test common scheduler routine_manager user_manager alert_manager.tests.TestStrategyChange")
+        self.changeDirectory("..")
+        return 0
+
+    def test_all(self):
+        self.unittest()
+
+        self.changeDirectory("src")
+        self.replacePatternInFile("CELERY_TEST = False", "CELERY_TEST = True", "pyros/settings.py")
+        self.execProcess("rm -f testdb.sqlite3")
+        self.changeDirectory("..")
+
+        self.migrate()
+        self.loaddata()
+        self.sims_launch()
+        self.singleWorker("alert_manager")
+        self.changeDirectory("src")
+        self.execProcessFromVenv(self.venv_bin + " manage.py test alert_manager.tests.AlertListenerTestsCelery --keepdb --nomigrations")
+        self.replacePatternInFile("CELERY_TEST = True", "CELERY_TEST = False", "pyros/settings.py")
+        self.execProcess("rm -f testdb.sqlite3")
+        self.changeDirectory("..")
+        self.kill_simulation()
+        return 0
+
+    def loaddata(self):
+        self.changeDirectory("src")
+        self.execProcessFromVenv(self.venv_bin + " manage.py loaddata misc/fixtures/" + self.init_fixture)
+        self.changeDirectory("..")
+        return 0
+
+    def celery_on(self):
+        self.changeDirectory("src")
+        self.execProcessFromVenvAsync(self.venv_cel + " worker -A pyros -Q alert_listener_q -n pyros@alert_listener -c 1")
+        self.execProcessFromVenvAsync(self.venv_cel + " worker -A pyros -Q monitoring_q -n pyros@monitoring -c 1")
+        self.execProcessFromVenvAsync(self.venv_cel + " worker -A pyros -Q majordome_q -n pyros@majordome -c 1")
+
+        self.execProcessFromVenvAsync(self.venv_cel + " worker -A pyros -Q scheduling_q --purge -n pyros@scheduling -c 1")
+        self.execProcessFromVenvAsync(self.venv_cel + " worker -A pyros -Q execute_sequence_q --purge -n pyros@execute_sequence -c 1")
+        self.execProcessFromVenvAsync(self.venv_cel + " worker -A pyros -Q execute_plan_vis_q --purge -n pyros@execute_plan_vis -c 1")
+        self.execProcessFromVenvAsync(self.venv_cel + " worker -A pyros -Q execute_plan_vis_q --purge -n pyros@execute_plan_nir -c 1")
+        self.execProcessFromVenvAsync(self.venv_cel + " worker -A pyros -Q create_calibrations_q --purge -n pyros@create_calibrations -c 1")
+        self.execProcessFromVenvAsync(self.venv_cel + " worker -A pyros -Q analysis_q --purge -n pyros@analysis -c 1")
+        self.execProcessFromVenvAsync(self.venv_cel + " worker -A pyros -Q system_status_q --purge -n pyros@system_status -c 1")
+        self.execProcessFromVenvAsync(self.venv_cel + " worker -A pyros -Q change_obs_conditions_q --purge -n pyros@change_obs_conditions -c 1")
+        self.changeDirectory("..")
+        return 0
+
+    def start(self):
+        self.stop()
+        self.celery_on()
+        return 0
+
+    def stop(self):
+        self.execProcessAsync("ps aux | grep \"celery worker\" | awk '{print $2}' | xargs kill -9")
+        return 0
+
+    def simulator(self):
+        self.changeDirectory("src")
+        self.replacePatternInFile("CELERY_TEST = True", "CELERY_TEST = False", "pyros/settings.py")
+        self.execProcess("rm -f testdb.sqlite3")
+        self.changeDirectory("..")
+        self.migrate()
+        self.loaddata()
+        self.server()
+        self.sleep(2)
+        self.printFullTerm(Colors.WARNING, "SUMMARY")
+        self.printColor(Colors.GREEN, "The simulator has been successfully initialised")
+        self.printColor(Colors.GREEN, "The simulator run on a temp database : src/testdb.sqlite3")
+        self.printColor(Colors.GREEN, "The simulation will be ended by the task 'simulator herself'")
+        self.printColor(Colors.GREEN, "If you want to shutdown the simulation, please run :")
+        self.printColor(Colors.GREEN, "CTRL-C or ./pyrosrun.sh kill_simulation")
+        self.printColor(Colors.GREEN, "If the simulation isn't correctly killed, please switch the variable")
+        self.printColor(Colors.GREEN, "CELERY_TEST in src/pyros/settings.py to false")
+        self.printFullTerm(Colors.WARNING, "SUMMARY")
+        self.celery_on()
+        self.sleep(3)
+        self.sims_launch()
+        return 0
+
+    def kill_simulation(self):
+        self.changeDirectory("src")
+        self.replacePatternInFile("CELERY_TEST = True", "CELERY_TEST = False", "pyros/settings.py")
+        self.execProcessAsync("fuser -k 8000/tcp")
+        self.execProcessAsync("rm -f testdb.sqlite3")
+        self.execProcessAsync("ps aux | grep \" userSimulator.py\" | awk '{ print $2 }' | xargs kill")
+        self.execProcessAsync("ps aux | grep \" alertSimulator.py\" | awk '{ print $2 }' | xargs kill")
+        self.execProcessAsync("ps aux | grep \" plcSimulator.py\" | awk '{ print $2 }' | xargs kill")
+        self.execProcessAsync("ps aux | grep \" telescopeSimulator.py\" | awk '{ print $2 }' | xargs kill")
+        self.execProcessAsync("ps aux | grep \" cameraNIRSimulator.py\" | awk '{ print $2 }' | xargs kill")
+        self.execProcessAsync("ps aux | grep \" cameraVISSimulator.py\" | awk '{ print $2 }' | xargs kill")
+        self.changeDirectory("..")
+        self.stop()
+        self.printFullTerm(Colors.GREEN, "simulation ended")
+        return 0
+
+    def sims_launch(self):
+        self.changeDirectory("simulators/config")
+        self.execProcess("ls conf*.json")
+        conf = self.askQuestion("Which simulation do you want to use", default="conf.json")
+        if not os.path.isfile(conf):
+            self.printColor(Colors.FAIL, "The simulation file " + conf + " does not exist")
+            return 1
+        self.changeDirectory("..")
+        self.changeDirectory("user")
+        self.execProcessFromVenvAsync(self.venv_bin + " userSimulator.py " + conf)
+        self.changeDirectory("..")
+        self.changeDirectory("alert")
+        self.execProcessFromVenvAsync(self.venv_bin + " alertSimulator.py " + conf)
+        self.changeDirectory("..")
+        self.changeDirectory("plc")
+        self.execProcessFromVenvAsync(self.venv_bin + " plcSimulator.py " + conf)
+        self.changeDirectory("..")
+        self.changeDirectory("camera")
+        self.execProcessFromVenvAsync(self.venv_bin + " cameraVISSimulator.py " + conf)
+        self.execProcessFromVenvAsync(self.venv_bin + " cameraNIRSimulator.py " + conf)
+        self.changeDirectory("..")
+        self.changeDirectory("telescope")
+        self.execProcessFromVenvAsync(self.venv_bin + " telescopeSimulator.py " + conf)
+        self.changeDirectory("..")
+        self.changeDirectory("..")
+        return 0
+
+    def singleWorker(self, worker):
+        self.changeDirectory("src")
+        self.execProcessFromVenvAsync(self.venv_cel + " worker -A pyros -Q "+ worker +"_q -n pyros@"+worker+" -c 1")
+        self.changeDirectory("..")
+        return 0
+
+    def __init__(self, argv):
+        super(Pyros, self).__init__(argv)
+        self.commandMatcher = {
+            "install": self.install,
+            "update": self.update,
+            "server": self.server,
+            "clean": self.clean,
+            "clean_logs": self.clean_logs,
+            "test": self.test,
+            "migrate": self.migrate,
+            "makemigrations": self.makemigrations,
+            "updatedb": self.updatedb,
+            "unittest": self.unittest,
+            "test_all": self.test_all,
+            "celery_on": self.celery_on,
+            "loaddata": self.loaddata,
+            "start": self.start,
+            "stop": self.stop,
+            "simulator": self.simulator,
+            "kill_simulation": self.kill_simulation,
+            "sims_launch": self.sims_launch,
+            "help": self.help,
+        }
+        self.commandDescription = {
+            "install": "Launch the server installation",
+            "update": "Update the server",
+            "server": "Launch the web server",
+            "loaddata": "Load the initial fixture in database",
+            "clean": "clean the repository",
+            "clean_logs": "clean the log directory",
+            "test": "launch the server tests",
+            "migrate": "execute migrations",
+            "makemigrations": "create new migrations",
+            "help": "Help message",
+            "updatedb": "Update the database",
+            "unittest": "Runs the tests thaht don't need celery",
+            "test_all": "Run all the existing tests (this command needs to be updated when tests are added in the project",
+            "celery_on": "Starts celery workers",
+            "start": "Stop the celery workers then the web server",
+            "stop": "stops the celery workers",
+            "simulator": "Launch a simulation",
+            "kill_simulation": "kill the simulators / celery workers / web server",
+            "sims_launch": "Launch only the simulators",
+        }
+
+if __name__ == "__main__":
+    conf = Config()
+    if conf.parseConf():
+        sys.exit(1)
+    pyros = Pyros(conf)
+    sys.exit(pyros.exec())
 \ No newline at end of file
@@ -10,7 +10,7 @@ class UserSimulator():
     conf_file = "../config/conf.json"
     conf_path = "../config/"
     request_path = "../resources/"
-    login = "http://localhost:8000/user_manager/login" # 
+    login = "http://localhost:8000/user_manager/login"
     url = "http://localhost:8000/routine_manager/import_request"
     get_url = "http://localhost:8000/routine_manager/"
     sims = []
@@ -51,16 +51,22 @@ class UserSimulator():
  
     def authenticate(self):
         self.client = requests.session()
-        self.client.get("http://localhost:8000/user_manager/login")
-        csrftoken = self.client.cookies['csrftoken']
-        self.logindata = dict(email="pyros", password="DjangoPyros", csrfmiddlewaretoken=csrftoken)
-        resp = self.client.post(self.login, data=self.logindata, headers=dict(Referer=self.login))
-        self.userPrint("Connection status : %d"%(resp.status_code))
+        try:
+            self.client.get("http://localhost:8000/user_manager/login")
+            csrftoken = self.client.cookies['csrftoken']
+            self.logindata = dict(email="pyros", password="DjangoPyros", csrfmiddlewaretoken=csrftoken)
+            resp = self.client.post(self.login, data=self.logindata, headers=dict(Referer=self.login))
+            self.userPrint("Connection status : %d"%(resp.status_code))
+        except Exception as e:
+            print(e, file=sys.stderr)
+            return 1
+        return 0
  
     def run(self):
         i = 0
         self.parse()
-        self.authenticate()
+        if self.authenticate():
+            return 1
         self.userPrint("The simulator will end in %d seconds"%(int(self.ended)))
         while (i < self.ended):
             for dic in self.sims:
@@ -72,4 +78,4 @@ class UserSimulator():
  
 if (__name__ == "__main__"):
     sim = UserSimulator(sys.argv)
-    sim.run()
+    sys.exit(sim.run())