Resolve CT-215

Closes CT-215

csp-lmc-common/csp_lmc_common/CspSubarray.py

@@ -319,8 +319,73 @@ class CspSubarray(SKASubarray):
             apiutil = tango.ApiUtil.instance()
             apiutil.set_asynch_cb_sub_model(tango.cb_sub_model.PUSH_CALLBACK)
             self.logger.info(message)
+
+            alignment_thr = threading.Thread(target=self.obs_state_alignment,
+                                                    name="Thread-Initialization ObsState Alignment",
+                                                    args=())
+            alignment_thr.start()
+
             return (result_code, message)
 
+        def obs_state_alignment(self):
+
+            device = self.target
+            # create a list with all the obs_states of sub-elements
+            # !!! delete the logger !!!
+            self.logger.info(f'obs state of CBF: {device._sc_subarray_obs_state[self.CbfSubarray].name}')
+
+            obs_states_list = [device._sc_subarray_obs_state[fqdn].name for fqdn in
+                               device._sc_subarray_fqdn]
+            # obs_state of cbf_subarray
+            #cbf_obs_state = device._sc_subarray_obs_state[self.CbfSubarray].name
+            # allowed coupled states for different sub-elements
+            allowed_coupled = {'RESOURCING': 'IDLE',
+                              'RESOURCING': 'EMPTY',
+                              'CONFIGURING': 'READY',
+                              'SCANNING': 'READY',
+                              'ABORTING': 'ABORTED',
+                              'RESETTING': 'IDLE',
+                              'RESTARTING': 'EMPTY'
+                               }
+            transitional_states = allowed_coupled.keys()
+            timeout = 10 # seconds
+
+            # CASE B: CBF is ON
+            if device._sc_subarray_state[self.CbfSubarray] == DevState.ON:
+                # start a loop in case of transitional states (CASE 2)
+                starting_time = time.time()
+                exit_loop = False
+                while time.time() - starting_time < timeout or exit_loop:
+                    # first creates an intersection list
+                    transitional_present = set(transitional_states) & set(obs_states_list)
+                    # CASE 1: Transitional states NOT present
+                    if not transitional_present:
+                        # CASE 1.1: All obsStates are EQUAL
+                        if len(set(obs_states_list)) == 1:
+                            self.state_model._update_obs_state(obs_states_list[0])
+                            exit_loop = True
+                        # CASE 1.1: obsStates are DIFFERENT
+                        else:
+                            self.state_model._update_obs_state('FAULT')
+                            exit_loop = True
+                    # CASE 2: Transitional states ARE present
+                    else:
+                        state = transitional_present[0]
+                        for sub_elt_obs_state in obs_states_list:
+                            # CASE 2.1: Other obs_states are NOT ALLOWED
+                            if sub_elt_obs_state is not (state or allowed_coupled[state]):
+                                self.state_model._update_obs_state('FAULT')
+                                exit_loop = True
+                                break
+                            # CASE 2.2: Other obs_states are ALLOWED
+                            else:
+                                self.state_model._update_obs_state(state)
+            # CASE A: CBF is OFF
+            else:
+                self.state_model._update_op_state('OFF')
+                self.state_model._update_obs_state('EMPTY')
+
+
     class OnCommand(SKASubarray.OnCommand):
         def do(self):
             super().do()
@@ -694,26 +759,26 @@ class CspSubarray(SKASubarray):
                 self.logger.info("CspSubarray timeout flag:{}".format(target_device._timeout_expired))
                 if target_device._abort_obs_event.is_set():
                     if target_device._timeout_expired or target_device._failure_raised:
-                        return target_device.abort_cmd_obj.failed()
+                        return target_device._abort_cmd_obj.failed()
                     self.logger.info("Abort configure ends with success!!")
                     if all(target_device._sc_subarray_obs_state[fqdn] == ObsState.ABORTED for fqdn in device_list):
-                        return target_device.abort_cmd_obj.succeeded()
-                    return target_device.abort_cmd_obj.abort_monitoring(device_list)
+                        return target_device._abort_cmd_obj.succeeded()
+                    return target_device._abort_cmd_obj.abort_monitoring(device_list)
 
                 if target_device._timeout_expired or target_device._failure_raised:
                     # if failure/timeout found check if the CBF subarray is configured. In
                     # this case the CSP.LMC Subarray obsState is set to READY.
                     if target_device._sc_subarray_obs_state[target_device.CbfSubarray] == ObsState.READY:
