def setUp(self):
link1 = Link('Link', '1', 'LinkId1', 'NodeId1', 'PortId1', 'NodeId2',
'PortId3', {})
link2 = Link('Link', '1', 'LinkId2', 'NodeId2', 'PortId4', 'NodeId1',
'PortId2', {})
self.target = LinkChanged('ID', LinkChanged.Action.UPDATE, '1', link1,
link2)
def setUp(self):
link1 = Link('Link', '1', 'LinkId1', 'NodeId1', 'PortId1', 'NodeId2',
'PortId3', {})
link2 = Link('Link', '1', 'LinkId2', 'NodeId2', 'PortId4', 'NodeId1',
'PortId2', {})
node1 = Node('Node', '1', 'NodeId1', {}, {})
node2 = Node('Node', '1', 'NodeId2', {}, {})
topology1 = Topology('Topology', 'version', {'NodeId1': node1},
{'LinkId1': link1})
topology2 = Topology('Topology', 'version', {'NodeId2': node2},
{'LinkId2': link2})
self.target = TopologyChanged('1', topology1, topology2)
def _delete_link_conversion(self, network_id, link):
logging.debug(">> %s", stack()[0][3])
resp_list = {}
if network_id is None or link is None:
return resp_list
dst_links = self._conversion_table.get_link(network_id,
link.link_id)
for dst_link in dst_links:
link_id = dst_link.split("::")
if link_id[0] not in self._network_interfaces:
continue
network_if = self._network_interfaces[link_id[0]]
resp = network_if.del_link(link_id[1])
resp_link = None
if resp.body is not None:
try:
resp_link = Link.create_from_packed(resp.body)
except KeyError, err:
logging.error("DELETE Link Invalid Response Message"
+ " KeyError: " + str(err))
return None
resp_list[dst_link] = resp_link
def create_from_packed(cls, packed):
action = packed[cls.ACTION]
version = ""
prev = None
curr = None
if action == cls.Action.ADD:
version = packed[cls.VERSION]
curr = Link.create_from_packed(packed[cls.CURR])
elif action == cls.Action.DELETE:
prev = Link.create_from_packed(packed[cls.PREV])
elif action == cls.Action.UPDATE:
version = packed[cls.VERSION]
prev = Link.create_from_packed(packed[cls.PREV])
curr = Link.create_from_packed(packed[cls.CURR])
return cls(packed[cls.ID], action, version, prev, curr)
def create_from_packed(cls, packed):
action = packed[cls.ACTION]
version = ""
prev = None
curr = None
if action == cls.Action.ADD:
version = packed[cls.VERSION]
curr = Link.create_from_packed(packed[cls.CURR])
elif action == cls.Action.DELETE:
prev = Link.create_from_packed(packed[cls.PREV])
elif action == cls.Action.UPDATE:
version = packed[cls.VERSION]
prev = Link.create_from_packed(packed[cls.PREV])
curr = Link.create_from_packed(packed[cls.CURR])
return cls(packed[cls.ID], action,
version, prev, curr)
def setUp(self):
port1 = Port('Port', '1', 'PortId1', 'NodeId1', 'LinkId1', None, {})
port2 = Port('Port', '1', 'PortId2', 'NodeId1', None, 'LinkId2', {})
port3 = Port('Port', '1', 'PortId3', 'NodeId2', None, 'LinkId1', {})
port4 = Port('Port', '1', 'PortId4', 'NodeId2', 'LinkId2', None, {})
node1 = Node('Node', '1', 'NodeId1', {
'PortId1': port1,
'PortId2': port2
}, {})
node2 = Node('Node', '1', 'NodeId2', {
'PortId3': port3,
'PortId4': port4
}, {})
link1 = Link('Link', '1', 'LinkId1', 'NodeId1', 'PortId1', 'NodeId2',
'PortId3', {})
link2 = Link('Link', '1', 'LinkId2', 'NodeId2', 'PortId4', 'NodeId1',
'PortId2', {})
self.nodes = {'NodeId1': node1, 'NodeId2': node2}
self.links = {'LinkId1': link1, 'LinkId2': link2}
self.target = Topology('Topology', '1', self.nodes, self.links)
def test_create_from_packed(self):
packed = self.target.packed_object()
result = Link.create_from_packed(packed)
self.assertEqual(result.type, 'Link')
self.assertEqual(result.version, '1')
self.assertEqual(result.link_id, 'LinkId')
self.assertEqual(result.src_node, 'SrcNodeId')
self.assertEqual(result.src_port, 'SrcPortId')
self.assertEqual(result.dst_node, 'DstNodeId')
self.assertEqual(result.dst_port, 'DstPortId')
self.assertEqual(len(result.attributes), 1)
self.assertEqual(result.attributes['Key'], 'Val')
def test_create_from_packed(self):
packed = self.target.packed_object()
result = Link.create_from_packed(packed)
self.assertEqual(result.type, 'Link')
self.assertEqual(result.version, '1')
self.assertEqual(result.link_id, 'LinkId')
self.assertEqual(result.src_node, 'SrcNodeId')
self.assertEqual(result.src_port, 'SrcPortId')
self.assertEqual(result.dst_node, 'DstNodeId')
self.assertEqual(result.dst_port, 'DstPortId')
self.assertEqual(len(result.attributes), 1)
self.assertEqual(result.attributes['Key'], 'Val')
def _update_link_conversion(self, network_id,
link_prev, link_curr, attributes):
logging.debug(">> %s", stack()[0][3])
resp_list = {}
if network_id is None or link_curr is None:
return resp_list
attributes_list = []
if attributes is None:
attributes_list = []
else:
attributes_list = attributes
# get ignore list
link_ignore_attributes = self.__get_ignore_keys(self.attributes_link,
attributes_list)
for dst_link in self._conversion_table.get_link(network_id,
link_curr.link_id):
link_id = dst_link.split("::")
if link_id[0] not in self._network_interfaces:
continue
network_if = self._network_interfaces[link_id[0]]
# get link
link = network_if.get_link(link_id[1])
if link is None:
continue
# attr copy (curr -> body)
updated = False
curr_attr = link_curr.attributes
for attr_key in curr_attr:
if (attr_key in link_ignore_attributes or
(attr_key in link.attributes and
link.attributes[attr_key] == curr_attr[attr_key])):
continue
updated = True
link.attributes[attr_key] = \
link_curr.attributes[attr_key]
# put link
if updated:
resp = network_if.put_link(link)
try:
resp_link = Link.create_from_packed(resp.body)
resp_list[dst_link] = resp_link
except KeyError, err:
logging.error("PUT Link Invalid Response Message"
+ " KeyError: " + str(err))
def get_links(self):
logging.debug("GET Links NetworkID:" + self.network_id)
resp = self._get_object_to_remote_object(self.LINKS_PATH)
if resp.is_error(Request.Method.GET):
return None
links = {}
try:
for link_id, link in resp.body.items():
links[link_id] = Link.create_from_packed(link)
except KeyError, err:
logging.error("GET Links Invalid Response Message" +
" KeyError: " + str(err))
return None
def create_from_packed(cls, packed):
version = None
if cls.VERSION in packed:
version = packed[cls.VERSION]
nodes = {}
for node_id, node in packed[cls.NODES].items():
nodes[node_id] = Node.create_from_packed(node)
links = {}
for link_id, link in packed[cls.LINKS].items():
links[link_id] = Link.create_from_packed(link)
return cls(packed[cls.TYPE], version, nodes, links)
def get_links(self):
logging.debug("GET Links NetworkID:" + self.network_id)
resp = self._get_object_to_remote_object(self.LINKS_PATH)
if resp.is_error(Request.Method.GET):
return None
links = {}
try:
for link_id, link in resp.body.items():
links[link_id] = Link.create_from_packed(link)
except KeyError, err:
logging.error("GET Links Invalid Response Message"
+ " KeyError: " + str(err))
return None
def create_from_packed(cls, packed):
version = None
if cls.VERSION in packed:
version = packed[cls.VERSION]
nodes = {}
for node_id, node in packed[cls.NODES].items():
nodes[node_id] = Node.create_from_packed(node)
links = {}
for link_id, link in packed[cls.LINKS].items():
links[link_id] = Link.create_from_packed(link)
return cls(packed[cls.TYPE], version,
nodes, links)
def get_link(self, link_id):
logging.debug("GET Link NetworkID:" + self.network_id +
" LinkID:" + link_id)
path = self.LINK_PATH % link_id
resp = self._get_object_to_remote_object(path)
if resp.is_error(Request.Method.GET):
return None
link = None
try:
link = Link.create_from_packed(resp.body)
except KeyError, err:
logging.error("GET Link Invalid Response Message"
+ " KeyError: " + str(err))
return None
def get_link(self, link_id):
logging.debug("GET Link NetworkID:" + self.network_id + " LinkID:" +
link_id)
path = self.LINK_PATH % link_id
resp = self._get_object_to_remote_object(path)
if resp.is_error(Request.Method.GET):
return None
link = None
try:
link = Link.create_from_packed(resp.body)
except KeyError, err:
logging.error("GET Link Invalid Response Message" + " KeyError: " +
str(err))
return None
def test_create_from_packed_without_version(self):
packed = {'type': 'Link', 'link_id': 'LinkId',
'src_node': 'SrcNodeId', 'src_port': 'SrcPortId',
'dst_node': 'DstNodeId', 'dst_port': 'DstPortId',
'attributes': {'Key': 'Val'}}
result = Link.create_from_packed(packed)
self.assertEqual(result.type, 'Link')
self.assertEqual(result.version, None)
self.assertEqual(result.link_id, 'LinkId')
self.assertEqual(result.src_node, 'SrcNodeId')
self.assertEqual(result.src_port, 'SrcPortId')
self.assertEqual(result.dst_node, 'DstNodeId')
self.assertEqual(result.dst_port, 'DstPortId')
self.assertEqual(len(result.attributes), 1)
self.assertEqual(result.attributes['Key'], 'Val')
def _add_link_conversion(self, network_id, link):
logging.debug(">> %s", stack()[0][3])
resp_list = {}
for nw_id in self._conversion_table.get_network(network_id):
if nw_id not in self._network_interfaces:
continue
network_if = self._network_interfaces[nw_id]
resp = network_if.put_link(link)
resp_list[nw_id] = resp
try:
resp_link = Link.create_from_packed(resp.body)
self._conversion_table.add_entry_link(network_id,
link.link_id,
nw_id,
resp_link.link_id)
except KeyError, err:
logging.error("PUT Link Invalid Response Message"
+ " KeyError: " + str(err))
def test_create_from_packed_without_version(self):
packed = {
'type': 'Link',
'link_id': 'LinkId',
'src_node': 'SrcNodeId',
'src_port': 'SrcPortId',
'dst_node': 'DstNodeId',
'dst_port': 'DstPortId',
'attributes': {
'Key': 'Val'
}
}
result = Link.create_from_packed(packed)
self.assertEqual(result.type, 'Link')
self.assertEqual(result.version, None)
self.assertEqual(result.link_id, 'LinkId')
self.assertEqual(result.src_node, 'SrcNodeId')
self.assertEqual(result.src_port, 'SrcPortId')
self.assertEqual(result.dst_node, 'DstNodeId')
self.assertEqual(result.dst_port, 'DstPortId')
self.assertEqual(len(result.attributes), 1)
self.assertEqual(result.attributes['Key'], 'Val')
def setUp(self):
self.target = Link('Link', '1', 'LinkId', 'SrcNodeId', 'SrcPortId',
'DstNodeId', 'DstPortId', {'Key': 'Val'})
class LinkTest(unittest.TestCase):
def setUp(self):
self.target = Link('Link', '1', 'LinkId', 'SrcNodeId', 'SrcPortId',
'DstNodeId', 'DstPortId', {'Key': 'Val'})
def tearDown(self):
pass
def test_constructor(self):
self.assertEqual(self.target._body[Link.TYPE], 'Link')
self.assertEqual(self.target._body[Link.VERSION], '1')
self.assertEqual(self.target._body[Link.LINK_ID], 'LinkId')
self.assertEqual(self.target._body[Link.SRC_NODE], 'SrcNodeId')
self.assertEqual(self.target._body[Link.SRC_PORT], 'SrcPortId')
self.assertEqual(self.target._body[Link.DST_NODE], 'DstNodeId')
self.assertEqual(self.target._body[Link.DST_PORT], 'DstPortId')
self.assertEqual(self.target._body[Link.ATTRIBUTES]['Key'], 'Val')
def test_type(self):
self.assertEqual(self.target.type, 'Link')
def test_version(self):
self.assertEqual(self.target.version, '1')
def test_link_id(self):
self.assertEqual(self.target.link_id, 'LinkId')
def test_src_node(self):
self.assertEqual(self.target.src_node, 'SrcNodeId')
def test_src_port(self):
self.assertEqual(self.target.src_port, 'SrcPortId')
def test_dst_node(self):
self.assertEqual(self.target.dst_node, 'DstNodeId')
def test_dst_port(self):
self.assertEqual(self.target.dst_port, 'DstPortId')
def test_attributes(self):
result = self.target.attributes
self.assertEqual(len(result), 1)
self.assertEqual(result['Key'], 'Val')
def test_create_from_packed(self):
packed = self.target.packed_object()
result = Link.create_from_packed(packed)
self.assertEqual(result.type, 'Link')
self.assertEqual(result.version, '1')
self.assertEqual(result.link_id, 'LinkId')
self.assertEqual(result.src_node, 'SrcNodeId')
self.assertEqual(result.src_port, 'SrcPortId')
self.assertEqual(result.dst_node, 'DstNodeId')
self.assertEqual(result.dst_port, 'DstPortId')
self.assertEqual(len(result.attributes), 1)
self.assertEqual(result.attributes['Key'], 'Val')
def test_create_from_packed_without_version(self):
packed = {
'type': 'Link',
'link_id': 'LinkId',
'src_node': 'SrcNodeId',
'src_port': 'SrcPortId',
'dst_node': 'DstNodeId',
'dst_port': 'DstPortId',
'attributes': {
'Key': 'Val'
}
}
result = Link.create_from_packed(packed)
self.assertEqual(result.type, 'Link')
self.assertEqual(result.version, None)
self.assertEqual(result.link_id, 'LinkId')
self.assertEqual(result.src_node, 'SrcNodeId')
self.assertEqual(result.src_port, 'SrcPortId')
self.assertEqual(result.dst_node, 'DstNodeId')
self.assertEqual(result.dst_port, 'DstPortId')
self.assertEqual(len(result.attributes), 1)
self.assertEqual(result.attributes['Key'], 'Val')
def test_packed_object(self):
result = self.target.packed_object()
self.assertEqual(
result, {
'type': 'Link',
'version': '1',
'link_id': 'LinkId',
'src_node': 'SrcNodeId',
'src_port': 'SrcPortId',
'dst_node': 'DstNodeId',
'dst_port': 'DstPortId',
'attributes': {
'Key': 'Val'
}
})
class LinkTest(unittest.TestCase):
def setUp(self):
self.target = Link('Link', '1', 'LinkId', 'SrcNodeId', 'SrcPortId',
'DstNodeId', 'DstPortId', {'Key': 'Val'})
def tearDown(self):
pass
def test_constructor(self):
self.assertEqual(self.target._body[Link.TYPE], 'Link')
self.assertEqual(self.target._body[Link.VERSION], '1')
self.assertEqual(self.target._body[Link.LINK_ID], 'LinkId')
self.assertEqual(self.target._body[Link.SRC_NODE], 'SrcNodeId')
self.assertEqual(self.target._body[Link.SRC_PORT], 'SrcPortId')
self.assertEqual(self.target._body[Link.DST_NODE], 'DstNodeId')
self.assertEqual(self.target._body[Link.DST_PORT], 'DstPortId')
self.assertEqual(self.target._body[Link.ATTRIBUTES]['Key'], 'Val')
def test_type(self):
self.assertEqual(self.target.type, 'Link')
def test_version(self):
self.assertEqual(self.target.version, '1')
def test_link_id(self):
self.assertEqual(self.target.link_id, 'LinkId')
def test_src_node(self):
self.assertEqual(self.target.src_node, 'SrcNodeId')
def test_src_port(self):
self.assertEqual(self.target.src_port, 'SrcPortId')
def test_dst_node(self):
self.assertEqual(self.target.dst_node, 'DstNodeId')
def test_dst_port(self):
self.assertEqual(self.target.dst_port, 'DstPortId')
def test_attributes(self):
result = self.target.attributes
self.assertEqual(len(result), 1)
self.assertEqual(result['Key'], 'Val')
def test_create_from_packed(self):
packed = self.target.packed_object()
result = Link.create_from_packed(packed)
self.assertEqual(result.type, 'Link')
self.assertEqual(result.version, '1')
self.assertEqual(result.link_id, 'LinkId')
self.assertEqual(result.src_node, 'SrcNodeId')
self.assertEqual(result.src_port, 'SrcPortId')
self.assertEqual(result.dst_node, 'DstNodeId')
self.assertEqual(result.dst_port, 'DstPortId')
self.assertEqual(len(result.attributes), 1)
self.assertEqual(result.attributes['Key'], 'Val')
def test_create_from_packed_without_version(self):
packed = {'type': 'Link', 'link_id': 'LinkId',
'src_node': 'SrcNodeId', 'src_port': 'SrcPortId',
'dst_node': 'DstNodeId', 'dst_port': 'DstPortId',
'attributes': {'Key': 'Val'}}
result = Link.create_from_packed(packed)
self.assertEqual(result.type, 'Link')
self.assertEqual(result.version, None)
self.assertEqual(result.link_id, 'LinkId')
self.assertEqual(result.src_node, 'SrcNodeId')
self.assertEqual(result.src_port, 'SrcPortId')
self.assertEqual(result.dst_node, 'DstNodeId')
self.assertEqual(result.dst_port, 'DstPortId')
self.assertEqual(len(result.attributes), 1)
self.assertEqual(result.attributes['Key'], 'Val')
def test_packed_object(self):
result = self.target.packed_object()
self.assertEqual(result, {'type': 'Link', 'version': '1',
'link_id': 'LinkId',
'src_node': 'SrcNodeId',
'src_port': 'SrcPortId',
'dst_node': 'DstNodeId',
'dst_port': 'DstPortId',
'attributes': {'Key': 'Val'}})
def setUp(self):
self.target = Link('Link', '1', 'LinkId', 'SrcNodeId', 'SrcPortId',
'DstNodeId', 'DstPortId', {'Key': 'Val'})
