Implémenté la commande "restart_init"

(voir doc "play with a pyros agent" pour voir comment redémarrer un agent)

Implémenté la commande "restart_init"
(voir doc "play with a pyros agent" pour voir comment redémarrer un agent)
Etienne Pallier
1 parent 03161a45
Showing 3 changed files with 140 additions and 112 deletions Show diff stats
README.md
src/agent/Agent.py
src/common/models.py
@@ -73,7 +73,7 @@ Author: E. Pallier
  
 VERSION: 0.20.32
  
-Comment: Implémenté le "abort" dans le simulateur
+Comment: Implémenté la commande "restart_init" (voir doc "play with a pyros agent")
  
 	- Scenario de test :
 		- lancer agents A et B en mode simu (option -t): ./pyros.py -t start agentA,agentB
@@ -87,7 +87,8 @@ Comment: Implémenté le &quot;abort&quot; dans le simulateur
 		(ou encore: activer l'environnement virtuel, puis lancer "cd src/agent/ ; ./AgentA.py configfile")
 		- pour utiliser thread ou processus : il suffit de mettre la constante RUN_IN_THREAD de AgentA (ou AgentB ou AgentX) à False ou True
  
-	- Historique des nouveautés :
+	- Historique des nouveautés implémentées :
+		- Implémenté le "abort" dans le simulateur
 		- Optimisation log_agent_status() (ex update_survey())
 		- AgentM (début) pour remplacer progressivement l'agent monitoring
 		- routine_process() : envoi commande n'est plus bloquant
@@ -475,122 +475,140 @@ class Agent:
         else:
             time.sleep(nbsec)
  
-    def run(self, nb_iter=None, FOR_REAL: bool = True):
+    def run(self, nb_iter:int=None, FOR_REAL:bool=True):
         """
             FOR_REAL: set to False if you don't want Majordome to send commands to devices
         """
  
-        self.load_config()
+        self.DO_EXIT = False
+        self.DO_RESTART = True
  
-        if self.SIMULATOR_MODE:
-            self._log.print("[IN SIMULATOR MODE]")
-        else:
-            self._log.print("[IN NORMAL MODE]")
-            self.SIMULATOR_MAX_DURATION_SEC=None 
-
-        start_time = time.time()
-
-        self.FOR_REAL = FOR_REAL
-
-        self.init()
+        # Will loop again only if DO_RESTART is True
+        while self.DO_RESTART:
+            self.DO_RESTART = False
  
-        # Avoid blocking on false "running" commands
-        # (old commands that stayed with "running" status when agent was killed)
-        Command.delete_commands_with_running_status_for_agent(self.name)
+            self.load_config()
  
-        # SIMULATOR MODE ONLY : flush previous commands to be sure to restart clean
-        if self.SIMULATOR_MODE:
-            self.print("flush previous commands to be sure to start in clean state")
-            Command.delete_pending_commands_for_agent(self.name)
-
-        '''
-        # SETUP
-        try:
-            self.config = get_object_or_404(Config, id=1)
-            # By default, set mode to SCHEDULER (False = REMOTE, which should never be the default)
-            self.config.global_mode = True
-            self.config.save()
-            # self.config = Config.objects.get(pk=1)
-            # self.config = Config.objects.get()[0]
-        except Exception as e:
-            # except Config.ObjectDoesNotExist:
-            self.printd("Config read (or write) exception", str(e))
-            return -1
-        '''
+            if self.SIMULATOR_MODE:
+                self._log.print("[IN SIMULATOR MODE]")
+            else:
+                self._log.print("[IN NORMAL MODE]")
+                self.SIMULATOR_MAX_DURATION_SEC=None 
+            self.start_time = time.time()
+            self.FOR_REAL = FOR_REAL
+
+            self.init()
+
+            # Avoid blocking on false "running" commands
+            # (old commands that stayed with "running" status when agent was killed)
+            Command.delete_commands_with_running_status_for_agent(self.name)
+            # SIMULATOR MODE ONLY : flush previous commands to be sure to restart clean
+            if self.SIMULATOR_MODE:
+                self.print("flush previous commands to be sure to start in clean state")
+                Command.delete_pending_commands_for_agent(self.name)
+
+            '''
+            # SETUP
+            try:
+                self.config = get_object_or_404(Config, id=1)
+                # By default, set mode to SCHEDULER (False = REMOTE, which should never be the default)
+                self.config.global_mode = True
+                self.config.save()
+                # self.config = Config.objects.get(pk=1)
+                # self.config = Config.objects.get()[0]
+            except Exception as e:
+                # except Config.ObjectDoesNotExist:
+                self.printd("Config read (or write) exception", str(e))
+                return -1
+            '''
+
+            self._iter_num = 1
+            self.DO_MAIN_LOOP = True
+            # Main loop
+            while self.DO_MAIN_LOOP:
+                try:
+                    self.main_loop(nb_iter,FOR_REAL)
+                    if not self.DO_MAIN_LOOP: break
+                except KeyboardInterrupt:
+                    # In case of CTRL-C, kill the current thread (process) before dying (in error)
+                    self.print("CTRL-C Interrupted, I kill the current thread (process) before exiting")
+                    self.kill_running_specific_cmd_if_exists()
+                    exit(1)
+            #if self.DO_EXIT: exit(0)
+
+
+
+    def main_loop(self, nb_iter:int=None, FOR_REAL:bool=True):
+
+        # Bad number of iterations, so exit
+        if nb_iter is not None:
+            if nb_iter <= 0:
+                self.DO_MAIN_LOOP = False 
+                return
+            # Number of iterations asked is reached, so exit
+            if self._iter_num > nb_iter:
+                print(f"Exit because number of iterations asked ({nb_iter}) has been reached") 
+                self.DO_MAIN_LOOP = False 
+                return
+
+        self.print()
+        self.print()
+        #self.printd("-"*80)
+        self.print("-"*20, f"MAIN LOOP ITERATION {self._iter_num} (START)", "-"*20)
+        self.set_status(self.STATUS_MAIN_LOOP)
+        self.show_mode_and_status()
+
+        # Wait a random number of sec before starting iteration
+        # (to let another agent having the chance to send a command before me)
+        random_waiting_sec = random.randint(0,5)
+        self.print(f"Waiting {random_waiting_sec} sec (random) before starting new iteration...")
+        time.sleep(random_waiting_sec)
+
+        self.load_config() # only if changed
+
+        # Log this agent status (update my current mode and status in DB)
+        self.log_agent_status()
+
+        self.printd("------START COMMMAND PROCESSING------")
+
+        # Purge commandes (every N iterations, delete old commands)
+        N=3
+        if ((self._iter_num-1) % N) == 0:
+            self.print("Looking for old commands to purge...")
+            #Command.purge_old_commands_for_agent(self.name)
+            self.purge_old_commands_sent_to_me()
+
+        # ROUTINE process
+        #if self.is_active(): 
+        self.routine_process()
+        #self.printd("I am IDLE, so I bypass the routine_process (do not send any new command)")
+
+        # Get next command to execute
+        cmd = self.get_next_valid_command()
+        #if cmd: cmd = self.general_process(cmd)
+        # Process this (next) command (if exists)
+        if cmd: cmd = self.command_process(cmd)
+        # if restart, exit this loop to restart from beginning
+        if self.DO_RESTART or self.DO_EXIT:
+            self.DO_MAIN_LOOP = False 
+            return
  
-        self._iter_num = 1
-        # Main loop
-        while True:
+        self.printd("------END COMMMAND PROCESSING------")
  
-            try:
+        #self.waitfor(self.mainloop_waittime)
  
-                # Bad number of iterations, so exit
-                if nb_iter is not None:
-                    if nb_iter <= 0: break
-                    # Number of iterations asked is reached, so exit
-                    if self._iter_num > nb_iter:
-                        print(f"Exit because number of iterations asked ({nb_iter}) has been reached") 
-                        break
-
-                self.print()
-                self.print()
-                #self.printd("-"*80)
-                self.print("-"*20, f"MAIN LOOP ITERATION {self._iter_num} (START)", "-"*20)
-                self.set_status(self.STATUS_MAIN_LOOP)
-                self.show_mode_and_status()
-
-                # Wait a random number of sec before starting iteration
-                # (to let another agent having the chance to send a command before me)
-                random_waiting_sec = random.randint(0,5)
-                self.print(f"Waiting {random_waiting_sec} sec (random) before starting new iteration...")
-                time.sleep(random_waiting_sec)
-
-                self.load_config() # only if changed
-
-                # Log this agent status (update my current mode and status in DB)
-                self.log_agent_status()
-
-                self.printd("------START COMMMAND PROCESSING------")
-
-                # Purge commandes (every N iterations, delete old commands)
-                N=3
-                if ((self._iter_num-1) % N) == 0:
-                    self.print("Looking for old commands to purge...")
-                    #Command.purge_old_commands_for_agent(self.name)
-                    self.purge_old_commands_sent_to_me()
-
-                # ROUTINE process
-                #if self.is_active(): 
-                self.routine_process()
-                #self.printd("I am IDLE, so I bypass the routine_process (do not send any new command)")
-
-                # Get next command to execute
-                cmd = self.get_next_valid_command()
-                #if cmd: cmd = self.general_process(cmd)
-                # Process this (next) command (if exists)
-                if cmd: cmd = self.command_process(cmd)
-
-                self.printd("------END COMMMAND PROCESSING------")
-
-                #self.waitfor(self.mainloop_waittime)
-
-                self.print("-"*20, "MAIN LOOP ITERATION (END)", "-"*20)
-                #self.do_log(LOG_DEBUG, "Ending main loop iteration")
-
-                # (simulator only) Exit if max duration is reached
-                if self.SIMULATOR_MAX_DURATION_SEC and (time.time()-start_time > self.SIMULATOR_MAX_DURATION_SEC):
-                    self.print("Exit because of max duration set to ", self.SIMULATOR_MAX_DURATION_SEC, "s")
-                    self.kill_running_specific_cmd_if_exists()
-                    if self.SIMULATOR_MODE and self.SIMULATOR_WITH_TEST: self.simulator_test_results()
-                    break
+        self.print("-"*20, "MAIN LOOP ITERATION (END)", "-"*20)
+        #self.do_log(LOG_DEBUG, "Ending main loop iteration")
  
-                self._iter_num += 1
+        # (simulator only) Exit if max duration is reached
+        if self.SIMULATOR_MAX_DURATION_SEC and (time.time()-self.start_time > self.SIMULATOR_MAX_DURATION_SEC):
+            self.print("Exit because of max duration set to ", self.SIMULATOR_MAX_DURATION_SEC, "s")
+            self.kill_running_specific_cmd_if_exists()
+            if self.SIMULATOR_MODE and self.SIMULATOR_WITH_TEST: self.simulator_test_results()
+            self.DO_MAIN_LOOP = False
+            return
  
-            except KeyboardInterrupt:
-                # In case of CTRL-C, kill the current thread (process) before dying (in error)
-                self.print("CTRL-C Interrupted, I kill the current thread (process) before exiting")
-                self.kill_running_specific_cmd_if_exists()
-                exit(1)
+        self._iter_num += 1
  
  
  
@@ -932,7 +950,8 @@ class Agent:
                 Command.show_commands(commands)
                 #if self.SIMULATOR_MODE and self.SIMULATOR_WITH_TEST and self.SIMULATOR_COMMANDS_DEST == "myself": self.simulator_test_results()
                 if self.SIMULATOR_MODE and self.SIMULATOR_WITH_TEST: self.simulator_test_results()
-                exit(0)
+                #self.DO_EXIT=True
+                #exit(0)
             # Command is executed, so return None
             return None
  
@@ -957,23 +976,27 @@ class Agent:
         cmd.set_as_running()
  
         # Executing command
-        if cmd.name == "go_active": 
+        if cmd.name == "go_active":
             self.set_active()
             cmd.set_result("I am now active")
             time.sleep(1)
-        elif cmd.name == "go_idle": 
+        elif cmd.name == "go_idle":
             self.set_idle()
             cmd.set_result("I am now idle")
             time.sleep(1)
         elif cmd.name in ("flush_commands"):
             self.print("flush_commands received: Delete all pending commands")
             Command.delete_pending_commands_for_agent(self.name)
-        # If cmd is "abort" or "exit", kill any currently running thread
-        elif cmd.name in ("abort", "exit"):
+        elif cmd.name in ("abort", "exit", "restart_init"):
             #self.printd("Current pending commands are:")
             #Command.show_commands(self._pending_commands)
             self.print("Aborting current executing command if exists:")
             self.kill_running_specific_cmd_if_exists()
+            if cmd.name == "restart_init":
+                self.print("restart_init received: Restarting from init()")
+                self.DO_RESTART=True
+            elif cmd.name == "exit":
+                self.DO_EXIT=True
         else:
             name = cmd.name
             args = None
@@ -348,7 +348,11 @@ class Command(models.Model):
         "CMD_KILLED", # cde ignorée (je suis idle… et j’ai ignoré cette commande, et je passe à la cde suivante) 
         "CMD_OUTOFDATE" # cde périmée 
     )
-    GENERIC_COMMANDS = ["eval", "go_idle", "go_active", "flush_commands", "abort", "exit", "restart_init"]
+    GENERIC_COMMANDS = [
+        "eval", "go_idle", "go_active",
+        # Commands executed in priority (even if other pending commands exist) 
+        "flush_commands", "abort", "exit", "restart_init"
+    ]
     #COMMANDS_PEREMPTION_HOURS = 48
     COMMANDS_PEREMPTION_HOURS = 60/60
     COMMANDS_VALIDITY_DURATION_SEC_DEFAULT = 30