-                        return target_device.configure_cmd_obj.succeeded()
+                        return target_device._configure_cmd_obj.succeeded()
                     self.logger.info("Configure ends with failure")
-                    return target_device.configure_cmd_obj.failed()
+                    return target_device._configure_cmd_obj.failed()
                 if all(target_device._sc_subarray_obs_state[fqdn] == ObsState.READY for fqdn in device_list):
                     target_device._valid_scan_configuration = input_arg[1]
                     target_device._cmd_duration_measured[cmd_name] = time.time() - command_start_time
                     target_device._cmd_progress[cmd_name] = 100
                     target_device._last_executed_command = cmd_name
                     self.logger.info("Configure ends with success!!")
-                    return target_device.configure_cmd_obj.succeeded()
+                    return target_device._configure_cmd_obj.succeeded()
 
         def validate_scan_configuration(self, argin):
             """
@@ -848,9 +913,9 @@ class CspSubarray(SKASubarray):
                 return
             if target_device._abort_obs_event.is_set():
                 if target_device._failure_raised or target_device._timeout_expired:
-                    return target_device.abort_cmd_obj.failed()
+                    return target_device._abort_cmd_obj.failed()
                 self.logger.info("Abort of scan command ends with success!")
-                return target_device.abort_cmd_obj.succeeded()
+                return target_device._abort_cmd_obj.succeeded()
 
     class EndScanCommand(SKASubarray.EndScanCommand):
 
@@ -902,7 +967,7 @@ class CspSubarray(SKASubarray):
                     if target_device._sc_subarray_obs_state[device] == ObsState.IDLE:
                         continue
                     if target_device._sc_subarray_obs_state[device] == ObsState.READY:
-                        (result_code, msg) = target_device.gotoidle_cmd_obj.do()
+                        (result_code, msg) = target_device._gotoidle_cmd_obj.do()
                 return (result_code, msg)
             for device in devices_to_reset:
                 try:
@@ -959,13 +1024,13 @@ class CspSubarray(SKASubarray):
             # end of the while loop
             # check for timeout/failure conditions on each sub-component
             if target_device._failure_raised or target_device._timeout_expired:
-                return target_device.obsreset_cmd_obj.failed()
+                return target_device._obsreset_cmd_obj.failed()
 
             if all(target_device._sc_subarray_obs_state[fqdn] == dev_successful_state for fqdn in device_list):
                 target_device._cmd_progress[cmd_name] = 100
                 target_device._last_executed_command = cmd_name
                 self.logger.info("ObsReset ends with success")
-                return target_device.obsreset_cmd_obj.succeeded()
+                return target_device._obsreset_cmd_obj.succeeded()
 
     class AbortCommand(SKASubarray.AbortCommand):
 
@@ -1040,13 +1105,13 @@ class CspSubarray(SKASubarray):
             # end of the while loop
             # check for timeout/failure conditions on each sub-component
             if target_device._failure_raised or target_device._timeout_expired:
-                return target_device.abort_cmd_obj.failed()
+                return target_device._abort_cmd_obj.failed()
 
             if all(target_device._sc_subarray_obs_state[fqdn] == ObsState.ABORTED for fqdn in device_list):
                 target_device._cmd_progress[cmd_name] = 100
                 target_device._last_executed_command = cmd_name
                 self.logger.info("Abort ends with success")
-                return target_device.abort_cmd_obj.succeeded()
+                return target_device._abort_cmd_obj.succeeded()
 
     class RestartCommand(SKASubarray.RestartCommand):
 
@@ -1123,13 +1188,13 @@ class CspSubarray(SKASubarray):
             # end of the while loop
             # check for timeout/failure conditions on each sub-component
             if target_device._failure_raised or target_device._timeout_expired:
-                return target_device.restart_cmd_obj.failed()
+                return target_device._restart_cmd_obj.failed()
 
             if all(target_device._sc_subarray_obs_state[fqdn] == ObsState.EMPTY for fqdn in device_list):
                 target_device._cmd_progress[cmd_name] = 100
                 target_device._last_executed_command = cmd_name
                 self.logger.info("Restart ends with success")
-                return target_device.restart_cmd_obj.succeeded()
+                return target_device._restart_cmd_obj.succeeded()
 
     '''
     class GoToIdleCommand(ActionCommand):
@@ -1299,14 +1364,14 @@ class CspSubarray(SKASubarray):
             self.logger.info("1")
             target_device._sc_subarray_cmd_exec_state[device][cmd_name] = CmdExecState.IDLE
             if target_device._failure_raised or target_device._timeout_expired:
-                return target_device.gotoidle_cmd_obj.failed()
+                return target_device._gotoidle_cmd_obj.failed()
                 
             self.logger.info("2")
             if all(target_device._sc_subarray_obs_state[fqdn] == dev_successful_state for fqdn in device_list):
                 target_device._last_executed_command = cmd_name
                 # reset the CSP Subarray command execution flag
                 target_device._cmd_execution_state[cmd_name] = CmdExecState.IDLE
-                return target_device.gotoidle_cmd_obj.succeeded()
+                return target_device._gotoidle_cmd_obj.succeeded()
 
         def check_allowed(self):
             """
