pyros.py peut lancer plusieurs agents (A et B) en même temps...

- Mode opératoire : - pour lancer agentA seulement : ./pyros.py start agentA [-c configfile] - pour lancer plusieurs agents : ./pyros.py start agentA,agentB,... [-c configfile] (ou encore: activer l'environnement virtuel, puis lancer "./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 - Scenario de test : - lancer agents A et B : ./pyros.py start agentA,agentB - attendre 1mn et attendre les 2 résultats suivants: (AgentA): Finished testing => result is ok (AgentB): Finished testing => result is ok - Autres remarques: - Nouvelle commande "flush_commands" pour purger les commmandes en attente - routine_process() implemented - Eval command implemented - Timeout géré : si commande pas exécutée en temps raisonnable => la même commande est ré-exéuctée à l'itération suivante - Chaque agent a son propre scenario de commandes à envoyer - GROSSE OPTIMISATION : plus besoin du script intermédiaire "start_agent.py" !!! ==> pyros.py lance directement "cd src/agent/ ; python AgentX.py"

pyros.py peut lancer plusieurs agents (A et B) en même temps...
- Mode opératoire : - pour lancer agentA seulement : ./pyros.py start agentA [-c configfile] - pour lancer plusieurs agents : ./pyros.py start agentA,agentB,... [-c configfile] (ou encore: activer l'environnement virtuel, puis lancer "./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 - Scenario de test : - lancer agents A et B : ./pyros.py start agentA,agentB - attendre 1mn et attendre les 2 résultats suivants: (AgentA): Finished testing => result is ok (AgentB): Finished testing => result is ok - Autres remarques: - Nouvelle commande "flush_commands" pour purger les commmandes en attente - routine_process() implemented - Eval command implemented - Timeout géré : si commande pas exécutée en temps raisonnable => la même commande est ré-exéuctée à l'itération suivante - Chaque agent a son propre scenario de commandes à envoyer - GROSSE OPTIMISATION : plus besoin du script intermédiaire "start_agent.py" !!! ==> pyros.py lance directement "cd src/agent/ ; python AgentX.py"
Etienne Pallier
1 parent 7d679ea0
Showing 7 changed files with 349 additions and 205 deletions Show diff stats
README.md
pyros.py
src/agent/Agent.py
src/agent/AgentA.py
src/agent/AgentB.py
src/agent/AgentX.py
src/common/models.py
@@ -74,18 +74,28 @@ Author: E. Pallier
 VERSION: 0.20.22
 Comment:
-	Multi-agents (2 agents) : AgentA (sender) sends commands to AgentB (receiver, and sender too)
-	
-	- Eval command
-	- Timeout géré si commande pas exécutée en temps raisonnable : la même commande est ré-exéuctée à l'itération suivante
-	- AgentA (et AgentB) a son propre scenario de commandes à envoyer à AgentB
-	- Mode opératoire pour lancer un agent:
-		- pour démarrer agentA : ./pyros.py start agentA [-c configfile]
+	pyros.py peut lancer plusieurs agents (A et B) en même temps (+ flush_commands + test)
+
+	- Mode opératoire :
+		- pour lancer agentA seulement : ./pyros.py start agentA [-c configfile]
+		- pour lancer plusieurs agents : ./pyros.py start agentA,agentB,... [-c configfile]
 		(ou encore: activer l'environnement virtuel, puis lancer "./AgentA.py configfile")
-		- pour démarrer agentB : ouvrir un autre terminal et taper "./pyros.py start agentB"
 		- pour utiliser thread ou processus : il suffit de mettre la constante RUN_IN_THREAD de AgentA (ou AgentB ou AgentX) à False ou True
-	- GROSSE OPTIMISATION : plus besoin du script intermédiaire "start_agent.py" !!!
-	==> pyros.py lance directement "cd src/agent/ ; python AgentX.py"
+		
+	- Scenario de test :
+		- lancer agents A et B : ./pyros.py start agentA,agentB
+		- attendre 1mn et attendre les 2 résultats suivants:
+		(AgentA): Finished testing => result is ok
+		(AgentB): Finished testing => result is ok
+	
+	- Autres remarques:
+		- Nouvelle commande "flush_commands" pour purger les commmandes en attente
+		- routine_process() implemented
+		- Eval command implemented
+		- Timeout géré : si commande pas exécutée en temps raisonnable => la même commande est ré-exéuctée à l'itération suivante
+		- Chaque agent a son propre scenario de commandes à envoyer
+		- GROSSE OPTIMISATION : plus besoin du script intermédiaire "start_agent.py" !!!
+			==> pyros.py lance directement "cd src/agent/ ; python AgentX.py"
 --------------------------------------------------------------------------------------------
 - TECHNICAL DOC: tinyurl.com/pyros-doc
@@ -123,6 +123,10 @@ def execProcess(command, from_venv=False, is_async=False):
     printFullTerm(Colors.BLUE, "Executing command" + " [" + command + "]" + from_venv_str)
     if from_venv: command = VENV_BIN+' ' + command
     process = subprocess.Popen(command, shell=True)
+    if is_async:
+        #current_processes.append(process)
+        return process
+    # Not is_async => Wait for end of execution
     process.wait()
     if process.returncode == 0:
         printFullTerm(Colors.GREEN, "Process executed successfully")
@@ -133,11 +137,14 @@ def execProcess(command, from_venv=False, is_async=False):
     #return process.returncode
     return True if process.returncode==0 else False
-def execProcessFromVenv(command:str):
-    return execProcess(command, from_venv=True)
+def execProcessFromVenv(command:str, is_async=False):
+    #return execProcess(command, from_venv=True, is_async)
+    return execProcess(command, True, is_async)
 #TODO: fusionner dans execProcess avec param is_async
 def execProcessFromVenvAsync(command:str):
+    return execProcessFromVenv(command, True)
+    """
     args = command.split()
     printFullTerm(
         Colors.BLUE, "Executing command from venv [" + str(" ".join(args[1:])) + "]"
@@ -148,7 +155,7 @@ def execProcessFromVenvAsync(command:str):
     # self.addExecuted(self.current_command, str(' '.join(args[1:])))
     # p.wait()
     return p
-
+    """
 def printColor(color: Colors, message, file=sys.stdout, eol=os.linesep, forced=False):
     #system = platform.system()
@@ -336,23 +343,16 @@ def start(agent:str, configfile:str):
             if not _check_agent(a): return
         print("Agents are:", agents)
     # 1 agent only
-    elif not _check_agent(agent): return
-    # VENV_BIN = 'private/venv_py3_pyros' +  os.sep + self.b_in_dir + os.sep + self.bin_name
-
-
-    # Start Agents
-    """            
-    if agent=="majordome" or agent=="all":
-        from majordome.tasks import Majordome
-        Majordome().run()
-    if agent=="alert_manager" or agent=="all":
-        from alert_manager.tasks import AlertListener
-        AlertListener().run()
-    """
+    else:
+        agents = [agent]
+        if not _check_agent(agent): return
+
+    # Start Agents (processes)
+    current_processes = []
     for agent_name,agent_folder in AGENTS.items():
-        if agent in ("all", agent_name) :
-            
+        #if agent in ("all", agent_name) :
+        if agent=="all" or agent_name in agents:
             # Default case, launch agentX
             #if agent_name == "agentX":
@@ -362,6 +362,8 @@ def start(agent:str, configfile:str):
             #if not test_mode(): execProcess(VENV_BIN + " manage.py runserver")
             #if not test_mode(): execProcessFromVenv("start_agent_" + agent_name + ".py " + configfile)
+            current_dir = os.getcwd()
+
             # OLD format agents: majordome, monitoring, alert...
             cmd = "start_agent.py " + agent_name + " " + configfile
@@ -379,39 +381,29 @@ def start(agent:str, configfile:str):
                 #cmd = "-m AgentX"
                 cmd = f" Agent{agent_name[5:]}.py {configfile}"
-            if not test_mode(): execProcessFromVenv(cmd)
+            #if not test_mode(): execProcessFromVenv(cmd)
+            if not test_mode(): current_processes.append( (execProcessFromVenvAsync(cmd), agent_name) )
             # self._change_dir("..")
+            os.chdir(current_dir)
-            '''
-            # Any other agent
-            else:
-                # Go into src/
-                # self._change_dir("src")
-                os.chdir("src")
-                # print("Current directory : " + str(os.getcwd()))
-                if agent_name != "webserver": os.chdir(agent_folder)
-                # self.execProcessFromVenvAsync(self.VENV_BIN + ' start_agent_'+agent+'.py')
-                #print(VENV_BIN)
-                print("Launching agent", agent_name, "...")
-                #if not test_mode(): execProcess(VENV_BIN + " start_agent_" + agent_name + ".py")
-                #TODO:
-                # - start_agent agent_name (1 script unique)
-                # - start_agent -c configfile
-                cmd = "start_agent_" + agent_name + ".py " + configfile
-                # Django default dev web server
-                if agent_name == "webserver": cmd = "manage.py runserver"
-                if not test_mode(): execProcessFromVenv(cmd)
-                # Go back to src/
-                # self._change_dir('..')
-                os.chdir("..")
-            '''
-                
     # Go back to root folder (/)
     # self._change_dir('..')
-    os.chdir("..")
-    return True
-
-
+    #os.chdir("..")
+    # Wait for end of each process execution
+    for (p,agent) in current_processes:
+        print(f"************ Waiting for end of execution of agent {agent} ************")
+        p.wait()
+        print(f"************ END of execution of agent {agent} ************")
+        if p.returncode == 0:
+            printFullTerm(Colors.GREEN, f"Process {agent} executed successfully")
+            # self.addExecuted(self.current_command, command)
+        else:
+            printFullTerm(Colors.WARNING, f"Process {agent} execution failed")
+            # self.addError(self.current_command, command)
+    
+    #print("************ end of START() ************")
+    # Only according to the last process status:
+    return True if p.returncode==0 else False
 @pyros_launcher.command(help="Kill an agent")
@@ -44,7 +44,7 @@ sys.path.append(&quot;../..&quot;)
 print("Starting with this sys.path", sys.path)
 # DJANGO setup
-# print("file is", __file__)
+# self.print("file is", __file__)
 # mypath = os.getcwd()
 # Go into src/
 ##os.chdir("..")
@@ -160,7 +160,7 @@ class Agent:
     SIMULATOR_COMMANDS_DEST = "myself"
     # Default scenario to be executed
     #SIMULATOR_COMMANDS = iter([
-    SIMULATOR_COMMANDS = [
+    SIMULATOR_COMMANDS_LIST = [
         "go_active",
         "go_idle",
@@ -210,6 +210,8 @@ class Agent:
         "go_active",
         "specific10"
     ]
+    #SIMULATOR_COMMANDS = iter(SIMULATOR_COMMANDS_LIST)
+
     """
@@ -290,25 +292,25 @@ class Agent:
     def __init__(self, name:str="Agent", config_filename:str=None, RUN_IN_THREAD=True):
         self.name = name
-        self.SIMULATOR_COMMANDS = iter(self.SIMULATOR_COMMANDS)
+        self.SIMULATOR_COMMANDS = iter(self.SIMULATOR_COMMANDS_LIST)
         self.RUN_IN_THREAD = RUN_IN_THREAD
         self.set_status(self.STATUS_LAUNCH)
         self.set_mode(self.MODE_IDLE)
         if not config_filename:
             config_filename = self.DEFAULT_CONFIG_FILE_NAME
-            
-        print(f"config_filename={config_filename}")
+
+        self.print(f"config_filename={config_filename}")
         # If config file name is RELATIVE (i.e. without path, just the file name)
         # => give it an absolute path (and remove "src/agent/" from it)
         if config_filename == os.path.basename(config_filename):
             tmp = os.path.abspath(self.CONFIG_DIR + os.sep + config_filename)
             config_filename = os.path.abspath(self.CONFIG_DIR + os.sep + config_filename).replace(os.sep+"src"+os.sep,os.sep).replace(os.sep+"agent"+os.sep,os.sep)
-        print("Config file used is", config_filename)
-        #print("current path", os.getcwd())
-        #print("this file path :", __file__)
-        #print("config file path is", config_filename)
+        self.print("Config file used is", config_filename)
+        #self.print("current path", os.getcwd())
+        #self.print("this file path :", __file__)
+        #self.print("config file path is", config_filename)
         # Instantiate an object for configuration
-        #print("config file path is ", config_abs_filename)
+        #self.print("config file path is ", config_abs_filename)
         self.config = ConfigPyros(config_filename)
         if self.config.get_last_errno() != self.config.NO_ERROR:
             raise Exception(f"Bad config file name '{config_filename}', error {str(self.config.get_last_errno())}: {str(self.config.get_last_errmsg())}")
@@ -324,7 +326,7 @@ class Agent:
         #if nb_agents == 0:
         if not AgentSurvey.objects.filter(name=self.name).exists():
             self._agent_survey = AgentSurvey.objects.create(name=self.name, validity_duration_sec=60, mode=self.mode, status=self.status)
-            print("Agent survey is", self._agent_survey)
+            self.print("Agent survey is", self._agent_survey)
             #self._agent_survey = AgentSurvey(name=self.name, validity_duration_sec=60, mode=self.mode, status=self.status)
             #self._agent_survey.save()
@@ -332,6 +334,14 @@ class Agent:
     def __str__(self):
         return "I am agent " + self.name
+    #def print(self, msg):
+    def print(self, *args, **kwargs):
+        #print(f"({self.name}): ", msg)
+        if args:
+            print(f"({self.name}): ", *args, **kwargs)
+        else:
+            print()
+
     def sleep(self, nbsec:float=2.0):
         # thread
         if self._current_specific_thread and self.RUN_IN_THREAD:
@@ -355,13 +365,13 @@ class Agent:
         # Avoid blocking on false "running" commands
         # (old commands that stayed with "running" status when agent was killed)
-        Command.delete_commands_with_running_status_if_exists_for_agent(self.name)
+        Command.delete_commands_with_running_status_for_agent(self.name)
         '''
-        print()
-        print(self)
-        print("FOR REAL ?", self.FOR_REAL)
-        print("DB3 used is:", djangosettings.DATABASES["default"]["NAME"])
+        self.print()
+        self.print(self)
+        self.print("FOR REAL ?", self.FOR_REAL)
+        self.print("DB3 used is:", djangosettings.DATABASES["default"]["NAME"])
         # SETUP
         try:
@@ -373,7 +383,7 @@ class Agent:
             # self.config = Config.objects.get()[0]
         except Exception as e:
             # except Config.ObjectDoesNotExist:
-            print("Config read (or write) exception", str(e))
+            self.print("Config read (or write) exception", str(e))
             return -1
         '''
@@ -383,15 +393,15 @@ class Agent:
             # Wait a random number of sec before starting new iteration
             # (to let another agent having the chance to send a command)
             random_waiting_sec = random.randint(0,5)
-            print(f"Waiting {random_waiting_sec} sec (random) before starting new iteration...")
+            self.print(f"Waiting {random_waiting_sec} sec (random) before starting new iteration...")
             time.sleep(random_waiting_sec)
             try:
-                print()
-                print()
-                #print("-"*80)
-                print("-"*20, f"MAIN LOOP ITERATION {self._iter_num} (START)", "-"*20)
+                self.print()
+                self.print()
+                #self.print("-"*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()
@@ -402,7 +412,7 @@ class Agent:
                 #if self.SIMULATOR_MODE: self.simulator_send_next_command()
                 # generic cmd in json format
-                print("------START COMMMAND PROCESSING------")
+                self.print("------START COMMMAND PROCESSING------")
                 cmd = self.get_next_valid_command()
                 #if cmd: cmd = self.general_process(cmd)
                 if cmd: cmd = self.command_process(cmd)
@@ -412,32 +422,33 @@ class Agent:
                     if cmd: self.specific_process(cmd)
                 '''
                 self.routine_process()
-                print("------END COMMMAND PROCESSING------")
+                self.print("------END COMMMAND PROCESSING------")
                 # Every N iterations, delete old commands
                 N=3
-                if ((self._iter_num-1) % N) == 0: Command.purge_old_commands_for_agent(self.name)
+                if ((self._iter_num-1) % N) == 0:
+                    self.print("Looking for old commands to purge...")
+                    Command.purge_old_commands_for_agent(self.name)
                 #self.waitfor(self.mainloop_waittime)
-                print("-"*20, "MAIN LOOP ITERATION (END)", "-"*20)
-                #print("-"*80)
+                self.print("-"*20, "MAIN LOOP ITERATION (END)", "-"*20)
+                #self.print("-"*80)
                 #self.do_log(LOG_DEBUG, "Ending main loop iteration")
                 self._iter_num += 1
                 # Exit if max duration is timed out
-                if self.MAX_DURATION_SEC:
-                    #print ("time", time.time()-start_time)
-                    if time.time()-start_time > self.MAX_DURATION_SEC:
-                        print("Exit because of max duration set to ", self.MAX_DURATION_SEC, "s")
-                        self.kill_running_specific_cmd_if_exists() 
-                        break
+                if self.MAX_DURATION_SEC and (time.time()-start_time > self.MAX_DURATION_SEC):
+                    self.print("Exit because of max duration set to ", self.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
             except KeyboardInterrupt:
                 # In case of CTRL-C, kill the current thread (process) before dying (in error)
-                print("CTRL-C Interrupted, I kill the current thread (process) before exiting")
+                self.print("CTRL-C Interrupted, I kill the current thread (process) before exiting")
                 self.kill_running_specific_cmd_if_exists()
                 exit(1)
@@ -467,7 +478,7 @@ class Agent:
         if self.cmdts is None: return
         # 1) Send cmd
-        print(f"Send command", self.cmdts)
+        self.print(f"Send command", self.cmdts)
         self.cmdts.send()
         cmdts_is_processed = False
         cmdts_res = None
@@ -475,7 +486,7 @@ class Agent:
         # 2) Wait for end of cmd execution
         #self.wait_for_execution_of_cmd(self.cmdts)
         while not cmdts_is_processed:
-            print(f"Waiting for end of cmd {self.cmdts.name} execution...")
+            self.print(f"Waiting for end of cmd {self.cmdts.name} execution...")
             self.cmdts.refresh_from_db()
             # timeout ?
             if self.cmdts.is_expired(): break
@@ -489,9 +500,9 @@ class Agent:
         # 3) Get cmd result
         if cmdts_is_processed:
-            print(f"Cmd executed. Result is '{cmdts_res}'")
+            self.print(f"Cmd executed. Result is '{cmdts_res}'")
         else:
-            print("Command was not completed")
+            self.print("Command was not completed")
     """
@@ -503,10 +514,10 @@ class Agent:
         NB: datetime.utcnow() is equivalent to datetime.now(timezone.utc)
         ###
-        print("Looking for old commands to purge...")
+        self.print("Looking for old commands to purge...")
         ###
         COMMAND_PEREMPTION_DATE_FROM_NOW = datetime.utcnow() - timedelta(hours = self.COMMANDS_PEREMPTION_HOURS)
-        #print("peremption date", COMMAND_PEREMPTION_DATE_FROM_NOW)
+        #self.print("peremption date", COMMAND_PEREMPTION_DATE_FROM_NOW)
         old_commands = Command.objects.filter(
             # only commands for me
             receiver = self.name,
@@ -516,22 +527,22 @@ class Agent:
         ###
         old_commands = Command.get_old_commands_for_agent(self.name)
         if old_commands.exists():
-            print("Found old commands to delete:")
-            for cmd in old_commands: print(cmd)
+            self.print("Found old commands to delete:")
+            for cmd in old_commands: self.print(cmd)
             old_commands.delete()
     """
     def waitfor(self, nbsec):
-            print(f"Now, waiting for {nbsec} seconds...")
+            self.print(f"Now, waiting for {nbsec} seconds...")
             time.sleep(nbsec)
     def set_status(self, status:str):
-        print(f"[NEW CURRENT STATUS: {status}] (switching from status {self.status})")
+        self.print(f"[NEW CURRENT STATUS: {status}] (switching from status {self.status})")
         self.status = status
         return False
     def set_mode(self, mode:str):
-        print(f"Switching from mode {self.mode} to mode {mode}")
+        self.print(f"Switching from mode {self.mode} to mode {mode}")
         self.mode = mode
     def is_active(self):
@@ -544,7 +555,7 @@ class Agent:
         self.set_mode(self.MODE_IDLE)
     def show_mode_and_status(self):
-        print(f"CURRENT MODE is {self.mode} (with status {self.status})")
+        self.print(f"CURRENT MODE is {self.mode} (with status {self.status})")
     def die(self):
         self.set_status(self.STATUS_EXIT)
@@ -592,7 +603,7 @@ class Agent:
     """
     def init(self):
-        print("Initializing...")
+        self.print("Initializing...")
         self.set_status(self.STATUS_INIT)
     def load_config(self):
@@ -600,7 +611,7 @@ class Agent:
         TODO:
         only si date fichier xml changée => en RAM, un objet Config avec méthodes d'accès, appelle le parser de AK (classe Config.py indépendante)
         """
-        print("Loading the config file...")
+        self.print("Loading the config file...")
         #config_filename = 'c:/srv/develop/pyros/config/config_unit_simulunit1.xml'
         #config.set_configfile(config_filename)
         self.config.load()
@@ -609,21 +620,21 @@ class Agent:
         # --- display informations
         # --- Get all the assembly of this unit[0] (mount + channels)
         if self.config.is_config_contents_changed():
-            print("--------- Components of the unit -----------")
-            print("Configuration file is {}".format(self.config.get_configfile()))            
+            self.print("--------- Components of the unit -----------")
+            self.print("Configuration file is {}".format(self.config.get_configfile()))            
             alias = self.config.get_aliases('unit')[0]
             namevalue = self.config.get_paramvalue(alias,'unit','name')
-            print("Unit alias is {}. Name is {}".format(alias,namevalue), ":")
+            self.print("Unit alias is {}. Name is {}".format(alias,namevalue), ":")
             unit_subtags = self.config.get_unit_subtags()
             for unit_subtag in unit_subtags:
                 aliases = self.config.get_aliases(unit_subtag)
                 for alias in aliases:
                     namevalue = self.config.get_paramvalue(alias,unit_subtag,'name')
-                    print(f"- {unit_subtag} alias is {alias}. Name is {namevalue}")
-            print("------------------------------------------")
+                    self.print(f"- {unit_subtag} alias is {alias}. Name is {namevalue}")
+            self.print("------------------------------------------")
             #params = self.config.get_params(unit_alias)
             #for param in params:
-            #    print("Unit component is {}".format(param))
+            #    self.print("Unit component is {}".format(param))
         """
         # self.config = Config.objects.get(pk=1)
@@ -637,15 +648,15 @@ class Agent:
         except Exception as e:
             # except Config.ObjectDoesNotExist:
             # except Config.DoesNotExist:
-            print("Config read (or write) exception", str(e))
+            self.print("Config read (or write) exception", str(e))
             # return self.config
             # return -1
             return False
         """
     def update_survey(self):
-        print("Updating the survey database table...")
-        print("- fetching table line for agent", self.name)
+        self.print("Updating the survey database table...")
+        #self.print("- fetching table line for agent", self.name)
         # only necessary when using process (not necessary with threads)
         #with transaction.atomic():
         self._agent_survey = AgentSurvey.objects.get(name=self.name)
@@ -653,26 +664,6 @@ class Agent:
         self._agent_survey.status = self.status
         self._agent_survey.save()
-
-    def simulator_get_next_command_to_send(self)->Command:
-        cmd_name = next(self.SIMULATOR_COMMANDS, None)
-        if cmd_name is None: return None
-        receiver_agent = self.name if self.SIMULATOR_COMMANDS_DEST=="myself" else self.SIMULATOR_COMMANDS_DEST
-        return Command(sender=self.name, receiver=receiver_agent, name=cmd_name)
-
-    def simulator_send_next_command(self):
-        #self._current_test_cmd = "go_idle" if self._current_test_cmd=="go_active" else "go_active"
-        #if self._nb_test_cmds == 4: self._current_test_cmd = "exit"
-        cmd_name = next(self.SIMULATOR_COMMANDS, None)
-        #print("next cmd is ", cmd_name)
-        if cmd_name is None: return
-        #Command.objects.create(sender=self.name, receiver=self.name, name=cmd_name)
-        receiver_agent = self.name if self.SIMULATOR_COMMANDS_DEST=="myself" else self.SIMULATOR_COMMANDS_DEST
-        Command.objects.create(sender=self.name, receiver=receiver_agent, name=cmd_name)
-        #time.sleep(1)
-        #self._simulator_current_cmd_idx += 1
-        #self._nb_test_cmds += 1
-
     """
     def send_command(self, cmd_name):
         receiver_agent = self.name if self.SIMULATOR_COMMANDS_DEST=="myself" else self.SIMULATOR_COMMANDS_DEST
@@ -686,26 +677,28 @@ class Agent:
         Commands are read in chronological order
         """
         self.set_status(self.STATUS_GET_NEXT_COMMAND)
-        print("Looking for new commands from the database ...")
+        self.print("Looking for new commands from the database ...")
         # 1) Get all pending commands for me (return if None)
-        # Not sure this is necessary, but there might be a risk
+        # Not sure this is necessary to do it in a transaction, 
+        # but there might be a risk
         # that a command status is modified while we are reading...
         with transaction.atomic():
             self._pending_commands = Command.get_pending_commands_for_agent(self.name)
         commands = self._pending_commands
         if not commands.exists():
-            print("No new command to process")
+            self.print("No new command to process")
             return None
-        print("Current pending commands are (time ordered) :")
+        self.print("Current pending commands are (time ordered) :")
         Command.show_commands(commands)
         # 2) If there is a "exit" or "abort" command pending (even at the end of the list),
         # which is VALID (not expired),
         # then pass it straight away to general_process() for execution
-        for cmd in commands: 
-            if cmd.name in ("exit", "abort"): break
-        if cmd.name in ("exit", "abort") and not cmd.is_expired(): return cmd
+        for cmd in commands:
+            if cmd.name in ("exit", "abort", "flush_commands"): break
+        if cmd.name in ("exit", "abort", "flush_commands") and not cmd.is_expired():
+            return cmd
         # 3) If first (oldest) command is currently running
         # (status CMD_RUNNING), then do nothing and return
@@ -721,16 +714,16 @@ class Agent:
         """
         cmd = commands[0]
         if cmd.is_running():
-            #print(f"There is currently a running command ({cmd_executing.first().name}), so I do nothing (wait for end of execution)")
-            print(f"There is currently a running command ({cmd.name})")
+            #self.print(f"There is currently a running command ({cmd_executing.first().name}), so I do nothing (wait for end of execution)")
+            self.print(f"There is currently a running command ({cmd.name})")
             """
             # Check that this command is not expired
             if cmd.is_expired():
-                print("But this command is expired, so set its status to OUTOFDATE, and go on")
+                self.print("But this command is expired, so set its status to OUTOFDATE, and go on")
                 cmd_executing.set_as_outofdate()
             else:
             """
-            print(f"Thus, I will do nothing until this command execution is finished")
+            self.print(f"Thus, I will do nothing until this command execution is finished")
             # TODO: kill si superieur a MAX_EXEC_TIME
             return None
@@ -745,10 +738,10 @@ class Agent:
         # 6) Current cmd must now be a valid (not expired) and PENDING one,
         # so pass it to general_process() for execution
-        #print(f"Got command {cmd.name} sent by agent {cmd.sender} at {cmd.sender_deposit_time}")
-        print("***")
-        print("*** Got", cmd)
-        print("***")
+        #self.print(f"Got command {cmd.name} sent by agent {cmd.sender} at {cmd.sender_deposit_time}")
+        self.print("***")
+        self.print("*** Got", cmd)
+        self.print("***")
         return cmd
@@ -762,34 +755,35 @@ class Agent:
     def general_process(self, cmd:Command)->Command:
         self.set_status(self.STATUS_GENERAL_PROCESS)
-        print(f"Starting general processing of {cmd}")
+        self.print(f"Starting general processing of {cmd}")
         # Update read time to say that the command has been READ
         cmd.set_read_time()
         # Precondition: command cmd is valid (not expired), has already been read, is pending
         assert (not cmd.is_expired()) and cmd.is_pending() and cmd.is_read() 
-        #print(f"Starting general processing of command {cmd.name} sent by agent {cmd.sender} at {cmd.sender_deposit_time}")
+        #self.print(f"Starting general processing of command {cmd.name} sent by agent {cmd.sender} at {cmd.sender_deposit_time}")
         """
         # 2) If expired command, change its status to expired and return
         if cmd.is_expired():
-            print("This command is expired, so mark it as such, and ignore it")
+            self.print("This command is expired, so mark it as such, and ignore it")
             cmd.set_as_outofdate()
             return None
         """
         # If cmd is generic, execute it, change its status to executed, and return
         if cmd.is_generic():
-            print("This command is generic, execute it...")
+            self.print("This command is generic, execute it...")
             self.exec_generic_cmd(cmd)
             # If cmd is "exit", kill myself (without any question, this is an order soldier !)
             # This "exit" should normally kill any current thread (to be checked...)
             if cmd.name == "exit":
-                print("(before exiting) Here are the current (still) pending commands (time ordered) :")
+                self.print("(before exiting) Here are the current (still) pending commands (time ordered) :")
                 commands = Command.get_pending_commands_for_agent(self.name)
                 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 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)
             # Command is executed, so return None
             return None
@@ -799,19 +793,19 @@ class Agent:
             # cmd is not generic but, as I am idle, change its status to SKIPPED, ignore it, and return
             #if self.mode == self.MODE_IDLE:
             if not self.is_active():
-                print("This command is not generic but, as I am IDLE, I mark it SKIPPED and ignore it")
+                self.print("This command is not generic but, as I am IDLE, I mark it SKIPPED and ignore it")
                 cmd.set_as_skipped()
                 return None
         # Je suis pas idle et cde pas générique: je la traite pas, elle sera traitée par core_process :
         # attendre que cette commande soit exécutée avant de passer à la commande suivante (situation “bloquante” normale)
-        print("This command is not generic and, as I am not IDLE, I pass it to the specific processing")
-        print("(then I will not execute any other new command until this command is EXECUTED)")
+        self.print("This command is not generic and, as I am not IDLE, I pass it to the specific processing")
+        self.print("(then I will not execute any other new command until this command is EXECUTED)")
         return cmd
     def exec_generic_cmd(self, cmd:Command):
-        print("Starting execution of a Generic cmd...")
+        self.print("Starting execution of a Generic cmd...")
         cmd.set_as_running()
         # Executing command
@@ -819,19 +813,22 @@ class Agent:
             self.set_active()
             cmd.set_result("I am now active")
             time.sleep(1)
-        if cmd.name == "go_idle": 
+        elif cmd.name == "go_idle": 
             self.set_idle()
             cmd.set_result("I am now idle")
             time.sleep(1)
-        # If cmd is "abort", kill any currently running thread
-        if cmd.name in ("abort", "exit"):
-            #print("Current pending commands are:")
+        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"):
+            #self.print("Current pending commands are:")
             #Command.show_commands(self._pending_commands)
-            print("Aborting current executing command if exists:")
+            self.print("Aborting current executing command if exists:")
             self.kill_running_specific_cmd_if_exists()
         cmd.set_as_processed()
-        print("...Generic cmd has been executed")
+        self.print("...Generic cmd has been executed")
@@ -842,7 +839,7 @@ class Agent:
         - in file
         - in db
         """
-        print("Logging data...")
+        self.print("Logging data...")
@@ -860,11 +857,11 @@ class Agent:
         self.set_status(self.STATUS_SPECIFIC_PROCESS)
         assert self.is_active()
         self._current_specific_cmd = cmd
-        print("Starting specific process...")
+        self.print("Starting specific process...")
         #self._current_thread = threading.Thread(target=self.exec_command)
         # Run in a thread
         if self.RUN_IN_THREAD:
-            print("(run cmd in a thread)")
+            self.print("(run cmd in a thread)")
             self._current_specific_thread = StoppableThreadEvenWhenSleeping(target=self.thread_exec_specific_cmd)
             #self._current_specific_thread = StoppableThreadEvenWhenSleeping(target=self.exec_specific_cmd, args=(cmd,))
             #self._current_thread = threading.Thread(target=self.exec_command)
@@ -873,7 +870,7 @@ class Agent:
             #self._current_specific_thread = thread_with_exception('thread test')
         # Run in a process
         else:
-            print("(run cmd in a process)")
+            self.print("(run cmd in a process)")
             # close the database connection first, it will be re-opened in each process
             db.connections.close_all()
             self._current_specific_thread = multiprocessing.Process(target=self.thread_exec_specific_cmd) 
@@ -883,14 +880,14 @@ class Agent:
         self._current_specific_thread.start()
         #my_thread.join()
         #self.waitfor(self.subloop_waittime)
-        print("Ending specific process (thread has been launched)")
+        self.print("Ending specific process (thread has been launched)")
     def kill_running_specific_cmd_if_exists(self):
         if (self._current_specific_thread is None) or not self._current_specific_thread.is_alive():
-            print("...No current specific command thread to abort...")
+            self.print("...No current specific command thread to abort...")
         else:
-            print(f"Killing command {self._current_specific_cmd.name}")
+            self.print(f"Killing command {self._current_specific_cmd.name}")
             # Ask the thread to stop itself
             #self._current_specific_thread.stop()
             #self._current_specific_thread._stop()
@@ -907,13 +904,42 @@ class Agent:
         self._current_specific_cmd = None
+    """
+    =================================================================
+        SIMULATOR DEDICATED FUNCTIONS
+    =================================================================
+    """
+
+    def simulator_get_next_command_to_send(self)->Command:
+        cmd_name = next(self.SIMULATOR_COMMANDS, None)
+        if cmd_name is None: return None
+        receiver_agent = self.name if self.SIMULATOR_COMMANDS_DEST=="myself" else self.SIMULATOR_COMMANDS_DEST
+        return Command(sender=self.name, receiver=receiver_agent, name=cmd_name)
+
+    """
+    def simulator_send_next_command(self):
+        #self._current_test_cmd = "go_idle" if self._current_test_cmd=="go_active" else "go_active"
+        #if self._nb_test_cmds == 4: self._current_test_cmd = "exit"
+        cmd_name = next(self.SIMULATOR_COMMANDS, None)
+        #self.print("next cmd is ", cmd_name)
+        if cmd_name is None: return
+        #Command.objects.create(sender=self.name, receiver=self.name, name=cmd_name)
+        receiver_agent = self.name if self.SIMULATOR_COMMANDS_DEST=="myself" else self.SIMULATOR_COMMANDS_DEST
+        Command.objects.create(sender=self.name, receiver=receiver_agent, name=cmd_name)
+        #time.sleep(1)
+        #self._simulator_current_cmd_idx += 1
+        #self._nb_test_cmds += 1
+    """
+
     def simulator_test_results(self):
-        print("\n--- Starting testing if result is ok")
-        print("Here are the 14 last commands:")
+        self.print("\n--- Testing if the commands I SENT had the awaited result")
+        self.print("Here are the last commands I sent:")
         #commands = list(Command.get_last_N_commands_for_agent(self.name, 16))
-        commands = Command.get_last_N_commands_for_agent(self.name, 16)
-        Command.show_commands(commands)
+        #commands = Command.get_last_N_commands_sent_to_agent(self.name, 16)
+        commands = Command.get_last_N_commands_sent_by_agent(self.name, len(self.SIMULATOR_COMMANDS_LIST))
         Command.show_commands(commands)
+        return commands
+        """ OLD SCENARIO
         nb_asserted = 0
         for cmd in commands:
             if cmd.name == "specific0":
@@ -937,7 +963,8 @@ class Agent:
                 assert cmd.is_executed()
                 nb_asserted+=1
         assert nb_asserted == 12
-        print("--- Finished testing => result is ok")
+        self.print("--- Finished testing => result is ok")
+        """
@@ -965,8 +992,8 @@ class Agent:
         cmd = self._current_specific_cmd
         """ specific command execution setting up """
         #cmd = self.get_current_specific_cmd()
-        print(">>>>> Thread: starting execution of command", cmd.name)
-        print(">>>>> Thread: PID: %s, Process Name: %s, Thread Name: %s" % (
+        self.print(">>>>> Thread: starting execution of command", cmd.name)
+        self.print(">>>>> Thread: PID: %s, Process Name: %s, Thread Name: %s" % (
             os.getpid(),
             multiprocessing.current_process().name,
             threading.current_thread().name)
@@ -1004,7 +1031,7 @@ class Agent:
     def thread_exec_specific_cmd_main(self):
         """
         cmd = self._current_specific_cmd
-        print("Doing nothing, just sleeping...")
+        self.print("Doing nothing, just sleeping...")
         self.sleep(3)
         """
@@ -1047,7 +1074,7 @@ class Agent:
             with transaction.atomic():
                 cmd.set_as_processed()
         """
-        print(">>>>> Thread: ended execution of command", cmd.name)
+        self.print(">>>>> Thread: ended execution of command", cmd.name)
         cmd = None
         # No more current thread
         #self._current_specific_thread = None
@@ -1058,9 +1085,9 @@ class Agent:
         # Exit if I was asked to stop
         cmd = self._current_specific_cmd
         if self.RUN_IN_THREAD and threading.current_thread().stopped():
-            print(f">>>>> Thread (cmd {cmd.name}): I received the stop signal, so I stop (in error)")
+            self.print(f">>>>> Thread (cmd {cmd.name}): I received the stop signal, so I stop (in error)")
             exit(1)
-        print(f">>>>> Thread (cmd {cmd.name}): step #{step}/{self._thread_total_steps_number}")
+        self.print(f">>>>> Thread (cmd {cmd.name}): step #{step}/{self._thread_total_steps_number}")
         # call a specific function to be defined by subclass
         cmd_step_function(step)
         # Wait for a specific time (interruptible)
@@ -1069,7 +1096,7 @@ class Agent:
     def thread_stop_if_asked(self):
         assert self._current_specific_thread is not None
         if self.RUN_IN_THREAD and threading.current_thread().stopped():
-            print("(Thread) I received the stop signal, so I stop (in error)")
+            self.print("(Thread) I received the stop signal, so I stop (in error)")
             exit(1)
     def thread_set_total_steps_number(self, nbsteps):
@@ -1103,6 +1130,11 @@ class Agent:
     """
+"""
+=================================================================
+    MAIN FUNCTION
+=================================================================
+"""
 if __name__ == "__main__":
     configfile = None
@@ -15,27 +15,36 @@ from Agent import Agent
 class AgentA(Agent):
     #MAX_DURATION_SEC = None
-    MAX_DURATION_SEC = 85
+    MAX_DURATION_SEC = 90
     # FOR TEST ONLY
     # Run this agent in simulator mode
     SIMULATOR_MODE = True
     # Run the assertion tests at the end
-    SIMULATOR_WITH_TEST = False
+    SIMULATOR_WITH_TEST = True
     # Who should I send commands to ?
     #SIMULATOR_COMMANDS_DEST = "myself"
     SIMULATOR_COMMANDS_DEST = "AgentB"
     # Scenario to be executed
-    SIMULATOR_COMMANDS = [
+    SIMULATOR_COMMANDS_LIST = [
+        # Ask receiver to delete all its previous commands 
+        "flush_commands",
+
         "go_active",
         "go_idle",
         # Not executed because receiver agent is now "idle"
         #"specific0",
-        # Executed because receiver agent is now "active"
         "go_active",
-        #"specific1",
+
+        # Executed because receiver agent is now "active"
+        "specific1",
+
+        # should abort previous command, but does not because specific1 is already executed
+        "abort",
+
+        # fully executed, result is 7
         "eval 4+3",
         "go_idle",
@@ -161,14 +170,68 @@ class AgentA(Agent):
         super().exec_specific_cmd_end(cmd, from_thread)
     '''
+    # @override
+    def simulator_test_results(self):
+        commands = super().simulator_test_results()
+        #self.print(commands)
+        """
+        "go_active",
+        "go_idle",
+        # Not executed because receiver agent is now "idle"
+        #"specific0",
+
+        # Executed because receiver agent is now "active"
+        "go_active",
+        #"specific1",
+        "eval 4+3",
+        "go_idle",
+        "exit",
+        """
+        nb_asserted = 0
+        for cmd in commands:
+            if cmd.name == "flush_commands":
+                assert cmd.is_executed()
+                nb_asserted+=1
+            # 2 times
+            if cmd.name == "go_active":
+                assert cmd.is_executed()
+                nb_asserted+=1
+            # 2 times
+            if cmd.name == "go_idle":
+                assert cmd.is_executed()
+                nb_asserted+=1
+            if cmd.name == "specific1":
+                assert cmd.is_executed()
+                assert cmd.result == "in step #5/5"
+                nb_asserted+=1
+            if cmd.name == "eval 4+3":
+                assert cmd.is_executed()
+                assert cmd.get_result() == "7"
+                nb_asserted+=1
+            if cmd.name in ("abort"):
+                assert cmd.is_executed()
+                nb_asserted+=1
+            if cmd.name in ("exit"):
+                assert cmd.is_executed()
+                nb_asserted+=1
+        #assert nb_asserted == 6
+        assert nb_asserted == len(self.SIMULATOR_COMMANDS_LIST)
+        self.print("************** Finished testing => result is ok **************")
+
+
+"""
+=================================================================
+    MAIN FUNCTION
+=================================================================
+"""
 if __name__ == "__main__":
     # with thread
     RUN_IN_THREAD=True
     # with process
-    RUN_IN_THREAD=False
+    #RUN_IN_THREAD=False
     configfile = None
@@ -14,16 +14,19 @@ from Agent import Agent
 class AgentB(Agent):
+    #MAX_DURATION_SEC = None
+    MAX_DURATION_SEC = 120
+
     # FOR TEST ONLY
     # Run this agent in simulator mode
     SIMULATOR_MODE = True
     # Run the assertion tests at the end
-    SIMULATOR_WITH_TEST = False
+    SIMULATOR_WITH_TEST = True
     # Who should I send commands to ?
     #SIMULATOR_COMMANDS_DEST = "myself"
     SIMULATOR_COMMANDS_DEST = "AgentA"
     # Scenario to be executed
-    SIMULATOR_COMMANDS = [
+    SIMULATOR_COMMANDS_LIST = [
         "go_active",
         "go_idle",
     ]
@@ -150,15 +153,30 @@ class AgentB(Agent):
         self.thread_exec_specific_cmd_step(5, self.cmd_step1, 3)
         ###
     """
-    
+
     '''
     # @override
     def exec_specific_cmd_end(self, cmd:Command, from_thread=True):
         super().exec_specific_cmd_end(cmd, from_thread)
     '''
-
-
+    # @override
+    def simulator_test_results(self):
+        commands = super().simulator_test_results()
+        nb_asserted = 0
+        for cmd in commands:
+            assert cmd.is_executed()
+            nb_asserted+=1
+        #assert nb_asserted == 2
+        assert nb_asserted == len(self.SIMULATOR_COMMANDS_LIST)
+        self.print("************** Finished testing => result is ok **************")
+
+
+"""
+=================================================================
+    MAIN FUNCTION
+=================================================================
+"""
 if __name__ == "__main__":
     # with thread
@@ -30,7 +30,7 @@ class AgentX(Agent):
     #SIMULATOR_COMMANDS_DEST = "myself"
     SIMULATOR_COMMANDS_DEST = "AgentA"
     # Scenario to be executed
-    SIMULATOR_COMMANDS = [
+    SIMULATOR_COMMANDS_LIST = [
         "go_active",
         "go_idle",
         "go_active",
@@ -244,7 +244,7 @@ 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 = ["go_idle", "go_active", "abort", "exit"]
+    GENERIC_COMMANDS = ["go_idle", "go_active", "flush_commands", "abort", "exit"]
     #COMMANDS_PEREMPTION_HOURS = 48
     COMMANDS_PEREMPTION_HOURS = 60/60
     COMMANDS_VALIDITY_DURATION_SEC_DEFAULT = 30
@@ -254,8 +254,8 @@ class Command(models.Model):
     #sender = models.CharField(max_length=50, blank=True, null=True, unique=True)
     sender = models.CharField(max_length=50, help_text='sender agent name')
-    receiver = models.CharField(max_length=50)
-    name = models.CharField(max_length=400)
+    receiver = models.CharField(max_length=50, help_text='receiver agent name')
+    name = models.CharField(max_length=400, help_text='command name')
     validity_duration_sec = models.PositiveIntegerField(default=COMMANDS_VALIDITY_DURATION_SEC_DEFAULT)
     # Automatically set at table line creation (line created by the sender)
     sender_deposit_time = models.DateTimeField(blank=True, null=True, auto_now_add=True)
@@ -289,7 +289,7 @@ class Command(models.Model):
         return datetime.utcnow().astimezone() - timedelta(hours = cls.COMMANDS_PEREMPTION_HOURS)
     @classmethod
-    def delete_commands_with_running_status_if_exists_for_agent(cls, agent_name):
+    def delete_commands_with_running_status_for_agent(cls, agent_name):
         running_commands = cls.objects.filter(
             # only commands for agent agent_name
             receiver = agent_name,
@@ -302,6 +302,23 @@ class Command(models.Model):
             print("Delete (false) 'running' command:")
             Command.show_commands(running_commands)
             running_commands.delete()
+        else: print("<None>")
+
+    @classmethod
+    def delete_pending_commands_for_agent(cls, agent_name):
+        pending_commands = cls.objects.filter(
+            # only commands for agent agent_name
+            receiver = agent_name,
+            # only running commands
+            receiver_status_code = cls.CMD_STATUS_CODES.CMD_PENDING,
+            # only not expired commands
+            #sender_deposit_time__gte = cls.get_peremption_date_from_now(),
+        )
+        if pending_commands:
+            print("Delete these pending command(s):")
+            Command.show_commands(pending_commands)
+            pending_commands.delete()
+        else: print("<None>")
     @classmethod
     def get_pending_commands_for_agent(cls, agent_name):
@@ -317,15 +334,27 @@ class Command(models.Model):
         ).order_by("sender_deposit_time")
     @classmethod
-    def get_commands_for_agent(cls, agent_name):
-        return cls.objects.filter(receiver = agent_name)
+    def get_commands_sent_to_agent(cls, agent_name):
+        return cls.objects.filter(receiver=agent_name)
+
+    @classmethod
+    def get_commands_sent_by_agent(cls, agent_name):
+        return cls.objects.filter(sender=agent_name)
+
+    @classmethod
+    def get_last_N_commands_sent_to_agent(cls, agent_name, N):
+        #filter(since=since)
+        #return cls.objects.all()[:nb_cmds]
+        #commands = cls.objects.filter(receiver = agent_name).order_by('-id')[:N]
+        commands = cls.get_commands_sent_to_agent(agent_name).order_by('-id')[:N]
+        return list(reversed(commands))
     @classmethod
-    def get_last_N_commands_for_agent(cls, agent_name, N):
+    def get_last_N_commands_sent_by_agent(cls, agent_name, N):
         #filter(since=since)
         #return cls.objects.all()[:nb_cmds]
         #commands = cls.objects.filter(receiver = agent_name).order_by('-id')[:N]
-        commands = cls.get_commands_for_agent(agent_name).order_by('-id')[:N]
+        commands = cls.get_commands_sent_by_agent(agent_name).order_by('-id')[:N]
         return list(reversed(commands))
     @classmethod
@@ -336,7 +365,7 @@ class Command(models.Model):
         NB: datetime.utcnow() is equivalent to datetime.now(timezone.utc)
         """
-        print(f"Looking for old commands to purge... (commands that are not executing and older than {cls.COMMANDS_PEREMPTION_HOURS} hour(s))")
+        print(f"(Looking for commands that are not executing and older than {cls.COMMANDS_PEREMPTION_HOURS} hour(s))")
         """
         COMMAND_PEREMPTION_DATE_FROM_NOW = datetime.utcnow() - timedelta(hours = self.COMMANDS_PEREMPTION_HOURS)
         #print("peremption date", COMMAND_PEREMPTION_DATE_FROM_NOW)