def keep_connected(self): """Keep reconnecting to the controller""" while not self.exiting: host, port = self.resolve_endpoint(self.controller_endpoint) log.info('connecting', host=host, port=port) if self.enable_tls: try: # Check that key_file and cert_file is provided and # the files exist if self.key_file is None or \ self.cert_file is None or \ not os.path.isfile(self.key_file) or \ not os.path.isfile(self.cert_file): raise Exception('key_file "{}" or cert_file "{}"' ' is not found'.format( self.key_file, self.cert_file)) with open(self.key_file) as keyFile: with open(self.cert_file) as certFile: clientCert = ssl.PrivateCertificate.loadPEM( keyFile.read() + certFile.read()) ctx = clientCert.options() self.connector = reactor.connectSSL(host, port, self, ctx) log.info('tls-enabled') except Exception as e: log.exception('failed-to-connect', reason=e) else: self.connector = reactor.connectTCP(host, port, self) log.info('tls-disabled') self.d_disconnected = Deferred() yield self.d_disconnected log.debug('reconnect', after_delay=self.retry_interval) yield asleep(self.retry_interval)
def test_in_sync_with_ont_g_values(self): self.setup_one_of_each() self.assertEqual(len(self.omci_agent.device_ids()), 1) version = 'abcDEF' tm_opt = 2 onu_survival = 123 def stuff_db(_results): self._stuff_database([(OntG.class_id, 0, { 'version': version, 'traffic_management_options': tm_opt, 'ont_survival_time': onu_survival })]) def do_my_tests(_results): config = self.onu_device.configuration # On no Class ID for requested property, None should be # returned self.assertEqual(config.version, version) self.assertEqual(config.traffic_management_option, tm_opt) self.assertEqual(config.onu_survival_time, onu_survival) # No capabilities available until started self.assertIsNone(self.onu_device.configuration) # Yield context so that MIB Database callLater runs. self.onu_device.start() d = asleep(0.2) d.addCallbacks(stuff_db, self.not_called) d.addCallbacks(do_my_tests, self.not_called) return d
def edit_config(self, config, target='running', default_operation='merge', test_option=None, error_option=None): """ Loads all or part of the specified config to the target configuration datastore with the ability to lock the datastore during the edit. :param config is the configuration, which must be rooted in the config element. It can be specified either as a string or an Element.format="xml" :param target is the name of the configuration datastore being edited :param default_operation if specified must be one of { 'merge', 'replace', or 'none' } :param test_option if specified must be one of { 'test_then_set', 'set' } :param error_option if specified must be one of { 'stop-on-error', 'continue-on-error', 'rollback-on-error' } The 'rollback-on-error' error_option depends on the :rollback-on-error capability. :return: (defeered) for RpcReply """ try: yield asleep(random.uniform(0.1, 2.0)) # Simulate NETCONF request delay except Exception as e: log.exception('edit_config', e=e) raise # TODO: Customize if needed... xml = _dummy_xml returnValue(RPCReply(xml))
def test_in_sync_with_uni_g_values(self): self.setup_one_of_each() self.assertEqual(len(self.omci_agent.device_ids()), 1) entity_id = 0x4321 mgmt_cap = 0 def stuff_db(_results): self._stuff_database([(UniG.class_id, entity_id, { 'management_capability': mgmt_cap })]) def do_my_tests(_results): config = self.onu_device.configuration unig = config.uni_g_entities self.assertTrue(isinstance(unig, dict)) self.assertEqual(len(unig), 1) self.assertEqual(unig[entity_id]['entity-id'], entity_id) self.assertEqual(unig[entity_id]['management-capability'], mgmt_cap) # No capabilities available until started self.assertIsNone(self.onu_device.configuration) # Yield context so that MIB Database callLater runs. self.onu_device.start() d = asleep(0.2) d.addCallbacks(stuff_db, self.not_called) d.addCallbacks(do_my_tests, self.not_called) return d
def monitor_logical_devices(self): log.debug('start-monitor-logical-devices') while self.running: log.info('monitoring-logical-devices') # should change to a gRPC streaming call # see https://jira.opencord.org/browse/CORD-821 try: if self.channel is not None and self.grpc_client is not None and \ self.subscription is not None: # get current list from Voltha devices = yield \ self.get_list_of_logical_devices_from_voltha() # update agent list and mapping tables as needed self.refresh_agent_connections(devices) else: log.info('vcore-communication-unavailable') # wait before next poll yield asleep(self.devices_refresh_interval) except _Rendezvous, e: log.error('vcore-communication-failure', exception=repr(e), status=e.code()) except Exception as e: log.exception('unexpected-vcore-communication-failure', exception=repr(e))
def _backoff(self, msg): wait_time = RETRY_BACKOFF[min(self.retries, len(RETRY_BACKOFF) - 1)] self.retry_time += wait_time self.retries += 1 log.error(msg, next_retry_in_secs=wait_time, total_delay_in_secs = self.retry_time, retries=self.retries) return asleep(wait_time)
def upload_mib(self, number_of_commands): ######################################## # Begin MIB Upload seq_no = None for seq_no in xrange(number_of_commands): max_tries = MibResyncTask.max_mib_upload_next_retries for retries in xrange(0, max_tries): try: self.strobe_watchdog() response = yield self._device.omci_cc.send_mib_upload_next( seq_no) omci_msg = response.fields['omci_message'].fields class_id = omci_msg['object_entity_class'] entity_id = omci_msg['object_entity_id'] # Filter out the 'mib_data_sync' from the database. We save that at # the device level and do not want it showing up during a re-sync # during data comparison from binascii import hexlify if class_id == OntData.class_id: break # The T&W ONU reports an ME with class ID 0 but only on audit. Perhaps others do as well. if class_id == 0 or class_id > 0xFFFF: self.log.warn('invalid-class-id', class_id=class_id) break attributes = { k: v for k, v in omci_msg['object_data'].items() } # Save to the database self._db_active.set(self.device_id, class_id, entity_id, attributes) break except TimeoutError: self.log.warn('mib-resync-timeout', seq_no=seq_no, number_of_commands=number_of_commands) if retries < max_tries - 1: self.strobe_watchdog() yield asleep(MibResyncTask.mib_upload_next_delay) else: raise except Exception as e: self.log.exception('resync', e=e, seq_no=seq_no, number_of_commands=number_of_commands) returnValue(seq_no + 1) # seq_no is zero based.
def close(self): """ Close the connection to the NETCONF server :return: (deferred) Deferred request """ yield asleep(random.uniform(0.1, 0.5)) # Simulate NETCONF request delay self._connected = False self._locked = {} returnValue(True)
def check_that_t1_t2_running_and_last_is_not(self, results): from pyvoltha.common.utils.asleep import asleep yield asleep(0.1) self.assertEqual(self.runner.pending_tasks, 1) self.assertEqual(self.runner.running_tasks, 2) self.assertEqual(self.runner.successful_tasks_completed, 1) returnValue(results)
def rpc(self, rpc_string): """ Custom RPC request :param rpc_string: (string) RPC request :return: (defeered) for GetReply """ yield asleep(random.uniform(0.1, 2.0)) # Simulate NETCONF request delay # TODO: Customize if needed... xml = _dummy_xml returnValue(RPCReply(xml))
def get(self, payload): """ Get the requested data from the server :param payload: Payload/filter :return: (defeered) for GetReply """ yield asleep(random.uniform(0.1, 3.0)) # Simulate NETCONF request delay # TODO: Customize if needed... xml = _dummy_xml returnValue(RPCReply(xml))
def add_gem_ctp_pm_me(self): config = self._device.configuration gem_ctps = config.gem_ctp_entities self.log.debug('gem-ctp-entities', gem_ctps=gem_ctps) if gem_ctps is not None: for entity_id in six.iterkeys(gem_ctps): self.add_pm_me(GemPortNetworkCtpMonitoringHistoryData.class_id, entity_id) else: yield asleep(0.3) self.add_gem_ctp_pm_me()
def get_config(self, source='running'): """ Get the configuration from the specified source :param source: (string) Configuration source, 'running', 'candidate', ... :return: (deferred) Deferred request that wraps the GetReply class """ yield asleep(random.uniform(0.1, 4.0)) # Simulate NETCONF request delay # TODO: Customize if needed... xml = _dummy_xml returnValue(RPCReply(xml))
def test_in_sync_with_ont_2g_values(self): self.setup_one_of_each() self.assertEqual(len(self.omci_agent.device_ids()), 1) equip_id = 'br-549' omcc_ver = OMCCVersion.G_988_2012 vend_code = 0x1234 queues = 64 scheds = 8 gem_ports = 24 uptime = 12345 conn_capp = 0x00aa qos_flex = 0x001b queue_scale = 1 def stuff_db(_results): self._stuff_database([(Ont2G.class_id, 0, { 'equipment_id': equip_id, 'omcc_version': omcc_ver.value, 'vendor_product_code': vend_code, 'total_priority_queue_number': queues, 'total_traffic_scheduler_number': scheds, 'total_gem_port_id_number': gem_ports, 'sys_uptime': uptime, 'connectivity_capability': conn_capp, 'qos_configuration_flexibility': qos_flex, 'priority_queue_scale_factor': queue_scale })]) def do_my_tests(_results): config = self.onu_device.configuration self.assertEqual(config.equipment_id, equip_id) self.assertEqual(config.omcc_version, omcc_ver) self.assertEqual(config.vendor_product_code, vend_code) self.assertEqual(config.total_priority_queues, queues) self.assertEqual(config.total_traffic_schedulers, scheds) self.assertEqual(config.total_gem_ports, gem_ports) self.assertEqual(config.uptime, uptime) self.assertEqual(config.connectivity_capability, conn_capp) self.assertEqual(config.qos_configuration_flexibility, qos_flex) self.assertEqual(config.priority_queue_scale_factor, queue_scale) # No capabilities available until started self.assertIsNone(self.onu_device.configuration) # Yield context so that MIB Database callLater runs. self.onu_device.start() d = asleep(0.2) d.addCallbacks(stuff_db, self.not_called) d.addCallbacks(do_my_tests, self.not_called) return d
def fix_onu_only_save_to_db(self, undecodable, onu_created, onu_db): """ In ONU database and needs to be saved to OLT/OpenOMCI database. Note that some, perhaps all, of these instances could be ONU create in response to the OLT creating some other ME instance. So treat the Database operation as a create. """ successes = 0 failures = 0 for cid, eid in undecodable + onu_created: if self.deferred.called: # Check if task canceled break try: # If in current MIB, had an audit issue or other MIB operation # put it into the database, declare it a failure so we audit again try: olt_entry = self._sync_sm.query_mib(class_id=cid, instance_id=eid) except KeyError: # Common for ONU created MEs during audit olt_entry = None if olt_entry is not None and len(olt_entry): self.log.debug('onu-only-in-current', cid=cid, eid=eid) failures += 1 # Mark as failure so we audit again elif cid not in onu_db: self.log.warn('onu-only-not-in-audit', cid=cid, eid=eid) failures += 1 else: entry = onu_db[cid][eid] self.strobe_watchdog() self._sync_sm.mib_set(cid, eid, entry[ATTRIBUTES_KEY]) successes += 1 # If we do nothing but DB updates for ALOT of MEs, we are # blocking other async twisted tasks, be kind and pause self._db_updates += 1 if self._db_updates >= MibReconcileTask.max_sequential_db_updates: self._db_updates = 0 self._local_deferred = yield asleep(MibReconcileTask.db_update_pause) except Exception as e: self.log.warn('onu-only-error', e=e) failures += 1 returnValue((successes, failures))
def connect(self, connect_timeout=None): """ Connect to the NETCONF server o To disable attempting publickey authentication altogether, call with allow_agent and look_for_keys as False.` o hostkey_verify enables hostkey verification from ~/.ssh/known_hosts :return: (deferred) Deferred request """ yield asleep(random.uniform(0.1, 5.0)) # Simulate NETCONF request delay self._connected = True self._locked = {} returnValue(True)
def snapshot_mib(self): """ Snapshot the MIB on the ONU and create a copy of our local MIB database :return: (pair) (db_copy, number_of_commands) """ db_copy = None number_of_commands = None try: max_tries = MibResyncTask.max_db_copy_retries - 1 for retries in xrange(0, max_tries + 1): # Send MIB Upload so ONU snapshots its MIB try: self.strobe_watchdog() number_of_commands = yield self.send_mib_upload() if number_of_commands is None: if retries >= max_tries: db_copy = None break except (TimeoutError, ValueError) as e: self.log.warn('timeout-or-value-error', e=e) if retries >= max_tries: raise self.strobe_watchdog() yield asleep(MibResyncTask.db_copy_retry_delay) continue # Get a snapshot of the local MIB database db_copy = self._device.query_mib() # if we made it this far, no need to keep trying break except Exception as e: self.log.exception('mib-resync', e=e) raise # Handle initial failures if db_copy is None or number_of_commands is None: raise MibCopyException( 'Failed to snapshot MIB copy after {} retries'.format( MibResyncTask.max_db_copy_retries)) returnValue((db_copy, number_of_commands))
def get_vcore_subscription(self): log.debug('start-get-vcore-subscription') while self.running and self.subscription is None: try: # If a subscription is not yet assigned then establish new GRPC connection # ... otherwise keep using existing connection details if self.subscription is None: self._assign_grpc_attributes() # Send subscription request to register the current ofagent instance container_name = self.instance_id if self.grpc_client is None: self.grpc_client = GrpcClient(self, self.channel, self.grpc_timeout, self.core_binding_key, self.core_transaction_key) subscription = yield self.grpc_client.subscribe( OfAgentSubscriber(ofagent_id=container_name)) # If the subscriber id matches the current instance # ... then the subscription has succeeded if subscription is not None and subscription.ofagent_id == container_name: if self.subscription is None: # Keep details on the current GRPC session and subscription log.debug('subscription-with-vcore-successful', subscription=subscription) self.subscription = subscription self.grpc_client.start() # Sleep a bit in between each subscribe yield asleep(self.subscription_refresh_interval) # Move on to next subscribe request continue # The subscription did not succeed, reset and move on else: log.info('subscription-with-vcore-unavailable', subscription=subscription) except _Rendezvous, e: log.error('subscription-with-vcore-terminated', exception=e, status=e.code()) except Exception as e: log.exception('unexpected-subscription-termination-with-vcore', e=e)
def snapshot_alarm(self): """ Snapshot the ALARM on the ONU and create a copy of our local ALARM database :return: (pair) (command_sequence_number) """ olt_db_copy = None command_sequence_number = None try: max_tries = AlarmResyncTask.max_retries - 1 for retries in range(0, max_tries + 1): # Send ALARM Upload so ONU snapshots its ALARM try: command_sequence_number = yield self.send_alarm_upload() self.strobe_watchdog() if command_sequence_number is None: if retries >= max_tries: olt_db_copy = None break except TimeoutError as e: self.log.warn('timeout', e=e) if retries >= max_tries: raise self.strobe_watchdog() yield asleep(AlarmResyncTask.retry_delay) continue # Get a snapshot of the local MIB database olt_db_copy = self._device.query_alarm_table() # if we made it this far, no need to keep trying break except Exception as e: self.log.exception('alarm-resync', e=e) raise # Handle initial failures if olt_db_copy is None or command_sequence_number is None: raise AlarmCopyException( 'Failed to snapshot ALARM copy after {} retries'.format( AlarmResyncTask.max_retries)) returnValue((olt_db_copy, command_sequence_number))
def lock(self, source, lock_timeout): """ Lock the configuration system :param source: is the name of the configuration datastore accessed :param lock_timeout: timeout in seconds for holding the lock :return: (defeered) for RpcReply """ expire_time = time.time() + lock_timeout if source not in self._locked: self._locked[source] = None while self._locked[source] is not None: # Watch for lock timeout if time.time() >= self._locked[source]: self._locked[source] = None break yield asleep(0.1) if time.time() < expire_time: yield asleep(random.uniform(0.1, 0.5)) # Simulate NETCONF request delay self._locked[source] = expire_time returnValue(RPCReply(_dummy_xml) if expire_time > time.time() else RPCError('TODO'))
def unlock(self, source): """ Get the requested data from the server :param rpc_string: RPC request :param source: is the name of the configuration datastore accessed :return: (defeered) for RpcReply """ if source not in self._locked: self._locked[source] = None if self._locked[source] is not None: yield asleep(random.uniform(0.1, 0.5)) # Simulate NETCONF request delay self._locked[source] = None returnValue(RPCReply(_dummy_xml))
def perform_task(self): """ Get the 'mib_data_sync' attribute of the ONU """ try: if self._delay > 0: yield asleep(self._delay) if self._success: self.deferred.callback(self._value) self.deferred.errback(failure.Failure(self._value)) except Exception as e: self.deferred.errback(failure.Failure(e))
def test_in_sync_with_circuitpack_values(self): self.setup_one_of_each() self.assertEqual(len(self.omci_agent.device_ids()), 1) cp_entity = 0x100 num_ports = 1 serial_num = 'ABCD01234' cp_version = '1234ABCD' vendor_id = 'AB-9876' tconts = 2 pqueues = 64 sched_count = 8 def stuff_db(_results): self._stuff_database([ (CircuitPack.class_id, cp_entity, {'number_of_ports': num_ports, 'serial_number': serial_num, 'version': cp_version, 'vendor_id': vendor_id, 'total_tcont_buffer_number': tconts, 'total_priority_queue_number': pqueues, 'total_traffic_scheduler_number': sched_count, })]) def do_my_tests(_results): config = self.onu_device.configuration circuitpack = config.circuitpack_entities self.assertTrue(isinstance(circuitpack, dict)) self.assertEqual(len(circuitpack), 1) self.assertEqual(circuitpack[cp_entity]['entity-id'], cp_entity) self.assertEqual(circuitpack[cp_entity]['number-of-ports'], num_ports) self.assertEqual(circuitpack[cp_entity]['serial-number'], serial_num) self.assertEqual(circuitpack[cp_entity]['version'], cp_version) self.assertEqual(circuitpack[cp_entity]['vendor-id'], vendor_id) self.assertEqual(circuitpack[cp_entity]['total-tcont-count'], tconts) self.assertEqual(circuitpack[cp_entity]['total-priority-queue-count'], pqueues) self.assertEqual(circuitpack[cp_entity]['total-traffic-sched-count'], sched_count) # No capabilities available until started self.assertIsNone(self.onu_device.configuration) # Yield context so that MIB Database callLater runs. self.onu_device.start() d = asleep(0.2) d.addCallbacks(stuff_db, self.not_called) d.addCallbacks(do_my_tests, self.not_called) return d
def upload_alarm(self, command_sequence_number): ######################################## # Begin ALARM Upload seq_no = None for seq_no in range(command_sequence_number): max_tries = AlarmResyncTask.max_alarm_upload_next_retries for retries in range(0, max_tries): try: response = yield self._device.omci_cc.send_get_all_alarm_next( seq_no) self.strobe_watchdog() omci_msg = response.fields['omci_message'].fields alarm_class_id = omci_msg['alarmed_entity_class'] alarm_entity_id = omci_msg['alarmed_entity_id'] alarm_bit_map = omci_msg['alarm_bit_map'] attributes = { AlarmDbExternal.ALARM_BITMAP_KEY: alarm_bit_map } # Save to the database self._db_active.set(self.device_id, alarm_class_id, alarm_entity_id, attributes) break except TimeoutError: self.log.warn( 'alarm-resync-timeout', seq_no=seq_no, command_sequence_number=command_sequence_number) if retries < max_tries - 1: yield asleep(AlarmResyncTask.alarm_upload_next_delay) self.strobe_watchdog() else: raise except Exception as e: self.log.exception( 'resync', e=e, seq_no=seq_no, command_sequence_number=command_sequence_number) returnValue(seq_no + 1) # seq_no is zero based and alarm table.
def reboot(self): self.log.info('rebooting', device_id=self.device_id) # Update the connect status to UNREACHABLE yield self.core_proxy.device_state_update( self.device_id, connect_status=ConnectStatus.UNREACHABLE) # Sleep 10 secs, simulating a reboot # TODO: send alert and clear alert after the reboot yield asleep(10) # Change the connection status back to REACHABLE. With a # real ONU the connection state must be the actual state yield self.core_proxy.device_state_update( self.device_id, connect_status=ConnectStatus.REACHABLE) self.log.info('rebooted', device_id=self.device_id)
def test_in_sync_with_software_values(self): self.setup_one_of_each() self.assertEqual(len(self.omci_agent.device_ids()), 1) sw_entity = 0x200 sw_version = 'Beta-0.0.2' sw_hash = md5("just_a_test").hexdigest() prod_code = 'MySoftware' sw_active = True sw_committed = True sw_valid = True def stuff_db(_results): self._stuff_database([(SoftwareImage.class_id, sw_entity, { 'version': sw_version, 'is_committed': sw_committed, 'is_active': sw_active, 'is_valid': sw_valid, 'product_code': prod_code, 'image_hash': sw_hash, })]) def do_my_tests(_results): config = self.onu_device.configuration images = config.software_images self.assertTrue(isinstance(images, list)) self.assertEqual(len(images), 1) self.assertEqual( images[0].name, 'running-revision' if sw_active else 'candidate-revision') self.assertEqual(images[0].version, sw_version) self.assertEqual(images[0].is_active, 1 if sw_active else 0) self.assertEqual(images[0].is_committed, 1 if sw_committed else 0) self.assertEqual(images[0].is_valid, 1 if sw_valid else 0) self.assertEqual(images[0].hash, sw_hash) # No capabilities available until started self.assertIsNone(self.onu_device.configuration) # Yield context so that MIB Database callLater runs. self.onu_device.start() d = asleep(0.2) d.addCallbacks(stuff_db, self.not_called) d.addCallbacks(do_my_tests, self.not_called) return d
def test_mib_query_ok_if_dev_started(self): self.setup_one_of_each() onu_device = self.agent.add_device(DEFAULT_ONU_DEVICE_ID, self.adapter_agent) self.assertIsNotNone(onu_device) self.assertEqual(len(self.agent.device_ids()), 1) self.assertEqual(self.agent.get_device(DEFAULT_ONU_DEVICE_ID), onu_device) def not_called(_reason): onu_device.stop() assert False, 'Should never be called' def check_status(_results): # Device started. Query will succeed but nothing should be populated # but the most basic items results = onu_device.query_mib() self.assertTrue(isinstance(results, dict)) self.assertEqual(results.get(DEVICE_ID_KEY), DEFAULT_ONU_DEVICE_ID) self.assertIsNotNone(results.get(VERSION_KEY)) self.assertIsNotNone(results.get(CREATED_KEY)) self.assertIsNone( results.get(MODIFIED_KEY)) # Created! but not yet modified self.assertEqual(results.get(MDS_KEY), 0) self.assertIsNone(results.get(LAST_SYNC_KEY)) self.assertIsNone(results.get(CLASS_ID_KEY)) # Stopping still allows a query. Note you just delete a device # to clean up any associated databases onu_device.stop() results = onu_device.query_mib() self.assertTrue(isinstance(results, dict)) # Yield context so that MIB Database callLater runs. This is a waiting # Async task from when the OpenOMCIAgent was started. But also start the # device so that it's queued async state machines can run as well onu_device.start() d = asleep(0.2) d.addCallbacks(check_status, not_called) return d
def test_in_sync_with_cardholder_values(self): self.setup_one_of_each() self.assertEqual(len(self.omci_agent.device_ids()), 1) ch_entity = 0x102 unit_type = 255 clie_code = 'abc123' prot_ptr = 0 def stuff_db(_results): self._stuff_database([(Cardholder.class_id, ch_entity, { 'actual_plugin_unit_type': unit_type, 'actual_equipment_id': clie_code, 'protection_profile_pointer': prot_ptr, })]) def do_my_tests(_results): config = self.onu_device.configuration cardholder = config.cardholder_entities self.assertTrue(isinstance(cardholder, dict)) self.assertEqual(len(cardholder), 1) self.assertEqual(cardholder[ch_entity]['entity-id'], ch_entity) self.assertEqual(cardholder[ch_entity]['is-single-piece'], ch_entity >= 256) self.assertEqual(cardholder[ch_entity]['slot-number'], ch_entity & 0xFF) self.assertEqual(cardholder[ch_entity]['actual-plug-in-type'], unit_type) self.assertEqual(cardholder[ch_entity]['actual-equipment-id'], clie_code) self.assertEqual(cardholder[ch_entity]['protection-profile-ptr'], prot_ptr) # No capabilities available until started self.assertIsNone(self.onu_device.configuration) # Yield context so that MIB Database callLater runs. self.onu_device.start() d = asleep(0.2) d.addCallbacks(stuff_db, self.not_called) d.addCallbacks(do_my_tests, self.not_called) return d
def test_defaults(self): self.setup_one_of_each() self.assertEqual(len(self.omci_agent.device_ids()), 1) @raises(AssertionError) def do_my_tests(_results): config = self.onu_device.configuration # Should raise assertion if never been synchronized config.version # No capabilities available until started self.assertIsNone(self.onu_device.configuration) # Yield context so that MIB Database callLater runs. This is a waiting # Async task from when the OpenOMCIAgent was started. But also start the # device so that it's queued async state machines can run as well self.onu_device.start() d = asleep(0.2) d.addCallbacks(do_my_tests, self.not_called) return d
def _register_with_core(self, retries): while 1: try: resp = yield self.core_proxy.register( self.adapter.adapter_descriptor(), self.adapter.device_types()) if resp: self.log.info('registered-with-core', coreId=resp.instance_id) returnValue(resp) except TimeOutError as e: self.log.warn("timeout-when-registering-with-core", e=e) if retries == 0: self.log.exception("no-more-retries", e=e) raise else: retries = retries if retries < 0 else retries - 1 yield asleep(defs['retry_interval']) except Exception as e: self.log.exception("failed-registration", e=e) raise