@@ -1441,7 +1506,7 @@ class CspSubarray(SKASubarray):
                 # update CSP sub-array SCM
                 #07-2020: with the new base classes, transitions are handled via actions.
                 #if evt.attr_value.name.lower() in ["state", "healthstate", "adminmode", "obsstate"]:
-                #    self.update_subarray_state()
+                #   self.update_subarray_state()
                 if evt.attr_value.name.lower() == "healthstate":
                     self._update_subarray_health_state()
             except tango.DevFailed as df:
@@ -1579,7 +1644,7 @@ class CspSubarray(SKASubarray):
            
     # Class protected methods
     # ---------------
-    
+
     def update_subarray_state(self):
         """
         Class protected method.
@@ -1603,12 +1668,12 @@ class CspSubarray(SKASubarray):
         # to determine the CSP health state.
         if self._sc_subarray_state[self.CbfSubarray] == DevState.OFF:
             if self._sc_subarray_obs_state[self.CbfSubarray] == ObsState.EMPTY:
-                self.off_cmd_obj.succeeded()
+                self._off_cmd_obj.succeeded()
         if self._sc_subarray_state[self.CbfSubarray] == DevState.ON:
             if self._sc_subarray_obs_state[self.CbfSubarray] == ObsState.EMPTY:
-                self.on_cmd_obj.succeeded()
+                self._on_cmd_obj.succeeded()
             if self._sc_subarray_obs_state[self.CbfSubarray] == ObsState.READY:
-                self.configure_cmd_obj.succeeded()
+                self._configure_cmd_obj.succeeded()
         #self.set_state(self._sc_subarray_state[self.CbfSubarray])
         #self.logger.info("Csp subarray state: {} obsState: {}".format(self.get_state(), self.state_model._obs_state))
         return True
@@ -1854,14 +1919,19 @@ class CspSubarray(SKASubarray):
         super().init_command_objects()
 
         args = (self, self.state_model, self.logger)
-        self.configure_cmd_obj = self.ConfigureCommand(*args)
-        self.off_cmd_obj = self.OffCommand(*args)
-        self.on_cmd_obj = self.OnCommand(*args)
-        self.scan_cmd_obj = self.ScanCommand(*args)
-        self.gotoidle_cmd_obj = self.GoToIdleCommand(*args)
-        self.obsreset_cmd_obj = self.ObsResetCommand(*args)
-        self.abort_cmd_obj = self.AbortCommand(*args)
-        self.restart_cmd_obj = self.RestartCommand(*args)
+        self._configure_cmd_obj = self.ConfigureCommand(*args)
+        self._off_cmd_obj = self.OffCommand(*args)
+        self._on_cmd_obj = self.OnCommand(*args)
+        self._scan_cmd_obj = self.ScanCommand(*args)
+        self._gotoidle_cmd_obj = self.GoToIdleCommand(*args)
+        self._obsreset_cmd_obj = self.ObsResetCommand(*args)
+        self._abort_cmd_obj = self.AbortCommand(*args)
+        self._restart_cmd_obj = self.RestartCommand(*args)
+        self._assignresources_cmd_obj = self.AssignResourcesCommand(*args)
+        self._releaseresources_cmd_obj = self.ReleaseResourcesCommand(*args)
+        self.register_command_object("AssignResources", self.AssignResourcesCommand(*args))
+        self.register_command_object("ReleaseResources", self.ReleaseResourcesCommand(*args))
+        self.register_command_object("ReleaseAllResources", self.ReleaseAllResourcesCommand(*args))
         self.register_command_object("GoToIdle", self.GoToIdleCommand(*args))
         self.register_command_object("Configure", self.ConfigureCommand(*args))
         self.register_command_object("Scan", self.ScanCommand(*args))