Add pause trigger to RDPActive when Processor is working!

Sources/pyOpenRPA/Orchestrator/Processor.py

@@ -1,7 +1,8 @@
 # 1.2.0 - general processor - contains old orchestrator processor + RDPActive processor
 import time, copy, threading
 # Run processor synchronious
-def ProcessorRunSync(inGSettings):
+# inThreadControlDict = {"ThreadExecuteBool":True}
+def ProcessorRunSync(inGSettings, inRobotRDPThreadControlDict):
     """
         "ProcessorDict": { # Has been changed. New general processor (one threaded) v.1.2.0
             "ActivityList": [ # List of the activities
@@ -24,7 +25,9 @@ def ProcessorRunSync(inGSettings):
         if len(lActivityList)>0:
             if lL: lL.debug(f'Processor ActivityList len: {len(lActivityList)}')
             lActivityItem = inGSettings["ProcessorDict"]["ActivityList"].pop(0) # Extract the first item from processor queue
+            inRobotRDPThreadControlDict["ThreadExecuteBool"]=False # Stop the RobotRDPActive monitoring
             ActivityListExecute(inGSettings = inGSettings, inActivityList = [lActivityItem]) # execute the activity item
+            inRobotRDPThreadControlDict["ThreadExecuteBool"] = True  # Continue the RobotRDPActive monitoring
         else:
             time.sleep(inGSettings["ProcessorDict"]["CheckIntervalSecFloat"]) # Sleep when list is empty
 

Sources/pyOpenRPA/Orchestrator/RobotRDPActive/RobotRDPActive.py

@@ -5,7 +5,8 @@ from . import ConnectorExceptions # Exceptions classes
 from . import Connector
 from . import Processor # Module for process some functions on thr RDP
 # Main function
-def RobotRDPActive(inGSettings):
+# inThreadControlDict = {"ThreadExecuteBool":True}
+def RobotRDPActive(inGSettings, inThreadControlDict):
     # inGSettings = {
     # ... "RobotRDPActive": {} ...
     # }
@@ -36,6 +37,7 @@ def RobotRDPActive(inGSettings):
         lResponsibilityCheckLastSec = time.time()  # Get current time for check interval
         while lFlagWhile:
             try:
+                if inThreadControlDict["ThreadExecuteBool"] == True:
                     # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
                     # Check RDP window is OK - reconnect if connection was lost
                     lUIOSelectorList = []
@@ -65,19 +67,6 @@ def RobotRDPActive(inGSettings):
                                 if lL: lL.exception(f"!!! ATTENTION !!! Unrecognized error")  #Logging
                                 pass
                     # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
-                # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
-                # Safe turn off the - no need because of Orchestrator control
-                #if inGlobalDict.get("OrchestratorToRobotResetStorage", {}).get("SafeTurnOff", False):
-                #    lFlagWhile = False
-                #    # Set status disconnected for all RDP List
-                #    for lItem in inGlobalDict["RDPList"]:
-                #        lItem["SessionIsWindowExistBool"] = False
-                #        lItem["SessionIsWindowResponsibleBool"] = False
-                #    # Kill all RDP sessions
-                #    os.system('taskkill /F /im mstsc.exe')
-                #    # Return from function
-                #    return
-                # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
                     Connector.SystemRDPWarningClickOk() # Click all warning messages
                     # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
                     # Check if RDP session is full screen (if is not ignored)

Sources/pyOpenRPA/Orchestrator/__Orchestrator__.py

@@ -922,7 +922,8 @@ def Orchestrator(inGSettings):
         if lL: lL.info("Robot Screen active has been started")  #Logging
 
         # Init the RobotRDPActive in another thread
-        lRobotRDPActiveThread = threading.Thread(target= RobotRDPActive.RobotRDPActive, kwargs={"inGSettings":gSettingsDict})
+        lRobotRDPThreadControlDict = {"ThreadExecuteBool":True} # inThreadControlDict = {"ThreadExecuteBool":True}
+        lRobotRDPActiveThread = threading.Thread(target= RobotRDPActive.RobotRDPActive, kwargs={"inGSettings":gSettingsDict, "inThreadControlDict":lRobotRDPThreadControlDict})
         lRobotRDPActiveThread.daemon = True # Run the thread in daemon mode.
         lRobotRDPActiveThread.start() # Start the thread execution.
         if lL: lL.info("Robot RDP active has been started")  #Logging
@@ -939,7 +940,7 @@ def Orchestrator(inGSettings):
             Processor.ActivityListOrDict(lActivityItem)
 
         # Processor thread
-        lProcessorThread = threading.Thread(target= Processor.ProcessorRunSync, kwargs={"inGSettings":gSettingsDict})
+        lProcessorThread = threading.Thread(target= Processor.ProcessorRunSync, kwargs={"inGSettings":gSettingsDict, "inRobotRDPThreadControlDict":lRobotRDPThreadControlDict})
         lProcessorThread.daemon = True # Run the thread in daemon mode.
         lProcessorThread.start() # Start the thread execution.
         if lL: lL.info("Processor has been started (ProcessorDict)")  #Logging