def test_events_stream(self): url = '%s/%s/events.json' % (self.url, self.conversation.key) events = DeferredQueue() errors = DeferredQueue() receiver = yield self.client.stream(TransportEvent, events.put, events.put, url, Headers(self.auth_headers)) msg1 = yield self.app_helper.make_stored_outbound(self.conversation, 'out 1', message_id='1') ack1 = yield self.app_helper.make_dispatch_ack(msg1, conv=self.conversation) msg2 = yield self.app_helper.make_stored_outbound(self.conversation, 'out 2', message_id='2') ack2 = yield self.app_helper.make_dispatch_ack(msg2, conv=self.conversation) ra1 = yield events.get() ra2 = yield events.get() receiver.disconnect() self.assertEqual(ack1['event_id'], ra1['event_id']) self.assertEqual(ack2['event_id'], ra2['event_id']) self.assertEqual(errors.size, None)
def test_messages_stream(self): url = '%s/%s/messages.json' % (self.url, self.conversation.key) messages = DeferredQueue() errors = DeferredQueue() receiver = self.client.stream(TransportUserMessage, messages.put, errors.put, url, Headers(self.auth_headers)) msg1 = yield self.app_helper.make_dispatch_inbound( 'in 1', message_id='1', conv=self.conversation) msg2 = yield self.app_helper.make_dispatch_inbound( 'in 2', message_id='2', conv=self.conversation) rm1 = yield messages.get() rm2 = yield messages.get() receiver.disconnect() # Sometimes messages arrive out of order if we're hitting real redis. rm1, rm2 = sorted([rm1, rm2], key=lambda m: m['message_id']) self.assertEqual(msg1['message_id'], rm1['message_id']) self.assertEqual(msg2['message_id'], rm2['message_id']) self.assertEqual(errors.size, None)
def __init__(self, adapter, device_id): self.log = structlog.get_logger(device_id=device_id) self.log.debug('function-entry') self.adapter = adapter self.adapter_agent = adapter.adapter_agent self.device_id = device_id self.incoming_messages = DeferredQueue() self.event_messages = DeferredQueue() self.proxy_address = None self.tx_id = 0 self._enabled = False self._omcc_version = OMCCVersion.Unknown self._total_tcont_count = 0 # From ANI-G ME self._qos_flexibility = 0 # From ONT2_G ME self._onu_indication = None self._unis = dict() # Port # -> UniPort self._port_number_pool = IndexPool(_MAXIMUM_PORT, 0) self._pon = None #TODO: probably shouldnt be hardcoded, determine from olt maybe? self._pon_port_number = 100 self.logical_device_id = None # Set up OpenOMCI environment self._onu_omci_device = None self._dev_info_loaded = False self._deferred = None self._in_sync_subscription = None self._connectivity_subscription = None self._capabilities_subscription = None
def __init__(self, adapter_agent, device_id, me_map=None, alarm_queue_limit=_MAX_INCOMING_ALARM_MESSAGES, avc_queue_limit=_MAX_INCOMING_ALARM_MESSAGES, test_results_queue_limit=_MAX_INCOMING_TEST_RESULT_MESSAGES): self.log = structlog.get_logger(device_id=device_id) self._adapter_agent = adapter_agent self._device_id = device_id self._proxy_address = None self._tx_tid = 1 self._enabled = False self._requests = dict() # Tx ID -> (timestamp, deferred, tx_frame, timeout) self._alarm_queue = DeferredQueue(size=alarm_queue_limit) self._avc_queue = DeferredQueue(size=avc_queue_limit) self._test_results_queue = DeferredQueue(size=test_results_queue_limit) self._me_map = me_map # Statistics self._tx_frames = 0 self._rx_frames = 0 self._rx_unknown_tid = 0 # Rx OMCI with no Tx TID match self._rx_onu_frames = 0 # Autonomously generated ONU frames self._rx_alarm_overflow = 0 # Autonomously generated ONU alarms rx overflow self._rx_avc_overflow = 0 # Autonomously generated ONU AVC rx overflow self._rx_onu_discards = 0 # Autonomously generated ONU unknown message types self._rx_timeouts = 0 self._rx_unknown_me = 0 # Number of managed entities Rx without a decode definition self._tx_errors = 0 # Exceptions during tx request self._consecutive_errors = 0 # Rx & Tx errors in a row, a good RX resets this to 0 self._reply_min = sys.maxint # Fastest successful tx -> rx self._reply_max = 0 # Longest successful tx -> rx self._reply_sum = 0.0 # Total seconds for successful tx->rx (float for average) self.event_bus = EventBusClient()
def __init__(self, connection_manager, channel, grpc_timeout, core_binding_key, core_transaction_key): self.connection_manager = connection_manager self.channel = channel self.grpc_timeout = grpc_timeout self.grpc_stub = VolthaServiceStub(channel) # This is the rw-core cluster to which an OFAgent is bound. # It is the affinity router that forwards all OFAgent # requests to a specific rw-core in this back-end cluster. self.core_group_id = '' self.core_group_id_key = core_binding_key # Since the api-router binds an OFAgent to two RW Cores in a pair and # transparently forward requests between the two then the onus is on # the OFAgent to fulfill part of the function of the api-server which # involves sending a transaction key to both RW Cores for the latter # to figure out which Core will handle the transaction. To prevent # collision between the api-server ID and the one from OFAgent then the # OFAgent ID will be prefixed with "O-". self.core_transaction_key = core_transaction_key self.stopped = False self.packet_out_queue = Queue() # queue to send out PacketOut msgs self.packet_in_queue = DeferredQueue() # queue to receive PacketIn self.change_event_queue = DeferredQueue() # queue change events
def __init__(self, adapter, device_id): self.log = structlog.get_logger(device_id=device_id) self.log.debug('function-entry') self.adapter = adapter self.adapter_agent = adapter.adapter_agent self.parent_adapter = None self.parent_id = None self.device_id = device_id self.incoming_messages = DeferredQueue() self.event_messages = DeferredQueue() self.proxy_address = None self.tx_id = 0 self._enabled = False self.alarms = None self.pm_metrics = None self._omcc_version = OMCCVersion.Unknown self._total_tcont_count = 0 # From ANI-G ME self._qos_flexibility = 0 # From ONT2_G ME self._onu_indication = None self._unis = dict() # Port # -> UniPort self._pon = None # TODO: probably shouldnt be hardcoded, determine from olt maybe? self._pon_port_number = 100 self.logical_device_id = None self._heartbeat = HeartBeat.create(self, device_id) # Set up OpenOMCI environment self._onu_omci_device = None self._dev_info_loaded = False self._deferred = None self._in_sync_subscription = None self._connectivity_subscription = None self._capabilities_subscription = None self.mac_bridge_service_profile_entity_id = 0x201 self.gal_enet_profile_entity_id = 0x1 self._tp_service_specific_task = dict() self._tech_profile_download_done = dict() # Initialize KV store client self.args = registry('main').get_args() if self.args.backend == 'etcd': host, port = self.args.etcd.split(':', 1) self.kv_client = EtcdStore( host, port, TechProfile.KV_STORE_TECH_PROFILE_PATH_PREFIX) elif self.args.backend == 'consul': host, port = self.args.consul.split(':', 1) self.kv_client = ConsulStore( host, port, TechProfile.KV_STORE_TECH_PROFILE_PATH_PREFIX) else: self.log.error('Invalid-backend') raise Exception("Invalid-backend-for-kv-store") # Handle received ONU event messages reactor.callLater(0, self.handle_onu_events)
def __init__(self): self.client_server = 'localhost' self.client_port = 9452 self.work_port_1 = 40062 self.work_port_2 = 41062 self.client_queue = DeferredQueue() self.work_command_queue = DeferredQueue() self.work_queue = DeferredQueue()
def __init__(self): self.home_server = 'student00.cse.nd.edu' self.home_port_1 = 40062 self.home_port_2 = 41062 self.student_server = 'student00.cse.nd.edu' self.student_port = 22 self.home_queue = DeferredQueue() self.student_queue = DeferredQueue()
def __init__(self): """Create a new TCP proxy. `self.server_queue` contains messages from end server to client. `self.client_queue` contains messages from client to end server. """ self.server_queue = DeferredQueue() self.client_queue = DeferredQueue() self.server_queue.get().addCallback(self.serverQueueCallback)
def __init__(self, connection_manager, channel): self.connection_manager = connection_manager self.channel = channel self.local_stub = VolthaLocalServiceStub(channel) self.stopped = False self.packet_out_queue = Queue() # queue to send out PacketOut msgs self.packet_in_queue = DeferredQueue() # queue to receive PacketIn self.change_event_queue = DeferredQueue() # queue change events
def __init__(self): self.state = State() self.cmd_queue = DeferredQueue() self.x1_queue = DeferredQueue() self.x1CliFac = X1ClientFactory(self.cmd_queue, self.x1_queue, self.state) self.x1tcp = None self.x2CliFac = X2ServerFactory() self._start_x2_server()
def __init__(self, adapter, device_id): kwargs = dict() super(AdtranOnuHandler, self).__init__(**kwargs) self.adapter = adapter self.adapter_agent = adapter.adapter_agent self.device_id = device_id self.log = structlog.get_logger(device_id=device_id) self.logical_device_id = None self.proxy_address = None self._enabled = False self.pm_metrics = None self.alarms = None self._openomci = OMCI(self, adapter.omci_agent) self._in_sync_subscription = None self._pon_port_number = 1 self._unis = dict() # Port # -> UniPort self._pon = PonPort.create(self, self._pon_port_number) self._heartbeat = HeartBeat.create(self, device_id) self._deferred = None # Flow entries self._flows = dict() # OMCI resources # TODO: Some of these could be dynamically chosen self.vlan_tcis_1 = 0x900 self.mac_bridge_service_profile_entity_id = self.vlan_tcis_1 self.gal_enet_profile_entity_id = 0 # Technology profile related values self.incoming_messages = DeferredQueue() self.event_messages = DeferredQueue() self._tp_service_specific_task = dict() self._tech_profile_download_done = dict() # Initialize KV store client self.args = registry('main').get_args() if self.args.backend == 'etcd': host, port = self.args.etcd.split(':', 1) self.kv_client = EtcdStore(host, port, TechProfile.KV_STORE_TECH_PROFILE_PATH_PREFIX) elif self.args.backend == 'consul': host, port = self.args.consul.split(':', 1) self.kv_client = ConsulStore(host, port, TechProfile.KV_STORE_TECH_PROFILE_PATH_PREFIX) else: self.log.error('Invalid-backend') raise Exception("Invalid-backend-for-kv-store") # Handle received ONU event messages reactor.callLater(0, self.handle_onu_events)
def __init__(self, player, port): self.server = 'student00.cse.nd.edu' self.port_1 = 40000 + port self.data_port_1 = 41000 + port self.incoming_data_queue = DeferredQueue() self.outgoing_data_queue = DeferredQueue() self.playerNumber = 'p' + str(player) if self.playerNumber == 'p1': self.otherNumber = 'p2' else: self.otherNumber = 'p1' self.game = Game(self)
def __init__(self): self.port_1 = 40062 self.port_2 = 40063 self.data_port_1 = 41062 self.data_port_2 = 41063 self.conn_queue = DeferredQueue() self.data_queue = DeferredQueue() self.playersConnected = 0 #Create an array that will contain dictionaries self.data_array = {'p1': [], 'p2': []} self.data_received = {'p1': False, 'p2': False}
def setUp(self): self.tr = proto_helpers.StringTransportWithDisconnection() self.clock = task.Clock() cmd_queue = DeferredQueue() x1_queue = DeferredQueue() state = State() factory = X1ClientFactory(cmd_queue, x1_queue, state) self.proto = factory.buildProtocol(('127.0.0.1', 0)) self.proto.callLater = self.clock.callLater self.tr.protocol = self.proto config.pingEnable = False self.cmd_data = []
def __init__(self, options): MultiService.__init__(self) setLogLevel(namespace='as7262', levelStr=options['log_level']) self.options = options self.serialService = None self.statsService = None self.consoService = None self.storageService = None self.factory = AS7262ProtocolFactory() self.queue = { 'AS7262': DeferredQueue(), 'OPT3001': DeferredQueue(), } self.stats = {}
def __init__(self, adapter, device_id): self.adapter = adapter self.adapter_agent = adapter.adapter_agent self.device_id = device_id self.log = structlog.get_logger(device_id=device_id) self.incoming_messages = DeferredQueue() self.proxy_address = None
def start(self): assert self._enabled, 'Start should only be called if enabled' self._cancel_deferred() # Handle received ONU event messages TODO: Deprecate this.... self._event_messages = DeferredQueue() self._event_deferred = reactor.callLater(0, self._handle_onu_events) # Register for adapter messages self.adapter_agent.register_for_inter_adapter_messages() # OpenOMCI Startup self._subscribe_to_events() self._openomci.enabled = True # Port startup if self._pon is not None: self._pon.enabled = True for port in self.uni_ports: port.enabled = True # Heartbeat self._heartbeat.enabled = True
def __init__(self, adapter, device_id): self.adapter = adapter self.adapter_agent = adapter.adapter_agent self.device_id = device_id self.log = structlog.get_logger(device_id=device_id) self.incoming_messages = DeferredQueue() self.event_messages = DeferredQueue() self.proxy_address = None self.tx_id = 0 # Need to query ONU for number of supported uni ports # For now, temporarily set number of ports to 1 - port #2 self.uni_ports = (2, ) # Handle received ONU event messages reactor.callLater(0, self.handle_onu_events)
def start(self): assert self._enabled, 'Start should only be called if enabled' # # TODO: Perform common startup tasks here # self._cancel_deferred() self._omci = OMCI_CC(self.adapter_agent, self.device_id, custom_me_entries=onu_custom_entity_classes) self._omci.enabled = True # Handle received ONU event messages self._event_messages = DeferredQueue() self._event_deferred = reactor.callLater(0, self._handle_onu_events) # Register for adapter messages self.adapter_agent.register_for_inter_adapter_messages() # Port startup for port in self.uni_ports: port.enabled = True for port in self.pon_ports: port.enabled = True # Heartbeat self._heartbeat.enabled = True
def __init__(self, vumi_transport): """ An SMPP 3.4 client suitable for use by a Vumi Transport. :param SmppTransceiverProtocol vumi_transport: The transport that is using this protocol to communicate with an SMSC. """ self.vumi_transport = vumi_transport self.config = self.vumi_transport.get_static_config() self.buffer = b'' self.state = self.CLOSED_STATE self.deliver_sm_processor = self.vumi_transport.deliver_sm_processor self.dr_processor = self.vumi_transport.dr_processor self.sequence_generator = self.vumi_transport.sequence_generator self.enquire_link_call = LoopingCall(self.enquire_link) self.drop_link_call = None self.idle_timeout = self.config.smpp_enquire_link_interval * 2 self.disconnect_call = self.clock.callLater( self.idle_timeout, self.disconnect, 'Disconnecting, no response from SMSC for longer ' 'than %s seconds' % (self.idle_timeout, )) self.unbind_resp_queue = DeferredQueue()
def makeService(options): from twisted.internet import reactor assert not (options["config"] and options["demo"]) if options["demo"]: app = DownloadEFolder.create_demo(reactor, Logger(log)) else: queue = DeferredQueue() app = DownloadEFolder.from_config( reactor, Logger(log), queue, options["config"], ) if options.subCommand == "create-database": return CreateDatabaseService(reactor, app) if not options["demo"]: app.start_fetch_document_types() app.queue_pending_work() service = MultiService() endpoint = serverFromString(reactor, "tcp:8080:interface=127.0.0.1") StreamServerEndpointService( endpoint, Site(app.app.resource(), logPath="/dev/null"), ).setServiceParent(service) if not options["demo"]: for _ in xrange(8): DeferredQueueConsumerService( queue, lambda item: item()).setServiceParent(service) return service
def __init__(self, pipe, width=5): Deferred.__init__(self) self.pipe = pipe self.width = width self.waiting = None self.running = 0 self.results = DeferredQueue()
def __init__(self, config, app): self.app = app self.config = config self.update_projects() self.dq = DeferredQueue(size=1) fp = 'setting.conf' conf = ConfigParser.ConfigParser() conf.read(fp) self.slave_id = conf.get('slave_id', 'slave_id') # 从配置文件中获取本机的ID self.dispatch_host = conf.get('dispatch', 'dispatch_host') # self.dispatch_port = conf.getint('dispatch', 'dispatch_port') # self.redis_conn = redis.Redis(host='10.195.112.13', port=6379, password='******') self.node_info = { 'ip': '', 'slaveid': '', 'operator': '', 'os': '', 'cpu': '', 'RAM': '', 'version': '', 'cpuUsed': '', 'RAMUsed': '', 'netCon': '' } # self.node_info['ip'] = get_local_ip() self.node_info['slaveid'] = self.slave_id self.node_info['os'] = sys.platform
def __init__(self, auto_accept=True, auto_unbind=True): self.auto_accept = auto_accept self.auto_unbind = auto_unbind self.pdu_queue = DeferredQueue() self.endpoint = FakeSMSCEndpoint(self) self.connected = False self._reset_connection_ds()
def __init__(self, kafka_host_port, default_topic, group_id_prefix, target_cls): """ Initialize the kafka proxy. This is a singleton (may change to non-singleton if performance is better) :param kafka_host_port: Kafka host and port :param default_topic: Default topic to subscribe to :param target_cls: target class - method of that class is invoked when a message is received on the default_topic """ # return an exception if the object already exist if IKafkaMessagingProxy._kafka_messaging_instance: raise Exception('Singleton-exist') log.debug("Initializing-KafkaProxy") self.kafka_host_port = kafka_host_port self.default_topic = default_topic self.default_group_id = "_".join((group_id_prefix, default_topic)) self.target_cls = target_cls self.topic_target_cls_map = {} self.topic_callback_map = {} self.subscribers = {} self.kafka_proxy = None self.transaction_id_deferred_map = {} # Ident -> KafkaWaitForResponse self.received_msg_queue = DeferredQueue() self.stopped = False self.tx_stats = None # First 'clear' of stats enables them self.rx_stats = None log.debug("KafkaProxy-initialized")
def setUp(self): self.cellulant_sms_calls = DeferredQueue() self.mock_cellulant_sms = MockHttpServer(self.handle_request) yield self.mock_cellulant_sms.start() self.add_cleanup(self.mock_cellulant_sms.stop) self.config = { 'web_path': "foo", 'web_port': 0, 'credentials': { '2371234567': { 'username': '******', 'password': '******', }, '9292': { 'username': '******', 'password': '******', } }, 'outbound_url': self.mock_cellulant_sms.url, 'validation_mode': 'permissive', } self.tx_helper = self.add_helper( TransportHelper(CellulantSmsTransport)) self.transport = yield self.tx_helper.get_transport(self.config) self.transport_url = self.transport.get_transport_url()
def setUp(self): self.mediaedgegsm_calls = DeferredQueue() self.mock_mediaedgegsm = MockHttpServer(self.handle_request) self.add_cleanup(self.mock_mediaedgegsm.stop) yield self.mock_mediaedgegsm.start() self.config = { 'web_path': "foo", 'web_port': 0, 'username': '******', 'password': '******', 'outbound_url': self.mock_mediaedgegsm.url, 'outbound_username': '******', 'outbound_password': '******', 'operator_mappings': { '417': { '417912': 'VODA', '417913': 'TIGO', '417914': 'UNKNOWN', } } } self.tx_helper = self.add_helper( TransportHelper(MediaEdgeGSMTransport)) self.transport = yield self.tx_helper.get_transport(self.config) self.transport_url = self.transport.get_transport_url() self.mediaedgegsm_response = '' self.mediaedgegsm_response_code = http.OK
def __init__(self, pubnub_instance): self._message_queue = DeferredQueue() self.worker_loop = None self._heartbeat_loop = None self._heartbeat_call = None self.clock = pubnub_instance.clock super(TwistedSubscriptionManager, self).__init__(pubnub_instance)
def __init__(self, service, bind_type): """ An SMPP 3.4 client suitable for use by a Vumi Transport. :param SmppService service: The SMPP service that is using this protocol to communicate with an SMSC. """ self.service = service self.log = service.log self.bind_pdu = self._BIND_PDU[bind_type] self.clock = service.clock self.config = self.service.get_config() self.buffer = b'' self.state = self.CLOSED_STATE self.deliver_sm_processor = self.service.deliver_sm_processor self.dr_processor = self.service.dr_processor self.sequence_generator = self.service.sequence_generator self.enquire_link_call = LoopingCall(self.enquire_link) self.drop_link_call = None self.idle_timeout = self.config.smpp_enquire_link_interval * 2 self.disconnect_call = None self.unbind_resp_queue = DeferredQueue()