from pyOpenRPA . Robot import UIDesktop
import os
import time # Time wait operations
from . import ConnectorExceptions # Exceptions classes
from . import Connector
from . import Processor # Module for process some functions on thr RDP
from . import Recovery
from . . import __Orchestrator__
# Main function
# inThreadControlDict = {"ThreadExecuteBool":True}
def RobotRDPActive ( inGSettings , inThreadControlDict ) :
# inGSettings = {
# ... "RobotRDPActive": {} ...
# }
lL = inGSettings [ " Logger " ] #Logger alias
Processor . gSettings = inGSettings # Set gSettings in processor module
mGSettingsRDPActiveDict = inGSettings [ " RobotRDPActive " ] # Get configuration from global dict settings
# Global error handler
try :
######## Init the RDP List
lNewRDPList = { }
for lRDPSessionKeyStrItem in mGSettingsRDPActiveDict [ " RDPList " ] :
lConfigurationItem = mGSettingsRDPActiveDict [ " RDPList " ] [ lRDPSessionKeyStrItem ]
lAddToNewRDPDict = True
if " SessionHex " not in lConfigurationItem : lAddToNewRDPDict = False # 2020.08.03 fix: Init the Session hex field. If no SessionHex - trash in structure - remove
if lConfigurationItem [ " SessionHex " ] is None or lConfigurationItem [ " SessionHex " ] == " " : # Minor fix - need for restore existed RDP sessions
lConfigurationItem [ " SessionIsWindowExistBool " ] = False # Flag that session is not started
lConfigurationItem [ " SessionIsWindowResponsibleBool " ] = False # Flag that session is not started
lConfigurationItem [ " SessionHex " ] = " 77777sdfsdf77777dsfdfsf77777777 " # Flag that session is not started
if lAddToNewRDPDict :
lNewRDPList [ lRDPSessionKeyStrItem ] = lConfigurationItem
mGSettingsRDPActiveDict [ " RDPList " ] = lNewRDPList # Update the structure
##########
# Run monitor - main loop
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
inGlobalDict = mGSettingsRDPActiveDict # Compatibility
inListUpdateTimeout = 1 # Compatibility
lFlagWhile = True
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 = [ ]
lRDPConfigurationDictList = [ ]
lRDPSessionKeyList = [ ]
# Prepare selectors list for check
for lRDPSessionKeyStrItem in inGlobalDict [ " RDPList " ] :
lRDPSessionKeyList . append ( lRDPSessionKeyStrItem )
lItem = inGlobalDict [ " RDPList " ] [ lRDPSessionKeyStrItem ]
lRDPConfigurationDictList . append ( lItem ) # Add RDP Configuration in list
lUIOSelectorList . append ( [ { " title_re " : f " { lItem [ ' SessionHex ' ] } .* " , " backend " : " win32 " } ] )
# Run wait command
lRDPDissappearList = UIDesktop . UIOSelectorsSecs_WaitDisappear_List ( lUIOSelectorList , inListUpdateTimeout )
for lItem in lRDPDissappearList : # Reconnect if connection was lost
lRDPSessionKeyStr = lRDPSessionKeyList [ lItem ]
lRDPConfigurationDict = lRDPConfigurationDictList [ lItem ] # Get RDP Configuration list
lRDPConfigurationDict [ " SessionIsWindowExistBool " ] = False # Set flag that session is disconnected
# Check if RDP window is not ignored
if not lRDPConfigurationDict [ " SessionIsIgnoredBool " ] :
try :
Connector . Session ( lRDPConfigurationDict , inScreenSize550x350Bool = True )
lRDPConfigurationDict [ " SessionIsWindowExistBool " ] = True # Flag that session is started
if lL : lL . info ( f " Host: { lRDPConfigurationDict [ ' Host ' ] } , Login: { lRDPConfigurationDict [ ' Login ' ] } , SessionHex: { str ( lRDPConfigurationDict [ ' SessionHex ' ] ) } :: Session has been initialized! " ) #Logging
# catch ConnectorExceptions.SessionWindowNotExistError
except ConnectorExceptions . SessionWindowNotExistError as e :
lRDPConfigurationDict [ " SessionIsWindowExistBool " ] = False # Set flag that session is disconnected
if lL : lL . warning ( f " Host: { lRDPConfigurationDict [ ' Host ' ] } , Login: { lRDPConfigurationDict [ ' Login ' ] } , SessionHex: { str ( lRDPConfigurationDict [ ' SessionHex ' ] ) } :: Session is not exist! Mark the retry " ) #Logging
# Recovery operations
Recovery . RetryMark ( inRDPSessionKeyStr = lRDPSessionKeyStr , inGSettings = inGSettings )
if Recovery . RetryIsTriggered ( inRDPSessionKeyStr = lRDPSessionKeyStr , inGSettings = inGSettings ) == True :
if lL : lL . warning ( f " !ATTENTION! Host: { lRDPConfigurationDict [ ' Host ' ] } , Login: { lRDPConfigurationDict [ ' Login ' ] } ; RDP is not responsible for many times - run recovery mode " )
Recovery . RetryHostClear ( inHostStr = lRDPConfigurationDict [ ' Host ' ] , inGSettings = inGSettings ) # Clear the stat about current host
if inGSettings [ " RobotRDPActive " ] [ " RecoveryDict " ] [ " DoDict " ] [ " OSRemotePCRestart " ] == True :
if lL : lL . warning ( f " !ATTENTION! Host: { lRDPConfigurationDict [ ' Host ' ] } , Send signal to restart remote PC. " )
__Orchestrator__ . OSRemotePCRestart ( inLogger = lL , inHostStr = lRDPConfigurationDict [ ' Host ' ] , inForceBool = True )
# general exceptions
except Exception as e :
if lL : lL . exception ( f " !!! ATTENTION !!! Unrecognized error " ) #Logging
pass
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
Connector . SystemRDPWarningClickOk ( ) # Click all warning messages
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Check if RDP session is full screen (if is not ignored)
if inGlobalDict [ " FullScreenRDPSessionKeyStr " ] is not None :
lRDPSessionKeyStr = inGlobalDict [ " FullScreenRDPSessionKeyStr " ] # Get the RDPSessionKeyStr
if lRDPSessionKeyStr in inGlobalDict [ " RDPList " ] : # Session Key is in dict
lRDPConfigurationDict = inGlobalDict [ " RDPList " ] [ lRDPSessionKeyStr ]
#if not lRDPConfigurationDict["SessionIsIgnoredBool"]: # Session is not ignored
# Check if full screen
lIsFullScreenBool = Connector . SessionIsFullScreen ( inSessionHexStr = lRDPConfigurationDict [ " SessionHex " ] )
if not lIsFullScreenBool : # If not the full screen
# Check all RDP window and minimize it
for lRDPSessionKeyStrItem in inGlobalDict [ " RDPList " ] :
lRDPConfigurationDictItem = inGlobalDict [ " RDPList " ] [ lRDPSessionKeyStrItem ]
if Connector . SessionIsFullScreen ( inSessionHexStr = lRDPConfigurationDictItem [ " SessionHex " ] ) :
if inThreadControlDict [ " ThreadExecuteBool " ] == True : # TEST FEATURE BEFORE ONE THREAD INTEGRATION
Connector . SessionScreenSize_X_Y_W_H ( inSessionHex = lRDPConfigurationDictItem [ " SessionHex " ] , inXInt = 10 , inYInt = 10 ,
inWInt = 550 ,
inHInt = 350 ) # Prepare little window
# Set full screen for new window
if inThreadControlDict [ " ThreadExecuteBool " ] == True : # TEST FEATURE BEFORE ONE THREAD INTEGRATION
Connector . SessionScreenFull ( inSessionHex = lRDPConfigurationDict [ " SessionHex " ] , inLogger = inGSettings [ " Logger " ] , inRDPConfigurationItem = inGlobalDict [ " RDPList " ] [ lRDPSessionKeyStrItem ] )
else :
# Check all RDP window and minimize it
for lRDPSessionKeyStrItem in inGlobalDict [ " RDPList " ] :
lRDPConfigurationDictItem = inGlobalDict [ " RDPList " ] [ lRDPSessionKeyStrItem ]
if Connector . SessionIsFullScreen ( inSessionHexStr = lRDPConfigurationDictItem [ " SessionHex " ] ) or Connector . SessionIsMinimizedScreen ( inSessionHexStr = lRDPConfigurationDictItem [ " SessionHex " ] ) : # If window is minimized - restore # if window in full screen - resize
if inThreadControlDict [ " ThreadExecuteBool " ] == True : # TEST FEATURE BEFORE ONE THREAD INTEGRATION
Connector . SessionScreenSize_X_Y_W_H ( inSessionHex = lRDPConfigurationDictItem [ " SessionHex " ] ,
inXInt = 10 , inYInt = 10 ,
inWInt = 550 ,
inHInt = 350 ) # Prepare little window
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Iterate the activity list in robot RDP active
lActivityListNew = [ ]
lActivityListOld = inGlobalDict [ " ActivityList " ]
inGlobalDict [ " ActivityList " ] = [ ]
for lActivityItem in lActivityListOld :
lSubmoduleFunctionName = lActivityItem [ " DefNameStr " ]
if lSubmoduleFunctionName in dir ( Processor ) :
lActivityItemResult = None # init the variable
try : # try to run function from Processor.py
lActivityItemResult = getattr ( Processor , lSubmoduleFunctionName ) (
* lActivityItem [ " ArgList " ] , * * lActivityItem [ " ArgDict " ] )
except Exception as e :
if lL : lL . exception ( f " RDP::main: Exception when run def in processor.py - activity will be ignored. Activity item: { lActivityItem } " ) #Logging
lActivityItemResult = True # True - clear from repeat list
lActivityItemResultType = type ( lActivityItemResult )
# Check if Result is bool
if lActivityItemResultType is bool :
if not lActivityItemResult :
# Activity is not done - add to list (retry in future)
lActivityListNew . append ( lActivityItem )
inGlobalDict [ " ActivityList " ] = lActivityListNew # Override the value
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
except RuntimeError as e :
# case noGUI error passed - do nothing
if lL : lL . warning ( f " Host session has lost the GUI " ) #Logging
finally :
# Wait for the next iteration
time . sleep ( 0.7 )
# Scheduler.Scheduler(mGSettingsRDPActiveDict["Scheduler"]) # Init & Run Scheduler TODO remake in processor list
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#Monitor.Monitor(mGSettingsRDPActiveDict, 1)
except Exception as e :
if lL : lL . exception ( f " !!! ATTENTION !!! Global error handler - look at code " ) #Logging
