def compose_sub():
resource("ska_mid/tm_subarray_node/1").assert_attribute(
"State").equals("ON")
resource("ska_mid/tm_subarray_node/1").assert_attribute(
"obsState").equals("EMPTY")
assign_resources_file = (
"resources/test_data/TMC_integration/assign_resources1.json")
update_resource_config_file(assign_resources_file)
config = load_config_from_file(assign_resources_file)
CentralNode = DeviceProxy("ska_mid/tm_central/central_node")
CentralNode.AssignResources(config)
LOGGER.info("Invoked AssignResources on CentralNode")
def check_subarry_state():
# check that the obsState of SDP-Subarray is IDEL
assert_that(
resource('mid_sdp/elt/subarray_1').get('obsState')).is_equal_to('IDLE')
# check that the obsState of CSP-Subarray is IDEL
assert_that(resource('ska_mid/tm_subarray_node/1').get(
'obsState')).is_equal_to('IDLE')
# check that the obsState of TMC-Subarray is IDEL
assert_that(resource('mid_csp/elt/subarray_01').get(
'obsState')).is_equal_to('IDLE')
LOGGER.info(
"Then the subarray is in the condition that allows scan configurations to take place: PASSED"
)
def pre_condition(dev_proxy, device_name, expected):
"""verify the device dish mode before executing mode transition requests"""
try:
assert_that(
resource(device_name).get('dishMode')).is_equal_to(expected)
except AssertionError:
# standbyfp mode is used as initial condition since it can be reached from other dish modes
_change_dish_mode(dev_proxy, 'SetStandbyFPMode', device_name)
_change_dish_mode(dev_proxy, mode_cmd_map[expected], device_name)
assert_that(
resource(device_name).get('dishMode')).is_equal_to(expected)
logging.info(device_name + ' initial dishMode: ' +
resource(device_name).get('dishMode'))
def check_subarray_composition(result):
#check that there was no error in response
assert_that(result['response']).is_equal_to(
ResourceAllocation(dishes=[Dish(1), Dish(2),
Dish(3), Dish(4)]))
#check that this is reflected correctly on TMC side
assert_that(resource('ska_mid/tm_subarray_node/1').get(
"receptorIDList")).is_equal_to((1, 2, 3, 4))
#check that this is reflected correctly on CSP side
assert_that(resource('mid_csp/elt/subarray_01').get(
'assignedReceptors')).is_equal_to((1, 2, 3, 4))
assert_that(
resource('mid_csp/elt/master').get('receptorMembership')).is_equal_to(
(1, 1, 1, 1))
def obsreset():
resource("ska_mid/tm_subarray_node/1").assert_attribute(
"State").equals("ON")
# resource('mid_csp/elt/subarray_01').assert_attribute('obsState').equals('ABORTED')
# resource('mid_sdp/elt/subarray_1').assert_attribute('obsState').equals('ABORTED')
SubarrayNode = DeviceProxy("ska_mid/tm_subarray_node/1")
# the_waiter.wait()
LOGGER.info(
"Subarray obsState before Aborted assertion check is: " +
str(SubarrayNode.obsState))
resource("ska_mid/tm_subarray_node/1").assert_attribute(
"obsState").equals("ABORTED")
SubarrayNode.ObsReset()
LOGGER.info("Subarray obsState is: " + str(SubarrayNode.obsState))
LOGGER.info("Invoked obsreset on Subarray")
def compose_sub():
resource("ska_mid/tm_subarray_node/1").assert_attribute("State").equals(
"ON")
resource("ska_mid/tm_subarray_node/1").assert_attribute("obsState").equals(
"EMPTY")
assign_resources_file = "resources/test_data/TMC_integration/assign_resources1.json"
sdp_block = update_resource_config_file(assign_resources_file)
LOGGER.info("_______sdp_block________" + str(sdp_block))
config = load_config_from_file(assign_resources_file)
CentralNode = DeviceProxy("ska_mid/tm_central/central_node")
CentralNode.AssignResources(config)
the_waiter = waiter()
the_waiter.wait()
LOGGER.info("Invoked AssignResources on CentralNode")
return sdp_block
def pre_condition(dev_proxy, device_name, expected):
"""verify the device dish mode before executing mode transition requests"""
actual = resource(device_name).get("dishMode")
LOGGER.info(
f"Resource actual dishMode: {actual}. Expected dishMode: {expected}")
if actual != expected:
# standbyfp is used as initial condition because it can be reached from other
# dish modes but dont request standbyfp if this is the current dish mode
if actual != "STANDBY_FP":
_change_dish_mode(dev_proxy, "SetStandbyFPMode", device_name)
_change_dish_mode(dev_proxy, mode_cmd_map[expected], device_name)
assert_that(resource(device_name).get("dishMode")).is_equal_to(expected)
LOGGER.info(
f"{device_name} initial dishMode: {resource(device_name).get('dishMode')}"
)
def teardown_function(function):
""" teardown any state that was previously setup with a setup_function
call.
"""
if (resource('ska_mid/tm_subarray_node/1').get("State") == "ON"):
the_waiter = waiter()
the_waiter.set_wait_for_tearing_down_subarray()
SubArray(1).deallocate()
the_waiter.wait()
LOGGER.info(the_waiter.logs)
if (resource('ska_mid/tm_subarray_node/1').get("State") == "OFF"):
the_waiter = waiter()
the_waiter.set_wait_for_going_to_standby()
SKAMid().standby()
the_waiter.wait()
LOGGER.info(the_waiter.logs)
def end(result):
""" teardown any state that was previously setup for the tests.
Args:
result (dict): fixture to track test state
"""
subarray = resource(result[SUBARRAY_USED])
obsstate = subarray.get('obsState')
LOGGER.info("CLEANUP: Sub-array in obsState %s ", obsstate)
if obsstate == "IDLE":
LOGGER.info("CLEANUP: tearing down composed subarray (IDLE)")
take_subarray(1).and_release_all_resources()
if obsstate == "READY":
LOGGER.info("CLEANUP: tearing down configured subarray (READY)")
take_subarray(1).and_end_sb_when_ready(
).and_release_all_resources()
if subarray.get('obsState') != "EMPTY":
LOGGER.warning(
"Subarray is still in %s Please restart MVP manually to complete tear down",
obsstate)
restart_subarray(1)
# raise exception since we are unable to continue with tear down
raise Exception("Unable to tear down test setup")
if not telescope_is_in_standby():
set_telescope_to_standby()
LOGGER.info("CLEANUP: Sub-array is in %s ",
subarray.get('obsState'))
def set_subarray_to_fault(result):
"""
Set sub-array to FAULT state by sending incomplete JSON in the Configure
command.
"""
LOGGER.info("Before starting the telescope checking if the TMC is in ON state")
assert(tmc_is_on())
if telescope_is_in_standby():
set_telescope_to_running()
take_subarray(1).to_be_composed_out_of(2)
subarray = SubArray(1)
conf_req = ConfigureRequest()
conf_req.dish = DishConfiguration(receiver_band=ReceiverBand.BAND_1)
# To set sub-array to FAULT, catch and ignore
# the DevFailed of a bad Configure command
try:
subarray.configure_from_cdm(conf_req)
except DevFailed:
pass
subarray_state = resource(result[SUBARRAY_USED]).get('obsState')
assert subarray_state == 'FAULT', \
f"Expected sub-array to be in FAULT but instead was in {subarray_state}"
LOGGER.info("Sub-array has been set to FAULT")
def _loop(self,resources,state_name,resolution,max_nr_of_records,specific_states):
n = 0
list = []
while self._get_running():
n +=1
record = {}
start_time = time()
record['seq'] = n
record['time_window'] = datetime.now().strftime('%H:%M:%S.%f')[:-3]
for resource_name in resources:
if specific_states == {}:
specific_state_name = state_name
else:
specific_state_name = self._get_specific_state(specific_states,resource_name,state_name)
record['{} state'.format(resource_name)] = resource(resource_name).get(specific_state_name)
record['{} delta'.format(resource_name)] = '{:f}'.format(time() - start_time)
if self._is_unique(list,record):
record['unique'] = True
else:
record['unique'] = False
list.append(record)
if max_nr_of_records != None:
if n >= max_nr_of_records:
logging.debug('nr of records ({}) is above max {}, stopping'.format(n,max_nr_of_records))
self._clear_running()
break
time_left_to_sleep = abs(resolution - (time() - start_time))
sleep(time_left_to_sleep)
self._update_records(list)
def test_init(self):
"""
Test the __init__ method.
"""
device_name = 'name'
item_under_test = resource(device_name)
assert item_under_test.device_name == device_name
def check_subarray_composition(result):
#check that there was no error in response
# TODO: To uncomment once latest tmc-mid chart is published
assert_that(result['response']).is_equal_to(
ResourceAllocation(dishes=[Dish(1), Dish(2),
Dish(3), Dish(4)]))
#check that this is reflected correctly on TMC side
assert_that(resource('ska_mid/tm_subarray_node/1').get(
"receptorIDList")).is_equal_to((1, 2, 3, 4))
#check that this is reflected correctly on CSP side
assert_that(resource('mid_csp/elt/subarray_01').get(
'assignedReceptors')).is_equal_to((1, 2, 3, 4))
#assert_that(resource('mid_csp/elt/master').get('receptorMembership')).is_equal_to((1, 1,))
#TODO need to find a better way of testing sets with sets
#assert_that(set(resource('mid_csp/elt/master').get('availableReceptorIDs'))).is_subset_of(set((4,3)))
#check that this is reflected correctly on SDP side - no code at the current implementation
LOGGER.info("Then I have a subarray composed of 4 dishes: PASSED")
def teardown_function(function):
"""teardown any state that was previously setup with a setup_function
call.
"""
if resource("ska_mid/tm_subarray_node/1").get("State") == "ON":
if resource("ska_mid/tm_subarray_node/1").get("obsState") == "IDLE":
LOGGER.info("tearing down composed subarray (IDLE)")
take_subarray(1).and_release_all_resources()
LOGGER.info(
"Resources are deallocated successfully from Subarray.")
if resource("ska_mid/tm_subarray_node/1").get("obsState") == "CONFIGURING":
LOGGER.warn(
"Subarray is still in CONFIFURING! Please restart MVP manually to complete tear down"
)
restart_subarray(1)
raise Exception("Unable to tear down test setup")
if resource("ska_mid/tm_subarray_node/1").get("obsState") == "READY":
LOGGER.info("tearing down configured subarray (READY)")
take_subarray(1).and_end_sb_when_ready().and_release_all_resources()
if resource("ska_mid/tm_subarray_node/1").get("obsState") == "SCANNING":
LOGGER.warn(
"Subarray is still in SCANNING! Please restart MVP manually to complete tear down"
)
restart_subarray(1)
raise Exception("Unable to tear down test setup")
if resource("ska_mid/tm_subarray_node/1").get("obsState") == "ABORTING":
LOGGER.warn(
"Subarray is still in ABORTING! Please restart MVP manually to complete tear down"
)
restart_subarray(1)
if resource("ska_mid/tm_subarray_node/1").get("obsState") == "ABORTED":
take_subarray(1).restart_when_aborted()
LOGGER.info("Put Telescope back to standby")
set_telescope_to_standby()
LOGGER.info("Telescope is in StandBy.")
def receptorID_list_empty():
watch_receptorIDList = watch(resource('ska_mid/tm_subarray_node/1')).for_a_change_on("receptorIDList")
# gather info
receptorIDList_val = watch_receptorIDList.get_value_when_changed()
# confirm
assert_that(receptorIDList_val == [])
logging.info("ReceptorIDList is empty")
# put telescope to standby
SKAMid().standby()
def set_stow_mode(az):
az['initial_az'] = resource(DISH).get("achievedPointing")[1]
dish_proxy = tango.DeviceProxy(DISH)
LOGGER.info(f"{DISH} initial azimuth: {az['initial_az']}")
LOGGER.info(
f"{DISH} initial elevation: {resource(DISH).get('achievedPointing')[2]}"
)
dish_proxy.setstowmode()
LOGGER.info(f"{DISH} requested dishMode: STOW")
def compose_sub():
resource('ska_mid/tm_subarray_node/1').assert_attribute('State').equals(
'ON')
resource('ska_mid/tm_subarray_node/1').assert_attribute('obsState').equals(
'EMPTY')
assign_resources_file = download_test_data(
"mid_assign_resources_v1.json",
"skampi-test-data/tmc-integration/assign-resources")
sdp_block = update_resource_config_file(assign_resources_file)
LOGGER.info("_______sdp_block________" + str(sdp_block))
config = load_config_from_file(assign_resources_file)
os.remove(assign_resources_file)
CentralNode = DeviceProxy('ska_mid/tm_central/central_node')
CentralNode.AssignResources(config)
the_waiter = waiter()
the_waiter.wait()
LOGGER.info('Invoked AssignResources on CentralNode')
return sdp_block
def end(result):
""" teardown any state that was previously setup with a setup_function
call.
"""
obsstate = resource(result[SUBARRAY_USED]).get('obsState')
if obsstate == "IDLE":
LOGGER.info("CLEANUP: tearing down composed subarray (IDLE)")
take_subarray(1).and_release_all_resources()
set_telescope_to_standby()
def restart_subarray(id):
devices = device_to_subarrays.keys()
filtered_devices = [
device for device in devices if device_to_subarrays[device] == id
]
the_waiter = waiter()
the_waiter.set_wait_for_going_to_standby()
exceptions_raised = ""
LOGGER.info("Inside restart subarray method.")
for device in filtered_devices:
try:
resource(device).restart()
LOGGER.info("Restart subarray API invoked on device :" +
str(device))
except Exception as e:
exceptions_raised += f"\nException raised on reseting {device}:{e}"
if exceptions_raised != "":
raise Exception(f"Error in initialising devices:{exceptions_raised}")
the_waiter.wait()
def start_up_telescope(result):
LOGGER.info("Before starting the telescope checking if the TMC is in ON state")
assert(tmc_is_on())
if telescope_is_in_standby():
LOGGER.info("PROCESS: Starting up telescope")
set_telescope_to_running()
subarray_state = resource(result[SUBARRAY_USED]).get('obsState')
assert subarray_state == 'EMPTY', \
f"Expected sub-array to be in EMPTY but instead was in {subarray_state}"
LOGGER.info("Sub-array is in ObsState EMPTY")
def teardown_function(function):
""" teardown any state that was previously setup with a setup_function
call.
"""
if (resource('ska_mid/tm_subarray_node/1').get("obsState") == "IDLE"):
LOGGER.info("Release all resources assigned to subarray")
take_subarray(1).and_release_all_resources()
LOGGER.info("ResourceIdList is empty for Subarray 1 ")
LOGGER.info("Put Telescope back to standby")
set_telescope_to_standby()
LOGGER.info("Telescope is in standby")
def set_telescope_in_off_state(result):
"""
Set telescope to OFF state (stand-by) if it is not yet OFF.
"""
LOGGER.info("Set telescope to stand-by")
if resource(result[CENTRAL_NODE_USED]).get('telescopeState') != 'STANDBY':
set_telescope_to_standby()
assert telescope_is_in_standby(), \
f"Telescope is not in STANDBY"
LOGGER.info("Telescope is in STANDBY")
def test_tm_subarray_inconsistent_at_start_up():
try:
LOGGER.info(
"Before starting the telescope checking if the TMC is in ON state")
assert (tmc_is_on())
LOGGER.info(
"Before starting the telescope checking if the telescope is in StandBy."
)
assert telescope_is_in_standby()
LOGGER.info("Telescope is in StandBy.")
LOGGER.info("Invoking Startup Telescope command on the telescope.")
set_telescope_to_running()
LOGGER.info("Telescope is started successfully.")
resource('ska_mid/tm_central/central_node').assert_attribute(
'telescopeState').equals('ON')
#teardown
finally:
if not telescope_is_in_standby():
set_telescope_to_standby()
def check_ready_state(fixture):
# check that the TMC report subarray as being in the obsState = READY
assert_that(resource('ska_mid/tm_subarray_node/1').get('obsState')).is_equal_to('SCANNING')
#current functionality implies TMC may be in scanning even though CSP is not yet
#logging.info("TMC-subarray obsState: " + resource('ska_mid/tm_subarray_node/1').get("obsState"))
#assert_that(resource('mid_csp/elt/subarray_01').get('obsState')).is_equal_to('SCANNING')
#logging.info("CSP-subarray obsState: " + resource('mid_csp/elt/subarray_01').get("obsState"))
#check that the SDP report subarray as being in the obsState = READY
#assert_that(resource('mid_sdp/elt/subarray_1').get('obsState')).is_equal_to('SCANNING')
#logging.info("SDP-subarray obsState: " + resource('mid_sdp/elt/subarray_1').get("obsState"))
return fixture
def check_final_state(result):
"""
Check that the central node device is in the expected state.
Args:
result (dict): fixture used to track test progress
"""
final_state = resource(result[CENTRAL_NODE_USED]).get('telescopeState')
assert final_state == 'ON', \
f"Expected telescope to be ON but instead was {final_state}"
LOGGER.info("Telescope is on")
def check_final_subarray_state(obsstate, result):
"""
Args:
obsstate (str): Sub-array Tango device ObsState
result (dict): Sub-array Tango device ObsState
"""
subarray_state = resource(result[SUBARRAY_USED]).get('obsState')
assert subarray_state == obsstate, \
f"Expected sub-array to be in {obsstate} but instead was in {subarray_state}"
LOGGER.info("Sub-array is in ObsState %s", obsstate)
def config():
timeout = 60
devices_to_log = [
'ska_mid/tm_subarray_node/1', 'mid_csp/elt/subarray_01',
'mid_csp_cbf/sub_elt/subarray_01', 'mid_sdp/elt/subarray_1',
'mid_d0001/elt/master', 'mid_d0002/elt/master', 'mid_d0003/elt/master',
'mid_d0004/elt/master'
]
non_default_states_to_check = {
'mid_d0001/elt/master': 'pointingState',
'mid_d0002/elt/master': 'pointingState',
'mid_d0003/elt/master': 'pointingState',
'mid_d0004/elt/master': 'pointingState'
}
# update the ID of the config data so that there is no duplicate configs send during tests
file = 'resources/test_data/polaris_b1_no_cam.json'
update_file(file)
signal.signal(signal.SIGALRM, handlde_timeout)
signal.alarm(timeout) # wait for 20 seconds and timeout if still stick
#set up logging of components
s = StateChecker(devices_to_log,
specific_states=non_default_states_to_check)
s.run(threaded=True, resolution=0.1)
LOGGER.info("Starting Configuration Test")
d = DeviceLogging('DeviceLoggingImplWithDBDirect')
d.update_traces(devices_to_log)
d.start_tracing()
#setup a watch for subarray node to change obstate as transaction should only be complete once it has changed
w = watch(
resource('ska_mid/tm_subarray_node/1')).for_a_change_on("obsState")
try:
SubArray(1).configure_from_file(file, with_processing=False)
except:
LOGGER.info(
"Configure Command timed out after {} seconds".format(timeout))
LOGGER.info("Gathering logs")
# sleep for 0.2 seconds to gather any pending events
sleep(0.2)
d.stop_tracing()
s.stop()
print_logs_to_file(s, d, status='error')
LOGGER.info(
"The following messages was logged from devices:\n{}".format(
d.get_printable_messages()))
#LOGGER.info("The following states was captured:\n{}".format(s.get_records()))
pytest.fail("timed out during confguration")
#ensure state is on Ready before proceeding
w.wait_until_value_changed_to('READY', timeout=20)
LOGGER.info("Configure executed successfully")
LOGGER.info("Gathering logs")
s.stop()
d.stop_tracing()
print_logs_to_file(s, d, status='ok')
def check_final_subarray_state(obsstate, result):
"""
Check that the final state of the sub-array is as expected.
Args:
obsstate (str): Sub-array Tango device ObsState
result (dict): fixture used to track progress
"""
subarray_state = resource(result[SUBARRAY_USED]).get('obsState')
assert subarray_state == obsstate, \
f"Expected sub-array to be in {obsstate} but instead was in {subarray_state}"
LOGGER.info("Sub-array is in ObsState %s", obsstate)
def check_going_out_of_empty():
##verify once for obstate = EMPTY
resource("mid_csp/elt/subarray_01").assert_attribute("obsState").equals(
"EMPTY")
resource("mid_sdp/elt/subarray_1").assert_attribute("obsState").equals(
"EMPTY")
resource("ska_mid/tm_subarray_node/1").assert_attribute("obsState").equals(
"EMPTY")
def check_going_out_of_configured():
##Can only return to ON/IDLE if in READY
resource("mid_csp/elt/subarray_01").assert_attribute("obsState").equals(
"READY")
resource("mid_sdp/elt/subarray_1").assert_attribute("obsState").equals(
"READY")
resource("ska_mid/tm_subarray_node/1").assert_attribute("obsState").equals(
"READY")