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)
def setUp(self):
self.target = Event(self.Publisher_id, self.Event_type, self.flow_target)
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)
