class Abstract(share.AbstractTest):
endpoint_alpha = model.NetworkEndpoint(share.make_datapath_id(1), 4)
endpoint_beta = model.NetworkEndpoint(share.make_datapath_id(2), 6)
endpoint_gamma = model.NetworkEndpoint(share.make_datapath_id(3), 8)
isl_alpha_beta = model.InterSwitchLink(
model.IslPathNode(endpoint_alpha.dpid, endpoint_alpha.port),
model.IslPathNode(endpoint_beta.dpid, endpoint_beta.port))
isl_beta_alpha = isl_alpha_beta.reversed()
def setUp(self):
super(Abstract, self).setUp()
for isl in (self.isl_alpha_beta, self.isl_beta_alpha):
isl_info = share.isl_info_payload(isl)
command = share.command(isl_info)
self.assertTrue(messageclasses.MessageItem(command).handle())
def take_response(self, **kwargs):
return self.take_kafka_response(config.KAFKA_NORTHBOUND_TOPIC,
**kwargs)
def _ensure_props_match(self, link_props, props):
with self.open_neo4j_session() as tx:
persistent = link_props_utils.read(tx, link_props)
self.assertEqual(props, persistent.props)
def _put(self, subject):
request = share.link_props_request(subject)
payload = share.link_props_put_payload(request)
self.feed_service(share.command(payload))
return payload
def test_multi_isl_port_down(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
sw_gamma = make_datapath_id(3)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
isl_beta_alpha = isl_alpha_beta.reversed()
isl_beta_gamma = model.InterSwitchLink(
model.NetworkEndpoint(sw_beta, 2),
model.NetworkEndpoint(sw_gamma, 3), None)
isl_gamma_beta = isl_beta_gamma.reversed()
for dpid in sw_alpha, sw_beta, sw_gamma:
self.assertTrue(make_switch_add(dpid))
self.assertTrue(share.exec_isl_discovery(isl_alpha_beta))
self.assertTrue(share.exec_isl_discovery(isl_beta_alpha))
self.assertTrue(share.exec_isl_discovery(isl_beta_gamma))
self.assertTrue(share.exec_isl_discovery(isl_gamma_beta))
self.assertTrue(make_port_down(isl_alpha_beta.dest))
self.ensure_isl_props(neo4j_connect, isl_alpha_beta,
ISL_STATUS_PROPS_HALF_UP)
self.ensure_isl_props(neo4j_connect, isl_beta_alpha,
ISL_STATUS_PROPS_DOWN)
self.ensure_isl_props(neo4j_connect, isl_beta_gamma,
ISL_STATUS_PROPS_DOWN)
self.ensure_isl_props(neo4j_connect, isl_gamma_beta,
ISL_STATUS_PROPS_HALF_UP)
def test_port_down_with_cost_as_string(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
self.assertTrue(share.exec_isl_discovery(isl_alpha_beta))
with neo4j_connect.begin() as tx:
isl_utils.set_props(tx, isl_alpha_beta, {"cost": "10"})
self.assertTrue(make_port_down(isl_alpha_beta.source))
def switch_unplug(tx, dpid):
logging.info("Deactivate all ISL to/from %s", dpid)
for db_link in fetch_by_datapath(tx, dpid):
source = model.NetworkEndpoint(db_link['src_switch'],
db_link['src_port'])
dest = model.NetworkEndpoint(db_link['dst_switch'],
db_link['dst_port'])
isl = model.InterSwitchLink(source, dest, db_link['actual'])
logging.debug("Found ISL: %s", isl)
set_active_field(tx, db.neo_id(db_link), 'inactive')
update_status(tx, isl)
def test_port_down_without_isl(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
isl_beta_alpha = isl_alpha_beta.reversed()
self.assertTrue(make_switch_add(sw_alpha))
self.assertTrue(make_port_down(isl_alpha_beta.source))
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_alpha_beta)
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_beta_alpha)
def isl_discovery_failed(self):
"""
:return: Ideally, this should return true IFF discovery is deleted or deactivated.
"""
path = self.payload['path']
switch_id = path[0]['switch_id']
port = int(path[0]['port_no'])
effective_policy = config.get("isl_failover_policy", "effective_policy")
logger.info('Isl failure: %s_%d -- apply policy %s: timestamp=%s',
switch_id, port, effective_policy, self.timestamp)
is_moved = self.payload['state'] == 'MOVED'
try:
with graph.begin() as tx:
updated = isl_utils.disable_by_endpoint(
tx, model.NetworkEndpoint(switch_id, port), is_moved)
updated.sort(key=lambda x: (x.source, x.dest))
for isl in updated:
# we can get multiple records for one port
# but will use lifecycle data from first one
life_cycle = isl_utils.get_life_cycle_fields(tx, isl)
self.update_payload_lifecycle(life_cycle)
break
except exc.DBRecordNotFound:
logger.error('There is no ISL on %s_%s', switch_id, port)
def test_time_update_on_isl_discovery(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
self.assertTrue(make_switch_add(sw_alpha))
self.assertTrue(make_switch_add(sw_beta))
update_point_a = model.TimeProperty.now(milliseconds_precission=True)
message = share.command(share.payload_isl_info(isl_alpha_beta))
message['timestamp'] = update_point_a.as_java_timestamp()
self.assertTrue(messageclasses.MessageItem(**message).handle())
recovered = model.TimeProperty.new_from_java_timestamp(
message['timestamp'])
self.assertEquals(update_point_a.value, recovered.value)
with neo4j_connect.begin() as tx:
isl = isl_utils.fetch(tx, isl_alpha_beta)
neo4j_connect.pull(isl)
db_ctime = model.TimeProperty.new_from_db(isl['time_create'])
self.assertEqual(update_point_a.value, db_ctime.value)
db_mtime = model.TimeProperty.new_from_db(isl['time_modify'])
self.assertEqual(update_point_a.value, db_mtime.value)
# one more update
update_point_b = model.TimeProperty.now(milliseconds_precission=True)
self.assertNotEqual(update_point_a.value, update_point_b.value)
message['timestamp'] = update_point_b.as_java_timestamp()
self.assertTrue(messageclasses.MessageItem(**message).handle())
with neo4j_connect.begin() as tx:
isl = isl_utils.fetch(tx, isl_alpha_beta)
neo4j_connect.pull(isl)
db_ctime = model.TimeProperty.new_from_db(isl['time_create'])
self.assertEqual(update_point_a.value, db_ctime.value)
db_mtime = model.TimeProperty.new_from_db(isl['time_modify'])
self.assertEqual(update_point_b.value, db_mtime.value)
def test_drop_multi(self):
any_endpoint = model.NetworkEndpoint(None, None)
lookup_mask = model.LinkProps(self.endpoint_alpha, any_endpoint)
self._drop(lookup_mask)
self._ensure_missing(
model.LinkProps(self.endpoint_alpha, self.endpoint_beta),
model.LinkProps(self.endpoint_alpha, self.endpoint_gamma))
self._ensure_exists(
model.LinkProps(self.endpoint_beta, self.endpoint_gamma))
def test_isl_without_life_cycle_fields(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
self.assertTrue(make_switch_add(sw_alpha))
self.assertTrue(make_switch_add(sw_beta))
self.assertTrue(share.exec_isl_discovery(isl_alpha_beta))
with neo4j_connect.begin() as tx:
neo4j_connect.pull(isl_utils.fetch(tx, isl_alpha_beta))
isl_utils.set_props(tx, isl_alpha_beta, {
'time_create': None,
'time_modify': None
})
self.assertTrue(share.exec_isl_discovery(isl_alpha_beta))
def test_put_incomplete(self):
link_props = model.LinkProps(self.endpoint_beta, self.endpoint_gamma)
link_props.source = model.NetworkEndpoint(self.endpoint_alpha.dpid,
None)
self._put(link_props)
response = self._get_kafka_response()
self.assertEqual(message_utils.MI_LINK_PROPS_RESPONSE,
response['clazz'])
self.assertIsNotNone(response['error'])
self.assertIsNone(response['link_props'])
class Abstract(share.AbstractTest):
endpoint_alpha = model.NetworkEndpoint(share.make_datapath_id(1), 4)
endpoint_beta = model.NetworkEndpoint(share.make_datapath_id(2), 6)
endpoint_gamma = model.NetworkEndpoint(share.make_datapath_id(3), 8)
isl_alpha_beta = model.InterSwitchLink(
model.IslPathNode(endpoint_alpha.dpid, endpoint_alpha.port),
model.IslPathNode(endpoint_beta.dpid, endpoint_beta.port))
isl_beta_alpha = isl_alpha_beta.reversed()
def setUp(self):
super(Abstract, self).setUp()
for isl in (self.isl_alpha_beta, self.isl_beta_alpha):
isl_info = share.isl_info_payload(isl)
command = share.command(isl_info)
self.assertTrue(messageclasses.MessageItem(command).handle())
def _put(self, subject):
request = share.link_props_request(subject)
payload = share.link_props_put_payload(request)
self.feed_service(share.command(payload))
return payload
def _get_kafka_response(self,
offset=0,
expect_class=message_utils.MT_INFO):
kafka_backlog = share.env.kafka_producer_stub.backlog
self.assertTrue(offset < len(kafka_backlog))
kafka_record = kafka_backlog[offset]
self.assertEqual(config.KAFKA_NORTHBOUND_TOPIC, kafka_record.topic)
message = json.loads(kafka_record.payload)
self.assertEqual(expect_class, message['clazz'])
return message['payload']
def port_down(self):
switch_id = self.payload['switch_id']
port_id = int(self.payload['port_no'])
logger.info('Port %s_%d deletion request: timestamp=%s', switch_id,
port_id, self.timestamp)
try:
with graph.begin() as tx:
for isl in isl_utils.disable_by_endpoint(
tx, model.NetworkEndpoint(switch_id, port_id)):
# TODO(crimi): should be policy / toggle based
isl_utils.set_cost(tx, isl, config.ISL_COST_WHEN_PORT_DOWN)
isl_utils.set_cost(tx, isl.reversed(),
config.ISL_COST_WHEN_PORT_DOWN)
except exc.DBRecordNotFound:
logger.info("There is no ISL on %s_%s", switch_id, port_id)
def test_drop_reject(self):
any_endpoint = model.NetworkEndpoint(None, None)
lookup_mask = model.LinkProps(any_endpoint, any_endpoint)
self._drop(lookup_mask)
self._ensure_exists(
model.LinkProps(self.endpoint_alpha, self.endpoint_beta),
model.LinkProps(self.endpoint_alpha, self.endpoint_gamma),
model.LinkProps(self.endpoint_beta, self.endpoint_gamma))
response = self.take_response(
expect_class=message_utils.MT_INFO_CHUNKED)
self.assertIsNotNone(response)
self.assertEqual(message_utils.MI_LINK_PROPS_RESPONSE,
response['clazz'])
self.assertIsNone(response['link_props'])
self.assertIsNotNone(response['error'])
def isl_discovery_failed(self):
"""
:return: Ideally, this should return true IFF discovery is deleted or deactivated.
"""
path = self.payload['path']
switch_id = path[0]['switch_id']
port = int(path[0]['port_no'])
effective_policy = config.get("isl_failover_policy",
"effective_policy")
logger.info('Isl failure: %s_%d -- apply policy %s: timestamp=%s',
switch_id, port, effective_policy, self.timestamp)
is_moved = self.payload['state'] == 'MOVED'
try:
with graph.begin() as tx:
isl_utils.disable_by_endpoint(
tx, model.NetworkEndpoint(switch_id, port), is_moved)
except exc.DBRecordNotFound:
logger.error('There is no ISL on %s_%s', switch_id, port)
return True
class TestIsl(unittest.TestCase):
src_endpoint = model.NetworkEndpoint(make_datapath_id(1), 2)
dst_endpoint = model.NetworkEndpoint(make_datapath_id(2), 4)
def setUp(self):
logging.basicConfig(level=logging.DEBUG)
with neo4j_connect.begin() as tx:
clean_neo4j_test_data(tx)
def tearDown(self):
with neo4j_connect.begin() as tx:
clean_neo4j_test_data(tx)
def test_isl_status(self):
src_endpoint, dst_endpoint = self.src_endpoint, self.dst_endpoint
forward = model.InterSwitchLink(src_endpoint, dst_endpoint, None)
reverse = forward.reversed()
make_switch_add(src_endpoint.dpid)
make_switch_add(dst_endpoint.dpid)
status_down = {
'actual': ISL_STATUS_INACTIVE,
'status': ISL_STATUS_INACTIVE
}
status_half_up = {
'actual': ISL_STATUS_ACTIVE,
'status': ISL_STATUS_INACTIVE
}
status_up = {'actual': ISL_STATUS_ACTIVE, 'status': ISL_STATUS_ACTIVE}
# 0 0
self.assertTrue(make_isl_discovery(forward))
# 1 0
self.ensure_isl_props(neo4j_connect, forward, status_half_up)
self.ensure_isl_props(neo4j_connect, reverse, status_down)
self.assertTrue(make_isl_discovery(reverse))
# 1 1
self.ensure_isl_props(neo4j_connect, forward, status_up)
self.ensure_isl_props(neo4j_connect, reverse, status_up)
self.assertTrue(make_isl_failed(src_endpoint))
# 0 1
self.ensure_isl_props(neo4j_connect, forward, status_down)
self.ensure_isl_props(neo4j_connect, reverse, status_half_up)
self.assertTrue(make_isl_discovery(forward))
# 1 1
self.ensure_isl_props(neo4j_connect, forward, status_up)
self.ensure_isl_props(neo4j_connect, reverse, status_up)
self.assertTrue(make_isl_failed(dst_endpoint))
# 1 0
self.ensure_isl_props(neo4j_connect, forward, status_half_up)
self.ensure_isl_props(neo4j_connect, reverse, status_down)
self.assertTrue(make_isl_discovery(reverse))
# 1 1
self.ensure_isl_props(neo4j_connect, forward, status_up)
self.ensure_isl_props(neo4j_connect, reverse, status_up)
self.assertTrue(make_isl_failed(src_endpoint))
# 0 1
self.ensure_isl_props(neo4j_connect, forward, status_down)
self.ensure_isl_props(neo4j_connect, reverse, status_half_up)
self.assertTrue(make_isl_failed(dst_endpoint))
# 0 0
self.ensure_isl_props(neo4j_connect, forward, status_down)
self.ensure_isl_props(neo4j_connect, reverse, status_down)
def test_isl_replug(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
sw_gamma = make_datapath_id(3)
sw_delta = make_datapath_id(4)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
isl_beta_alpha = isl_alpha_beta.reversed()
isl_beta_gamma = model.InterSwitchLink(
model.NetworkEndpoint(sw_beta, 2),
model.NetworkEndpoint(sw_gamma, 3), None)
isl_gamma_beta = isl_beta_gamma.reversed()
isl_gamma_delta = model.InterSwitchLink(
model.NetworkEndpoint(sw_gamma, 3),
model.NetworkEndpoint(sw_delta, 3), None)
isl_delta_gamma = isl_gamma_delta.reversed()
for dpid in sw_alpha, sw_beta, sw_gamma, sw_delta:
self.assertTrue(make_switch_add(dpid))
self.assertTrue(make_isl_discovery(isl_alpha_beta))
self.assertTrue(make_isl_discovery(isl_beta_alpha))
self.assertTrue(make_isl_discovery(isl_gamma_delta))
self.assertTrue(make_isl_discovery(isl_delta_gamma))
self.ensure_isl_props(neo4j_connect, isl_alpha_beta,
ISL_STATUS_PROPS_UP)
self.ensure_isl_props(neo4j_connect, isl_beta_alpha,
ISL_STATUS_PROPS_UP)
self.ensure_isl_props(neo4j_connect, isl_gamma_delta,
ISL_STATUS_PROPS_UP)
self.ensure_isl_props(neo4j_connect, isl_delta_gamma,
ISL_STATUS_PROPS_UP)
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_beta_gamma)
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_gamma_beta)
# replug
self.assertTrue(make_isl_discovery(isl_beta_gamma))
# alpha <-> beta is down
self.ensure_isl_props(neo4j_connect, isl_alpha_beta,
ISL_STATUS_PROPS_HALF_UP)
self.ensure_isl_props(neo4j_connect, isl_beta_alpha,
ISL_STATUS_PROPS_DOWN)
# gamma -> delta is down
self.ensure_isl_props(neo4j_connect, isl_gamma_delta,
ISL_STATUS_PROPS_DOWN)
self.ensure_isl_props(neo4j_connect, isl_delta_gamma,
ISL_STATUS_PROPS_HALF_UP)
# beta <-> gamma is half up
self.ensure_isl_props(neo4j_connect, isl_beta_gamma,
ISL_STATUS_PROPS_HALF_UP)
self.ensure_isl_props(neo4j_connect, isl_gamma_beta,
ISL_STATUS_PROPS_DOWN)
self.assertTrue(make_isl_discovery(isl_gamma_beta))
# alpha <-> beta is down
self.ensure_isl_props(neo4j_connect, isl_alpha_beta,
ISL_STATUS_PROPS_HALF_UP)
self.ensure_isl_props(neo4j_connect, isl_beta_alpha,
ISL_STATUS_PROPS_DOWN)
# gamma -> delta is down
self.ensure_isl_props(neo4j_connect, isl_gamma_delta,
ISL_STATUS_PROPS_DOWN)
self.ensure_isl_props(neo4j_connect, isl_delta_gamma,
ISL_STATUS_PROPS_HALF_UP)
# beta <-> gamma is up
self.ensure_isl_props(neo4j_connect, isl_beta_gamma,
ISL_STATUS_PROPS_UP)
self.ensure_isl_props(neo4j_connect, isl_gamma_beta,
ISL_STATUS_PROPS_UP)
def test_switch_unplug(self):
src_endpoint, dst_endpoint = self.src_endpoint, self.dst_endpoint
forward = model.InterSwitchLink(src_endpoint, dst_endpoint, None)
reverse = forward.reversed()
self.assertTrue(make_switch_add(src_endpoint.dpid))
self.assertTrue(make_switch_add(dst_endpoint.dpid))
self.assertTrue(make_isl_discovery(forward))
self.assertTrue(make_isl_discovery(reverse))
self.ensure_isl_props(neo4j_connect, forward, ISL_STATUS_PROPS_UP)
self.ensure_isl_props(neo4j_connect, reverse, ISL_STATUS_PROPS_UP)
self.assertTrue(make_switch_remove(src_endpoint.dpid))
self.ensure_isl_props(neo4j_connect, forward, ISL_STATUS_PROPS_DOWN)
self.ensure_isl_props(neo4j_connect, reverse, ISL_STATUS_PROPS_HALF_UP)
def test_isl_down_without_isl(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
isl_beta_alpha = isl_alpha_beta.reversed()
self.assertTrue(make_switch_add(sw_alpha))
self.assertTrue(make_isl_failed(isl_alpha_beta.source))
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_alpha_beta)
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_beta_alpha)
def test_port_down_without_isl(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
isl_beta_alpha = isl_alpha_beta.reversed()
self.assertTrue(make_switch_add(sw_alpha))
self.assertTrue(make_port_down(isl_alpha_beta.source))
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_alpha_beta)
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_beta_alpha)
def test_multi_isl_port_down(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
sw_gamma = make_datapath_id(3)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
isl_beta_alpha = isl_alpha_beta.reversed()
isl_beta_gamma = model.InterSwitchLink(
model.NetworkEndpoint(sw_beta, 2),
model.NetworkEndpoint(sw_gamma, 3), None)
isl_gamma_beta = isl_beta_gamma.reversed()
for dpid in sw_alpha, sw_beta, sw_gamma:
self.assertTrue(make_switch_add(dpid))
self.assertTrue(make_isl_discovery(isl_alpha_beta))
self.assertTrue(make_isl_discovery(isl_beta_alpha))
self.assertTrue(make_isl_discovery(isl_beta_gamma))
self.assertTrue(make_isl_discovery(isl_gamma_beta))
self.assertTrue(make_port_down(isl_alpha_beta.dest))
self.ensure_isl_props(neo4j_connect, isl_alpha_beta,
ISL_STATUS_PROPS_HALF_UP)
self.ensure_isl_props(neo4j_connect, isl_beta_alpha,
ISL_STATUS_PROPS_DOWN)
self.ensure_isl_props(neo4j_connect, isl_beta_gamma,
ISL_STATUS_PROPS_DOWN)
self.ensure_isl_props(neo4j_connect, isl_gamma_beta,
ISL_STATUS_PROPS_HALF_UP)
def test_cost_raise_on_port_down(self):
self.setup_initial_data()
self._cost_raise_on_port_down(1, 10000, 10000)
def test_cost_raise_on_port_down_without_link_props(self):
self.setup_initial_data(make_link_props=False)
self._cost_raise_on_port_down(None, 10000, 10000)
def _cost_raise_on_port_down(self, initial, down, recover):
src_endpoint, dst_endpoint = self.src_endpoint, self.dst_endpoint
isl = model.InterSwitchLink(src_endpoint, dst_endpoint, None)
self.ensure_isl_costs((src_endpoint, initial), (dst_endpoint, initial))
self.assertTrue(make_port_down(src_endpoint),
'Port DOWN command have failed')
self.ensure_isl_costs((src_endpoint, down), (dst_endpoint, down))
self.assertTrue(make_isl_discovery(isl),
'ISL discovery command have failed')
self.ensure_isl_costs((src_endpoint, recover), (dst_endpoint, recover))
def test_no_cost_raise_on_isl_down(self):
self.setup_initial_data()
src_endpoint, dst_endpoint = self.src_endpoint, self.dst_endpoint
isl = model.InterSwitchLink(src_endpoint, dst_endpoint, None)
self.ensure_isl_costs((src_endpoint, 1), (dst_endpoint, 1))
self.assertTrue(make_isl_failed(src_endpoint),
'Port DOWN command have failed')
self.ensure_isl_costs((src_endpoint, 1), (dst_endpoint, 1))
self.assertTrue(make_isl_discovery(isl),
'ISL discovery command have failed')
self.ensure_isl_costs((src_endpoint, 1), (dst_endpoint, 1))
def test_moved_isl_should_be_marked(self):
self.setup_initial_data()
src_endpoint, dst_endpoint = self.src_endpoint, self.dst_endpoint
forward = model.InterSwitchLink(src_endpoint, dst_endpoint, None)
make_isl_moved(forward)
self.ensure_isl_props(neo4j_connect, forward, ISL_STATUS_PROPS_MOVED)
def ensure_isl_props(self, tx, isl, props):
isl_record = isl_utils.fetch(tx, isl)
neo4j_connect.pull(isl_record)
for name in props:
self.assertEqual(
props[name], isl_record[name],
"Invalid ISL's {!r} value ({!r})".format(name, isl_record))
def ensure_isl_costs(self, *endpoint_cost_pairs):
endpoints = []
costs = []
for pair in endpoint_cost_pairs:
endpoints.append(pair[0])
costs.append(pair[1])
for isl, expect in zip(self.enumerate_isl(*endpoints), costs):
self.assertEqual(
expect, isl['cost'],
'Bad "cost" value {!r} (expect {!r}) in isl {!r}'.format(
isl['cost'], expect, isl))
def enumerate_isl(self, *endpoints):
with neo4j_connect.begin() as tx:
for node in endpoints:
q = ('MATCH (a:switch)-[self:isl]->(:switch)\n'
'WHERE a.name=$dpid\n'
'RETURN self')
for data_set in tx.run(q, dpid=node.dpid):
node = data_set['self']
neo4j_connect.pull(node)
yield node
def setup_initial_data(self, make_link_props=True):
src_endpoint, dst_endpoint = self.src_endpoint, self.dst_endpoint
make_switch_add(src_endpoint.dpid)
make_switch_add(dst_endpoint.dpid)
if make_link_props:
with neo4j_connect.begin() as tx:
payload = {'cost': 1}
inject_db_link_props(tx, src_endpoint, dst_endpoint, payload)
inject_db_link_props(tx, dst_endpoint, src_endpoint, payload)
make_isl_pair(src_endpoint, dst_endpoint)
class TestIsl(share.AbstractTest):
src_endpoint = model.NetworkEndpoint(make_datapath_id(1), 2)
dst_endpoint = model.NetworkEndpoint(make_datapath_id(2), 4)
def setUp(self):
super(TestIsl, self).setUp()
with neo4j_connect.begin() as tx:
clean_neo4j_test_data(tx)
def test_isl_status(self):
src_endpoint, dst_endpoint = self.src_endpoint, self.dst_endpoint
forward = model.InterSwitchLink(src_endpoint, dst_endpoint, None)
reverse = forward.reversed()
make_switch_add(src_endpoint.dpid)
make_switch_add(dst_endpoint.dpid)
status_down = {
'actual': ISL_STATUS_INACTIVE,
'status': ISL_STATUS_INACTIVE
}
status_half_up = {
'actual': ISL_STATUS_ACTIVE,
'status': ISL_STATUS_INACTIVE
}
status_up = {'actual': ISL_STATUS_ACTIVE, 'status': ISL_STATUS_ACTIVE}
# 0 0
self.assertTrue(share.exec_isl_discovery(forward))
# 1 0
self.ensure_isl_props(neo4j_connect, forward, status_half_up)
self.ensure_isl_props(neo4j_connect, reverse, status_down)
self.assertTrue(share.exec_isl_discovery(reverse))
# 1 1
self.ensure_isl_props(neo4j_connect, forward, status_up)
self.ensure_isl_props(neo4j_connect, reverse, status_up)
self.assertTrue(make_isl_failed(src_endpoint))
# 0 1
self.ensure_isl_props(neo4j_connect, forward, status_down)
self.ensure_isl_props(neo4j_connect, reverse, status_half_up)
self.assertTrue(share.exec_isl_discovery(forward))
# 1 1
self.ensure_isl_props(neo4j_connect, forward, status_up)
self.ensure_isl_props(neo4j_connect, reverse, status_up)
self.assertTrue(make_isl_failed(dst_endpoint))
# 1 0
self.ensure_isl_props(neo4j_connect, forward, status_half_up)
self.ensure_isl_props(neo4j_connect, reverse, status_down)
self.assertTrue(share.exec_isl_discovery(reverse))
# 1 1
self.ensure_isl_props(neo4j_connect, forward, status_up)
self.ensure_isl_props(neo4j_connect, reverse, status_up)
self.assertTrue(make_isl_failed(src_endpoint))
# 0 1
self.ensure_isl_props(neo4j_connect, forward, status_down)
self.ensure_isl_props(neo4j_connect, reverse, status_half_up)
self.assertTrue(make_isl_failed(dst_endpoint))
# 0 0
self.ensure_isl_props(neo4j_connect, forward, status_down)
self.ensure_isl_props(neo4j_connect, reverse, status_down)
@unittest.skip(
'ISL conflict resolution was disabled, because event topology is responsible for them now'
)
def test_isl_replug(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
sw_gamma = make_datapath_id(3)
sw_delta = make_datapath_id(4)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
isl_beta_alpha = isl_alpha_beta.reversed()
isl_beta_gamma = model.InterSwitchLink(
model.NetworkEndpoint(sw_beta, 2),
model.NetworkEndpoint(sw_gamma, 3), None)
isl_gamma_beta = isl_beta_gamma.reversed()
isl_gamma_delta = model.InterSwitchLink(
model.NetworkEndpoint(sw_gamma, 3),
model.NetworkEndpoint(sw_delta, 3), None)
isl_delta_gamma = isl_gamma_delta.reversed()
for dpid in sw_alpha, sw_beta, sw_gamma, sw_delta:
self.assertTrue(make_switch_add(dpid))
self.assertTrue(share.exec_isl_discovery(isl_alpha_beta))
self.assertTrue(share.exec_isl_discovery(isl_beta_alpha))
self.assertTrue(share.exec_isl_discovery(isl_gamma_delta))
self.assertTrue(share.exec_isl_discovery(isl_delta_gamma))
self.ensure_isl_props(neo4j_connect, isl_alpha_beta,
ISL_STATUS_PROPS_UP)
self.ensure_isl_props(neo4j_connect, isl_beta_alpha,
ISL_STATUS_PROPS_UP)
self.ensure_isl_props(neo4j_connect, isl_gamma_delta,
ISL_STATUS_PROPS_UP)
self.ensure_isl_props(neo4j_connect, isl_delta_gamma,
ISL_STATUS_PROPS_UP)
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_beta_gamma)
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_gamma_beta)
# replug
self.assertTrue(share.exec_isl_discovery(isl_beta_gamma))
# alpha <-> beta is down
self.ensure_isl_props(neo4j_connect, isl_alpha_beta,
ISL_STATUS_PROPS_HALF_UP)
self.ensure_isl_props(neo4j_connect, isl_beta_alpha,
ISL_STATUS_PROPS_DOWN)
# gamma -> delta is down
self.ensure_isl_props(neo4j_connect, isl_gamma_delta,
ISL_STATUS_PROPS_DOWN)
self.ensure_isl_props(neo4j_connect, isl_delta_gamma,
ISL_STATUS_PROPS_HALF_UP)
# beta <-> gamma is half up
self.ensure_isl_props(neo4j_connect, isl_beta_gamma,
ISL_STATUS_PROPS_HALF_UP)
self.ensure_isl_props(neo4j_connect, isl_gamma_beta,
ISL_STATUS_PROPS_DOWN)
self.assertTrue(share.exec_isl_discovery(isl_gamma_beta))
# alpha <-> beta is down
self.ensure_isl_props(neo4j_connect, isl_alpha_beta,
ISL_STATUS_PROPS_HALF_UP)
self.ensure_isl_props(neo4j_connect, isl_beta_alpha,
ISL_STATUS_PROPS_DOWN)
# gamma -> delta is down
self.ensure_isl_props(neo4j_connect, isl_gamma_delta,
ISL_STATUS_PROPS_DOWN)
self.ensure_isl_props(neo4j_connect, isl_delta_gamma,
ISL_STATUS_PROPS_HALF_UP)
# beta <-> gamma is up
self.ensure_isl_props(neo4j_connect, isl_beta_gamma,
ISL_STATUS_PROPS_UP)
self.ensure_isl_props(neo4j_connect, isl_gamma_beta,
ISL_STATUS_PROPS_UP)
def test_switch_unplug(self):
src_endpoint, dst_endpoint = self.src_endpoint, self.dst_endpoint
forward = model.InterSwitchLink(src_endpoint, dst_endpoint, None)
reverse = forward.reversed()
self.assertTrue(make_switch_add(src_endpoint.dpid))
self.assertTrue(make_switch_add(dst_endpoint.dpid))
self.assertTrue(share.exec_isl_discovery(forward))
self.assertTrue(share.exec_isl_discovery(reverse))
self.ensure_isl_props(neo4j_connect, forward, ISL_STATUS_PROPS_UP)
self.ensure_isl_props(neo4j_connect, reverse, ISL_STATUS_PROPS_UP)
self.assertTrue(make_switch_remove(src_endpoint.dpid))
self.ensure_isl_props(neo4j_connect, forward, ISL_STATUS_PROPS_DOWN)
self.ensure_isl_props(neo4j_connect, reverse, ISL_STATUS_PROPS_HALF_UP)
def test_isl_down_without_isl(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
isl_beta_alpha = isl_alpha_beta.reversed()
self.assertTrue(make_switch_add(sw_alpha))
self.assertTrue(make_isl_failed(isl_alpha_beta.source))
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_alpha_beta)
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_beta_alpha)
def test_port_down_without_isl(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
isl_beta_alpha = isl_alpha_beta.reversed()
self.assertTrue(make_switch_add(sw_alpha))
self.assertTrue(make_port_down(isl_alpha_beta.source))
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_alpha_beta)
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_beta_alpha)
def test_port_down_with_cost_as_string(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
self.assertTrue(share.exec_isl_discovery(isl_alpha_beta))
with neo4j_connect.begin() as tx:
isl_utils.set_props(tx, isl_alpha_beta, {"cost": "10"})
self.assertTrue(make_port_down(isl_alpha_beta.source))
def test_multi_isl_port_down(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
sw_gamma = make_datapath_id(3)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
isl_beta_alpha = isl_alpha_beta.reversed()
isl_beta_gamma = model.InterSwitchLink(
model.NetworkEndpoint(sw_beta, 2),
model.NetworkEndpoint(sw_gamma, 3), None)
isl_gamma_beta = isl_beta_gamma.reversed()
for dpid in sw_alpha, sw_beta, sw_gamma:
self.assertTrue(make_switch_add(dpid))
self.assertTrue(share.exec_isl_discovery(isl_alpha_beta))
self.assertTrue(share.exec_isl_discovery(isl_beta_alpha))
self.assertTrue(share.exec_isl_discovery(isl_beta_gamma))
self.assertTrue(share.exec_isl_discovery(isl_gamma_beta))
self.assertTrue(make_port_down(isl_alpha_beta.dest))
self.ensure_isl_props(neo4j_connect, isl_alpha_beta,
ISL_STATUS_PROPS_HALF_UP)
self.ensure_isl_props(neo4j_connect, isl_beta_alpha,
ISL_STATUS_PROPS_DOWN)
self.ensure_isl_props(neo4j_connect, isl_beta_gamma,
ISL_STATUS_PROPS_DOWN)
self.ensure_isl_props(neo4j_connect, isl_gamma_beta,
ISL_STATUS_PROPS_HALF_UP)
def test_cost_raise_on_port_down(self):
self.setup_initial_data()
self._cost_raise_on_port_down(10, 10010, 10010)
self._cost_raise_on_port_down(10010, 10010, 10010)
self._set_isl_cost('20')
self._cost_raise_on_port_down('20', 10020, 10020)
self._cost_raise_on_port_down(10020, 10020, 10020)
self._set_isl_cost(0)
self._cost_raise_on_port_down(0, 10000, 10000)
self._cost_raise_on_port_down(10000, 10000, 10000)
def test_cost_raise_on_port_down_without_link_props(self):
self.setup_initial_data(make_link_props=False)
self._cost_raise_on_port_down(None, 10000, 10000)
def _cost_raise_on_port_down(self, initial, down, recover):
src_endpoint, dst_endpoint = self.src_endpoint, self.dst_endpoint
isl = model.InterSwitchLink(src_endpoint, dst_endpoint, None)
self.ensure_isl_costs((src_endpoint, initial), (dst_endpoint, initial))
self.assertTrue(make_port_down(src_endpoint),
'Port DOWN command have failed')
self.ensure_isl_costs((src_endpoint, down), (dst_endpoint, down))
self.assertTrue(share.exec_isl_discovery(isl),
'ISL discovery command have failed')
self.ensure_isl_costs((src_endpoint, recover), (dst_endpoint, recover))
def _set_isl_cost(self, value):
with neo4j_connect.begin() as tx:
isl = model.InterSwitchLink(self.src_endpoint, self.dst_endpoint,
None)
isl_utils.set_cost(tx, isl, value)
isl_utils.set_cost(tx, isl.reversed(), value)
with neo4j_connect.begin() as tx:
props = {'cost': value}
self.ensure_isl_props(tx, isl, props)
self.ensure_isl_props(tx, isl.reversed(), props)
def test_no_cost_raise_on_isl_down(self):
self.setup_initial_data()
src_endpoint, dst_endpoint = self.src_endpoint, self.dst_endpoint
isl = model.InterSwitchLink(src_endpoint, dst_endpoint, None)
self.ensure_isl_costs((src_endpoint, 10), (dst_endpoint, 10))
self.assertTrue(make_isl_failed(src_endpoint),
'Port DOWN command have failed')
self.ensure_isl_costs((src_endpoint, 10), (dst_endpoint, 10))
self.assertTrue(share.exec_isl_discovery(isl),
'ISL discovery command have failed')
self.ensure_isl_costs((src_endpoint, 10), (dst_endpoint, 10))
def test_moved_isl_should_be_marked(self):
self.setup_initial_data()
src_endpoint, dst_endpoint = self.src_endpoint, self.dst_endpoint
forward = model.InterSwitchLink(src_endpoint, dst_endpoint, None)
make_isl_moved(forward)
self.ensure_isl_props(neo4j_connect, forward, ISL_STATUS_PROPS_MOVED)
def test_isl_without_life_cycle_fields(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
self.assertTrue(make_switch_add(sw_alpha))
self.assertTrue(make_switch_add(sw_beta))
self.assertTrue(share.exec_isl_discovery(isl_alpha_beta))
with neo4j_connect.begin() as tx:
neo4j_connect.pull(isl_utils.fetch(tx, isl_alpha_beta))
isl_utils.set_props(tx, isl_alpha_beta, {
'time_create': None,
'time_modify': None
})
self.assertTrue(share.exec_isl_discovery(isl_alpha_beta))
def test_time_update_on_isl_discovery(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
self.assertTrue(make_switch_add(sw_alpha))
self.assertTrue(make_switch_add(sw_beta))
update_point_a = model.TimeProperty.now(milliseconds_precission=True)
message = share.command(share.payload_isl_info(isl_alpha_beta))
message['timestamp'] = update_point_a.as_java_timestamp()
self.assertTrue(messageclasses.MessageItem(**message).handle())
recovered = model.TimeProperty.new_from_java_timestamp(
message['timestamp'])
self.assertEquals(update_point_a.value, recovered.value)
with neo4j_connect.begin() as tx:
isl = isl_utils.fetch(tx, isl_alpha_beta)
neo4j_connect.pull(isl)
db_ctime = model.TimeProperty.new_from_db(isl['time_create'])
self.assertEqual(update_point_a.value, db_ctime.value)
db_mtime = model.TimeProperty.new_from_db(isl['time_modify'])
self.assertEqual(update_point_a.value, db_mtime.value)
# one more update
update_point_b = model.TimeProperty.now(milliseconds_precission=True)
self.assertNotEqual(update_point_a.value, update_point_b.value)
message['timestamp'] = update_point_b.as_java_timestamp()
self.assertTrue(messageclasses.MessageItem(**message).handle())
with neo4j_connect.begin() as tx:
isl = isl_utils.fetch(tx, isl_alpha_beta)
neo4j_connect.pull(isl)
db_ctime = model.TimeProperty.new_from_db(isl['time_create'])
self.assertEqual(update_point_a.value, db_ctime.value)
db_mtime = model.TimeProperty.new_from_db(isl['time_modify'])
self.assertEqual(update_point_b.value, db_mtime.value)
def ensure_isl_props(self, tx, isl, props):
isl_record = isl_utils.fetch(tx, isl)
neo4j_connect.pull(isl_record)
for name in props:
self.assertEqual(
props[name], isl_record[name],
"Invalid ISL's {!r} value ({!r})".format(name, isl_record))
def ensure_isl_costs(self, *endpoint_cost_pairs):
endpoints = []
costs = []
for pair in endpoint_cost_pairs:
endpoints.append(pair[0])
costs.append(pair[1])
for isl, expect in zip(self.enumerate_isl(*endpoints), costs):
self.assertEqual(
expect, isl['cost'],
'Bad "cost" value {!r} (expect {!r}) in isl {!r}'.format(
isl['cost'], expect, isl))
def enumerate_isl(self, *endpoints):
with neo4j_connect.begin() as tx:
for node in endpoints:
q = ('MATCH (a:switch)-[self:isl]->(:switch)\n'
'WHERE a.name=$dpid\n'
'RETURN self')
for data_set in tx.run(q, dpid=node.dpid):
node = data_set['self']
neo4j_connect.pull(node)
yield node
def setup_initial_data(self, make_link_props=True):
src_endpoint, dst_endpoint = self.src_endpoint, self.dst_endpoint
make_switch_add(src_endpoint.dpid)
make_switch_add(dst_endpoint.dpid)
if make_link_props:
with neo4j_connect.begin() as tx:
payload = {'cost': 10}
inject_db_link_props(tx, src_endpoint, dst_endpoint, payload)
inject_db_link_props(tx, dst_endpoint, src_endpoint, payload)
make_isl_pair(src_endpoint, dst_endpoint)
def test_isl_replug(self):
sw_alpha = make_datapath_id(1)
sw_beta = make_datapath_id(2)
sw_gamma = make_datapath_id(3)
sw_delta = make_datapath_id(4)
isl_alpha_beta = model.InterSwitchLink(
model.NetworkEndpoint(sw_alpha, 2),
model.NetworkEndpoint(sw_beta, 2), None)
isl_beta_alpha = isl_alpha_beta.reversed()
isl_beta_gamma = model.InterSwitchLink(
model.NetworkEndpoint(sw_beta, 2),
model.NetworkEndpoint(sw_gamma, 3), None)
isl_gamma_beta = isl_beta_gamma.reversed()
isl_gamma_delta = model.InterSwitchLink(
model.NetworkEndpoint(sw_gamma, 3),
model.NetworkEndpoint(sw_delta, 3), None)
isl_delta_gamma = isl_gamma_delta.reversed()
for dpid in sw_alpha, sw_beta, sw_gamma, sw_delta:
self.assertTrue(make_switch_add(dpid))
self.assertTrue(share.exec_isl_discovery(isl_alpha_beta))
self.assertTrue(share.exec_isl_discovery(isl_beta_alpha))
self.assertTrue(share.exec_isl_discovery(isl_gamma_delta))
self.assertTrue(share.exec_isl_discovery(isl_delta_gamma))
self.ensure_isl_props(neo4j_connect, isl_alpha_beta,
ISL_STATUS_PROPS_UP)
self.ensure_isl_props(neo4j_connect, isl_beta_alpha,
ISL_STATUS_PROPS_UP)
self.ensure_isl_props(neo4j_connect, isl_gamma_delta,
ISL_STATUS_PROPS_UP)
self.ensure_isl_props(neo4j_connect, isl_delta_gamma,
ISL_STATUS_PROPS_UP)
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_beta_gamma)
self.assertRaises(exc.DBRecordNotFound, isl_utils.fetch, neo4j_connect,
isl_gamma_beta)
# replug
self.assertTrue(share.exec_isl_discovery(isl_beta_gamma))
# alpha <-> beta is down
self.ensure_isl_props(neo4j_connect, isl_alpha_beta,
ISL_STATUS_PROPS_HALF_UP)
self.ensure_isl_props(neo4j_connect, isl_beta_alpha,
ISL_STATUS_PROPS_DOWN)
# gamma -> delta is down
self.ensure_isl_props(neo4j_connect, isl_gamma_delta,
ISL_STATUS_PROPS_DOWN)
self.ensure_isl_props(neo4j_connect, isl_delta_gamma,
ISL_STATUS_PROPS_HALF_UP)
# beta <-> gamma is half up
self.ensure_isl_props(neo4j_connect, isl_beta_gamma,
ISL_STATUS_PROPS_HALF_UP)
self.ensure_isl_props(neo4j_connect, isl_gamma_beta,
ISL_STATUS_PROPS_DOWN)
self.assertTrue(share.exec_isl_discovery(isl_gamma_beta))
# alpha <-> beta is down
self.ensure_isl_props(neo4j_connect, isl_alpha_beta,
ISL_STATUS_PROPS_HALF_UP)
self.ensure_isl_props(neo4j_connect, isl_beta_alpha,
ISL_STATUS_PROPS_DOWN)
# gamma -> delta is down
self.ensure_isl_props(neo4j_connect, isl_gamma_delta,
ISL_STATUS_PROPS_DOWN)
self.ensure_isl_props(neo4j_connect, isl_delta_gamma,
ISL_STATUS_PROPS_HALF_UP)
# beta <-> gamma is up
self.ensure_isl_props(neo4j_connect, isl_beta_gamma,
ISL_STATUS_PROPS_UP)
self.ensure_isl_props(neo4j_connect, isl_gamma_beta,
ISL_STATUS_PROPS_UP)
