def do(self):
"""
Initializes the attributes and properties of the Central Node Low.
:return: A tuple containing a return code and a string message indicating status.
The message is for information purpose only.
:rtype: (ReturnCode, str)
:raises: DevFailed if error occurs while initializing the CentralNode device or if error occurs while
creating device proxy for any of the devices like SubarrayNodeLow or MccsMasterLeafNode.
"""
super().do()
device = self.target
try:
self.logger.info("Device initialisating...")
device_data = DeviceData.get_instance()
device.device_data = device_data
# Get Instance of TangoServerHelper class
this_server = TangoServerHelper.get_instance()
this_server.set_tango_class(device)
device.attr_map = {}
# Initialise Attributes
device.attr_map["telescopeHealthState"] = HealthState.UNKNOWN
device.attr_map["subarray1HealthState"] = HealthState.UNKNOWN
device.attr_map["activityMessage"] = ""
device._health_state = HealthState.OK
device._build_state = "{},{},{}".format(
release.name, release.version, release.description)
device._version_id = release.version
device_data.mccs_controller_fqdn = "low-mccs/control/control"
self.logger.debug(const.STR_INIT_SUCCESS)
except DevFailed as dev_failed:
log_msg = f"{const.ERR_INIT_PROP_ATTR_CN}{dev_failed}"
self.logger.exception(dev_failed)
this_server.write_attr("activityMessage",
const.ERR_INIT_PROP_ATTR_CN, False)
tango.Except.throw_exception(
const.STR_CMD_FAILED,
log_msg,
"CentralNode.InitCommand.do()",
tango.ErrSeverity.ERR,
)
for subarray in range(0, len(device.TMLowSubarrayNodes)):
# populate subarray_id-subarray proxy map
tokens = device.TMLowSubarrayNodes[subarray].split("/")
subarray_id = int(tokens[2])
device_data.subarray_FQDN_dict[
subarray_id] = device.TMLowSubarrayNodes[subarray]
this_server.write_attr("activityMessage",
const.STR_CN_INIT_SUCCESS, False)
self.logger.info(device.attr_map["activityMessage"])
return (ResultCode.OK, device.attr_map["activityMessage"])
def do(self):
"""
Method to invoke StandBy command.
param argin: None.
return:
A tuple containing a return code and a string message indicating status.
The message is for information purpose only.
rtype:
(ResultCode, str)
raises:
AssertionError if Mccs On command is not completed.
"""
device_data = self.target
try:
self.this_server = TangoServerHelper.get_instance()
# Check if Mccs On command is completed
cmd_res = json.loads(device_data.cmd_res_evt_val)
log_msg = "commandresult attribute value in StandByTelescope command", cmd_res
self.logger.debug(log_msg)
if cmd_res["result_code"] != 0:
retry = 0
while retry < 3:
if cmd_res["result_code"] == 0:
break
retry += 1
time.sleep(0.1)
assert cmd_res["result_code"] == 0, "Startup command completed OK"
self.mccs_master_ln_fqdn = ""
property_value = self.this_server.read_property("MCCSMasterLeafNodeFQDN")
self.mccs_master_ln_fqdn = self.mccs_master_ln_fqdn.join(property_value)
self.create_mccs_client(self.mccs_master_ln_fqdn)
subarray_low = self.this_server.read_property("TMLowSubarrayNodes")
self.create_subarray_client(subarray_low)
device_data.health_aggreegator.unsubscribe_event()
log_msg = const.STR_STANDBY_CMD_ISSUED
self.logger.info(log_msg)
self.this_server.write_attr("activityMessage", log_msg, False)
# Unsubscribe commandResult attribute of MccsController
cmd_res_subscriber_unsubscriber_obj = CommandResultFetcher()
cmd_res_subscriber_unsubscriber_obj._unsubscribe_cmd_res_attribute_events()
return (ResultCode.OK, const.STR_STANDBY_CMD_ISSUED)
except AssertionError:
log_msg = const.ERR_STARTUP_CMD_INCOMPLETE
self.logger.exception(log_msg)
self.this_server.write_attr("activityMessage", const.ERR_STARTUP_CMD_INCOMPLETE, False)
tango.Except.throw_exception(const.STR_STANDBY_EXEC, log_msg,
"CentralNode.StandByTelescopeCommand",
tango.ErrSeverity.ERR)
def __init__(self, logger=None):
if logger is None:
self.logger = logging.getLogger(__name__)
else:
self.logger = logger
self._mccs_sa_obs_state = None
self.mccs_obs_state_event_id = {}
self.this_server = TangoServerHelper.get_instance()
self.device_data = DeviceData.get_instance()
def do(self):
"""
Initializes the attributes and properties of the CspSubarrayLeafNode.
:return: A tuple containing a return code and a string message indicating status. The message is
for information purpose only.
:rtype: (ReturnCode, str)
:raises: DevFailed if error occurs in creating proxy for CSPSubarray.
"""
super().do()
device = self.target
this_server = TangoServerHelper.get_instance()
this_server.set_tango_class(device)
device.attr_map = {}
device.attr_map["delayModel"] = " "
device.attr_map["activityMessage"] = ""
device._build_state = "{},{},{}".format(release.name,
release.version,
release.description)
device._version_id = release.version
device._versioninfo = " "
# The IERS_A file needs to be downloaded each time when the MVP is deployed.
delay_manager_obj = DelayManager.get_instance()
try:
download_iers_thread = threading.Thread(
None, delay_manager_obj.download_IERS_file,
"CspSubarrayLeafNode")
download_iers_thread.start()
except Exception as delay_execption:
log_msg = f"Exception in DelayCorrection Katpoint API {delay_execption}"
self.logger.exception(log_msg)
tango.Except.throw_exception(
const.STR_CMD_FAILED,
log_msg,
"CspSubarrayLeafNode.InitCommand.do()",
tango.ErrSeverity.ERR,
)
ApiUtil.instance().set_asynch_cb_sub_model(
tango.cb_sub_model.PUSH_CALLBACK)
this_server.write_attr(
"activityMessage",
f"{const.STR_SETTING_CB_MODEL}{ApiUtil.instance().get_asynch_cb_sub_model()}",
False,
)
this_server.set_status(const.STR_CSPSALN_INIT_SUCCESS)
this_server.write_attr("activityMessage",
const.STR_CSPSALN_INIT_SUCCESS, False)
self.logger.info(const.STR_CSPSALN_INIT_SUCCESS)
return (ResultCode.OK, const.STR_CSPSALN_INIT_SUCCESS)
def __init__(self, logger=None):
if logger == None:
self.logger = logging.getLogger(__name__)
else:
self.logger = logger
self.device_data = DeviceData.get_instance()
self.this_server = TangoServerHelper.get_instance()
self.event_id = None
self.csp_master = TangoClient(
self.this_server.read_property("CspMasterFQDN")[0])
def __init__(self, logger=None):
if logger == None:
self.logger = logging.getLogger(__name__)
else:
self.logger = logger
self.mccs_ln_asigned_res_event_id = {}
self.this_server = TangoServerHelper.get_instance()
self.device_data = DeviceData.get_instance()
mccs_subarray_ln_fqdn = self.this_server.read_property(
"MccsSubarrayLNFQDN")[0]
self.mccs_client = TangoClient(mccs_subarray_ln_fqdn)
def do(self, argin):
"""
Method to invoke Configure command.
:param argin: DevString.
JSON string example is:
{"interface":"https://schema.skatelescope.org/ska-low-tmc-configure/1.0","mccs":{"stations":[{"station_id":1},{"station_id":2}],"subarray_beams":[{"subarray_beam_id":1,"station_ids":[1,2],"update_rate":0.0,"channels":[[0,8,1,1],[8,8,2,1],[24,16,2,1]],"antenna_weights":[1.0,1.0,1.0],"phase_centre":[0.0,0.0],"target":{"system":"HORIZON","name":"DriftScan","az":180.0,"el":45.0}}]},"sdp":{},"tmc":{"scan_duration":10.0}}
return:
A tuple containing a return code and a string message indicating status.
The message is for information purpose only.
rtype:
(ReturnCode, str)
raises:
JSONDecodeError if input argument json string contains invalid value
DevFailed if the command execution is not successful.
"""
device_data = self.target
device_data.is_scan_completed = False
device_data.is_release_resources = False
device_data.is_abort_command_executed = False
device_data.is_obsreset_command_executed = False
device_data.is_restart_command_executed = False
self.logger.info(const.STR_CONFIGURE_CMD_INVOKED_SA_LOW)
log_msg = f"{const.STR_CONFIGURE_IP_ARG}{argin}"
self.logger.info(log_msg)
self.this_server = TangoServerHelper.get_instance()
self.this_server.write_attr("activityMessage",
const.STR_CONFIGURE_CMD_INVOKED_SA_LOW,
False)
try:
scan_configuration = json.loads(argin)
except json.JSONDecodeError as jerror:
log_message = f"{const.ERR_INVALID_JSON}{jerror}"
self.logger.error(log_message)
self.this_server.write_attr("activityMessage", log_message, False)
tango.Except.throw_exception(
const.STR_CMD_FAILED,
log_message,
const.STR_CONFIGURE_EXEC,
tango.ErrSeverity.ERR,
)
tmc_configure = scan_configuration["tmc"]
device_data.scan_duration = int(tmc_configure["scan_duration"])
self._create_mccs_cmd_data(scan_configuration)
message = "Configure command invoked"
self.logger.info(message)
return (ResultCode.STARTED, message)
def do(self):
"""
Initializes the attributes and properties of the Subarray Node.
return:
A tuple containing a return code and a string message indicating status.
The message is for information purpose only.
rtype:
(ReturnCode, str)
raises:
DevFailed if the error while subscribing the tango attribute
"""
super().do()
device = self.target
device.set_status(const.STR_SA_INIT)
device_data = DeviceData.get_instance()
device.device_data = device_data
this_server = TangoServerHelper.get_instance()
this_server.set_tango_class(device)
device.attr_map = {}
device.attr_map["scanID"] = ""
device.attr_map["assigned_resources"] = ""
device.attr_map["activityMessage"] = ""
device._obs_mode = ObsMode.IDLE
device._resource_list = []
device.is_end_command = False
device.is_release_resources = False
device._build_state = "{},{},{}".format(release.name,
release.version,
release.description)
device._version_id = release.version
device._health_event_id = []
device._mccs_sa_obs_state = ObsState.EMPTY
device.subarray_ln_health_state_map = {}
device._subarray_health_state = (
HealthState.OK) # Aggregated Subarray Health State
device.device_data.obs_state_aggr = ObsStateAggregator(self.logger)
device.device_data.obs_state_aggr.subscribe()
# subscribe to HealthState
device.device_data.health_state_aggr = HealthStateAggregator(
self.logger)
device.device_data.health_state_aggr.subscribe()
device_data.assigned_resources_maintainer = AssignedResourcesMaintainer(
)
device_data.assigned_resources_maintainer.subscribe()
this_server.write_attr("activityMessage",
const.STR_SA_INIT_SUCCESS, False)
self.logger.info(const.STR_SA_INIT_SUCCESS)
return (ResultCode.OK, const.STR_SA_INIT_SUCCESS)
def validate_obs_state(self):
self.this_server = TangoServerHelper.get_instance()
sdp_subarray_fqdn = self.this_server.read_property("SdpSubarrayFQDN")[0]
sdp_sa_client = TangoClient(sdp_subarray_fqdn)
if sdp_sa_client.get_attribute("obsState").value in [ObsState.EMPTY, ObsState.IDLE]:
self.logger.info(
"SDP subarray is in required obstate,Hence resources to SDP can be assign."
)
else:
self.logger.error("Subarray is not in EMPTY obstate")
log_msg = "Error in device obstate."
self.this_server.write_attr("activityMessage", log_msg, False)
raise InvalidObsStateError("SDP subarray is not in EMPTY obstate.")
def do(self, argin):
"""
Method to invoke Scan command on MCCS Subarray.
:param argin: JSON string consists of scan id (int) and start_time.
Example:
{"interface":"https://schema.skatelescope.org/ska-low-mccs-scan/1.0","scan_id":1,"start_time":0.0}
Note: Enter the json string without spaces as a input.
return:
None
raises:
DevFailed if the command execution is not successful
"""
this_server = TangoServerHelper.get_instance()
device_data = DeviceData.get_instance()
try:
mccs_subarray_fqdn = ""
property_value = this_server.read_property("MccsSubarrayFQDN")[0]
mccs_subarray_fqdn = mccs_subarray_fqdn.join(property_value)
mccs_subarray_client = TangoClient(mccs_subarray_fqdn)
assert mccs_subarray_client.get_attribute(
"obsState").value == ObsState.READY
mccs_subarray_client.send_command_async(const.CMD_SCAN, argin,
self.scan_cmd_ended_cb)
this_server.write_attr("activityMessage", const.STR_SCAN_SUCCESS,
False)
self.logger.info(const.STR_SCAN_SUCCESS)
except AssertionError as assertion_error:
log_msg = f"{const.ERR_DEVICE_NOT_READY}{assertion_error}"
device_data._read_activity_message = log_msg
self.logger.exception(log_msg)
tango.Except.throw_exception(const.STR_SCAN_EXEC, log_msg,
"MccsSubarrayLeafNode.Scan",
tango.ErrSeverity.ERR)
except DevFailed as dev_failed:
log_msg = f"{const.ERR_SCAN_RESOURCES}{dev_failed}"
this_server.write_attr("activityMessage", log_msg, False)
self.logger.exception(dev_failed)
tango.Except.throw_exception(
const.STR_SCAN_EXEC,
log_msg,
"MccsSubarrayLeafNode.Scan",
tango.ErrSeverity.ERR,
)
def __init__(self, logger=None):
if logger == None:
self.logger = logging.getLogger(__name__)
else:
self.logger = logger
self.subarray_ln_health_state_map = {}
self.mccs_ln_health_event_id = {}
self.this_server = TangoServerHelper.get_instance()
self.device_data = DeviceData.get_instance()
mccs_subarray_ln_fqdn = ""
property_val = self.this_server.read_property("MccsSubarrayLNFQDN")
mccs_subarray_ln_fqdn = mccs_subarray_ln_fqdn.join(property_val)
self.mccs_client = TangoClient(mccs_subarray_ln_fqdn)
def do(self, argin):
"""
Method to invoke Configure command on dish.
:param argin:
A String in a JSON format that includes pointing parameters of Dish- Azimuth and
Elevation Angle.
Example:
{"pointing":{"target":{"system":"ICRS","name":"Polaris Australis","RA":"21:08:47.92","dec":"-88:57:22.9"}},
"dish":{"receiverBand":"1"}}
return:
None
raises:
DevFailed If error occurs while invoking ConfigureBand<> command on DishMaster or
if the json string contains invalid data.
"""
device_data = self.target
command_name = "Configure"
try:
this_server = TangoServerHelper.get_instance()
self.dish_master_fqdn = ""
property_value = this_server.read_property("DishMasterFQDN")
self.dish_master_fqdn = self.dish_master_fqdn.join(property_value)
json_argument = device_data._load_config_string(argin)
receiver_band = json_argument["dish"]["receiverBand"]
self._configure_band(receiver_band)
except DevFailed as dev_failed:
self.logger.exception(dev_failed)
log_message = (
f"Exception occured while executing the '{command_name}' command."
)
this_server.write_attr("activityMessage", log_message, False)
tango.Except.re_throw_exception(
dev_failed,
f"Exception in '{command_name}' command.",
log_message,
f"DishLeafNode.{command_name}Command",
tango.ErrSeverity.ERR,
)
except KeyError as key_error:
raise Exception(
f"JSON key not found.'{key_error}'in Configure.do().")
self.logger.info("'%s' command executed successfully.", command_name)
def do(self):
"""
Method to invoke SetOperateMode command on DishMaster.
param argin:
None
return:
None
raises:
DevFailed If error occurs while invoking SetOperateMode command on DishMaster.
"""
cmd_ended_cb = CommandCallBack(self.logger).cmd_ended_cb
attributes_to_subscribe_to = (
"dishMode",
"capturing",
"achievedPointing",
"desiredPointing",
)
command_name = "SetOperateMode"
cmd_ended_cb = CommandCallBack(self.logger).cmd_ended_cb
try:
self.this_server = TangoServerHelper.get_instance()
self.dish_master_fqdn = ""
property_value = self.this_server.read_property("DishMasterFQDN")
self.dish_master_fqdn = self.dish_master_fqdn.join(property_value)
dish_client = TangoClient(self.dish_master_fqdn)
# Subscribe the DishMaster attributes
self._subscribe_to_attribute_events(attributes_to_subscribe_to, dish_client)
dish_client.send_command_async(command_name, callback_method=cmd_ended_cb)
self.logger.info("'%s' command executed successfully.", command_name)
except DevFailed as dev_failed:
self.logger.exception(dev_failed)
log_message = (
f"Exception occured while executing the '{command_name}' command."
)
self.this_server.write_attr("activityMessage", log_message, False)
tango.Except.re_throw_exception(
dev_failed,
f"Exception in '{command_name}' command.",
log_message,
f"DishLeafNode.{command_name}Command",
tango.ErrSeverity.ERR,
)
def do(self):
"""
Initializes the attributes and properties of the DishLeafNode.
:return: A tuple containing a return code and a string message indicating status.
The message is for information purpose only.
:rtype: (ResultCode, str)
:raises DevFailed: If error occurs in creating a DeviceProxy instance for DishMaster
"""
super().do()
device = self.target
self.logger.info("Initializing DishLeafNode...")
# Create DeviceData class instance
device_data = DeviceData.get_instance()
device.device_data = device_data
# Get Instance of TangoServerHelper class
this_server = TangoServerHelper.get_instance()
this_server.device = device
device.attr_map = {}
# Initialise Attributes
device.attr_map["activityMessage"] = ""
device._build_state = (
f"{release.name},{release.version},{release.description}")
device._version_id = release.version
device_data.set_dish_name_number(device.DishMasterFQDN)
azel_converter = AzElConverter(self.logger)
azel_converter.create_antenna_obj()
log_message = f"DishMasterFQDN :-> {device.DishMasterFQDN}"
self.logger.debug(log_message)
this_server.write_attr("activityMessage", log_message, False)
device._health_state = HealthState.OK
device._simulation_mode = SimulationMode.FALSE
ApiUtil.instance().set_asynch_cb_sub_model(
tango.cb_sub_model.PUSH_CALLBACK)
log_message = f"Setting CallBack Model as :-> {ApiUtil.instance().get_asynch_cb_sub_model()}"
self.logger.debug(log_message)
this_server.write_attr("activityMessage", log_message, False)
# Download IERS file from internet
self.download_iers_thread = threading.Thread(
None, azel_converter.download_IERS_file, "DishLeafNode")
self.download_iers_thread.start()
log_message = "Dish Leaf Node initialized successfully."
device.set_status(log_message)
this_server.write_attr("activityMessage", log_message, False)
self.logger.info(log_message)
return (ResultCode.OK, log_message)
def __init__(self, logger=None):
if logger == None:
self.logger = logging.getLogger(__name__)
else:
self.logger = logger
self.device_data = DeviceData.get_instance()
self.subarray_health_state_map = {}
self.this_server = TangoServerHelper.get_instance()
#self.mccs_master_ln_fqdn = self.this_server.read_property("MCCSMasterLeafNodeFQDN")[0]
self.mccs_master_ln_fqdn = ""
property_value = self.this_server.read_property(
"MCCSMasterLeafNodeFQDN")
self.mccs_master_ln_fqdn = self.mccs_master_ln_fqdn.join(
property_value)
self.health_state_event_map = {}
def do(self):
"""
Initializes the attributes and properties of the MccsMasterLeafNode.
:return: A tuple containing a return code and a string message indicating status.
The message is for information purpose only.
:rtype: (ResultCode, str)
:raises: DevFailed if error occurs while creating the device proxy for Mccs Master or
subscribing the evennts.
"""
super().do()
device = self.target
device._health_state = HealthState.OK # Setting healthState to "OK"
device._simulation_mode = (SimulationMode.FALSE
) # Enabling the simulation mode
device._test_mode = TestMode.NONE
device._build_state = "{},{},{}".format(release.name,
release.version,
release.description)
device._version_id = release.version
self.this_server = TangoServerHelper.get_instance()
self.this_server.set_tango_class(device)
device.attr_map = {}
# Initialise Attributes
device.attr_map["activityMessage"] = ""
# Create DeviceData class instance
device_data = DeviceData.get_instance()
device.device_data = device_data
self.this_server.write_attr("activityMessage",
const.STR_MCCS_INIT_LEAF_NODE, False)
self.this_server.write_attr(
"activityMessage",
f"{const.STR_MCCSMASTER_FQDN}{device.MccsMasterFQDN}", False)
# Creating proxy to the CSPMaster
log_msg = f"MCCS Master name: {device.MccsMasterFQDN}"
self.logger.debug(log_msg)
ApiUtil.instance().set_asynch_cb_sub_model(
tango.cb_sub_model.PUSH_CALLBACK)
log_msg = f"{const.STR_SETTING_CB_MODEL}{ApiUtil.instance().get_asynch_cb_sub_model()}"
self.logger.debug(log_msg)
self.this_server.write_attr("activityMessage",
const.STR_INIT_SUCCESS, False)
self.logger.info(const.STR_INIT_SUCCESS)
return (ResultCode.OK, const.STR_INIT_SUCCESS)
def do(self):
"""
Method to invoke On command on CSP Element.
param argin:
None
return:
A tuple containing a return code and a string message indicating status.
The message is for information purpose only.
rtype:
(ResultCode, str)
raises:
DevFailed on communication failure with CspMaster or CspMaster is in error state.
"""
device_data = self.target
this_device = TangoServerHelper.get_instance()
try:
csp_mln_client_obj = TangoClient(
this_device.read_property("CspMasterFQDN")[0])
csp_mln_client_obj.send_command_async(const.CMD_ON, [],
self.on_cmd_ended_cb)
self.logger.debug(const.STR_ON_CMD_ISSUED)
this_device.write_attr("activityMessage", const.STR_ON_CMD_ISSUED,
False)
device_data.cbf_health_updator = CbfHealthStateAttributeUpdator()
device_data.cbf_health_updator.start()
device_data.pss_health_updator = PssHealthStateAttributeUpdator()
device_data.pss_health_updator.start()
device_data.pst_health_updator = PstHealthStateAttributeUpdator()
device_data.pst_health_updator.start()
return (ResultCode.OK, const.STR_ON_CMD_ISSUED)
except DevFailed as dev_failed:
log_msg = f"{const.ERR_EXE_ON_CMD}{dev_failed}"
self.logger.exception(dev_failed)
this_device.write_attr("activityMessage", const.ERR_EXE_ON_CMD,
False)
tango.Except.re_throw_exception(
dev_failed,
const.STR_ON_EXEC,
log_msg,
"CspMasterLeafNode.OnCommand",
tango.ErrSeverity.ERR,
)
def do(self):
"""
Method to invoke EndScan command.
return:
A tuple containing a return code and a string message indicating status.
The message is for information purpose only.
rtype:
(ReturnCode, str)
raises:
DevFailed if the command execution is not successful.
"""
device_data = self.target
device_data.is_release_resources = False
device_data.is_abort_command_executed = False
device_data.is_obsreset_command_executed = False
device_data.is_restart_command_executed = False
this_server = TangoServerHelper.get_instance()
try:
if device_data.scan_timer_handler.is_scan_running():
device_data.scan_timer_handler.stop_scan_timer() # stop timer when EndScan command is called
device_data.isScanRunning = False
device_data.is_scan_completed = True
mccs_subarray_ln_fqdn = ""
property_val = this_server.read_property("MccsSubarrayLNFQDN")
mccs_subarray_ln_fqdn = mccs_subarray_ln_fqdn.join(property_val)
mccs_subarray_ln_client = TangoClient(mccs_subarray_ln_fqdn)
mccs_subarray_ln_client.send_command(const.CMD_END_SCAN)
self.logger.debug(const.STR_MCCS_END_SCAN_INIT)
this_server.write_attr("activityMessage", const.STR_MCCS_END_SCAN_INIT, False)
this_server.write_attr("scanID", "")
self.logger.info(const.STR_SCAN_COMPLETE)
this_server.write_attr("activityMessage", const.STR_END_SCAN_SUCCESS, False)
return (ResultCode.OK, const.STR_END_SCAN_SUCCESS)
except DevFailed as dev_failed:
log_msg = f"{const.ERR_END_SCAN_CMD_ON_MCCS}{dev_failed}"
self.logger.exception(dev_failed)
tango.Except.throw_exception(
const.STR_END_SCAN_EXEC,
log_msg,
"SubarrayNode.EndScanCommand",
tango.ErrSeverity.ERR,
)
def validate_obs_state(self):
this_server = TangoServerHelper.get_instance()
csp_subarray_fqdn = this_server.read_property("CspSubarrayFQDN")[0]
csp_sa_client = TangoClient(csp_subarray_fqdn)
if csp_sa_client.get_attribute("obsState").value in [
ObsState.EMPTY,
ObsState.IDLE,
]:
self.logger.info(
"CSP Subarray is in required obsState, resources will be assigned"
)
else:
self.logger.error("CSP Subarray is not in EMPTY/IDLE obsState")
this_server.write_attr("activityMessage",
"Error in device obsState", False)
raise InvalidObsStateError(
"CSP Subarray is not in EMPTY/IDLE obsState")
def do(self):
"""
Method to invoke End command on MCCS Subarray.
return:
None
raises:
DevFailed if the command execution is not successful.
"""
this_server = TangoServerHelper.get_instance()
device_data = DeviceData.get_instance()
try:
mccs_subarray_fqdn = ""
property_value = this_server.read_property("MccsSubarrayFQDN")[0]
mccs_subarray_fqdn = mccs_subarray_fqdn.join(property_value)
mccs_subarray_client = TangoClient(mccs_subarray_fqdn)
assert mccs_subarray_client.get_attribute(
"obsState").value == ObsState.READY
mccs_subarray_client.send_command_async(const.CMD_END, None,
self.end_cmd_ended_cb)
this_server.write_attr("activityMessage", const.STR_END_SUCCESS,
False)
self.logger.info(const.STR_END_SUCCESS)
except AssertionError:
log_msg = const.STR_OBS_STATE
device_data._read_activity_message = const.ERR_DEVICE_NOT_READY
self.logger.error(log_msg)
tango.Except.throw_exception(const.STR_END_EXEC,
const.ERR_DEVICE_NOT_READY,
"MCCSSubarrayLeafNode.End",
tango.ErrSeverity.ERR)
except DevFailed as dev_failed:
log_msg = f"{const.ERR_END_INVOKING_CMD}{dev_failed}"
this_server.write_attr("activityMessage", log_msg, False)
self.logger.exception(dev_failed)
tango.Except.throw_exception(
const.ERR_END_INVOKING_CMD,
log_msg,
"MccsSubarrayLeafNode.End()",
tango.ErrSeverity.ERR,
)
def do(self):
"""
Initializes the attributes and properties of the SdpMasterLeafNode.
return:
A tuple containing a return code and a string message indicating status.
The message is for information purpose only.
rtype:
(ReturnCode, str)
"""
super().do()
device = self.target
device_data = DeviceData.get_instance()
device.device_data = device_data
# Creating Instance of TangoServerHelper class
self.this_server = TangoServerHelper.get_instance()
self.this_server.device = device
device.attr_map = {}
# Initialising Attributes
device.attr_map["versionInfo"]=""
device.attr_map["activityMessage"]=""
device.attr_map["ProcessingBlockList"]= "test"
device._health_state = HealthState.OK # Setting healthState to "OK"
device._simulation_mode = (
SimulationMode.FALSE
) # Enabling the simulation mode
device._test_mode = TestMode.NONE
device.set_status(const.STR_INIT_SUCCESS)
device._build_state = "{},{},{}".format(
release.name, release.version, release.description
)
device._version_id = release.version
ApiUtil.instance().set_asynch_cb_sub_model(tango.cb_sub_model.PUSH_CALLBACK)
log_msg = f"{const.STR_SETTING_CB_MODEL}{ApiUtil.instance().get_asynch_cb_sub_model()}"
self.logger.debug(log_msg)
self.this_server.write_attr("activityMessage", const.STR_INIT_SUCCESS, False)
self.logger.info(const.STR_INIT_SUCCESS)
return (ResultCode.OK, const.STR_INIT_SUCCESS)
def do(self):
"""
Method to invoke End command.
return:
A tuple containing a return code and a string message indicating status.
The message is for information purpose only.
rtype:
(ResultCode, str)
raises:
DevFailed if the command execution is not successful.
"""
device_data = self.target
this_server = TangoServerHelper.get_instance()
device_data.is_end_command = False
device_data.is_release_resources = False
device_data.is_abort_command_executed = False
device_data.is_obsreset_command_executed = False
device_data.is_restart_command_executed = False
try:
self.logger.info(const.STR_END_CMD_INVOKED_SA_LOW)
mccs_subarray_ln_fqdn = ""
property_val = this_server.read_property("MccsSubarrayLNFQDN")
mccs_subarray_ln_fqdn = mccs_subarray_ln_fqdn.join(property_val)
mccs_subarray_ln_client = TangoClient(mccs_subarray_ln_fqdn)
mccs_subarray_ln_client.send_command(const.CMD_END)
self.logger.info(const.STR_CMD_END_INV_MCCS)
this_server.write_attr("activityMessage", const.STR_END_SUCCESS, False)
self.logger.info(const.STR_END_SUCCESS)
device_data.is_end_command = True
return (ResultCode.OK, const.STR_END_SUCCESS)
except DevFailed as dev_failed:
log_msg = f"{const.ERR_END_INVOKING_CMD}{dev_failed}"
self.logger.exception(log_msg)
tango.Except.throw_exception(
const.STR_END_EXEC,
log_msg,
"SubarrayNode.EndCommand",
tango.ErrSeverity.ERR,
)
def do(self):
"""
Invokes TrackStop command on the DishMaster.
param argin:
None
return:
None
raises:
DevFailed If error occurs while invoking TrackStop command on DishMaster.
"""
device_data = self.target
command_name = "Abort"
device_data.event_track_time.set()
cmd_ended_cb = CommandCallBack(self.logger).cmd_ended_cb
try:
this_server = TangoServerHelper.get_instance()
self.dish_master_fqdn = ""
property_value = this_server.read_property("DishMasterFQDN")
self.dish_master_fqdn = self.dish_master_fqdn.join(property_value)
dish_client = TangoClient(self.dish_master_fqdn)
dish_pointing_state = dish_client.get_attribute("pointingState")
if (dish_pointing_state.value is not PointingState.READY):
dish_client.send_command_async("TrackStop",
callback_method=cmd_ended_cb)
self.logger.info("'%s' command executed successfully.",
command_name)
except DevFailed as dev_failed:
self.logger.exception(dev_failed)
log_message = (
f"Exception occured while executing the '{command_name}' command."
)
this_server.write_attr("activityMessage", log_message, False)
tango.Except.re_throw_exception(
dev_failed,
f"Exception in '{command_name}' command.",
log_message,
"Abort.do()",
tango.ErrSeverity.ERR,
)
def assign_resources_ended(self, event):
"""
Callback function immediately executed when the asynchronous invoked
command returns.
:param: CmdDoneEvent object
It has the following members:
- device : (DeviceProxy) The DeviceProxy object on which the call was executed.
- cmd_name : (str) The command name
- argout_raw : (DeviceData) The command argout
- argout : The command argout
- err : (bool) A boolean flag set to true if the command failed. False otherwise
- errors : (sequence<DevError>) The error stack
- ext
:return: none
:raises: DevFailed if this command is not allowed to be run
in current device state
"""
self.logger.info("Executing callback assign_resources_ended_cb")
this_server = TangoServerHelper.get_instance()
try:
if event.err:
this_server.write_attr("activityMessage", f"{const.ERR_INVOKING_CMD}{event.cmd_name}\n{event.errors}", False)
log = const.ERR_INVOKING_CMD + event.cmd_name
self.logger.error(log)
else:
log = const.STR_COMMAND + event.cmd_name + const.STR_INVOKE_SUCCESS
this_server.write_attr("activityMessage", log, False)
self.logger.info(log)
except tango.DevFailed as df:
self.logger.exception(df)
tango.Except.re_throw_exception(
df,
"CSP subarray gave an error response",
"CSP subarray threw error in AddReceptors CSP LMC_CommandFailed",
"AddReceptors",
tango.ErrSeverity.ERR,
)
def __init__(self):
"""Private constructor of the class"""
if DeviceData.__instance != None:
raise Exception("This is singletone class")
else:
DeviceData.__instance = self
self.this_server = TangoServerHelper.get_instance()
self.el = 30.0
self.az = 0.0
self.ele_max_lim = 90
self.ele_min_lim = 17.5
self.el_limit = False
self.radec_value = ""
self.dish_name = ""
self.dish_number = ""
self.event_track_time = threading.Event()
self.attr_event_map = {}
self.observer = None
def __init__(self, logger=None):
"""Private constructor of the class"""
if DelayManager.__instance is not None:
raise Exception("This is singletone class")
else:
DelayManager.__instance = self
if logger is None:
self.logger = logging.getLogger(__name__)
else:
self.logger = logger
self.fsids_list = []
self.delay_model_json = {}
self.device_data = DeviceData.get_instance()
self._DELAY_UPDATE_INTERVAL = 10
# _delay_in_advance variable (in seconds) is added to current timestamp and is used to calculate advance
# delay coefficients.
self._delay_in_advance = 60
self.this_server = TangoServerHelper.get_instance()
def do(self):
"""
Method to invoke ReleaseAllResources command on CSP Subarray.
return:
None
raises:
DevFailed if the command execution is not successful
"""
device_data = self.target
try:
# Invoke RemoveAllResources command on CspSubarray
device_data.receptorIDList_str = []
device_data.fsids_list = []
this_server = TangoServerHelper.get_instance()
csp_subarray_fqdn = ""
property_val = this_server.read_property("CspSubarrayFQDN")
csp_subarray_fqdn = csp_subarray_fqdn.join(property_val)
csp_sub_client_obj = TangoClient(csp_subarray_fqdn)
csp_sub_client_obj.send_command_async(
const.CMD_RELEASE_ALL_RESOURCES,
None,
self.releaseallresources_cmd_ended_cb,
)
this_server.write_attr("activityMessage",
const.STR_RELEASE_ALL_RESOURCES_SUCCESS,
False)
self.logger.info(const.STR_RELEASE_ALL_RESOURCES_SUCCESS)
except DevFailed as dev_failed:
log_msg = f"{const.ERR_RELEASE_ALL_RESOURCES}{dev_failed}"
this_server.write_attr("activityMessage", log_msg, False)
self.logger.exception(dev_failed)
tango.Except.throw_exception(
const.STR_RELEASE_RES_EXEC,
log_msg,
"CspSubarrayLeafNode.ReleaseAllResourcesCommand",
tango.ErrSeverity.ERR,
)
def do(self):
"""
Method to invoke ObsReset command.
return:
A tuple containing a return code and a string
message indicating status. The message is for
information purpose only.
rtype:
(ResultCode, str)
raises:
DevFailed if error occurs while invoking command on MccsSubarrayLeafNode.
"""
device_data = self.target
device_data.is_abort_command_executed = False
this_server = TangoServerHelper.get_instance()
try:
self.logger.info("ObsReset command invoked on SubarrayNodeLow.")
mccs_subarray_ln_fqdn = ""
property_val = this_server.read_property("MccsSubarrayLNFQDN")
mccs_subarray_ln_fqdn = mccs_subarray_ln_fqdn.join(property_val)
mccs_subarray_ln_client = TangoClient(mccs_subarray_ln_fqdn)
mccs_subarray_ln_client.send_command(const.CMD_OBSRESET)
this_server.write_attr("activityMessage",
const.STR_OBSRESET_SUCCESS, False)
self.logger.info(const.STR_OBSRESET_SUCCESS)
this_server.set_status(const.STR_OBSRESET_SUCCESS)
device_data.is_obsreset_command_executed = True
return (ResultCode.STARTED, const.STR_OBSRESET_SUCCESS)
except DevFailed as dev_failed:
log_msg = f"{const.ERR_OBSRESET_INVOKING_CMD}{dev_failed}"
self.logger.exception(log_msg)
tango.Except.throw_exception(
const.STR_OBSRESET_EXEC,
log_msg,
"SKASubarrayLow.ObsReset",
tango.ErrSeverity.ERR,
)
def do(self):
"""
Method to invoke Abort command.
return:
A tuple containing a return code and a string
message indicating status. The message is for
information purpose only.
rtype:
(ResultCode, str)
raises:
DevFailed if error occurs in invoking command on MCCS Subarrayleaf node.
"""
device_data = self.target
device_data.is_release_resources = False
device_data.is_end_command = False
device_data.is_obsreset_command_executed = False
device_data.is_restart_command_executed = False
this_server = TangoServerHelper.get_instance()
try:
if device_data.scan_timer_handler.is_scan_running():
device_data.scan_timer_handler.stop_scan_timer()
mccs_subarray_ln_fqdn = ""
property_val = this_server.read_property("MccsSubarrayLNFQDN")
mccs_subarray_ln_fqdn = mccs_subarray_ln_fqdn.join(property_val)
self.abort_mccs(mccs_subarray_ln_fqdn)
device_data.is_abort_command_executed = True
return (ResultCode.STARTED, const.STR_ABORT_SUCCESS)
except DevFailed as dev_failed:
log_msg = f"{const.ERR_ABORT_INVOKING_CMD}{dev_failed}"
self.logger.exception(dev_failed)
tango.Except.throw_exception(
const.ERR_ABORT_INVOKING_CMD,
log_msg,
"SubarrayNode.Abort",
tango.ErrSeverity.ERR,
)
def do(self, argin):
"""
Method to invoke Slew command on Dish Master.
:param argin: list
[0] = Azimuth, in degrees
[1] = Elevation, in degrees
return:
None
raises:
DevFailed If error occurs while invoking Slew command on DishMaster.
"""
command_name = "Slew"
cmd_ended_cb = CommandCallBack(self.logger).cmd_ended_cb
try:
this_server = TangoServerHelper.get_instance()
self.dish_master_fqdn = ""
property_value = this_server.read_property("DishMasterFQDN")
self.dish_master_fqdn = self.dish_master_fqdn.join(property_value)
dish_client = TangoClient(self.dish_master_fqdn)
dish_client.send_command_async(command_name,
command_data=argin,
callback_method=cmd_ended_cb)
self.logger.info("'%s' command executed successfully.",
command_name)
except DevFailed as dev_failed:
self.logger.exception(dev_failed)
log_message = (
f"Exception occured while executing the '{command_name}' command."
)
this_server.write_attr("activityMessage", log_message, False)
tango.Except.re_throw_exception(
dev_failed,
f"Exception in '{command_name}' command.",
log_message,
"Slew.do()",
tango.ErrSeverity.ERR,
)
