def test_redisSubscriberRunnable_except(self): event = Event("publisher_id", "event_type", "event_body") pk = msgpack.Packer() resb = bytearray() resb.extend(pk.pack(2)) resb.extend(pk.pack(0)) resb.extend(pk.pack("publisher_id:event_type")) resb.extend(pk.pack(event.packed_object())) self.value = {"type": "message", "data": resb} with nested(patch("redis.client.PubSub.subscribe"), patch("logging.error"), patch("redis.client.PubSub.unsubscribe"), patch("redis.client.PubSub.listen"), patch(self.EVENT_PATH + ".create_from_packed")) as (mock_subscribe, logging_error, mock_unsubscribe, mock_listen, mock_event): mock_subscribe.return_value = None mock_unsubscribe.return_value = None mock_listen.return_value = [self.value] mock_event.side_effect = KeyError() self.target.start() self.target._MessageDispatcher__redisSubscriberRunnable() self.target.close() mock_event.assert_called_any_with( ["publisher_id", "event_type", "event_body"])
def test_packed_object_hasattr_False(self): self.newtarget = Event(self.Publisher_id, self.Event_type, self.flow_target_packed_object) self.result = self.newtarget.packed_object() self.assertEqual(self.result[0], self.Publisher_id) self.assertEqual(self.result[1], self.Event_type) self.assertEqual(self.result[2], self.flow_target_packed_object)
def test_redisSubscriberRunnable_except(self): event = Event("publisher_id", "event_type", "event_body") pk = msgpack.Packer() resb = bytearray() resb.extend(pk.pack(2)) resb.extend(pk.pack(0)) resb.extend(pk.pack("publisher_id:event_type")) resb.extend(pk.pack(event.packed_object())) self.value = {"type": "message", "data": resb} with nested( patch("redis.client.PubSub.subscribe"), patch("logging.error"), patch("redis.client.PubSub.unsubscribe"), patch("redis.client.PubSub.listen"), patch(self.EVENT_PATH + ".create_from_packed")) as ( mock_subscribe, logging_error, mock_unsubscribe, mock_listen, mock_event): mock_subscribe.return_value = None mock_unsubscribe.return_value = None mock_listen.return_value = [self.value] mock_event.side_effect = KeyError() self.target.start() self.target._MessageDispatcher__redisSubscriberRunnable() self.target.close() mock_event.assert_called_any_with( ["publisher_id", "event_type", "event_body"])
class EventTest(unittest.TestCase): Type = "BasicFlow" Version = "v01" Flow_id = "Id01" Owner = "Owner" Enabled = True Priority = "65535" Status = "none" Attributes = {"bandwidth": "10Mbps", "req_bandwidth": "11Mbps", "latency": "10msec", "req_latency": "11msec"} Publisher_id = "Id1" Event_type = "flowchanged" flow_target = Flow(Type, Version, Flow_id, Owner, Enabled, Priority, Status, Attributes) flow_target_packed_object = flow_target.packed_object() def setUp(self): self.target = Event(self.Publisher_id, self.Event_type, self.flow_target) def tearDown(self): self.target = None def test_constructor(self): self.assertEqual(self.target.publisher_id, self.Publisher_id) self.assertEqual(self.target.event_type, self.Event_type) self.assertEqual(self.target.body, self.flow_target) def test_create_from_packed(self): Type = "BasicFlow" Version = "v02" Flow_id = "Id02" Owner = "Owner" Enabled = True Priority = "65535" Status = "none" Attributes = {"bandwidth": "20Mbps", "req_bandwidth": "11Mbps", "latency": "30msec", "req_latency": "11msec"} Publisher_id = "Id1" Event_type = "flowchanged" flow_target = Flow(Type, Version, Flow_id, Owner, Enabled, Priority, Status, Attributes) value = [Publisher_id, Event_type, flow_target] self.result = self.target.create_from_packed(value) self.assertEqual(self.result.publisher_id, self.Publisher_id) self.assertEqual(self.result.event_type, self.Event_type) self.assertEqual(self.result.body, flow_target) def test_packed_object_hasattr_True(self): self.result = self.target.packed_object() self.assertEqual(self.result[0], self.Publisher_id) self.assertEqual(self.result[1], self.Event_type) self.assertEqual(self.result[2], self.flow_target_packed_object) def test_packed_object_hasattr_False(self): self.newtarget = Event(self.Publisher_id, self.Event_type, self.flow_target_packed_object) self.result = self.newtarget.packed_object() self.assertEqual(self.result[0], self.Publisher_id) self.assertEqual(self.result[1], self.Event_type) self.assertEqual(self.result[2], self.flow_target_packed_object)
def test_redisSubscriberRunnable_TYPE_EVENT(self): event = Event("publisher_id", "event_type", "event_body") pk = msgpack.Packer() resb = bytearray() resb.extend(pk.pack(2)) resb.extend(pk.pack(0)) resb.extend(pk.pack("publisher_id:event_type")) resb.extend(pk.pack(event.packed_object())) self.value = {"type": "message", "data": resb} self.target.thread_pool = futures.ThreadPoolExecutor(max_workers=8) self.target._MessageDispatcher__redisSubscriber = redis.StrictRedis( host=self.target._MessageDispatcher__redisServer, port=self.target._MessageDispatcher__redisPort) self.target._MessageDispatcher__redisSubscriber =\ self.target._MessageDispatcher__redisSubscriber.pubsub() with nested(patch("redis.client.PubSub.subscribe"), patch("redis.client.PubSub.unsubscribe"), patch("redis.client.PubSub.listen"), patch(self.EVENT_PATH + ".create_from_packed")) as (mock_subscribe, mock_unsubscribe, mock_listen, mock_event): mock_subscribe.return_value = None mock_unsubscribe.return_value = None mock_listen.return_value = [self.value] self.target._MessageDispatcher__redisSubscriberRunnable() mock_event.assert_called_once_with( ["publisher_id", "event_type", "event_body"])
def test__do_event_outpacketadded_create_from_packed_error(self): Dispatcher = Mock() Dispatcher.network_id = "NetworkId" Network_id = "NetworkId" Evbody = {"id": "OutPacketId1"} Event1 = Event("NetworkId", "OutPacketAdded", Evbody) self.target._network_interfaces["NetworkId"] =\ NetworkInterface(Dispatcher, Network_id) debug_log = "Receive Invalid OutPacketAdded Message"\ + " KeyError: " + "1" with nested( patch( 'org.o3project.odenos.core.component.network.packet.' 'out_packet_added.OutPacketAdded.create_from_packed', side_effect=KeyError(1)), patch('org.o3project.odenos.core.util.network_interface.' 'NetworkInterface.del_out_packet'), patch('logging.error')) as (m_create_from_packed, m_del_out_packet, m_logerror): self.target._do_event_outpacketadded(Event1) self.assertEqual(m_create_from_packed.call_count, 1) m_create_from_packed.assert_any_call(Evbody) self.assertEqual(m_del_out_packet.call_count, 0) self.assertEqual(m_logerror.call_count, 1) m_logerror.assert_any_call(debug_log)
def test__do_event_outpacketadded_NotNetworkId(self): Dispatcher = Mock() Dispatcher.network_id = "NetworkId" Network_id = "NetworkId" Evbody = {"id": "OutPacketId1"} Event1 = Event("NetworkId_dmy", "OutPacketAdded", Evbody) Event_packed = OutPacketAdded.create_from_packed(Evbody) self.target._network_interfaces[Network_id] =\ NetworkInterface(Dispatcher, Network_id) with nested( patch( 'org.o3project.odenos.core.component.network.packet.' 'out_packet_added.OutPacketAdded.create_from_packed', return_value=Event_packed), patch('org.o3project.odenos.core.util.network_interface.' 'NetworkInterface.del_out_packet'), patch('logging.error')) as (m_create_from_packed, m_del_out_packet, m_logerror): self.target._do_event_outpacketadded(Event1) self.assertEqual(m_create_from_packed.call_count, 1) m_create_from_packed.assert_any_call(Evbody) self.assertEqual(m_del_out_packet.call_count, 0) self.assertEqual(m_logerror.call_count, 0)
def test_publish_event_async(self): event = Event("publisher_id", "event_type", "event_body") self.target.publish_event_async(event) self.result = self.target._MessageDispatcher__pubsqueue.get() self.assertEqual(self.result.trans, None) self.assertEqual(self.result.type, 2) self.assertEqual(self.result.sno, 0) self.assertEqual(self.result.channel, "publisher_id:event_type")
def test_redisSubscriberRunnable_TYPE_EVENT(self): event = Event("publisher_id", "event_type", "event_body") pk = msgpack.Packer() resb = bytearray() resb.extend(pk.pack(2)) resb.extend(pk.pack(0)) resb.extend(pk.pack("publisher_id:event_type")) resb.extend(pk.pack(event.packed_object())) self.value = {"type": "message", "data": resb} self.target.thread_pool = futures.ThreadPoolExecutor(max_workers=8) self.target._MessageDispatcher__redisSubscriber = redis.StrictRedis( host=self.target._MessageDispatcher__redisServer, port=self.target._MessageDispatcher__redisPort) self.target._MessageDispatcher__redisSubscriber =\ self.target._MessageDispatcher__redisSubscriber.pubsub() with nested( patch("redis.client.PubSub.subscribe"), patch("redis.client.PubSub.unsubscribe"), patch("redis.client.PubSub.listen"), patch(self.EVENT_PATH + ".create_from_packed")) as ( mock_subscribe, mock_unsubscribe, mock_listen, mock_event): mock_subscribe.return_value = None mock_unsubscribe.return_value = None mock_listen.return_value = [self.value] self.target._MessageDispatcher__redisSubscriberRunnable() mock_event.assert_called_once_with( ["publisher_id", "event_type", "event_body"])
def __redisSubscriberRunnable(self): for mesg in self.__redisSubscriber.listen(): if mesg['type'] != 'message': continue try: bio = BytesIO() bio.write(mesg['data']) bio.seek(0) upk = msgpack.Unpacker(bio) tp = upk.unpack() sno = upk.unpack() srcid = upk.unpack() if tp == self.TYPE_REQUEST: request = Request.create_from_packed(upk.unpack()) def request_runnable(request, sno, srcid): response = self.dispatch_request(request) pk = msgpack.Packer() resb = bytearray() resb.extend(pk.pack(self.TYPE_RESPONSE)) resb.extend(pk.pack(sno)) resb.extend(pk.pack(request.object_id)) resb.extend(pk.pack(response.packed_object())) self.__pubsqueue.put( MessageDispatcher.PublishData(None, self.TYPE_RESPONSE, sno, srcid, resb)) self.thread_pool.submit(request_runnable, request, sno, srcid) elif tp == self.TYPE_RESPONSE: trans = self.__clients[srcid] response = Response.create_from_packed(upk.unpack()) trans.signalResponse(sno, response) elif tp == self.TYPE_EVENT: event = Event.create_from_packed(upk.unpack()) def event_runnable(event): self.dispatch_event(event) self.thread_pool.submit(event_runnable, event) except: logging.error(traceback.format_exc()) pass
def __redisSubscriberRunnable(self): for mesg in self.__redisSubscriber.listen(): if mesg['type'] != 'message': continue try: bio = BytesIO() bio.write(mesg['data']) bio.seek(0) upk = msgpack.Unpacker(bio) tp = upk.unpack() sno = upk.unpack() srcid = upk.unpack() if tp == self.TYPE_REQUEST: request = Request.create_from_packed(upk.unpack()) def request_runnable(request, sno, srcid): response = self.dispatch_request(request) pk = msgpack.Packer() resb = bytearray() resb.extend(pk.pack(self.TYPE_RESPONSE)) resb.extend(pk.pack(sno)) resb.extend(pk.pack(request.object_id)) resb.extend(pk.pack(response.packed_object())) self.__pubsqueue.put( MessageDispatcher.PublishData( None, self.TYPE_RESPONSE, sno, srcid, resb)) self.thread_pool.submit(request_runnable, request, sno, srcid) elif tp == self.TYPE_RESPONSE: trans = self.__clients[srcid] response = Response.create_from_packed(upk.unpack()) trans.signalResponse(sno, response) elif tp == self.TYPE_EVENT: event = Event.create_from_packed(upk.unpack()) def event_runnable(event): self.dispatch_event(event) self.thread_pool.submit(event_runnable, event) except: logging.error(traceback.format_exc()) pass
def test_dispatch_event_id_equal_del_obj_ids(self): event = Event("key01", "value01", "event_body") subscription_map =\ self.target._MessageDispatcher__subscription_map subscription_map._EventSubscriptionMap__subscriptions =\ {"remote_object": set(["key01:value01", "key01:value02"]), "local_object": set(["key01:value01", "key01:value02"])} subscription_map._EventSubscriptionMap__subscription_map =\ {"key01:value01": set(["remote_object", "local_object"]), "key01:value02": set(["remote_object", "local_object"])} self.target._MessageDispatcher__local_objects =\ {"remote_object": None} with patch(self.DISPATCHER_PATH + ".EventSubscriptionMap" + ".remove_subscription") as mock_remove_subscription: self.target.dispatch_event(event) mock_remove_subscription.assert_called_once_with("remote_object")
def test_dispatch_event(self): event = Event("key01", "value01", "event_body") subscription_map =\ self.target._MessageDispatcher__subscription_map subscription_map._EventSubscriptionMap__subscriptions =\ {"remote_object": set(["key01:value01", "key01:value02"]), "local_object": set(["key01:value01", "key01:value02"])} subscription_map._EventSubscriptionMap__subscription_map =\ {"key01:value01": set(["remote_object", "local_object"]), "key01:value02": set(["remote_object", "local_object"])} remote_object = RemoteObject("remote_object", self.target) self.target._MessageDispatcher__local_objects =\ {"remote_object": remote_object} with patch("org.o3project.odenos.remoteobject." + "remote_object.RemoteObject." + "dispatch_event") as mock_dispatch_event: self.target.dispatch_event(event) mock_dispatch_event.assert_called_once_with(event)
def _publish_event_async(self, event_type, body): return self.dispatcher.publish_event_async( Event(self.object_id, event_type, body))
def setUp(self): self.target = Event(self.Publisher_id, self.Event_type, self.flow_target)
class EventTest(unittest.TestCase): Type = "BasicFlow" Version = "v01" Flow_id = "Id01" Owner = "Owner" Enabled = True Priority = "65535" Status = "none" Attributes = { "bandwidth": "10Mbps", "req_bandwidth": "11Mbps", "latency": "10msec", "req_latency": "11msec" } Publisher_id = 'Id1' Event_type = 'flowchanged' flow_target = Flow(Type, Version, Flow_id, Owner, Enabled, Priority, Status, Attributes) flow_target_packed_object = flow_target.packed_object() def setUp(self): self.target = Event(self.Publisher_id, self.Event_type, self.flow_target) def tearDown(self): self.target = None def test_constructor(self): self.assertEqual(self.target.publisher_id, self.Publisher_id) self.assertEqual(self.target.event_type, self.Event_type) self.assertEqual(self.target.body, self.flow_target) def test_create_from_packed(self): Type = "BasicFlow" Version = "v02" Flow_id = "Id02" Owner = "Owner" Enabled = True Priority = "65535" Status = "none" Attributes = { "bandwidth": "20Mbps", "req_bandwidth": "11Mbps", "latency": "30msec", "req_latency": "11msec" } Publisher_id = 'Id1' Event_type = 'flowchanged' flow_target = Flow(Type, Version, Flow_id, Owner, Enabled, Priority, Status, Attributes) value = [Publisher_id, Event_type, flow_target] self.result = self.target.create_from_packed(value) self.assertEqual(self.result.publisher_id, self.Publisher_id) self.assertEqual(self.result.event_type, self.Event_type) self.assertEqual(self.result.body, flow_target) def test_packed_object_hasattr_True(self): self.result = self.target.packed_object() self.assertEqual(self.result[0], self.Publisher_id) self.assertEqual(self.result[1], self.Event_type) self.assertEqual(self.result[2], self.flow_target_packed_object) def test_packed_object_hasattr_False(self): self.newtarget = Event(self.Publisher_id, self.Event_type, self.flow_target_packed_object) self.result = self.newtarget.packed_object() self.assertEqual(self.result[0], self.Publisher_id) self.assertEqual(self.result[1], self.Event_type) self.assertEqual(self.result[2], self.flow_target_packed_object)