class TestObservatoryUtil(IonUnitTestCase): def setUp(self): self.mu = MockUtil() self.process_mock = self.mu.create_process_mock() self.container_mock = self.mu.create_container_mock() self.dsm_mock = self.mu.create_device_status_manager_mock() res_list = [ dict(rt='Org', _id='Org_1', attr={}), dict(rt='Observatory', _id='Obs_1', attr={}), dict(rt='Observatory', _id='Obs_2', attr={}), dict(rt='Subsite', _id='Sub_1', attr={}), dict(rt='Subsite', _id='Sub_2', attr={}), dict(rt='PlatformSite', _id='PS_1', attr={}), dict(rt='InstrumentSite', _id='IS_1', attr={}), dict(rt='PlatformDevice', _id='PD_1', attr={}), dict(rt='InstrumentDevice', _id='ID_1', attr={}), ] assoc_list = [ ['Obs_1', 'hasSite', 'Sub_1'], ['Sub_1', 'hasSite', 'PS_1'], ['PS_1', 'hasSite', 'IS_1'], ] assoc_list1 = [ ['Org_1', 'hasResource', 'Obs_1'], ['Org_1', 'hasResource', 'Obs_2'], ['Obs_2', 'hasSite', 'Sub_2'], ] assoc_list2 = [ ['PS_1', 'hasDevice', 'PD_1'], ['IS_1', 'hasDevice', 'ID_1'], ['PD_1', 'hasDevice', 'ID_1'], ] def spy_get_child_sites(self, parent_site_id=None, org_id=None, exclude_types=None, include_parents=True, id_only=True): child_sites, site_ancestors = self.obs_util.get_child_sites(parent_site_id=parent_site_id, org_id=org_id, exclude_types=exclude_types, include_parents=include_parents, id_only=id_only) print "child_sites of", parent_site_id, "are", child_sites print "site_ancestors of", parent_site_id, "are", site_ancestors return child_sites, site_ancestors def test_get_child_sites(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) site_resources, site_children = self.spy_get_child_sites(parent_site_id='Obs_1', include_parents=False, id_only=True) self.assertEquals(len(site_resources), 3) self.assertEquals(len(site_children), 3) self.assertIn('Sub_1', site_resources) self.assertIn('PS_1', site_resources) self.assertIn('IS_1', site_resources) self.assertNotIn('Obs_1', site_resources) self.assertEquals(len([v for v in site_resources.values() if v is None]), 3) site_resources, site_children = self.spy_get_child_sites(parent_site_id='Obs_1', include_parents=False, id_only=False) self.assertEquals(len(site_resources), 3) self.assertEquals(len(site_children), 3) self.assertEquals(len([v for v in site_resources.values() if v is None]), 0) self.assertEquals(site_resources['Sub_1']._get_type(), RT.Subsite) site_resources, site_children = self.spy_get_child_sites(parent_site_id='Obs_1', include_parents=True) self.assertEquals(len(site_resources), 4) self.assertEquals(len(site_children), 3) self.assertIn('Obs_1', site_resources) site_resources, site_children = self.spy_get_child_sites(parent_site_id='Sub_1', include_parents=False) self.assertEquals(len(site_resources), 2) self.assertEquals(len(site_children), 2) self.assertNotIn('Sub_1', site_resources) site_resources, site_children = self.spy_get_child_sites(parent_site_id='Sub_1', include_parents=True) self.assertEquals(len(site_resources), 4) self.assertEquals(len(site_children), 3) self.assertIn('Sub_1', site_resources) self.assertIn('Obs_1', site_resources) site_resources, site_children = self.spy_get_child_sites(parent_site_id='PS_1', include_parents=False) self.assertEquals(len(site_resources), 1) self.assertEquals(len(site_children), 1) site_resources, site_children = self.spy_get_child_sites(parent_site_id='PS_1', include_parents=True) self.assertEquals(len(site_resources), 4) self.assertEquals(len(site_children), 3) site_resources, site_children = self.spy_get_child_sites(parent_site_id='IS_1', include_parents=False) self.assertEquals(len(site_resources), 0) self.assertEquals(len(site_children), 0) site_resources, site_children = self.spy_get_child_sites(parent_site_id='IS_1', include_parents=True) self.assertEquals(len(site_resources), 4) self.assertEquals(len(site_children), 3) site_resources, site_children = self.spy_get_child_sites(parent_site_id='XXX', include_parents=True) self.assertEquals(len(site_resources), 1) self.assertEquals(len(site_children), 0) def test_get_child_sites_org(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list + self.assoc_list1) self.mu.assign_mockres_find_objects(filter_predicate="hasResource") self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) child_sites, site_ancestors = self.obs_util.get_child_sites(org_id='Org_1', include_parents=False, id_only=True) self.assertEquals(len(child_sites), 6) self.assertEquals(len(site_ancestors), 5) self.assertIn('Sub_1', child_sites) self.assertIn('PS_1', child_sites) self.assertIn('IS_1', child_sites) self.assertIn('Obs_1', child_sites) self.assertIn('Obs_2', child_sites) child_sites, site_ancestors = self.obs_util.get_child_sites(org_id='Org_1', include_parents=True, id_only=True) self.assertEquals(len(child_sites), 7) self.assertEquals(len(site_ancestors), 5) child_sites, site_ancestors = self.obs_util.get_child_sites(org_id='Org_1', include_parents=True, id_only=False) self.assertEquals(len(child_sites), 7) self.assertEquals(len(site_ancestors), 5) self.assertEquals(len([v for v in child_sites.values() if v is None]), 0) self.assertEquals(child_sites['Org_1']._get_type(), RT.Org) def test_get_site_devices(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list2) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) site_devices = self.obs_util.get_site_devices(['Sub_1', 'PS_1', 'IS_1']) self.assertEquals(len(site_devices), 3) self.assertEquals(site_devices['Sub_1'], []) self.assertEquals(site_devices['IS_1'], [('InstrumentSite', 'ID_1', 'InstrumentDevice')]) def test_get_child_devices(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list2) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) child_devices = self.obs_util.get_child_devices('PD_1') self.assertEquals(len(child_devices), 2) self.assertEquals(child_devices['PD_1'][0][1], 'ID_1') child_devices = self.obs_util.get_child_devices('ID_1') self.assertEquals(len(child_devices), 1) self.assertEquals(child_devices['ID_1'], []) child_devices = self.obs_util.get_child_devices('Sub_1') self.assertEquals(len(child_devices), 1) self.assertEquals(child_devices['Sub_1'], []) child_devices = self.obs_util.get_child_devices('XXX') self.assertEquals(len(child_devices), 1) def test_get_device_data_products(self): self.mu.load_mock_resources(self.res_list + self.res_list1) self.mu.load_mock_associations(self.assoc_list + self.assoc_list1 + self.assoc_list2 + self.assoc_list3) self.mu.assign_mockres_find_objects(filter_predicate="hasResource") self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) res_dict = self.obs_util.get_site_data_products('Obs_1', RT.Observatory) self.assertGreaterEqual(len(res_dict), 6) self.assertIsNone(res_dict['data_product_resources']) self.assertIn('ID_1', res_dict['device_data_products']) self.assertEquals(len(res_dict['device_data_products']['ID_1']), 3) self.assertIn('DP_1', res_dict['device_data_products']['ID_1']) self.assertIn('PD_1', res_dict['device_data_products']) self.assertEquals(len(res_dict['device_data_products']['PD_1']), 3) res_dict = self.obs_util.get_site_data_products('PS_1', RT.PlatformSite) self.assertEquals(len(res_dict['device_data_products']['ID_1']), 3) self.assertIn('ID_1', res_dict['device_data_products']) self.assertIn('DP_1', res_dict['device_data_products']['ID_1']) self.assertIn('PD_1', res_dict['device_data_products']) self.assertEquals(len(res_dict['device_data_products']['PD_1']), 3) res_dict = self.obs_util.get_site_data_products('Org_1', RT.Org) self.assertIn('DP_1', res_dict['device_data_products']['ID_1']) res_dict = self.obs_util.get_site_data_products('PS_1', RT.PlatformSite, include_data_products=True) self.assertIsNotNone(res_dict['data_product_resources']) self.assertIn('DP_1', res_dict['data_product_resources']) #import pprint #pprint.pprint(res_dict) status_by_device_1 = { "ID_1": _devstat("ID_1", DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK), "PD_1": _devstat("PD_1", DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK), } status_by_device_2 = { "ID_1": _devstat("ID_1", DST.STATUS_WARNING, DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK), "PD_1": _devstat("PD_1", DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK), } status_by_device_3 = { "ID_1": _devstat("ID_1", DST.STATUS_WARNING, DST.STATUS_WARNING, DST.STATUS_OK, DST.STATUS_OK), "PD_1": _devstat("PD_1", DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK), } status_by_device_4 = { "ID_1": _devstat("ID_1", DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK), "PD_1": _devstat("PD_1", DST.STATUS_WARNING, DST.STATUS_WARNING, DST.STATUS_OK, DST.STATUS_OK), } def test_get_status_roll_ups(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list + self.assoc_list1 + self.assoc_list2) self.mu.load_mock_device_statuses(self.status_by_device_1) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock, device_status_mgr=self.dsm_mock) # No problems status_rollups = self.obs_util.get_status_roll_ups('ID_1', RT.InstrumentDevice) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('PD_1', RT.PlatformDevice) self.assertIn('PD_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('IS_1', RT.InstrumentSite) self.assertEquals(len(status_rollups), 6) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('PS_1', RT.PlatformSite) self.assertEquals(len(status_rollups), 6) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'PS_1') self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('Sub_1', RT.Subsite) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Sub_1') self._assert_status(status_rollups, 'PS_1') self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('Obs_1', RT.Observatory) self.assertIn('Obs_1', status_rollups) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Obs_1') self._assert_status(status_rollups, 'Sub_1') self._assert_status(status_rollups, 'PS_1') self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') # ID_1 power warning self.mu.load_mock_device_statuses(self.status_by_device_2) status_rollups = self.obs_util.get_status_roll_ups('ID_1', RT.InstrumentDevice) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('PD_1', RT.PlatformDevice) self._assert_status(status_rollups, 'PD_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('IS_1', RT.InstrumentSite) self.assertIn('IS_1', status_rollups) self._assert_status(status_rollups, 'IS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('PS_1', RT.PlatformSite) self.assertIn('PS_1', status_rollups) self.assertIn('IS_1', status_rollups) self._assert_status(status_rollups, 'PS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING) self._assert_status(status_rollups, 'IS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING) # ID_1 power+comms warning self.mu.load_mock_device_statuses(self.status_by_device_3) status_rollups = self.obs_util.get_status_roll_ups('ID_1', RT.InstrumentDevice) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('PD_1', RT.PlatformDevice) self._assert_status(status_rollups, 'PD_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('IS_1', RT.InstrumentSite) self.assertEquals(len(status_rollups), 6) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'IS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('PS_1', RT.PlatformSite) self.assertEquals(len(status_rollups), 6) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'PS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('Sub_1', RT.Subsite) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Sub_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('Obs_1', RT.Observatory) self.assertIn('Obs_1', status_rollups) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Obs_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'Sub_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) def test_get_status_roll_ups_platform_warn(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list + self.assoc_list1 + self.assoc_list2) self.mu.load_mock_device_statuses(self.status_by_device_4) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock, device_status_mgr=self.dsm_mock) # PD_1 power+comms warning status_rollups = self.obs_util.get_status_roll_ups('ID_1', RT.InstrumentDevice) self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('PD_1', RT.PlatformDevice) #log.warn("status %s" % status_rollups) self._assert_status(status_rollups, 'PD_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('IS_1', RT.InstrumentSite) self.assertEquals(len(status_rollups), 6) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('PS_1', RT.PlatformSite) self.assertEquals(len(status_rollups), 6) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'PS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('Sub_1', RT.Subsite) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Sub_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('Obs_1', RT.Observatory) self.assertIn('Obs_1', status_rollups) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Obs_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'Sub_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') def _assert_status(self, status_rollups, res_id=None, agg=DST.STATUS_OK, loc=DST.STATUS_OK, data=DST.STATUS_OK, comms=DST.STATUS_OK, power=DST.STATUS_OK): res_status = status_rollups[res_id] if res_id else status_rollups log.debug("_assert_status(%s) = %s", res_id, res_status) self.assertEquals(len(res_status), 5) if agg is not None: self.assertEquals(res_status['agg'], agg) if loc is not None: self.assertEquals(res_status[AggregateStatusType.AGGREGATE_LOCATION], loc) if data is not None: self.assertEquals(res_status[AggregateStatusType.AGGREGATE_DATA], data) if comms is not None: self.assertEquals(res_status[AggregateStatusType.AGGREGATE_COMMS], comms) if power is not None: self.assertEquals(res_status[AggregateStatusType.AGGREGATE_POWER], power) res_list1 = [ dict(rt='DataProduct', _id='DP_1', attr={}), dict(rt='DataProduct', _id='DP_2', attr={}), dict(rt='DataProduct', _id='DP_3', attr={}), dict(rt='DataProduct', _id='DP_4', attr={}), dict(rt='DataProduct', _id='DP_5', attr={}), ] assoc_list3 = [ ['DP_1', 'hasSource', 'ID_1'], ['DP_1', 'hasSource', 'IS_1'], ['DP_2', 'hasSource', 'ID_1'], ['DP_3', 'hasSource', 'ID_1'], ['DP_3', 'hasSource', 'PD_1'], ['DP_4', 'hasSource', 'PD_1'], ['DP_5', 'hasSource', 'PD_1'], ]
class TestObservatoryUtil(IonUnitTestCase): def setUp(self): self.mu = MockUtil() self.process_mock = self.mu.create_process_mock() self.container_mock = self.mu.create_container_mock() res_list = [ dict(rt='Org', _id='Org_1', attr={}), dict(rt='Observatory', _id='Obs_1', attr={}), dict(rt='Observatory', _id='Obs_2', attr={}), dict(rt='Subsite', _id='Sub_1', attr={}), dict(rt='Subsite', _id='Sub_2', attr={}), dict(rt='PlatformSite', _id='PS_1', attr={}), dict(rt='InstrumentSite', _id='IS_1', attr={}), dict(rt='PlatformDevice', _id='PD_1', attr={}), dict(rt='InstrumentDevice', _id='ID_1', attr={}), ] assoc_list = [ ['Obs_1', 'hasSite', 'Sub_1'], ['Sub_1', 'hasSite', 'PS_1'], ['PS_1', 'hasSite', 'IS_1'], ] assoc_list1 = [ ['Org_1', 'hasResource', 'Obs_1'], ['Org_1', 'hasResource', 'Obs_2'], ['Obs_2', 'hasSite', 'Sub_2'], ] assoc_list2 = [ ['PS_1', 'hasDevice', 'PD_1'], ['IS_1', 'hasDevice', 'ID_1'], ['PD_1', 'hasDevice', 'ID_1'], ] def spy_get_child_sites(self, parent_site_id=None, org_id=None, exclude_types=None, include_parents=True, id_only=True): child_sites, site_ancestors = self.obs_util.get_child_sites(parent_site_id=parent_site_id, org_id=org_id, exclude_types=exclude_types, include_parents=include_parents, id_only=id_only) print "child_sites of", parent_site_id, "are", child_sites print "site_ancestors of", parent_site_id, "are", site_ancestors return child_sites, site_ancestors def test_get_child_sites(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) child_sites, site_ancestors = self.spy_get_child_sites(parent_site_id='Obs_1', include_parents=False, id_only=True) self.assertEquals(len(child_sites), 3) self.assertEquals(len(site_ancestors), 3) self.assertIn('Sub_1', child_sites) self.assertIn('PS_1', child_sites) self.assertIn('IS_1', child_sites) self.assertNotIn('Obs_1', child_sites) self.assertEquals(len([v for v in child_sites.values() if v is None]), 3) child_sites, site_ancestors = self.spy_get_child_sites(parent_site_id='Obs_1', include_parents=False, id_only=False) self.assertEquals(len(child_sites), 3) self.assertEquals(len(site_ancestors), 3) self.assertEquals(len([v for v in child_sites.values() if v is None]), 0) self.assertEquals(child_sites['Sub_1']._get_type(), RT.Subsite) child_sites, site_ancestors = self.spy_get_child_sites(parent_site_id='Obs_1', include_parents=True) self.assertEquals(len(child_sites), 4) self.assertEquals(len(site_ancestors), 3) self.assertIn('Obs_1', child_sites) child_sites, site_ancestors = self.spy_get_child_sites(parent_site_id='Sub_1', include_parents=False) self.assertEquals(len(child_sites), 2) self.assertEquals(len(site_ancestors), 2) self.assertNotIn('Sub_1', child_sites) child_sites, site_ancestors = self.spy_get_child_sites(parent_site_id='Sub_1', include_parents=True) self.assertEquals(len(child_sites), 4) self.assertEquals(len(site_ancestors), 3) self.assertIn('Sub_1', child_sites) self.assertIn('Obs_1', child_sites) child_sites, site_ancestors = self.spy_get_child_sites(parent_site_id='PS_1', include_parents=False) self.assertEquals(len(child_sites), 1) self.assertEquals(len(site_ancestors), 1) child_sites, site_ancestors = self.spy_get_child_sites(parent_site_id='PS_1', include_parents=True) self.assertEquals(len(child_sites), 4) self.assertEquals(len(site_ancestors), 3) child_sites, site_ancestors = self.spy_get_child_sites(parent_site_id='IS_1', include_parents=False) self.assertEquals(len(child_sites), 0) self.assertEquals(len(site_ancestors), 0) child_sites, site_ancestors = self.spy_get_child_sites(parent_site_id='IS_1', include_parents=True) self.assertEquals(len(child_sites), 4) self.assertEquals(len(site_ancestors), 3) child_sites, site_ancestors = self.spy_get_child_sites(parent_site_id='XXX', include_parents=True) self.assertEquals(len(child_sites), 1) self.assertEquals(len(site_ancestors), 0) def test_get_child_sites_org(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list + self.assoc_list1) self.mu.assign_mockres_find_objects(filter_predicate="hasResource") self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) child_sites, site_ancestors = self.obs_util.get_child_sites(org_id='Org_1', include_parents=False, id_only=True) self.assertEquals(len(child_sites), 6) self.assertEquals(len(site_ancestors), 5) self.assertIn('Sub_1', child_sites) self.assertIn('PS_1', child_sites) self.assertIn('IS_1', child_sites) self.assertIn('Obs_1', child_sites) self.assertIn('Obs_2', child_sites) child_sites, site_ancestors = self.obs_util.get_child_sites(org_id='Org_1', include_parents=True, id_only=True) self.assertEquals(len(child_sites), 7) self.assertEquals(len(site_ancestors), 5) child_sites, site_ancestors = self.obs_util.get_child_sites(org_id='Org_1', include_parents=True, id_only=False) self.assertEquals(len(child_sites), 7) self.assertEquals(len(site_ancestors), 5) self.assertEquals(len([v for v in child_sites.values() if v is None]), 0) self.assertEquals(child_sites['Org_1']._get_type(), RT.Org) def test_get_site_devices(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list2) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) site_devices = self.obs_util.get_site_devices(['Sub_1', 'PS_1', 'IS_1']) self.assertEquals(len(site_devices), 3) self.assertEquals(site_devices['Sub_1'], []) self.assertEquals(site_devices['IS_1'], [('InstrumentSite', 'ID_1', 'InstrumentDevice')]) def test_get_child_devices(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list2) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) child_devices = self.obs_util.get_child_devices('PD_1') self.assertEquals(len(child_devices), 1) self.assertEquals(child_devices['PD_1'][0][1], 'ID_1') child_devices = self.obs_util.get_child_devices('ID_1') self.assertEquals(len(child_devices), 1) self.assertEquals(child_devices['ID_1'], []) child_devices = self.obs_util.get_child_devices('Sub_1') self.assertEquals(len(child_devices), 1) self.assertEquals(child_devices['Sub_1'], []) child_devices = self.obs_util.get_child_devices('XXX') self.assertEquals(len(child_devices), 1) event_list1 = [ dict(et='DeviceStatusEvent', o='ID_1', attr=dict(status=DeviceStatusType.STATUS_WARNING) ) ] event_list2 = [ dict(et='DeviceStatusEvent', o='ID_1', attr=dict(status=DeviceStatusType.STATUS_WARNING)) ] event_list3 = [ dict(et='DeviceCommsEvent', o='ID_1', attr=dict(state=DeviceCommsType.DATA_DELIVERY_INTERRUPTION)) ] event_list4 = [ dict(et='DeviceStatusEvent', o='PD_1', attr=dict(status=DeviceStatusType.STATUS_WARNING)), dict(et='DeviceCommsEvent', o='PD_1', attr=dict(state=DeviceCommsType.DATA_DELIVERY_INTERRUPTION)) ] def test_get_status_roll_ups(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list + self.assoc_list1 + self.assoc_list2) self.mu.load_mock_events(self.event_list1) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) # No problems status_rollups = self.obs_util.get_status_roll_ups('ID_1', RT.InstrumentDevice) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('PD_1', RT.PlatformDevice) self.assertIn('PD_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('IS_1', RT.InstrumentSite) self.assertEquals(len(status_rollups), 6) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('PS_1', RT.PlatformSite) self.assertEquals(len(status_rollups), 6) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'PS_1') self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('Sub_1', RT.Subsite) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Sub_1') self._assert_status(status_rollups, 'PS_1') self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('Obs_1', RT.Observatory) self.assertIn('Obs_1', status_rollups) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Obs_1') self._assert_status(status_rollups, 'Sub_1') self._assert_status(status_rollups, 'PS_1') self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') # ID_1 power warning self.mu.load_mock_events(self.event_list2) status_rollups = self.obs_util.get_status_roll_ups('ID_1', RT.InstrumentDevice) self._assert_status(status_rollups, 'ID_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('PD_1', RT.PlatformDevice) self._assert_status(status_rollups, 'PD_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('IS_1', RT.InstrumentSite) self.assertIn('IS_1', status_rollups) self._assert_status(status_rollups, 'IS_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('PS_1', RT.PlatformSite) self.assertIn('PS_1', status_rollups) self.assertIn('IS_1', status_rollups) self._assert_status(status_rollups, 'PS_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'IS_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING) # ID_1 power+comms warning self.mu.load_mock_events(self.event_list3) status_rollups = self.obs_util.get_status_roll_ups('ID_1', RT.InstrumentDevice) self._assert_status(status_rollups, 'ID_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('PD_1', RT.PlatformDevice) self._assert_status(status_rollups, 'PD_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('IS_1', RT.InstrumentSite) self.assertEquals(len(status_rollups), 6) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'IS_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('PS_1', RT.PlatformSite) self.assertEquals(len(status_rollups), 6) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'PS_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('Sub_1', RT.Subsite) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Sub_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'PS_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('Obs_1', RT.Observatory) self.assertIn('Obs_1', status_rollups) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Obs_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'Sub_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'PS_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) def test_get_status_roll_ups_platform_warn(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list + self.assoc_list1 + self.assoc_list2) self.mu.load_mock_events(self.event_list4) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) # PD_1 power+comms warning status_rollups = self.obs_util.get_status_roll_ups('ID_1', RT.InstrumentDevice) self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('PD_1', RT.PlatformDevice) #log.warn("status %s" % status_rollups) self._assert_status(status_rollups, 'PD_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('IS_1', RT.InstrumentSite) self.assertEquals(len(status_rollups), 6) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('PS_1', RT.PlatformSite) self.assertEquals(len(status_rollups), 6) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'PS_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('Sub_1', RT.Subsite) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Sub_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'PS_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('Obs_1', RT.Observatory) self.assertIn('Obs_1', status_rollups) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Obs_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'Sub_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'PS_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1', agg=DeviceStatusType.STATUS_WARNING, power=DeviceStatusType.STATUS_WARNING, comms=DeviceStatusType.STATUS_WARNING) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') def _assert_status(self, status_rollups, res_id=None, agg=DeviceStatusType.STATUS_OK, loc=DeviceStatusType.STATUS_OK, data=DeviceStatusType.STATUS_OK, comms=DeviceStatusType.STATUS_OK, power=DeviceStatusType.STATUS_OK): res_status = status_rollups[res_id] if res_id else status_rollups self.assertEquals(len(res_status), 5) # #self.assertEquals(res_status['agg'], agg) # self.assertEquals(res_status['loc'], loc) # self.assertEquals(res_status['data'], data) # self.assertEquals(res_status['comms'], comms) # self.assertEquals(res_status['power'], power) res_list1 = [ dict(rt='DataProduct', _id='DP_1', attr={}), dict(rt='DataProduct', _id='DP_2', attr={}), dict(rt='DataProduct', _id='DP_3', attr={}), dict(rt='DataProduct', _id='DP_4', attr={}), dict(rt='DataProduct', _id='DP_5', attr={}), ] assoc_list3 = [ ['DP_1', 'hasSource', 'ID_1'], ['DP_2', 'hasSource', 'ID_1'], ['DP_3', 'hasSource', 'ID_1'], ['DP_3', 'hasSource', 'PD_1'], ['DP_4', 'hasSource', 'PD_1'], ['DP_5', 'hasSource', 'PD_1'], ] def test_get_device_data_products(self): self.mu.load_mock_resources(self.res_list + self.res_list1) self.mu.load_mock_associations(self.assoc_list + self.assoc_list1 + self.assoc_list2 + self.assoc_list3) self.mu.assign_mockres_find_objects(filter_predicate="hasResource") self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) res_dict = self.obs_util.get_site_data_products('Obs_1', RT.Observatory) self.assertGreaterEqual(len(res_dict), 6) self.assertIsNone(res_dict['data_product_resources']) self.assertIn('ID_1', res_dict['device_data_products']) self.assertEquals(len(res_dict['device_data_products']['ID_1']), 3) self.assertIn('DP_1', res_dict['device_data_products']['ID_1']) self.assertIn('PD_1', res_dict['device_data_products']) self.assertEquals(len(res_dict['device_data_products']['PD_1']), 3) res_dict = self.obs_util.get_site_data_products('PS_1', RT.PlatformSite) self.assertEquals(len(res_dict['device_data_products']['ID_1']), 3) self.assertIn('ID_1', res_dict['device_data_products']) self.assertIn('DP_1', res_dict['device_data_products']['ID_1']) self.assertIn('PD_1', res_dict['device_data_products']) self.assertEquals(len(res_dict['device_data_products']['PD_1']), 3) res_dict = self.obs_util.get_site_data_products('Org_1', RT.Org) self.assertIn('DP_1', res_dict['device_data_products']['ID_1']) res_dict = self.obs_util.get_site_data_products('PS_1', RT.PlatformSite, include_data_products=True) self.assertIsNotNone(res_dict['data_product_resources']) self.assertIn('DP_1', res_dict['data_product_resources'])
class TestObservatoryUtil(IonUnitTestCase): def setUp(self): self.mu = MockUtil() self.process_mock = self.mu.create_process_mock() self.container_mock = self.mu.create_container_mock() res_list = [ dict(rt='Org', _id='Org_1', attr={}), dict(rt='Observatory', _id='Obs_1', attr={}), dict(rt='Observatory', _id='Obs_2', attr={}), dict(rt='Subsite', _id='Sub_1', attr={}), dict(rt='Subsite', _id='Sub_2', attr={}), dict(rt='PlatformSite', _id='PS_1', attr={}), dict(rt='InstrumentSite', _id='IS_1', attr={}), dict(rt='PlatformDevice', _id='PD_1', attr={}), dict(rt='InstrumentDevice', _id='ID_1', attr={}), ] assoc_list = [ ['Obs_1', 'hasSite', 'Sub_1'], ['Sub_1', 'hasSite', 'PS_1'], ['PS_1', 'hasSite', 'IS_1'], ] assoc_list1 = [ ['Org_1', 'hasResource', 'Obs_1'], ['Org_1', 'hasResource', 'Obs_2'], ['Obs_2', 'hasSite', 'Sub_2'], ] assoc_list2 = [ ['PS_1', 'hasDevice', 'PD_1'], ['IS_1', 'hasDevice', 'ID_1'], ['PD_1', 'hasDevice', 'ID_1'], ] def spy_get_child_sites(self, parent_site_id=None, org_id=None, exclude_types=None, include_parents=True, id_only=True): child_sites, site_ancestors = self.obs_util.get_child_sites( parent_site_id=parent_site_id, org_id=org_id, exclude_types=exclude_types, include_parents=include_parents, id_only=id_only) print "child_sites of", parent_site_id, "are", child_sites print "site_ancestors of", parent_site_id, "are", site_ancestors return child_sites, site_ancestors def test_get_child_sites(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) site_resources, site_children = self.spy_get_child_sites( parent_site_id='Obs_1', include_parents=False, id_only=True) self.assertEquals(len(site_resources), 3) self.assertEquals(len(site_children), 3) self.assertIn('Sub_1', site_resources) self.assertIn('PS_1', site_resources) self.assertIn('IS_1', site_resources) self.assertNotIn('Obs_1', site_resources) self.assertEquals( len([v for v in site_resources.values() if v is None]), 3) site_resources, site_children = self.spy_get_child_sites( parent_site_id='Obs_1', include_parents=False, id_only=False) self.assertEquals(len(site_resources), 3) self.assertEquals(len(site_children), 3) self.assertEquals( len([v for v in site_resources.values() if v is None]), 0) self.assertEquals(site_resources['Sub_1']._get_type(), RT.Subsite) site_resources, site_children = self.spy_get_child_sites( parent_site_id='Obs_1', include_parents=True) self.assertEquals(len(site_resources), 4) self.assertEquals(len(site_children), 3) self.assertIn('Obs_1', site_resources) site_resources, site_children = self.spy_get_child_sites( parent_site_id='Sub_1', include_parents=False) self.assertEquals(len(site_resources), 2) self.assertEquals(len(site_children), 2) self.assertNotIn('Sub_1', site_resources) site_resources, site_children = self.spy_get_child_sites( parent_site_id='Sub_1', include_parents=True) self.assertEquals(len(site_resources), 4) self.assertEquals(len(site_children), 3) self.assertIn('Sub_1', site_resources) self.assertIn('Obs_1', site_resources) site_resources, site_children = self.spy_get_child_sites( parent_site_id='PS_1', include_parents=False) self.assertEquals(len(site_resources), 1) self.assertEquals(len(site_children), 1) site_resources, site_children = self.spy_get_child_sites( parent_site_id='PS_1', include_parents=True) self.assertEquals(len(site_resources), 4) self.assertEquals(len(site_children), 3) site_resources, site_children = self.spy_get_child_sites( parent_site_id='IS_1', include_parents=False) self.assertEquals(len(site_resources), 0) self.assertEquals(len(site_children), 0) site_resources, site_children = self.spy_get_child_sites( parent_site_id='IS_1', include_parents=True) self.assertEquals(len(site_resources), 4) self.assertEquals(len(site_children), 3) site_resources, site_children = self.spy_get_child_sites( parent_site_id='XXX', include_parents=True) self.assertEquals(len(site_resources), 1) self.assertEquals(len(site_children), 0) def test_get_child_sites_org(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list + self.assoc_list1) self.mu.assign_mockres_find_objects(filter_predicate="hasResource") self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) child_sites, site_ancestors = self.obs_util.get_child_sites( org_id='Org_1', include_parents=False, id_only=True) self.assertEquals(len(child_sites), 6) self.assertEquals(len(site_ancestors), 5) self.assertIn('Sub_1', child_sites) self.assertIn('PS_1', child_sites) self.assertIn('IS_1', child_sites) self.assertIn('Obs_1', child_sites) self.assertIn('Obs_2', child_sites) child_sites, site_ancestors = self.obs_util.get_child_sites( org_id='Org_1', include_parents=True, id_only=True) self.assertEquals(len(child_sites), 7) self.assertEquals(len(site_ancestors), 5) child_sites, site_ancestors = self.obs_util.get_child_sites( org_id='Org_1', include_parents=True, id_only=False) self.assertEquals(len(child_sites), 7) self.assertEquals(len(site_ancestors), 5) self.assertEquals(len([v for v in child_sites.values() if v is None]), 0) self.assertEquals(child_sites['Org_1']._get_type(), RT.Org) def test_get_site_devices(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list2) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) site_devices = self.obs_util.get_site_devices( ['Sub_1', 'PS_1', 'IS_1']) self.assertEquals(len(site_devices), 3) self.assertEquals(site_devices['Sub_1'], []) self.assertEquals(site_devices['IS_1'], [('InstrumentSite', 'ID_1', 'InstrumentDevice')]) def test_get_child_devices(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list2) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) child_devices = self.obs_util.get_child_devices('PD_1') self.assertEquals(len(child_devices), 1) self.assertEquals(child_devices['PD_1'][0][1], 'ID_1') child_devices = self.obs_util.get_child_devices('ID_1') self.assertEquals(len(child_devices), 1) self.assertEquals(child_devices['ID_1'], []) child_devices = self.obs_util.get_child_devices('Sub_1') self.assertEquals(len(child_devices), 1) self.assertEquals(child_devices['Sub_1'], []) child_devices = self.obs_util.get_child_devices('XXX') self.assertEquals(len(child_devices), 1) event_list1 = [ dict(et='DeviceStatusEvent', o='ID_1', attr=dict(status=DeviceStatusType.STATUS_WARNING)) ] event_list2 = [ dict(et='DeviceStatusEvent', o='ID_1', attr=dict(status=DeviceStatusType.STATUS_WARNING)) ] event_list3 = [ dict(et='DeviceCommsEvent', o='ID_1', attr=dict(state=DeviceCommsType.DATA_DELIVERY_INTERRUPTION)) ] event_list4 = [ dict(et='DeviceStatusEvent', o='PD_1', attr=dict(status=DeviceStatusType.STATUS_WARNING)), dict(et='DeviceCommsEvent', o='PD_1', attr=dict(state=DeviceCommsType.DATA_DELIVERY_INTERRUPTION)) ] def _assert_status(self, status_rollups, res_id=None, agg=DeviceStatusType.STATUS_OK, loc=DeviceStatusType.STATUS_OK, data=DeviceStatusType.STATUS_OK, comms=DeviceStatusType.STATUS_OK, power=DeviceStatusType.STATUS_OK): res_status = status_rollups[res_id] if res_id else status_rollups self.assertEquals(len(res_status), 5) # #self.assertEquals(res_status['agg'], agg) # self.assertEquals(res_status['loc'], loc) # self.assertEquals(res_status['data'], data) # self.assertEquals(res_status['comms'], comms) # self.assertEquals(res_status['power'], power) res_list1 = [ dict(rt='DataProduct', _id='DP_1', attr={}), dict(rt='DataProduct', _id='DP_2', attr={}), dict(rt='DataProduct', _id='DP_3', attr={}), dict(rt='DataProduct', _id='DP_4', attr={}), dict(rt='DataProduct', _id='DP_5', attr={}), ] assoc_list3 = [ ['DP_1', 'hasSource', 'ID_1'], ['DP_2', 'hasSource', 'ID_1'], ['DP_3', 'hasSource', 'ID_1'], ['DP_3', 'hasSource', 'PD_1'], ['DP_4', 'hasSource', 'PD_1'], ['DP_5', 'hasSource', 'PD_1'], ] def test_get_device_data_products(self): self.mu.load_mock_resources(self.res_list + self.res_list1) self.mu.load_mock_associations(self.assoc_list + self.assoc_list1 + self.assoc_list2 + self.assoc_list3) self.mu.assign_mockres_find_objects(filter_predicate="hasResource") self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) res_dict = self.obs_util.get_site_data_products( 'Obs_1', RT.Observatory) self.assertGreaterEqual(len(res_dict), 6) self.assertIsNone(res_dict['data_product_resources']) self.assertIn('ID_1', res_dict['device_data_products']) self.assertEquals(len(res_dict['device_data_products']['ID_1']), 3) self.assertIn('DP_1', res_dict['device_data_products']['ID_1']) self.assertIn('PD_1', res_dict['device_data_products']) self.assertEquals(len(res_dict['device_data_products']['PD_1']), 3) res_dict = self.obs_util.get_site_data_products( 'PS_1', RT.PlatformSite) self.assertEquals(len(res_dict['device_data_products']['ID_1']), 3) self.assertIn('ID_1', res_dict['device_data_products']) self.assertIn('DP_1', res_dict['device_data_products']['ID_1']) self.assertIn('PD_1', res_dict['device_data_products']) self.assertEquals(len(res_dict['device_data_products']['PD_1']), 3) res_dict = self.obs_util.get_site_data_products('Org_1', RT.Org) self.assertIn('DP_1', res_dict['device_data_products']['ID_1']) res_dict = self.obs_util.get_site_data_products( 'PS_1', RT.PlatformSite, include_data_products=True) self.assertIsNotNone(res_dict['data_product_resources']) self.assertIn('DP_1', res_dict['data_product_resources'])
class TestObservatoryUtil(IonUnitTestCase): def setUp(self): self.mu = MockUtil() self.process_mock = self.mu.create_process_mock() self.container_mock = self.mu.create_container_mock() self.dsm_mock = self.mu.create_device_status_manager_mock() res_list = [ dict(rt='Org', _id='Org_1', attr={}), dict(rt='Observatory', _id='Obs_1', attr={}), dict(rt='Observatory', _id='Obs_2', attr={}), dict(rt='Subsite', _id='Sub_1', attr={}), dict(rt='Subsite', _id='Sub_2', attr={}), dict(rt='PlatformSite', _id='PS_1', attr={}), dict(rt='InstrumentSite', _id='IS_1', attr={}), dict(rt='PlatformDevice', _id='PD_1', attr={}), dict(rt='InstrumentDevice', _id='ID_1', attr={}), ] assoc_list = [ ['Obs_1', 'hasSite', 'Sub_1'], ['Sub_1', 'hasSite', 'PS_1'], ['PS_1', 'hasSite', 'IS_1'], ] assoc_list1 = [ ['Org_1', 'hasResource', 'Obs_1'], ['Org_1', 'hasResource', 'Obs_2'], ['Obs_2', 'hasSite', 'Sub_2'], ] assoc_list2 = [ ['PS_1', 'hasDevice', 'PD_1'], ['IS_1', 'hasDevice', 'ID_1'], ['PD_1', 'hasDevice', 'ID_1'], ] def spy_get_child_sites(self, parent_site_id=None, org_id=None, exclude_types=None, include_parents=True, id_only=True): child_sites, site_ancestors = self.obs_util.get_child_sites( parent_site_id=parent_site_id, org_id=org_id, exclude_types=exclude_types, include_parents=include_parents, id_only=id_only) print "child_sites of", parent_site_id, "are", child_sites print "site_ancestors of", parent_site_id, "are", site_ancestors return child_sites, site_ancestors def test_get_child_sites(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) site_resources, site_children = self.spy_get_child_sites( parent_site_id='Obs_1', include_parents=False, id_only=True) self.assertEquals(len(site_resources), 3) self.assertEquals(len(site_children), 3) self.assertIn('Sub_1', site_resources) self.assertIn('PS_1', site_resources) self.assertIn('IS_1', site_resources) self.assertNotIn('Obs_1', site_resources) self.assertEquals( len([v for v in site_resources.values() if v is None]), 3) site_resources, site_children = self.spy_get_child_sites( parent_site_id='Obs_1', include_parents=False, id_only=False) self.assertEquals(len(site_resources), 3) self.assertEquals(len(site_children), 3) self.assertEquals( len([v for v in site_resources.values() if v is None]), 0) self.assertEquals(site_resources['Sub_1']._get_type(), RT.Subsite) site_resources, site_children = self.spy_get_child_sites( parent_site_id='Obs_1', include_parents=True) self.assertEquals(len(site_resources), 4) self.assertEquals(len(site_children), 3) self.assertIn('Obs_1', site_resources) site_resources, site_children = self.spy_get_child_sites( parent_site_id='Sub_1', include_parents=False) self.assertEquals(len(site_resources), 2) self.assertEquals(len(site_children), 2) self.assertNotIn('Sub_1', site_resources) site_resources, site_children = self.spy_get_child_sites( parent_site_id='Sub_1', include_parents=True) self.assertEquals(len(site_resources), 4) self.assertEquals(len(site_children), 3) self.assertIn('Sub_1', site_resources) self.assertIn('Obs_1', site_resources) site_resources, site_children = self.spy_get_child_sites( parent_site_id='PS_1', include_parents=False) self.assertEquals(len(site_resources), 1) self.assertEquals(len(site_children), 1) site_resources, site_children = self.spy_get_child_sites( parent_site_id='PS_1', include_parents=True) self.assertEquals(len(site_resources), 4) self.assertEquals(len(site_children), 3) site_resources, site_children = self.spy_get_child_sites( parent_site_id='IS_1', include_parents=False) self.assertEquals(len(site_resources), 0) self.assertEquals(len(site_children), 0) site_resources, site_children = self.spy_get_child_sites( parent_site_id='IS_1', include_parents=True) self.assertEquals(len(site_resources), 4) self.assertEquals(len(site_children), 3) site_resources, site_children = self.spy_get_child_sites( parent_site_id='XXX', include_parents=True) self.assertEquals(len(site_resources), 1) self.assertEquals(len(site_children), 0) def test_get_child_sites_org(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list + self.assoc_list1) self.mu.assign_mockres_find_objects(filter_predicate="hasResource") self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) child_sites, site_ancestors = self.obs_util.get_child_sites( org_id='Org_1', include_parents=False, id_only=True) self.assertEquals(len(child_sites), 6) self.assertEquals(len(site_ancestors), 5) self.assertIn('Sub_1', child_sites) self.assertIn('PS_1', child_sites) self.assertIn('IS_1', child_sites) self.assertIn('Obs_1', child_sites) self.assertIn('Obs_2', child_sites) child_sites, site_ancestors = self.obs_util.get_child_sites( org_id='Org_1', include_parents=True, id_only=True) self.assertEquals(len(child_sites), 7) self.assertEquals(len(site_ancestors), 5) child_sites, site_ancestors = self.obs_util.get_child_sites( org_id='Org_1', include_parents=True, id_only=False) self.assertEquals(len(child_sites), 7) self.assertEquals(len(site_ancestors), 5) self.assertEquals(len([v for v in child_sites.values() if v is None]), 0) self.assertEquals(child_sites['Org_1']._get_type(), RT.Org) def test_get_site_devices(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list2) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) site_devices = self.obs_util.get_site_devices( ['Sub_1', 'PS_1', 'IS_1']) self.assertEquals(len(site_devices), 3) self.assertEquals(site_devices['Sub_1'], []) self.assertEquals(site_devices['IS_1'], [('InstrumentSite', 'ID_1', 'InstrumentDevice')]) def test_get_child_devices(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list2) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) child_devices = self.obs_util.get_child_devices('PD_1') self.assertEquals(len(child_devices), 2) self.assertEquals(child_devices['PD_1'][0][1], 'ID_1') child_devices = self.obs_util.get_child_devices('ID_1') self.assertEquals(len(child_devices), 1) self.assertEquals(child_devices['ID_1'], []) child_devices = self.obs_util.get_child_devices('Sub_1') self.assertEquals(len(child_devices), 1) self.assertEquals(child_devices['Sub_1'], []) child_devices = self.obs_util.get_child_devices('XXX') self.assertEquals(len(child_devices), 1) def test_get_device_data_products(self): self.mu.load_mock_resources(self.res_list + self.res_list1) self.mu.load_mock_associations(self.assoc_list + self.assoc_list1 + self.assoc_list2 + self.assoc_list3) self.mu.assign_mockres_find_objects(filter_predicate="hasResource") self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock) res_dict = self.obs_util.get_site_data_products( 'Obs_1', RT.Observatory) self.assertGreaterEqual(len(res_dict), 6) self.assertIsNone(res_dict['data_product_resources']) self.assertIn('ID_1', res_dict['device_data_products']) self.assertEquals(len(res_dict['device_data_products']['ID_1']), 3) self.assertIn('DP_1', res_dict['device_data_products']['ID_1']) self.assertIn('PD_1', res_dict['device_data_products']) self.assertEquals(len(res_dict['device_data_products']['PD_1']), 3) res_dict = self.obs_util.get_site_data_products( 'PS_1', RT.PlatformSite) self.assertEquals(len(res_dict['device_data_products']['ID_1']), 3) self.assertIn('ID_1', res_dict['device_data_products']) self.assertIn('DP_1', res_dict['device_data_products']['ID_1']) self.assertIn('PD_1', res_dict['device_data_products']) self.assertEquals(len(res_dict['device_data_products']['PD_1']), 3) res_dict = self.obs_util.get_site_data_products('Org_1', RT.Org) self.assertIn('DP_1', res_dict['device_data_products']['ID_1']) res_dict = self.obs_util.get_site_data_products( 'PS_1', RT.PlatformSite, include_data_products=True) self.assertIsNotNone(res_dict['data_product_resources']) self.assertIn('DP_1', res_dict['data_product_resources']) #import pprint #pprint.pprint(res_dict) status_by_device_1 = { "ID_1": _devstat("ID_1", DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK), "PD_1": _devstat("PD_1", DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK), } status_by_device_2 = { "ID_1": _devstat("ID_1", DST.STATUS_WARNING, DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK), "PD_1": _devstat("PD_1", DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK), } status_by_device_3 = { "ID_1": _devstat("ID_1", DST.STATUS_WARNING, DST.STATUS_WARNING, DST.STATUS_OK, DST.STATUS_OK), "PD_1": _devstat("PD_1", DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK), } status_by_device_4 = { "ID_1": _devstat("ID_1", DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK, DST.STATUS_OK), "PD_1": _devstat("PD_1", DST.STATUS_WARNING, DST.STATUS_WARNING, DST.STATUS_OK, DST.STATUS_OK), } def test_get_status_roll_ups(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list + self.assoc_list1 + self.assoc_list2) self.mu.load_mock_device_statuses(self.status_by_device_1) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock, device_status_mgr=self.dsm_mock) # No problems status_rollups = self.obs_util.get_status_roll_ups( 'ID_1', RT.InstrumentDevice) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups( 'PD_1', RT.PlatformDevice) self.assertIn('PD_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups( 'IS_1', RT.InstrumentSite) self.assertEquals(len(status_rollups), 6) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups( 'PS_1', RT.PlatformSite) self.assertEquals(len(status_rollups), 6) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'PS_1') self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('Sub_1', RT.Subsite) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Sub_1') self._assert_status(status_rollups, 'PS_1') self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups( 'Obs_1', RT.Observatory) self.assertIn('Obs_1', status_rollups) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Obs_1') self._assert_status(status_rollups, 'Sub_1') self._assert_status(status_rollups, 'PS_1') self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') # ID_1 power warning self.mu.load_mock_device_statuses(self.status_by_device_2) status_rollups = self.obs_util.get_status_roll_ups( 'ID_1', RT.InstrumentDevice) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups( 'PD_1', RT.PlatformDevice) self._assert_status(status_rollups, 'PD_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups( 'IS_1', RT.InstrumentSite) self.assertIn('IS_1', status_rollups) self._assert_status(status_rollups, 'IS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups( 'PS_1', RT.PlatformSite) self.assertIn('PS_1', status_rollups) self.assertIn('IS_1', status_rollups) self._assert_status(status_rollups, 'PS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING) self._assert_status(status_rollups, 'IS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING) # ID_1 power+comms warning self.mu.load_mock_device_statuses(self.status_by_device_3) status_rollups = self.obs_util.get_status_roll_ups( 'ID_1', RT.InstrumentDevice) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups( 'PD_1', RT.PlatformDevice) self._assert_status(status_rollups, 'PD_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups( 'IS_1', RT.InstrumentSite) self.assertEquals(len(status_rollups), 6) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'IS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups( 'PS_1', RT.PlatformSite) self.assertEquals(len(status_rollups), 6) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'PS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups('Sub_1', RT.Subsite) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Sub_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) status_rollups = self.obs_util.get_status_roll_ups( 'Obs_1', RT.Observatory) self.assertIn('Obs_1', status_rollups) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Obs_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'Sub_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1') self._assert_status(status_rollups, 'IS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) def test_get_status_roll_ups_platform_warn(self): self.mu.load_mock_resources(self.res_list) self.mu.load_mock_associations(self.assoc_list + self.assoc_list1 + self.assoc_list2) self.mu.load_mock_device_statuses(self.status_by_device_4) self.obs_util = ObservatoryUtil(self.process_mock, self.container_mock, device_status_mgr=self.dsm_mock) # PD_1 power+comms warning status_rollups = self.obs_util.get_status_roll_ups( 'ID_1', RT.InstrumentDevice) self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups( 'PD_1', RT.PlatformDevice) #log.warn("status %s" % status_rollups) self._assert_status(status_rollups, 'PD_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups( 'IS_1', RT.InstrumentSite) self.assertEquals(len(status_rollups), 6) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups( 'PS_1', RT.PlatformSite) self.assertEquals(len(status_rollups), 6) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'PS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups('Sub_1', RT.Subsite) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Sub_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') status_rollups = self.obs_util.get_status_roll_ups( 'Obs_1', RT.Observatory) self.assertIn('Obs_1', status_rollups) self.assertIn('Sub_1', status_rollups) self.assertIn('PS_1', status_rollups) self.assertIn('PD_1', status_rollups) self.assertIn('IS_1', status_rollups) self.assertIn('ID_1', status_rollups) self._assert_status(status_rollups, 'Obs_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'Sub_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PS_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'PD_1', agg=DST.STATUS_WARNING, power=DST.STATUS_WARNING, comms=DST.STATUS_WARNING) self._assert_status(status_rollups, 'IS_1') self._assert_status(status_rollups, 'ID_1') def _assert_status(self, status_rollups, res_id=None, agg=DST.STATUS_OK, loc=DST.STATUS_OK, data=DST.STATUS_OK, comms=DST.STATUS_OK, power=DST.STATUS_OK): res_status = status_rollups[res_id] if res_id else status_rollups log.debug("_assert_status(%s) = %s", res_id, res_status) self.assertEquals(len(res_status), 5) if agg is not None: self.assertEquals(res_status['agg'], agg) if loc is not None: self.assertEquals( res_status[AggregateStatusType.AGGREGATE_LOCATION], loc) if data is not None: self.assertEquals(res_status[AggregateStatusType.AGGREGATE_DATA], data) if comms is not None: self.assertEquals(res_status[AggregateStatusType.AGGREGATE_COMMS], comms) if power is not None: self.assertEquals(res_status[AggregateStatusType.AGGREGATE_POWER], power) res_list1 = [ dict(rt='DataProduct', _id='DP_1', attr={}), dict(rt='DataProduct', _id='DP_2', attr={}), dict(rt='DataProduct', _id='DP_3', attr={}), dict(rt='DataProduct', _id='DP_4', attr={}), dict(rt='DataProduct', _id='DP_5', attr={}), ] assoc_list3 = [ ['DP_1', 'hasSource', 'ID_1'], ['DP_1', 'hasSource', 'IS_1'], ['DP_2', 'hasSource', 'ID_1'], ['DP_3', 'hasSource', 'ID_1'], ['DP_3', 'hasSource', 'PD_1'], ['DP_4', 'hasSource', 'PD_1'], ['DP_5', 'hasSource', 'PD_1'], ]
class ObservatoryManagementService(BaseObservatoryManagementService): def on_init(self): IonObject("Resource") # suppress pyflakes error CFG, log, RT, PRED, LCS, LCE, NotFound, BadRequest, log #suppress pyflakes errors about "unused import" self.override_clients(self.clients) self.outil = ObservatoryUtil(self) self.HIERARCHY_DEPTH = {RT.InstrumentSite: 3, RT.PlatformSite: 2, RT.Subsite: 1, RT.Observatory: 0, } self.HIERARCHY_LOOKUP = [RT.Observatory, RT.Subsite, RT.PlatformSite, RT.InstrumentSite] #todo: add lcs methods for these?? # # set up all of the policy interceptions # if self.container and self.container.governance_controller: # reg_precondition = self.container.governance_controller.register_process_operation_precondition # reg_precondition(self, 'execute_observatory_lifecycle', # self.RR2.policy_fn_lcs_precondition("observatory_id")) # reg_precondition(self, 'execute_subsite_lifecycle', # self.RR2.policy_fn_lcs_precondition("subsite_id")) # reg_precondition(self, 'execute_platform_site_lifecycle', # self.RR2.policy_fn_lcs_precondition("platform_site_id")) # reg_precondition(self, 'execute_instrument_site_lifecycle', # self.RR2.policy_fn_lcs_precondition("instrument_site_id")) def override_clients(self, new_clients): """ Replaces the service clients with a new set of them... and makes sure they go to the right places """ self.RR2 = EnhancedResourceRegistryClient(new_clients.resource_registry) #shortcut names for the import sub-services if hasattr(new_clients, "resource_registry"): self.RR = new_clients.resource_registry if hasattr(new_clients, "instrument_management"): self.IMS = new_clients.instrument_management if hasattr(new_clients, "data_process_management"): self.PRMS = new_clients.data_process_management #farm everything out to the impls self.dataproductclient = DataProductManagementServiceClient() self.dataprocessclient = DataProcessManagementServiceClient() def _calc_geospatial_point_center(self, site): siteTypes = [RT.Site, RT.Subsite, RT.Observatory, RT.PlatformSite, RT.InstrumentSite] if site and site.type_ in siteTypes: # if the geospatial_bounds is set then calculate the geospatial_point_center for constraint in site.constraint_list: if constraint.type_ == OT.GeospatialBounds: site.geospatial_point_center = GeoUtils.calc_geospatial_point_center(constraint) ########################################################################## # # CRUD OPS # ########################################################################## def create_marine_facility(self, org=None): """Create an Org (domain of authority) that realizes a marine facility. This Org will have set up roles for a marine facility. Shared resources, such as a device can only be registered in one marine facility Org, and additionally in many virtual observatory Orgs. The marine facility operators will have more extensive permissions and will supercede virtual observatory commands @param org Org @retval org_id str @throws BadRequest if object does not have _id or _rev attribute @throws NotFound object with specified id does not exist """ log.debug("ObservatoryManagementService.create_marine_facility(): %s", org) # create the org org.org_type = OrgTypeEnum.MARINE_FACILITY org_id = self.clients.org_management.create_org(org) #Instantiate initial set of User Roles for this marine facility instrument_operator_role = IonObject(RT.UserRole, governance_name=INSTRUMENT_OPERATOR_ROLE, name='Observatory Operator', #previously Instrument Operator description='Operate and post events related to Observatory Platforms and Instruments') self.clients.org_management.add_user_role(org_id, instrument_operator_role) observatory_operator_role = IonObject(RT.UserRole, governance_name=OBSERVATORY_OPERATOR_ROLE, name='Observatory Manager', # previously Observatory Operator description='Change Observatory configuration, post Site-related events') self.clients.org_management.add_user_role(org_id, observatory_operator_role) data_operator_role = IonObject(RT.UserRole, governance_name=DATA_OPERATOR_ROLE, name='Observatory Data Operator', # previously Data Operator description='Manipulate and post events related to Observatory Data products') self.clients.org_management.add_user_role(org_id, data_operator_role) return org_id def create_virtual_observatory(self, org=None): """Create an Org (domain of authority) that realizes a virtual observatory. This Org will have set up roles for a virtual observatory. Shared resources, such as a device can only be registered in one marine facility Org, and additionally in many virtual observatory Orgs. The marine facility operators will have more extensive permissions and will supercede virtual observatory commands @param org Org @retval org_id str @throws BadRequest if object does not have _id or _rev attribute @throws NotFound object with specified id does not exist """ log.debug("ObservatoryManagementService.create_virtual_observatory(): %s", org) # create the org org.org_type = OrgTypeEnum.VIRTUAL_OBSERVATORY org_id = self.clients.org_management.create_org(org) return org_id def create_observatory(self, observatory=None, org_id=""): """Create a Observatory resource. An observatory is coupled with one Org. The Org is created and associated as part of this call. @param observatory Observatory @retval observatory_id str @throws BadRequest if object does not have _id or _rev attribute @throws NotFound object with specified id does not exist """ # if the geospatial_bounds is set then calculate the geospatial_point_center self._calc_geospatial_point_center(observatory) # create the marine facility observatory_id = self.RR2.create(observatory, RT.Observatory) if org_id: self.assign_resource_to_observatory_org(observatory_id, org_id) return observatory_id def read_observatory(self, observatory_id=''): """Read a Observatory resource @param observatory_id str @retval observatory Observatory @throws NotFound object with specified id does not exist """ return self.RR2.read(observatory_id, RT.Observatory) def update_observatory(self, observatory=None): """Update a Observatory resource @param observatory Observatory @throws NotFound object with specified id does not exist """ # if the geospatial_bounds is set then calculate the geospatial_point_center self._calc_geospatial_point_center(observatory) return self.RR2.update(observatory, RT.Observatory) def delete_observatory(self, observatory_id=''): """Delete a Observatory resource @param observatory_id str @throws NotFound object with specified id does not exist """ return self.RR2.retire(observatory_id, RT.Observatory) def force_delete_observatory(self, observatory_id=''): return self.RR2.pluck_delete(observatory_id, RT.Observatory) def create_subsite(self, subsite=None, parent_id=''): """Create a Subsite resource. A subsite is a frame of reference within an observatory. Its parent is either the observatory or another subsite. @param subsite Subsite @param parent_id str @retval subsite_id str @throws BadRequest if object does not have _id or _rev attribute @throws NotFound object with specified id does not exist """ # if the geospatial_bounds is set then calculate the geospatial_point_center self._calc_geospatial_point_center(subsite) subsite_id = self.RR2.create(subsite, RT.Subsite) if parent_id: self.assign_site_to_site(subsite_id, parent_id) return subsite_id def read_subsite(self, subsite_id=''): """Read a Subsite resource @param subsite_id str @retval subsite Subsite @throws NotFound object with specified id does not exist """ return self.RR2.read(subsite_id, RT.Subsite) def update_subsite(self, subsite=None): """Update a Subsite resource @param subsite Subsite @throws NotFound object with specified id does not exist """ # if the geospatial_bounds is set then calculate the geospatial_point_center self._calc_geospatial_point_center(subsite) return self.RR2.update(subsite, RT.Subsite) def delete_subsite(self, subsite_id=''): """Delete a subsite resource, removes assocations to parents @param subsite_id str @throws NotFound object with specified id does not exist """ self.RR2.retire(subsite_id, RT.Subsite) def force_delete_subsite(self, subsite_id=''): self.RR2.pluck_delete(subsite_id, RT.Subsite) def create_platform_site(self, platform_site=None, parent_id=''): """Create a PlatformSite resource. A platform_site is a frame of reference within an observatory. Its parent is either the observatory or another platform_site. @param platform_site PlatformSite @param parent_id str @retval platform_site_id str @throws BadRequest if object does not have _id or _rev attribute @throws NotFound object with specified id does not exist """ # if the geospatial_bounds is set then calculate the geospatial_point_center self._calc_geospatial_point_center(platform_site) platform_site_id = self.RR2.create(platform_site, RT.PlatformSite) if parent_id: self.RR2.assign_site_to_one_site_with_has_site(platform_site_id, parent_id) return platform_site_id def read_platform_site(self, platform_site_id=''): """Read a PlatformSite resource @param platform_site_id str @retval platform_site PlatformSite @throws NotFound object with specified id does not exist """ return self.RR2.read(platform_site_id, RT.PlatformSite) def update_platform_site(self, platform_site=None): """Update a PlatformSite resource @param platform_site PlatformSite @throws NotFound object with specified id does not exist """ # if the geospatial_bounds is set then calculate the geospatial_point_center self._calc_geospatial_point_center(platform_site) return self.RR2.update(platform_site, RT.PlatformSite) def delete_platform_site(self, platform_site_id=''): """Delete a PlatformSite resource, removes assocations to parents @param platform_site_id str @throws NotFound object with specified id does not exist """ self.RR2.retire(platform_site_id, RT.PlatformSite) def force_delete_platform_site(self, platform_site_id=''): self.RR2.pluck_delete(platform_site_id, RT.PlatformSite) def create_instrument_site(self, instrument_site=None, parent_id=''): """Create a InstrumentSite resource. A instrument_site is a frame of reference within an observatory. Its parent is either the observatory or another instrument_site. @param instrument_site InstrumentSite @param parent_id str @retval instrument_site_id str @throws BadRequest if object does not have _id or _rev attribute @throws NotFound object with specified id does not exist """ # if the geospatial_bounds is set then calculate the geospatial_point_center self._calc_geospatial_point_center(instrument_site) instrument_site_id = self.RR2.create(instrument_site, RT.InstrumentSite) if parent_id: self.RR2.assign_site_to_one_site_with_has_site(instrument_site_id, parent_id) return instrument_site_id def read_instrument_site(self, instrument_site_id=''): """Read a InstrumentSite resource @param instrument_site_id str @retval instrument_site InstrumentSite @throws NotFound object with specified id does not exist """ return self.RR2.read(instrument_site_id, RT.InstrumentSite) def update_instrument_site(self, instrument_site=None): """Update a InstrumentSite resource @param instrument_site InstrumentSite @throws NotFound object with specified id does not exist """ # if the geospatial_bounds is set then calculate the geospatial_point_center self._calc_geospatial_point_center(instrument_site) return self.RR2.update(instrument_site, RT.InstrumentSite) def delete_instrument_site(self, instrument_site_id=''): """Delete a InstrumentSite resource, removes assocations to parents @param instrument_site_id str @throws NotFound object with specified id does not exist """ # todo: give InstrumentSite a lifecycle in COI so that we can remove the "True" argument here self.RR2.retire(instrument_site_id, RT.InstrumentSite) def force_delete_instrument_site(self, instrument_site_id=''): self.RR2.pluck_delete(instrument_site_id, RT.InstrumentSite) #todo: convert to resource_impl def create_deployment(self, deployment=None, site_id="", device_id=""): """ Create a Deployment resource. Represents a (possibly open-ended) time interval grouping one or more resources within a given context, such as an instrument deployment on a platform at an observatory site. """ deployment_id = self.RR2.create(deployment, RT.Deployment) #Verify that site and device exist, add links if they do if site_id: site_obj = self.RR2.read(site_id) if site_obj: self.RR2.assign_deployment_to_site_with_has_deployment(deployment_id, site_id) if device_id: device_obj = self.RR2.read(device_id) if device_obj: self.RR2.assign_deployment_to_device_with_has_deployment(deployment_id, device_id) return deployment_id def update_deployment(self, deployment=None): # Overwrite Deployment object self.RR2.update(deployment, RT.Deployment) def read_deployment(self, deployment_id=''): deployment_obj = self.RR2.read(deployment_id, RT.Deployment) return deployment_obj def delete_deployment(self, deployment_id=''): """ Delete a Deployment resource """ self.RR2.retire(deployment_id, RT.Deployment) def force_delete_deployment(self, deployment_id=''): self.RR2.pluck_delete(deployment_id, RT.Deployment) ############################ # # ASSOCIATIONS # ############################ def assign_site_to_site(self, child_site_id='', parent_site_id=''): """Connects a child site (any subtype) to a parent site (any subtype) @param child_site_id str @param parent_site_id str @throws NotFound object with specified id does not exist """ self.RR2.assign_site_to_site_with_has_site(child_site_id, parent_site_id) def unassign_site_from_site(self, child_site_id='', parent_site_id=''): """Disconnects a child site (any subtype) from a parent site (any subtype) @param child_site_id str @param parent_site_id str @throws NotFound object with specified id does not exist """ self.RR2.unassign_site_from_site_with_has_site(child_site_id, parent_site_id) def assign_device_to_site(self, device_id='', site_id=''): """Connects a device (any type) to a site (any subtype) @param device_id str @param site_id str @throws NotFound object with specified id does not exist """ self.RR2.assign_device_to_site_with_has_device(device_id, site_id) def unassign_device_from_site(self, device_id='', site_id=''): """Disconnects a device (any type) from a site (any subtype) @param device_id str @param site_id str @throws NotFound object with specified id does not exist """ self.RR2.unassign_device_from_site_with_has_device(device_id, site_id) def assign_device_to_network_parent(self, child_device_id='', parent_device_id=''): """Connects a device (any type) to parent in the RSN network @param child_device_id str @param parent_device_id str @throws NotFound object with specified id does not exist """ self.RR2.assign_device_to_one_device_with_has_network_parent(parent_device_id, child_device_id) def unassign_device_from_network_parent(self, child_device_id='', parent_device_id=''): """Disconnects a child device (any type) from parent in the RSN network @param child_device_id str @param parent_device_id str @throws NotFound object with specified id does not exist """ self.RR2.unassign_device_from_device_with_has_network_parent(parent_device_id, child_device_id) def assign_instrument_model_to_instrument_site(self, instrument_model_id='', instrument_site_id=''): self.RR2.assign_instrument_model_to_instrument_site_with_has_model(instrument_model_id, instrument_site_id) def unassign_instrument_model_from_instrument_site(self, instrument_model_id='', instrument_site_id=''): self.RR2.unassign_instrument_model_from_instrument_site_with_has_model(self, instrument_model_id, instrument_site_id) def assign_platform_model_to_platform_site(self, platform_model_id='', platform_site_id=''): self.RR2.assign_platform_model_to_platform_site_with_has_model(platform_model_id, platform_site_id) def unassign_platform_model_from_platform_site(self, platform_model_id='', platform_site_id=''): self.RR2.unassign_platform_model_from_platform_site_with_has_model(platform_model_id, platform_site_id) def assign_resource_to_observatory_org(self, resource_id='', org_id=''): if not org_id: raise BadRequest("Org id not given") if not resource_id: raise BadRequest("Resource id not given") #log.trace("assign_resource_to_observatory_org: org_id=%s, resource_id=%s ", org_id, resource_id) self.clients.org_management.share_resource(org_id, resource_id) def unassign_resource_from_observatory_org(self, resource_id='', org_id=''): if not org_id: raise BadRequest("Org id not given") if not resource_id: raise BadRequest("Resource id not given") self.clients.org_management.unshare_resource(org_id, resource_id) ########################################################################## # # DEPLOYMENTS # ########################################################################## def deploy_instrument_site(self, instrument_site_id='', deployment_id=''): self.RR2.assign_deployment_to_instrument_site_with_has_deployment(deployment_id, instrument_site_id) def undeploy_instrument_site(self, instrument_site_id='', deployment_id=''): self.RR2.unassign_deployment_from_instrument_site_with_has_deployment(deployment_id, instrument_site_id) def deploy_platform_site(self, platform_site_id='', deployment_id=''): self.RR2.assign_deployment_to_platform_site_with_has_deployment(deployment_id, platform_site_id) def undeploy_platform_site(self, platform_site_id='', deployment_id=''): self.RR2.unassign_deployment_from_platform_site_with_has_deployment(deployment_id, platform_site_id) def activate_deployment(self, deployment_id='', activate_subscriptions=False): """ Make the devices on this deployment the primary devices for the sites """ #Verify that the deployment exists depl_obj = self.RR2.read(deployment_id) log.debug("Activing deployment '%s' (%s)", depl_obj.name, deployment_id) deployment_activator_factory = DeploymentActivatorFactory(self.clients) deployment_activator = deployment_activator_factory.create(depl_obj) deployment_activator.prepare() # process any removals for site_id, device_id in deployment_activator.hasdevice_associations_to_delete(): log.info("Unassigning hasDevice; device '%s' from site '%s'", device_id, site_id) self.unassign_device_from_site(device_id, site_id) # process the additions for site_id, device_id in deployment_activator.hasdevice_associations_to_create(): log.info("Setting primary device '%s' for site '%s'", device_id, site_id) self.assign_device_to_site(device_id, site_id) # self.RR.execute_lifecycle_transition(deployment_id, LCE.DEPLOY) def deactivate_deployment(self, deployment_id=''): """Remove the primary device designation for the deployed devices at the sites @param deployment_id str @throws NotFound object with specified id does not exist @throws BadRequest if devices can not be undeployed """ #Verify that the deployment exists deployment_obj = self.RR2.read(deployment_id) # if LCS.DEPLOYED != deployment_obj.lcstate: # raise BadRequest("This deploment is not active") # get all associated components collector_factory = DeploymentResourceCollectorFactory(self.clients) resource_collector = collector_factory.create(deployment_obj) resource_collector.collect() # must only remove from sites that are not deployed under a different active deployment # must only remove devices that are not deployed under a different active deployment def filter_alternate_deployments(resource_list): # return the list of ids for devices or sites not connected to an alternate lcs.deployed deployment ret = [] for r in resource_list: depls, _ = self.RR.find_objects(r, PRED.hasDeployment, RT.Deployment) keep = True for d in depls: if d._id != deployment_id and LCS.DEPLOYED == d.lcstate: keep = False if keep: ret.append(r) return ret device_ids = filter_alternate_deployments(resource_collector.collected_device_ids()) site_ids = filter_alternate_deployments(resource_collector.collected_site_ids()) # delete only associations where both site and device have passed the filter for s in site_ids: ds, _ = self.RR.find_objects(s, PRED.hasDevice, id_only=True) for d in ds: if d in device_ids: a = self.RR.get_association(s, PRED.hasDevice, d) self.RR.delete_association(a) # # # mark deployment as not deployed (developed seems appropriate) # self.RR.execute_lifecycle_transition(deployment_id, LCE.DEVELOPED) ########################################################################## # # FIND OPS # ########################################################################## def find_org_by_observatory(self, observatory_id=''): """ """ orgs,_ = self.RR.find_subjects(RT.Org, PRED.hasResource, observatory_id, id_only=False) return orgs def find_related_frames_of_reference(self, input_resource_id='', output_resource_type_list=None): # use the related resources crawler finder = RelatedResourcesCrawler() # generate the partial function (cached association list) get_assns = finder.generate_related_resources_partial(self.RR, [PRED.hasSite]) # run 2 searches allowing all site-based resource types: one down (subj-obj), one up (obj-subj) full_crawllist = [RT.InstrumentSite, RT.PlatformSite, RT.Subsite, RT.Observatory] search_down = get_assns({PRED.hasSite: (True, False)}, full_crawllist) search_up = get_assns({PRED.hasSite: (False, True)}, full_crawllist) # the searches return a list of association objects, so compile all the ids by extracting them retval_ids = set([]) # we want only those IDs that are not the input resource id for a in search_down(input_resource_id, -1) + search_up(input_resource_id, -1): if a.o not in retval_ids and a.o != input_resource_id: retval_ids.add(a.o) if a.s not in retval_ids and a.s != input_resource_id: retval_ids.add(a.s) log.trace("converting retrieved ids to objects = %s" % retval_ids) #initialize the dict retval = dict((restype, []) for restype in output_resource_type_list) #workaround for read_mult problem all_res = [] if retval_ids: all_res = self.RR.read_mult(list(retval_ids)) #all_res = self.RR.read_mult(retval_ids) # put resources in the slot based on their type for resource in all_res: typename = type(resource).__name__ if typename in output_resource_type_list: retval[typename].append(resource) # display a count of how many resources we retrieved log.debug("got these resources: %s", dict([(k, len(v)) for k, v in retval.iteritems()])) return retval def find_related_sites(self, parent_resource_id='', exclude_site_types=None, include_parents=False, id_only=False): if not parent_resource_id: raise BadRequest("Must provide a parent parent_resource_id") exclude_site_types = exclude_site_types or [] if not isinstance(exclude_site_types, list): raise BadRequest("exclude_site_types mut be a list, is: %s" % type(exclude_site_types)) parent_resource = self.RR.read(parent_resource_id) org_id, site_id = None, None if parent_resource.type_ == RT.Org: org_id = parent_resource_id elif RT.Site in parent_resource._get_extends(): site_id = parent_resource_id else: raise BadRequest("Illegal parent_resource_id type. Expected Org/Site, given:%s" % parent_resource.type_) site_resources, site_children = self.outil.get_child_sites(site_id, org_id, exclude_types=exclude_site_types, include_parents=include_parents, id_only=id_only) return site_resources, site_children def get_sites_devices_status(self, parent_resource_id='', include_devices=False, include_status=False): if not parent_resource_id: raise BadRequest("Must provide a parent parent_resource_id") parent_resource = self.RR.read(parent_resource_id) org_id, site_id = None, None if parent_resource.type_ == RT.Org: org_id = parent_resource_id elif RT.Site in parent_resource._get_extends(): site_id = parent_resource_id result_dict = {} if include_status: status_rollups = self.outil.get_status_roll_ups(parent_resource_id, parent_resource.type_, include_structure=True) struct_dict = status_rollups.pop("_system") if "_system" in status_rollups else {} result_dict["site_resources"] = struct_dict.get("sites", {}) result_dict["site_children"] = struct_dict.get("ancestors", {}) if include_devices: site_devices = struct_dict.get("devices", {}) result_dict["site_devices"] = site_devices device_ids = [tuple_list[0][1] for tuple_list in site_devices.values() if tuple_list] device_objs = self.RR.read_mult(device_ids) result_dict["device_resources"] = dict(zip(device_ids, device_objs)) result_dict["site_status"] = status_rollups else: site_resources, site_children = self.outil.get_child_sites(site_id, org_id, include_parents=True, id_only=False) result_dict["site_resources"] = site_resources result_dict["site_children"] = site_children return result_dict def find_site_data_products(self, parent_resource_id='', include_sites=False, include_devices=False, include_data_products=False): if not parent_resource_id: raise BadRequest("Must provide a parent parent_resource_id") res_dict = self.outil.get_site_data_products(parent_resource_id, include_sites=include_sites, include_devices=include_devices, include_data_products=include_data_products) return res_dict ############################ # # EXTENDED RESOURCES # ############################ def _get_site_extension(self, site_id='', ext_associations=None, ext_exclude=None, user_id=''): """Returns an InstrumentDeviceExtension object containing additional related information @param site_id str @param ext_associations dict @param ext_exclude list @retval observatory ObservatoryExtension @throws BadRequest A parameter is missing @throws NotFound An object with the specified observatory_id does not exist """ if not site_id: raise BadRequest("The site_id parameter is empty") extended_resource_handler = ExtendedResourceContainer(self) extended_site = extended_resource_handler.create_extended_resource_container( extended_resource_type=OT.SiteExtension, resource_id=site_id, computed_resource_type=OT.SiteComputedAttributes, ext_associations=ext_associations, ext_exclude=ext_exclude, user_id=user_id) RR2 = EnhancedResourceRegistryClient(self.RR) RR2.cache_predicate(PRED.hasModel) # Get status of Site instruments. a, b = self._get_instrument_states(extended_site.instrument_devices) extended_site.instruments_operational, extended_site.instruments_not_operational = a, b # lookup all hasModel predicates # lookup is a 2d associative array of [subject type][subject id] -> object id lookup = dict([(rt, {}) for rt in [RT.InstrumentDevice, RT.PlatformDevice]]) for a in RR2.filter_cached_associations(PRED.hasModel, lambda assn: assn.st in lookup): lookup[a.st][a.s] = a.o def retrieve_model_objs(rsrc_list, object_type): # rsrc_list is devices that need models looked up. object_type is the resource type (a device) # not all devices have models (represented as None), which kills read_mult. so, extract the models ids, # look up all the model ids, then create the proper output model_list = [lookup[object_type].get(r._id) for r in rsrc_list] model_uniq = list(set([m for m in model_list if m is not None])) model_objs = self.RR2.read_mult(model_uniq) model_dict = dict(zip(model_uniq, model_objs)) return [model_dict.get(m) for m in model_list] extended_site.instrument_models = retrieve_model_objs(extended_site.instrument_devices, RT.InstrumentDevice) extended_site.platform_models = retrieve_model_objs(extended_site.platform_devices, RT.PlatformDevice) # Status computation extended_site.computed.instrument_status = [AgentStatusBuilder.get_aggregate_status_of_device(idev._id, "aggstatus") for idev in extended_site.instrument_devices] extended_site.computed.platform_status = [AgentStatusBuilder.get_aggregate_status_of_device(pdev._id, "aggstatus") for pdev in extended_site.platform_devices] # AgentStatusBuilder.add_device_aggregate_status_to_resource_extension(device_id, # 'aggstatus', # extended_site) def status_unknown(): return ComputedIntValue(status=ComputedValueAvailability.PROVIDED, value=StatusType.STATUS_UNKNOWN) extended_site.computed.communications_status_roll_up = status_unknown() extended_site.computed.power_status_roll_up = status_unknown() extended_site.computed.data_status_roll_up = status_unknown() extended_site.computed.location_status_roll_up = status_unknown() extended_site.computed.aggregated_status = status_unknown() extended_site.computed.site_status = [StatusType.STATUS_UNKNOWN] * len(extended_site.sites) return extended_site, RR2 def _get_site_extension_plus(self, site_id='', ext_associations=None, ext_exclude=None, user_id=''): # the "plus" means "plus all sub-site objects" extended_site, RR2 = self._get_site_extension(site_id, ext_associations, ext_exclude, user_id) # use the related resources crawler finder = RelatedResourcesCrawler() get_assns = finder.generate_related_resources_partial(RR2, [PRED.hasSite]) full_crawllist = [RT.InstrumentSite, RT.PlatformSite, RT.Subsite] search_down = get_assns({PRED.hasSite: (True, False)}, full_crawllist) # the searches return a list of association objects, so compile all the ids by extracting them subsite_ids = set([]) # we want only those IDs that are not the input resource id for a in search_down(site_id, -1): if a.o != site_id: subsite_ids.add(a.o) log.trace("converting retrieved ids to objects = %s" % subsite_ids) subsite_objs = RR2.read_mult(list(subsite_ids)) # filtered subsites def fs(resource_type, filter_fn): both = lambda s: ((resource_type == s._get_type()) and filter_fn(s)) return filter(both, subsite_objs) def pfs(filter_fn): return fs(RT.PlatformSite, filter_fn) def ifs(filter_fn): return fs(RT.InstrumentSite, filter_fn) extended_site.computed.platform_station_sites = pfs(lambda s: "StationSite" == s.alt_resource_type) extended_site.computed.platform_component_sites = pfs(lambda s: "PlatformComponentSite" == s.alt_resource_type) extended_site.computed.platform_assembly_sites = pfs(lambda s: "PlatformAssemblySite" == s.alt_resource_type) extended_site.computed.instrument_sites = ifs(lambda _: True) return extended_site, RR2, subsite_objs # TODO: will remove this one def get_site_extension(self, site_id='', ext_associations=None, ext_exclude=None, user_id=''): extended_site, _ = self._get_site_extension(site_id, ext_associations, ext_exclude, user_id) return extended_site def get_observatory_site_extension(self, site_id='', ext_associations=None, ext_exclude=None, user_id=''): extended_site, RR2, subsite_objs = self._get_site_extension_plus(site_id, ext_associations, ext_exclude, user_id) return extended_site def get_platform_station_site_extension(self, site_id='', ext_associations=None, ext_exclude=None, user_id=''): extended_site, RR2, subsite_objs = self._get_site_extension_plus(site_id, ext_associations, ext_exclude, user_id) return extended_site def get_platform_assembly_site_extension(self, site_id='', ext_associations=None, ext_exclude=None, user_id=''): extended_site, RR2, subsite_objs = self._get_site_extension_plus(site_id, ext_associations, ext_exclude, user_id) return extended_site def get_platform_component_site_extension(self, site_id='', ext_associations=None, ext_exclude=None, user_id=''): extended_site, RR2, subsite_objs = self._get_site_extension_plus(site_id, ext_associations, ext_exclude, user_id) return extended_site def get_instrument_site_extension(self, site_id='', ext_associations=None, ext_exclude=None, user_id=''): extended_site, _ = self._get_site_extension(site_id, ext_associations, ext_exclude, user_id) # no subsites of instrument, so shortcut extended_site.computed.platform_station_sites = [] extended_site.computed.platform_component_sites = [] extended_site.computed.platform_assembly_sites = [] extended_site.computed.instrument_sites = [] return extended_site def _get_instrument_states(self, instrument_device_obj_list=None): op = [] non_op = [] if instrument_device_obj_list is None: instrument_device_list = [] #call eventsdb to check data-related events from this device. Use UNix vs NTP tiem for now, as # resource timestaps are in Unix, data is in NTP now = str(int(time.time() * 1000)) query_interval = str(int(time.time() - (AGENT_STATUS_EVENT_DELTA_DAYS * 86400) ) *1000) for device_obj in instrument_device_obj_list: # first check the instrument lifecycle state # if not ( device_obj.lcstate in [LCS.DEPLOYED_AVAILABLE, LCS.INTEGRATED_DISCOVERABLE] ): # TODO: check that this is the intended lcs behavior and maybe check availability if not ( device_obj.lcstate in [LCS.DEPLOYED, LCS.INTEGRATED] ): non_op.append(device_obj) else: # we dont have a find_events that takes a list yet so loop thru the instruments and get # recent events for each. events = self.clients.user_notification.find_events(origin=device_obj._id, type= 'ResourceAgentStateEvent', max_datetime = now, min_datetime = query_interval, limit=1) # the most recent event is first so assume that is the current state if not events: non_op.append(device_obj) else: current_instrument_state = events[0].state if current_instrument_state in [ResourceAgentState.STREAMING, ResourceAgentState.CALIBRATE, ResourceAgentState.BUSY, ResourceAgentState.DIRECT_ACCESS]: op.append(device_obj) else: op.append(device_obj) return op, non_op def get_deployment_extension(self, deployment_id='', ext_associations=None, ext_exclude=None, user_id=''): if not deployment_id: raise BadRequest("The deployment_id parameter is empty") extended_resource_handler = ExtendedResourceContainer(self) extended_deployment = extended_resource_handler.create_extended_resource_container( extended_resource_type=OT.DeploymentExtension, resource_id=deployment_id, computed_resource_type=OT.DeploymentComputedAttributes, ext_associations=ext_associations, ext_exclude=ext_exclude, user_id=user_id) devices = set() instrument_device_ids = [] iplatform_device_ids = [] subjs, _ = self.RR.find_subjects( predicate=PRED.hasDeployment, object=deployment_id, id_only=False) for subj in subjs: log.debug('get_deployment_extension obj: %s', subj) if subj.type_ == "InstrumentDevice": extended_deployment.instrument_devices.append(subj) devices.add((subj._id, PRED.hasModel)) elif subj.type_ == "InstrumentSite": extended_deployment.instrument_sites.append(subj) elif subj.type_ == "PlatformDevice": extended_deployment.platform_devices.append(subj) devices.add((subj._id, PRED.hasModel)) elif subj.type_ == "PlatformSite": extended_deployment.platform_sites.append(subj) else: log.warning("get_deployment_extension found invalid type connected to deployment %s. Object details: %s ", deployment_id, subj) all_models = set() device_to_model_map = {} model_map = {} assocs = self.RR.find_associations(anyside=list(devices), id_only=False) for assoc in assocs: log.debug('get_deployment_extension assoc subj: %s pred: %s obj: %s', assoc.s, assoc.p, assoc.o) all_models.add(assoc.o) device_to_model_map[assoc.s] = assoc.o model_objs = self.RR.read_mult( list(all_models) ) for model_obj in model_objs: model_map[model_obj._id] = model_obj for instrument in extended_deployment.instrument_devices: model_id = device_to_model_map[instrument._id] extended_deployment.instrument_models.append( model_map[model_id] ) for platform in extended_deployment.platform_devices: model_id = device_to_model_map[platform._id] extended_deployment.platform_models.append( model_map[model_id] ) return extended_deployment