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()
