def setup(self):
"""Replace the '__init__' method for the KytosNApp subclass.
The setup method is automatically called by the controller when your
application is loaded.
So, if you have any setup routine, insert it here.
"""
# object used to scheduler circuit events
self.sched = Scheduler()
# object to save and load circuits
self.storehouse = StoreHouse(self.controller)
# set the controller that will manager the dynamic paths
DynamicPathManager.set_controller(self.controller)
# dictionary of EVCs created. It acts as a circuit buffer.
# Every create/update/delete must be synced to storehouse.
self.circuits = {}
self._lock = Lock()
self.execute_as_loop(settings.DEPLOY_EVCS_INTERVAL)
self.execution_rounds = 0
self.load_all_evcs()
class TestStoreHouse(TestCase):
"""Tests to verify StoreHouse class."""
def setUp(self):
"""Execute steps before each tests."""
self.storehouse = StoreHouse(get_controller_mock())
def test_get_stored_box(self):
"""Test get_stored_box method."""
self.storehouse.controller.buffers = Mock()
self.storehouse.get_stored_box(1)
self.storehouse.controller.buffers.app.put.assert_called_once()
def test_create_box(self):
"""Test get_stored_box method."""
self.storehouse.controller.buffers = Mock()
self.storehouse.create_box()
self.storehouse.controller.buffers.app.put.assert_called_once()
@patch('napps.kytos.mef_eline.storehouse.log')
def test_save_evc_callback_no_error(self, log_mock):
# pylint: disable=protected-access
"""Test _save_evc_callback method."""
self.storehouse._lock = Mock()
data = Mock()
data.box_id = 1
self.storehouse._save_evc_callback('event', data, None)
self.storehouse._lock.release.assert_called_once()
log_mock.error.assert_not_called()
@patch('napps.kytos.mef_eline.storehouse.log')
def test_save_evc_callback_with_error(self, log_mock):
# pylint: disable=protected-access
"""Test _save_evc_callback method."""
self.storehouse._lock = Mock()
self.storehouse.box = Mock()
self.storehouse.box.box_id = 1
data = Mock()
data.box_id = 1
self.storehouse._save_evc_callback('event', data, 'error')
self.storehouse._lock.release.assert_called_once()
log_mock.error.assert_called_once()
@patch('napps.kytos.mef_eline.storehouse.StoreHouse.get_stored_box')
def test_get_data(self, get_stored_box_mock):
"""Test get_data method."""
self.storehouse.box = Mock()
self.storehouse.box.box_id = 2
self.storehouse.get_data()
get_stored_box_mock.assert_called_once_with(2)
def setup(self):
"""Replace the '__init__' method for the KytosNApp subclass.
The setup method is automatically called by the controller when your
application is loaded.
So, if you have any setup routine, insert it here.
"""
# object used to scheduler circuit events
self.sched = Scheduler()
# object to save and load circuits
self.storehouse = StoreHouse(self.controller)
# set the controller that will manager the dynamic paths
DynamicPathManager.set_controller(self.controller)
def setup(self):
"""Replace the '__init__' method for the KytosNApp subclass.
The setup method is automatically called by the controller when your
application is loaded.
So, if you have any setup routine, insert it here.
"""
# object used to scheduler circuit events
self.sched = Scheduler()
# object to save and load circuits
self.storehouse = StoreHouse(self.controller)
# set the controller that will manager the dynamic paths
DynamicPathManager.set_controller(self.controller)
# dictionary of EVCs created. It acts as a circuit buffer.
# Every create/update/delete must be synced to storehouse.
self.circuits = {}
# dictionary of EVCs by interface
self._circuits_by_interface = {}
class Main(KytosNApp):
"""Main class of amlight/mef_eline NApp.
This class is the entry point for this napp.
"""
def setup(self):
"""Replace the '__init__' method for the KytosNApp subclass.
The setup method is automatically called by the controller when your
application is loaded.
So, if you have any setup routine, insert it here.
"""
# object used to scheduler circuit events
self.sched = Scheduler()
# object to save and load circuits
self.storehouse = StoreHouse(self.controller)
# set the controller that will manager the dynamic paths
DynamicPathManager.set_controller(self.controller)
# dictionary of EVCs created. It acts as a circuit buffer.
# Every create/update/delete must be synced to storehouse.
self.circuits = {}
# dictionary of EVCs by interface
self._circuits_by_interface = {}
def execute(self):
"""Execute once when the napp is running."""
def shutdown(self):
"""Execute when your napp is unloaded.
If you have some cleanup procedure, insert it here.
"""
@rest('/v2/evc/', methods=['GET'])
def list_circuits(self):
"""Endpoint to return circuits stored.
If archived is set to True return all circuits, else only the ones
not archived.
"""
log.debug('list_circuits /v2/evc')
archived = request.args.get('archived', False)
circuits = self.storehouse.get_data()
if not circuits:
return jsonify({}), 200
if archived:
return jsonify(circuits), 200
return jsonify({
circuit_id: circuit
for circuit_id, circuit in circuits.items()
if not circuit.get('archived', False)
}), 200
@rest('/v2/evc/<circuit_id>', methods=['GET'])
def get_circuit(self, circuit_id):
"""Endpoint to return a circuit based on id."""
log.debug('get_circuit /v2/evc/%s', circuit_id)
circuits = self.storehouse.get_data()
try:
result = circuits[circuit_id]
except KeyError:
result = f'circuit_id {circuit_id} not found'
log.debug('get_circuit result %s %s', result, 404)
raise NotFound(result)
status = 200
log.debug('get_circuit result %s %s', result, status)
return jsonify(result), status
@rest('/v2/evc/', methods=['POST'])
def create_circuit(self):
"""Try to create a new circuit.
Firstly, for EVPL: E-Line NApp verifies if UNI_A's requested C-VID and
UNI_Z's requested C-VID are available from the interfaces' pools. This
is checked when creating the UNI object.
Then, E-Line NApp requests a primary and a backup path to the
Pathfinder NApp using the attributes primary_links and backup_links
submitted via REST
# For each link composing paths in #3:
# - E-Line NApp requests a S-VID available from the link VLAN pool.
# - Using the S-VID obtained, generate abstract flow entries to be
# sent to FlowManager
Push abstract flow entries to FlowManager and FlowManager pushes
OpenFlow entries to datapaths
E-Line NApp generates an event to notify all Kytos NApps of a new EVC
creation
Finnaly, notify user of the status of its request.
"""
# Try to create the circuit object
log.debug('create_circuit /v2/evc/')
try:
data = request.get_json()
except BadRequest:
result = 'The request body is not a well-formed JSON.'
log.debug('create_circuit result %s %s', result, 400)
raise BadRequest(result)
if data is None:
result = 'The request body mimetype is not application/json.'
log.debug('create_circuit result %s %s', result, 415)
raise UnsupportedMediaType(result)
try:
evc = self._evc_from_dict(data)
except ValueError as exception:
log.debug('create_circuit result %s %s', exception, 400)
raise BadRequest(str(exception))
# verify duplicated evc
if self._is_duplicated_evc(evc):
result = "The EVC already exists."
log.debug('create_circuit result %s %s', result, 409)
raise Conflict(result)
# store circuit in dictionary
self.circuits[evc.id] = evc
# save circuit
self.storehouse.save_evc(evc)
# Schedule the circuit deploy
self.sched.add(evc)
# Circuit has no schedule, deploy now
if not evc.circuit_scheduler:
evc.deploy()
# Notify users
event = KytosEvent(name='kytos.mef_eline.created',
content=evc.as_dict())
self.controller.buffers.app.put(event)
result = {"circuit_id": evc.id}
status = 201
log.debug('create_circuit result %s %s', result, status)
return jsonify(result), status
@rest('/v2/evc/<circuit_id>', methods=['PATCH'])
def update(self, circuit_id):
"""Update a circuit based on payload.
The EVC required attributes (name, uni_a, uni_z) can't be updated.
"""
log.debug('update /v2/evc/%s', circuit_id)
try:
evc = self.circuits[circuit_id]
except KeyError:
result = f'circuit_id {circuit_id} not found'
log.debug('update result %s %s', result, 404)
raise NotFound(result)
if evc.archived:
result = f'Can\'t update archived EVC'
log.debug('update result %s %s', result, 405)
raise MethodNotAllowed(['GET'], result)
try:
data = request.get_json()
except BadRequest:
result = 'The request body is not a well-formed JSON.'
log.debug('update result %s %s', result, 400)
raise BadRequest(result)
if data is None:
result = 'The request body mimetype is not application/json.'
log.debug('update result %s %s', result, 415)
raise UnsupportedMediaType(result)
try:
enable, path = \
evc.update(**self._evc_dict_with_instances(data))
except ValueError as exception:
log.error(exception)
log.debug('update result %s %s', exception, 400)
raise BadRequest(str(exception))
if evc.is_active():
if enable is False: # disable if active
evc.remove()
elif path is not None: # redeploy if active
evc.remove()
evc.deploy()
else:
if enable is True: # enable if inactive
evc.deploy()
result = {evc.id: evc.as_dict()}
status = 200
log.debug('update result %s %s', result, status)
return jsonify(result), status
@rest('/v2/evc/<circuit_id>', methods=['DELETE'])
def delete_circuit(self, circuit_id):
"""Remove a circuit.
First, the flows are removed from the switches, and then the EVC is
disabled.
"""
log.debug('delete_circuit /v2/evc/%s', circuit_id)
try:
evc = self.circuits[circuit_id]
except KeyError:
result = f'circuit_id {circuit_id} not found'
log.debug('delete_circuit result %s %s', result, 404)
raise NotFound(result)
if evc.archived:
result = f'Circuit {circuit_id} already removed'
log.debug('delete_circuit result %s %s', result, 404)
raise NotFound(result)
log.info('Removing %s', evc)
evc.remove_current_flows()
evc.deactivate()
evc.disable()
self.sched.remove(evc)
evc.archive()
evc.sync()
log.info('EVC removed. %s', evc)
result = {'response': f'Circuit {circuit_id} removed'}
status = 200
log.debug('delete_circuit result %s %s', result, status)
return jsonify(result), status
@rest('/v2/evc/schedule', methods=['GET'])
def list_schedules(self):
"""Endpoint to return all schedules stored for all circuits.
Return a JSON with the following template:
[{"schedule_id": <schedule_id>,
"circuit_id": <circuit_id>,
"schedule": <schedule object>}]
"""
log.debug('list_schedules /v2/evc/schedule')
circuits = self.storehouse.get_data().values()
if not circuits:
result = {}
status = 200
return jsonify(result), status
result = []
status = 200
for circuit in circuits:
circuit_scheduler = circuit.get("circuit_scheduler")
if circuit_scheduler:
for scheduler in circuit_scheduler:
value = {
"schedule_id": scheduler.get("id"),
"circuit_id": circuit.get("id"),
"schedule": scheduler
}
result.append(value)
log.debug('list_schedules result %s %s', result, status)
return jsonify(result), status
@rest('/v2/evc/schedule/', methods=['POST'])
def create_schedule(self):
"""
Create a new schedule for a given circuit.
This service do no check if there are conflicts with another schedule.
Payload example:
{
"circuit_id":"aa:bb:cc",
"schedule": {
"date": "2019-08-07T14:52:10.967Z",
"interval": "string",
"frequency": "1 * * * *",
"action": "create"
}
}
"""
log.debug('create_schedule /v2/evc/schedule/')
json_data = self.json_from_request('create_schedule')
try:
circuit_id = json_data['circuit_id']
except TypeError:
result = 'The payload should have a dictionary.'
log.debug('create_schedule result %s %s', result, 400)
raise BadRequest(result)
except KeyError:
result = 'Missing circuit_id.'
log.debug('create_schedule result %s %s', result, 400)
raise BadRequest(result)
try:
schedule_data = json_data['schedule']
except KeyError:
result = 'Missing schedule data.'
log.debug('create_schedule result %s %s', result, 400)
raise BadRequest(result)
# Get EVC from circuits buffer
circuits = self._get_circuits_buffer()
# get the circuit
evc = circuits.get(circuit_id)
# get the circuit
if not evc:
result = f'circuit_id {circuit_id} not found'
log.debug('create_schedule result %s %s', result, 404)
raise NotFound(result)
# Can not modify circuits deleted and archived
if evc.archived:
result = f'Circuit {circuit_id} is archived. Update is forbidden.'
log.debug('create_schedule result %s %s', result, 403)
raise Forbidden(result)
# new schedule from dict
new_schedule = CircuitSchedule.from_dict(schedule_data)
# If there is no schedule, create the list
if not evc.circuit_scheduler:
evc.circuit_scheduler = []
# Add the new schedule
evc.circuit_scheduler.append(new_schedule)
# Add schedule job
self.sched.add_circuit_job(evc, new_schedule)
# save circuit to storehouse
evc.sync()
result = new_schedule.as_dict()
status = 201
log.debug('create_schedule result %s %s', result, status)
return jsonify(result), status
@rest('/v2/evc/schedule/<schedule_id>', methods=['PATCH'])
def update_schedule(self, schedule_id):
"""Update a schedule.
Change all attributes from the given schedule from a EVC circuit.
The schedule ID is preserved as default.
Payload example:
{
"date": "2019-08-07T14:52:10.967Z",
"interval": "string",
"frequency": "1 * * *",
"action": "create"
}
"""
log.debug('update_schedule /v2/evc/schedule/%s', schedule_id)
# Try to find a circuit schedule
evc, found_schedule = self._find_evc_by_schedule_id(schedule_id)
# Can not modify circuits deleted and archived
if not found_schedule:
result = f'schedule_id {schedule_id} not found'
log.debug('update_schedule result %s %s', result, 404)
raise NotFound(result)
if evc.archived:
result = f'Circuit {evc.id} is archived. Update is forbidden.'
log.debug('update_schedule result %s %s', result, 403)
raise Forbidden(result)
data = self.json_from_request('update_schedule')
new_schedule = CircuitSchedule.from_dict(data)
new_schedule.id = found_schedule.id
# Remove the old schedule
evc.circuit_scheduler.remove(found_schedule)
# Append the modified schedule
evc.circuit_scheduler.append(new_schedule)
# Cancel all schedule jobs
self.sched.cancel_job(found_schedule.id)
# Add the new circuit schedule
self.sched.add_circuit_job(evc, new_schedule)
# Save EVC to the storehouse
evc.sync()
result = new_schedule.as_dict()
status = 200
log.debug('update_schedule result %s %s', result, status)
return jsonify(result), status
@rest('/v2/evc/schedule/<schedule_id>', methods=['DELETE'])
def delete_schedule(self, schedule_id):
"""Remove a circuit schedule.
Remove the Schedule from EVC.
Remove the Schedule from cron job.
Save the EVC to the Storehouse.
"""
log.debug('delete_schedule /v2/evc/schedule/%s', schedule_id)
evc, found_schedule = self._find_evc_by_schedule_id(schedule_id)
# Can not modify circuits deleted and archived
if not found_schedule:
result = f'schedule_id {schedule_id} not found'
log.debug('delete_schedule result %s %s', result, 404)
raise NotFound(result)
if evc.archived:
result = f'Circuit {evc.id} is archived. Update is forbidden.'
log.debug('delete_schedule result %s %s', result, 403)
raise Forbidden(result)
# Remove the old schedule
evc.circuit_scheduler.remove(found_schedule)
# Cancel all schedule jobs
self.sched.cancel_job(found_schedule.id)
# Save EVC to the storehouse
evc.sync()
result = "Schedule removed"
status = 200
log.debug('delete_schedule result %s %s', result, status)
return jsonify(result), status
def _is_duplicated_evc(self, evc):
"""Verify if the circuit given is duplicated with the stored evcs.
Args:
evc (EVC): circuit to be analysed.
Returns:
boolean: True if the circuit is duplicated, otherwise False.
"""
for circuit in self.circuits.values():
if not circuit.archived and circuit == evc:
return True
return False
@listen_to('kytos/topology.link_up')
def handle_link_up(self, event):
"""Change circuit when link is up or end_maintenance."""
log.debug("Event handle_link_up %s", event)
for evc in self.circuits.values():
if evc.is_enabled() and not evc.archived:
evc.handle_link_up(event.content['link'])
@listen_to('kytos/topology.link_down')
def handle_link_down(self, event):
"""Change circuit when link is down or under_mantenance."""
log.debug("Event handle_link_down %s", event)
for evc in self.circuits.values():
if evc.is_affected_by_link(event.content['link']):
log.info('handling evc %s' % evc)
evc.handle_link_down()
def load_circuits_by_interface(self, circuits):
"""Load circuits in storehouse for in-memory dictionary."""
for circuit_id, circuit in circuits.items():
intf_a = circuit['uni_a']['interface_id']
self.add_to_dict_of_sets(intf_a, circuit_id)
intf_z = circuit['uni_z']['interface_id']
self.add_to_dict_of_sets(intf_z, circuit_id)
for path in ('current_path', 'primary_path', 'backup_path'):
for link in circuit[path]:
intf_a = link['endpoint_a']['id']
self.add_to_dict_of_sets(intf_a, circuit_id)
intf_b = link['endpoint_b']['id']
self.add_to_dict_of_sets(intf_b, circuit_id)
def add_to_dict_of_sets(self, intf, circuit_id):
"""Add a single item to the dictionary of circuits by interface."""
if intf not in self._circuits_by_interface:
self._circuits_by_interface[intf] = set()
self._circuits_by_interface[intf].add(circuit_id)
@listen_to('kytos/topology.port.created')
def load_evcs(self, event):
"""Try to load the unloaded EVCs from storehouse."""
log.debug("Event load_evcs %s", event)
circuits = self.storehouse.get_data()
if not self._circuits_by_interface:
self.load_circuits_by_interface(circuits)
interface_id = '{}:{}'.format(event.content['switch'],
event.content['port'])
for circuit_id in self._circuits_by_interface.get(interface_id, []):
if circuit_id in circuits and circuit_id not in self.circuits:
try:
evc = self._evc_from_dict(circuits[circuit_id])
except ValueError as exception:
log.info(
f'Could not load EVC {circuit_id} because {exception}')
continue
log.info(f'Loading EVC {circuit_id}')
if evc.archived:
continue
new_evc = self.circuits.setdefault(circuit_id, evc)
if new_evc == evc:
if evc.is_enabled():
log.info(f'Trying to deploy EVC {circuit_id}')
evc.deploy()
self.sched.add(evc)
def _evc_dict_with_instances(self, evc_dict):
"""Convert some dict values to instance of EVC classes.
This method will convert: [UNI, Link]
"""
data = evc_dict.copy() # Do not modify the original dict
for attribute, value in data.items():
# Get multiple attributes.
# Ex: uni_a, uni_z
if 'uni' in attribute:
try:
data[attribute] = self._uni_from_dict(value)
except ValueError as exc:
raise ValueError(f'Error creating UNI: {exc}')
if attribute == 'circuit_scheduler':
data[attribute] = []
for schedule in value:
data[attribute].append(CircuitSchedule.from_dict(schedule))
# Get multiple attributes.
# Ex: primary_links,
# backup_links,
# current_links_cache,
# primary_links_cache,
# backup_links_cache
if 'links' in attribute:
data[attribute] = [
self._link_from_dict(link) for link in value
]
# Get multiple attributes.
# Ex: current_path,
# primary_path,
# backup_path
if 'path' in attribute and attribute != 'dynamic_backup_path':
data[attribute] = Path(
[self._link_from_dict(link) for link in value])
return data
def _evc_from_dict(self, evc_dict):
data = self._evc_dict_with_instances(evc_dict)
return EVC(self.controller, **data)
def _uni_from_dict(self, uni_dict):
"""Return a UNI object from python dict."""
if uni_dict is None:
return False
interface_id = uni_dict.get("interface_id")
interface = self.controller.get_interface_by_id(interface_id)
if interface is None:
raise ValueError(f'Could not instantiate interface {interface_id}')
try:
tag_dict = uni_dict["tag"]
except KeyError:
tag = None
else:
tag = TAG.from_dict(tag_dict)
uni = UNI(interface, tag)
return uni
def _link_from_dict(self, link_dict):
"""Return a Link object from python dict."""
id_a = link_dict.get('endpoint_a').get('id')
id_b = link_dict.get('endpoint_b').get('id')
endpoint_a = self.controller.get_interface_by_id(id_a)
endpoint_b = self.controller.get_interface_by_id(id_b)
link = Link(endpoint_a, endpoint_b)
if 'metadata' in link_dict:
link.extend_metadata(link_dict.get('metadata'))
s_vlan = link.get_metadata('s_vlan')
if s_vlan:
tag = TAG.from_dict(s_vlan)
if tag is False:
error_msg = f'Could not instantiate tag from dict {s_vlan}'
raise ValueError(error_msg)
link.update_metadata('s_vlan', tag)
return link
def _find_evc_by_schedule_id(self, schedule_id):
"""
Find an EVC and CircuitSchedule based on schedule_id.
:param schedule_id: Schedule ID
:return: EVC and Schedule
"""
circuits = self._get_circuits_buffer()
found_schedule = None
evc = None
# pylint: disable=unused-variable
for c_id, circuit in circuits.items():
for schedule in circuit.circuit_scheduler:
if schedule.id == schedule_id:
found_schedule = schedule
evc = circuit
break
if found_schedule:
break
return evc, found_schedule
def _get_circuits_buffer(self):
"""
Return the circuit buffer.
If the buffer is empty, try to load data from storehouse.
"""
if not self.circuits:
# Load storehouse circuits to buffer
circuits = self.storehouse.get_data()
for c_id, circuit in circuits.items():
evc = self._evc_from_dict(circuit)
self.circuits[c_id] = evc
return self.circuits
@staticmethod
def json_from_request(caller):
"""Return a json from request.
If it was not possible to get a json from the request, log, for debug,
who was the caller and the error that ocurred, and raise an
Exception.
"""
try:
json_data = request.get_json()
except ValueError as exception:
log.error(exception)
log.debug(f'{caller} result {exception} 400')
raise BadRequest(str(exception))
except BadRequest:
result = 'The request is not a valid JSON.'
log.debug(f'{caller} result {result} 400')
raise BadRequest(result)
if json_data is None:
result = 'Content-Type must be application/json'
log.debug(f'{caller} result {result} 415')
raise UnsupportedMediaType(result)
return json_data
def __init__(self, controller, **kwargs):
"""Create an EVC instance with the provided parameters.
Args:
id(str): EVC identifier. Whether it's None an ID will be genereted.
Only the first 14 bytes passed will be used.
name: represents an EVC name.(Required)
uni_a (UNI): Endpoint A for User Network Interface.(Required)
uni_z (UNI): Endpoint Z for User Network Interface.(Required)
start_date(datetime|str): Date when the EVC was registred.
Default is now().
end_date(datetime|str): Final date that the EVC will be fineshed.
Default is None.
bandwidth(int): Bandwidth used by EVC instance. Default is 0.
primary_links(list): Primary links used by evc. Default is []
backup_links(list): Backups links used by evc. Default is []
current_path(list): Circuit being used at the moment if this is an
active circuit. Default is [].
primary_path(list): primary circuit offered to user IF one or more
links were provided. Default is [].
backup_path(list): backup circuit offered to the user IF one or
more links were provided. Default is [].
dynamic_backup_path(bool): Enable computer backup path dynamically.
Dafault is False.
creation_time(datetime|str): datetime when the circuit should be
activated. default is now().
enabled(Boolean): attribute to indicate the administrative state;
default is False.
active(Boolean): attribute to indicate the operational state;
default is False.
archived(Boolean): indicate the EVC has been deleted and is
archived; default is False.
owner(str): The EVC owner. Default is None.
priority(int): Service level provided in the request. Default is 0.
Raises:
ValueError: raised when object attributes are invalid.
"""
self._validate(**kwargs)
super().__init__()
# required attributes
self._id = kwargs.get('id', uuid4().hex)[:14]
self.uni_a = kwargs.get('uni_a')
self.uni_z = kwargs.get('uni_z')
self.name = kwargs.get('name')
# optional attributes
self.start_date = get_time(kwargs.get('start_date')) or now()
self.end_date = get_time(kwargs.get('end_date')) or None
self.queue_id = kwargs.get('queue_id', None)
self.bandwidth = kwargs.get('bandwidth', 0)
self.primary_links = Path(kwargs.get('primary_links', []))
self.backup_links = Path(kwargs.get('backup_links', []))
self.current_path = Path(kwargs.get('current_path', []))
self.primary_path = Path(kwargs.get('primary_path', []))
self.backup_path = Path(kwargs.get('backup_path', []))
self.dynamic_backup_path = kwargs.get('dynamic_backup_path', False)
self.creation_time = get_time(kwargs.get('creation_time')) or now()
self.owner = kwargs.get('owner', None)
self.priority = kwargs.get('priority', 0)
self.circuit_scheduler = kwargs.get('circuit_scheduler', [])
self.current_links_cache = set()
self.primary_links_cache = set()
self.backup_links_cache = set()
self.lock = Lock()
self.archived = kwargs.get('archived', False)
self._storehouse = StoreHouse(controller)
if kwargs.get('active', False):
self.activate()
else:
self.deactivate()
if kwargs.get('enabled', False):
self.enable()
else:
self.disable()
# datetime of user request for a EVC (or datetime when object was
# created)
self.request_time = kwargs.get('request_time', now())
# dict with the user original request (input)
self._requested = kwargs
class EVCBase(GenericEntity):
"""Class to represent a circuit."""
unique_attributes = ['name', 'uni_a', 'uni_z']
def __init__(self, controller, **kwargs):
"""Create an EVC instance with the provided parameters.
Args:
id(str): EVC identifier. Whether it's None an ID will be genereted.
Only the first 14 bytes passed will be used.
name: represents an EVC name.(Required)
uni_a (UNI): Endpoint A for User Network Interface.(Required)
uni_z (UNI): Endpoint Z for User Network Interface.(Required)
start_date(datetime|str): Date when the EVC was registred.
Default is now().
end_date(datetime|str): Final date that the EVC will be fineshed.
Default is None.
bandwidth(int): Bandwidth used by EVC instance. Default is 0.
primary_links(list): Primary links used by evc. Default is []
backup_links(list): Backups links used by evc. Default is []
current_path(list): Circuit being used at the moment if this is an
active circuit. Default is [].
primary_path(list): primary circuit offered to user IF one or more
links were provided. Default is [].
backup_path(list): backup circuit offered to the user IF one or
more links were provided. Default is [].
dynamic_backup_path(bool): Enable computer backup path dynamically.
Dafault is False.
creation_time(datetime|str): datetime when the circuit should be
activated. default is now().
enabled(Boolean): attribute to indicate the administrative state;
default is False.
active(Boolean): attribute to indicate the operational state;
default is False.
archived(Boolean): indicate the EVC has been deleted and is
archived; default is False.
owner(str): The EVC owner. Default is None.
priority(int): Service level provided in the request. Default is 0.
Raises:
ValueError: raised when object attributes are invalid.
"""
self._validate(**kwargs)
super().__init__()
# required attributes
self._id = kwargs.get('id', uuid4().hex)[:14]
self.uni_a = kwargs.get('uni_a')
self.uni_z = kwargs.get('uni_z')
self.name = kwargs.get('name')
# optional attributes
self.start_date = get_time(kwargs.get('start_date')) or now()
self.end_date = get_time(kwargs.get('end_date')) or None
self.queue_id = kwargs.get('queue_id', None)
self.bandwidth = kwargs.get('bandwidth', 0)
self.primary_links = Path(kwargs.get('primary_links', []))
self.backup_links = Path(kwargs.get('backup_links', []))
self.current_path = Path(kwargs.get('current_path', []))
self.primary_path = Path(kwargs.get('primary_path', []))
self.backup_path = Path(kwargs.get('backup_path', []))
self.dynamic_backup_path = kwargs.get('dynamic_backup_path', False)
self.creation_time = get_time(kwargs.get('creation_time')) or now()
self.owner = kwargs.get('owner', None)
self.priority = kwargs.get('priority', 0)
self.circuit_scheduler = kwargs.get('circuit_scheduler', [])
self.current_links_cache = set()
self.primary_links_cache = set()
self.backup_links_cache = set()
self.lock = Lock()
self.archived = kwargs.get('archived', False)
self._storehouse = StoreHouse(controller)
if kwargs.get('active', False):
self.activate()
else:
self.deactivate()
if kwargs.get('enabled', False):
self.enable()
else:
self.disable()
# datetime of user request for a EVC (or datetime when object was
# created)
self.request_time = kwargs.get('request_time', now())
# dict with the user original request (input)
self._requested = kwargs
def sync(self):
"""Sync this EVC in the storehouse."""
self._storehouse.save_evc(self)
log.info(f'EVC {self.id} was synced to the storehouse.')
def update(self, **kwargs):
"""Update evc attributes.
This method will raises an error trying to change the following
attributes: [name, uni_a and uni_z]
Returns:
the values for enable and a path attribute, if exists and None
otherwise
Raises:
ValueError: message with error detail.
"""
enable, path = (None, None)
for attribute, value in kwargs.items():
if attribute in self.unique_attributes:
raise ValueError(f'{attribute} can\'t be be updated.')
if hasattr(self, attribute):
if attribute in ('enable', 'enabled'):
if value:
self.enable()
else:
self.disable()
enable = value
elif attribute in ('active', 'activate'):
if value:
self.activate()
else:
self.deactivate()
else:
setattr(self, attribute, value)
if 'path' in attribute:
path = value
else:
raise ValueError(f'The attribute "{attribute}" is invalid.')
self.sync()
return enable, path
def __repr__(self):
"""Repr method."""
return f"EVC({self._id}, {self.name})"
def _validate(self, **kwargs):
"""Do Basic validations.
Verify required attributes: name, uni_a, uni_z
Verify if the attributes uni_a and uni_z are valid.
Raises:
ValueError: message with error detail.
"""
for attribute in self.unique_attributes:
if attribute not in kwargs:
raise ValueError(f'{attribute} is required.')
if 'uni' in attribute:
uni = kwargs.get(attribute)
if not isinstance(uni, UNI):
raise ValueError(f'{attribute} is an invalid UNI.')
if not uni.is_valid():
tag = uni.user_tag.value
message = f'VLAN tag {tag} is not available in {attribute}'
raise ValueError(message)
def __eq__(self, other):
"""Override the default implementation."""
if not isinstance(other, EVC):
return False
attrs_to_compare = ['name', 'uni_a', 'uni_z', 'owner', 'bandwidth']
for attribute in attrs_to_compare:
if getattr(other, attribute) != getattr(self, attribute):
return False
return True
def shares_uni(self, other):
"""Check if two EVCs share an UNI."""
if other.uni_a in (self.uni_a, self.uni_z) or \
other.uni_z in (self.uni_a, self.uni_z):
return True
return False
def as_dict(self):
"""Return a dictionary representing an EVC object."""
evc_dict = {
"id": self.id,
"name": self.name,
"uni_a": self.uni_a.as_dict(),
"uni_z": self.uni_z.as_dict()
}
time_fmt = "%Y-%m-%dT%H:%M:%S"
evc_dict["start_date"] = self.start_date
if isinstance(self.start_date, datetime):
evc_dict["start_date"] = self.start_date.strftime(time_fmt)
evc_dict["end_date"] = self.end_date
if isinstance(self.end_date, datetime):
evc_dict["end_date"] = self.end_date.strftime(time_fmt)
evc_dict['queue_id'] = self.queue_id
evc_dict['bandwidth'] = self.bandwidth
evc_dict['primary_links'] = self.primary_links.as_dict()
evc_dict['backup_links'] = self.backup_links.as_dict()
evc_dict['current_path'] = self.current_path.as_dict()
evc_dict['primary_path'] = self.primary_path.as_dict()
evc_dict['backup_path'] = self.backup_path.as_dict()
evc_dict['dynamic_backup_path'] = self.dynamic_backup_path
# if self._requested:
# request_dict = self._requested.copy()
# request_dict['uni_a'] = request_dict['uni_a'].as_dict()
# request_dict['uni_z'] = request_dict['uni_z'].as_dict()
# request_dict['circuit_scheduler'] = self.circuit_scheduler
# evc_dict['_requested'] = request_dict
evc_dict["request_time"] = self.request_time
if isinstance(self.request_time, datetime):
evc_dict["request_time"] = self.request_time.strftime(time_fmt)
time = self.creation_time.strftime(time_fmt)
evc_dict['creation_time'] = time
evc_dict['owner'] = self.owner
evc_dict['circuit_scheduler'] = [
sc.as_dict() for sc in self.circuit_scheduler
]
evc_dict['active'] = self.is_active()
evc_dict['enabled'] = self.is_enabled()
evc_dict['archived'] = self.archived
evc_dict['priority'] = self.priority
return evc_dict
@property
def id(self): # pylint: disable=invalid-name
"""Return this EVC's ID."""
return self._id
def archive(self):
"""Archive this EVC on deletion."""
self.archived = True
class Main(KytosNApp):
"""Main class of amlight/mef_eline NApp.
This class is the entry point for this napp.
"""
def setup(self):
"""Replace the '__init__' method for the KytosNApp subclass.
The setup method is automatically called by the controller when your
application is loaded.
So, if you have any setup routine, insert it here.
"""
# object used to scheduler circuit events
self.sched = Scheduler()
# object to save and load circuits
self.storehouse = StoreHouse(self.controller)
# set the controller that will manager the dynamic paths
DynamicPathManager.set_controller(self.controller)
def execute(self):
"""Execute once when the napp is running."""
def shutdown(self):
"""Execute when your napp is unloaded.
If you have some cleanup procedure, insert it here.
"""
@rest('/v2/evc/', methods=['GET'])
def list_circuits(self):
"""Endpoint to return all circuits stored."""
circuits = self.storehouse.get_data()
if not circuits:
return jsonify({}), 200
return jsonify(circuits), 200
@rest('/v2/evc/<circuit_id>', methods=['GET'])
def get_circuit(self, circuit_id):
"""Endpoint to return a circuit based on id."""
circuits = self.storehouse.get_data()
if circuit_id in circuits:
result = circuits[circuit_id]
status = 200
else:
result = {'response': f'circuit_id {circuit_id} not found'}
status = 400
return jsonify(result), status
@rest('/v2/evc/', methods=['POST'])
def create_circuit(self):
"""Try to create a new circuit.
Firstly, for EVPL: E-Line NApp verifies if UNI_A's requested C-VID and
UNI_Z's requested C-VID are available from the interfaces' pools. This
is checked when creating the UNI object.
Then, E-Line NApp requests a primary and a backup path to the
Pathfinder NApp using the attributes primary_links and backup_links
submitted via REST
# For each link composing paths in #3:
# - E-Line NApp requests a S-VID available from the link VLAN pool.
# - Using the S-VID obtained, generate abstract flow entries to be
# sent to FlowManager
Push abstract flow entries to FlowManager and FlowManager pushes
OpenFlow entries to datapaths
E-Line NApp generates an event to notify all Kytos NApps of a new EVC
creation
Finnaly, notify user of the status of its request.
"""
# Try to create the circuit object
data = request.get_json()
if not data:
return jsonify("Bad request: The request do not have a json."), 400
try:
evc = self.evc_from_dict(data)
except ValueError as exception:
return jsonify("Bad request: {}".format(exception)), 400
# verify duplicated evc
if self.is_duplicated_evc(evc):
return jsonify("Not Acceptable: This evc already exists."), 409
# save circuit
self.storehouse.save_evc(evc)
# Schedule the circuit deploy
self.sched.add(evc)
# Circuit has no schedule, deploy now
if not evc.circuit_scheduler:
evc.deploy()
# Notify users
event = KytosEvent(name='kytos.mef_eline.created',
content=evc.as_dict())
self.controller.buffers.app.put(event)
return jsonify({"circuit_id": evc.id}), 201
@rest('/v2/evc/<circuit_id>', methods=['PATCH'])
def update(self, circuit_id):
"""Update a circuit based on payload.
The EVC required attributes can't be updated.
"""
data = request.get_json()
circuits = self.storehouse.get_data()
if circuit_id not in circuits:
result = {'response': f'circuit_id {circuit_id} not found'}
return jsonify(result), 404
try:
evc = self.evc_from_dict(circuits.get(circuit_id))
evc.update(**data)
self.storehouse.save_evc(evc)
result = {evc.id: evc.as_dict()}
status = 200
except ValueError as exception:
result = "Bad request: {}".format(exception)
status = 400
return jsonify(result), status
@rest('/v2/evc/<circuit_id>', methods=['DELETE'])
def delete_circuit(self, circuit_id):
"""Remove a circuit.
First, flows are removed from the switches, then the EVC is
disabled.
"""
circuits = self.storehouse.get_data()
log.info("Removing %s" % circuit_id)
evc = self.evc_from_dict(circuits.get(circuit_id))
evc.remove_current_flows()
evc.disable()
self.storehouse.save_evc(evc)
return jsonify("Circuit removed"), 200
def is_duplicated_evc(self, evc):
"""Verify if the circuit given is duplicated with the stored evcs.
Args:
evc (EVC): circuit to be analysed.
Returns:
boolean: True if the circuit is duplicated, otherwise False.
"""
for circuit_dict in self.storehouse.get_data().values():
try:
circuit = self.evc_from_dict(circuit_dict)
except ValueError:
continue
if circuit == evc:
return True
return False
@listen_to('kytos/topology.link_up')
def handle_link_up(self, event):
"""Change circuit when link is up or end_maintenance."""
evc = None
for data in self.storehouse.get_data().values():
try:
evc = self.evc_from_dict(data)
except ValueError as _exception:
log.debug(f'{data.get("id")} can not be provisioning yet.')
continue
evc.handle_link_up(event.content['link'])
@listen_to('kytos/topology.link_down')
def handle_link_down(self, event):
"""Change circuit when link is down or under_mantenance."""
evc = None
for data in self.storehouse.get_data().values():
try:
evc = self.evc_from_dict(data)
except ValueError as _exception:
log.debug(f'{data.get("id")} can not be provisioned yet.')
continue
if evc.is_affected_by_link(event.content['link']):
log.info('handling evc %s' % evc)
evc.handle_link_down()
def evc_from_dict(self, evc_dict):
"""Convert some dict values to instance of EVC classes.
This method will convert: [UNI, Link]
"""
data = evc_dict.copy() # Do not modify the original dict
for attribute, value in data.items():
if 'uni' in attribute:
try:
data[attribute] = self.uni_from_dict(value)
except ValueError as exc:
raise ValueError(f'Error creating UNI: {exc}')
if attribute == 'circuit_scheduler':
data[attribute] = []
for schedule in value:
data[attribute].append(CircuitSchedule.from_dict(schedule))
if 'link' in attribute:
if value:
data[attribute] = self.link_from_dict(value)
if 'path' in attribute and attribute != 'dynamic_backup_path':
if value:
data[attribute] = [
self.link_from_dict(link) for link in value
]
return EVC(self.controller, **data)
def uni_from_dict(self, uni_dict):
"""Return a UNI object from python dict."""
if uni_dict is None:
return False
interface_id = uni_dict.get("interface_id")
interface = self.controller.get_interface_by_id(interface_id)
if interface is None:
raise ValueError(f'Could not instantiate interface {interface_id}')
tag_dict = uni_dict.get("tag")
tag = TAG.from_dict(tag_dict)
if tag is False:
raise ValueError(f'Could not instantiate tag from dict {tag_dict}')
uni = UNI(interface, tag)
return uni
def link_from_dict(self, link_dict):
"""Return a Link object from python dict."""
id_a = link_dict.get('endpoint_a').get('id')
id_b = link_dict.get('endpoint_b').get('id')
endpoint_a = self.controller.get_interface_by_id(id_a)
endpoint_b = self.controller.get_interface_by_id(id_b)
link = Link(endpoint_a, endpoint_b)
if 'metadata' in link_dict:
link.extend_metadata(link_dict.get('metadata'))
s_vlan = link.get_metadata('s_vlan')
if s_vlan:
tag = TAG.from_dict(s_vlan)
if tag is False:
error_msg = f'Could not instantiate tag from dict {s_vlan}'
raise ValueError(error_msg)
link.update_metadata('s_vlan', tag)
return link
class TestStoreHouse(TestCase):
"""Tests to verify StoreHouse class."""
def setUp(self):
"""Execute steps before each tests."""
self.storehouse = StoreHouse(get_controller_mock())
def test_get_stored_box(self):
"""Test get_stored_box method."""
self.storehouse.controller.buffers = Mock()
self.storehouse.get_stored_box(1)
self.storehouse.controller.buffers.app.put.assert_called_once()
def test_create_box(self):
"""Test get_stored_box method."""
self.storehouse.controller.buffers = Mock()
self.storehouse.create_box()
self.storehouse.controller.buffers.app.put.assert_called_once()
@patch("napps.kytos.mef_eline.storehouse.log")
def test_save_evc_callback_no_error(self, log_mock):
# pylint: disable=protected-access
"""Test _save_evc_callback method."""
self.storehouse._lock = Mock()
data = Mock()
data.box_id = 1
self.storehouse._save_evc_callback("event", data, None)
self.storehouse._lock.release.assert_called_once()
log_mock.error.assert_not_called()
@patch("napps.kytos.mef_eline.storehouse.log")
def test_save_evc_callback_with_error(self, log_mock):
# pylint: disable=protected-access
"""Test _save_evc_callback method."""
self.storehouse._lock = Mock()
self.storehouse.box = Mock()
self.storehouse.box.box_id = 1
data = Mock()
data.box_id = 1
self.storehouse._save_evc_callback("event", data, "error")
self.storehouse._lock.release.assert_called_once()
log_mock.error.assert_called_once()
@patch("napps.kytos.mef_eline.storehouse.StoreHouse.get_stored_box")
def test_get_data(self, get_stored_box_mock):
"""Test get_data method."""
self.storehouse.box = Mock()
self.storehouse.box.box_id = 2
self.storehouse.get_data()
get_stored_box_mock.assert_called_once_with(2)
@patch('napps.kytos.mef_eline.storehouse.log')
def test_create_box_callback(self, log_mock):
# pylint: disable=protected-access
"""Test _create_box_callback method."""
data = Mock()
data.box_id = 1
self.storehouse._create_box_callback('event', data, None)
log_mock.error.assert_not_called()
log_mock.debug.assert_called_once()
# test with error
log_mock.debug.call_count = 0
self.storehouse._create_box_callback('event', data, 'error')
log_mock.error.assert_called_once()
log_mock.debug.assert_called_once()
@patch('napps.kytos.mef_eline.storehouse.StoreHouse.get_stored_box')
@patch('napps.kytos.mef_eline.storehouse.StoreHouse.create_box')
def test_get_or_create_box(self, create_box_mock, get_stored_box_mock):
"""Test _get_or_create_a_box_from_list_of_boxes method."""
# pylint: disable=protected-access
self.storehouse._get_or_create_a_box_from_list_of_boxes(
'event', [2], None)
get_stored_box_mock.assert_called_once_with(2)
self.storehouse._get_or_create_a_box_from_list_of_boxes(
'event', None, 'error')
create_box_mock.assert_called_once()
@patch('napps.kytos.mef_eline.storehouse.log')
def test_get_box_callback(self, log_mock):
# pylint: disable=protected-access
"""Test _get_box_callback method."""
self.storehouse._lock = Mock()
data = Mock()
data.box_id = 1
self.storehouse._get_box_callback('event', data, None)
self.storehouse._lock.release.assert_called_once()
log_mock.error.assert_not_called()
# test with error
self.storehouse._lock.release.call_count = 0
log_mock.debug.call_count = 0
self.storehouse._get_box_callback('event', data, 'error')
self.storehouse._lock.release.assert_called_once()
log_mock.error.assert_called_once()
self.assertEqual(log_mock.debug.call_count, 2)
def setUp(self):
"""Execute steps before each tests."""
self.storehouse = StoreHouse(get_controller_mock())
class Main(KytosNApp):
"""Main class of amlight/mef_eline NApp.
This class is the entry point for this napp.
"""
spec = load_spec()
def setup(self):
"""Replace the '__init__' method for the KytosNApp subclass.
The setup method is automatically called by the controller when your
application is loaded.
So, if you have any setup routine, insert it here.
"""
# object used to scheduler circuit events
self.sched = Scheduler()
# object to save and load circuits
self.storehouse = StoreHouse(self.controller)
# set the controller that will manager the dynamic paths
DynamicPathManager.set_controller(self.controller)
# dictionary of EVCs created. It acts as a circuit buffer.
# Every create/update/delete must be synced to storehouse.
self.circuits = {}
self._lock = Lock()
self.execute_as_loop(settings.DEPLOY_EVCS_INTERVAL)
self.execution_rounds = 0
self.load_all_evcs()
def execute(self):
"""Execute once when the napp is running."""
if self._lock.locked():
return
log.debug("Starting consistency routine")
with self._lock:
self.execute_consistency()
log.debug("Finished consistency routine")
def execute_consistency(self):
"""Execute consistency routine."""
self.execution_rounds += 1
stored_circuits = self.storehouse.get_data().copy()
for circuit in tuple(self.circuits.values()):
stored_circuits.pop(circuit.id, None)
if (
circuit.is_enabled()
and not circuit.is_active()
and not circuit.lock.locked()
):
if circuit.check_traces():
log.info(f"{circuit} enabled but inactive - activating")
with circuit.lock:
circuit.activate()
circuit.sync()
else:
if self.execution_rounds > settings.WAIT_FOR_OLD_PATH:
log.info(f"{circuit} enabled but inactive - redeploy")
with circuit.lock:
circuit.deploy()
for circuit_id in stored_circuits:
log.info(f"EVC found in storehouse but unloaded {circuit_id}")
self._load_evc(stored_circuits[circuit_id])
def shutdown(self):
"""Execute when your napp is unloaded.
If you have some cleanup procedure, insert it here.
"""
@rest("/v2/evc/", methods=["GET"])
def list_circuits(self):
"""Endpoint to return circuits stored.
If archived is set to True return all circuits, else only the ones
not archived.
"""
log.debug("list_circuits /v2/evc")
archived = request.args.get("archived", False)
circuits = self.storehouse.get_data()
if not circuits:
return jsonify({}), 200
if archived:
return jsonify(circuits), 200
return (
jsonify(
{
circuit_id: circuit
for circuit_id, circuit in circuits.items()
if not circuit.get("archived", False)
}
),
200,
)
@rest("/v2/evc/<circuit_id>", methods=["GET"])
def get_circuit(self, circuit_id):
"""Endpoint to return a circuit based on id."""
log.debug("get_circuit /v2/evc/%s", circuit_id)
circuits = self.storehouse.get_data()
try:
result = circuits[circuit_id]
except KeyError:
result = f"circuit_id {circuit_id} not found"
log.debug("get_circuit result %s %s", result, 404)
raise NotFound(result) from KeyError
status = 200
log.debug("get_circuit result %s %s", result, status)
return jsonify(result), status
@rest("/v2/evc/", methods=["POST"])
@validate(spec)
def create_circuit(self, data):
"""Try to create a new circuit.
Firstly, for EVPL: E-Line NApp verifies if UNI_A's requested C-VID and
UNI_Z's requested C-VID are available from the interfaces' pools. This
is checked when creating the UNI object.
Then, E-Line NApp requests a primary and a backup path to the
Pathfinder NApp using the attributes primary_links and backup_links
submitted via REST
# For each link composing paths in #3:
# - E-Line NApp requests a S-VID available from the link VLAN pool.
# - Using the S-VID obtained, generate abstract flow entries to be
# sent to FlowManager
Push abstract flow entries to FlowManager and FlowManager pushes
OpenFlow entries to datapaths
E-Line NApp generates an event to notify all Kytos NApps of a new EVC
creation
Finnaly, notify user of the status of its request.
"""
# Try to create the circuit object
log.debug("create_circuit /v2/evc/")
try:
evc = self._evc_from_dict(data)
except ValueError as exception:
log.debug("create_circuit result %s %s", exception, 400)
raise BadRequest(str(exception)) from BadRequest
if evc.primary_path:
try:
evc.primary_path.is_valid(
evc.uni_a.interface.switch,
evc.uni_z.interface.switch,
bool(evc.circuit_scheduler),
)
except InvalidPath as exception:
raise BadRequest(
f"primary_path is not valid: {exception}"
) from exception
if evc.backup_path:
try:
evc.backup_path.is_valid(
evc.uni_a.interface.switch,
evc.uni_z.interface.switch,
bool(evc.circuit_scheduler),
)
except InvalidPath as exception:
raise BadRequest(
f"backup_path is not valid: {exception}"
) from exception
# verify duplicated evc
if self._is_duplicated_evc(evc):
result = "The EVC already exists."
log.debug("create_circuit result %s %s", result, 409)
raise Conflict(result)
if (
not evc.primary_path
and evc.dynamic_backup_path is False
and evc.uni_a.interface.switch != evc.uni_z.interface.switch
):
result = "The EVC must have a primary path or allow dynamic paths."
log.debug("create_circuit result %s %s", result, 400)
raise BadRequest(result)
# store circuit in dictionary
self.circuits[evc.id] = evc
# save circuit
self.storehouse.save_evc(evc)
# Schedule the circuit deploy
self.sched.add(evc)
# Circuit has no schedule, deploy now
if not evc.circuit_scheduler:
with evc.lock:
evc.deploy()
# Notify users
event = KytosEvent(
name="kytos.mef_eline.created", content=evc.as_dict()
)
self.controller.buffers.app.put(event)
result = {"circuit_id": evc.id}
status = 201
log.debug("create_circuit result %s %s", result, status)
emit_event(self.controller, "created", evc_id=evc.id)
return jsonify(result), status
@rest("/v2/evc/<circuit_id>", methods=["PATCH"])
def update(self, circuit_id):
"""Update a circuit based on payload.
The EVC required attributes (name, uni_a, uni_z) can't be updated.
"""
log.debug("update /v2/evc/%s", circuit_id)
try:
evc = self.circuits[circuit_id]
except KeyError:
result = f"circuit_id {circuit_id} not found"
log.debug("update result %s %s", result, 404)
raise NotFound(result) from NotFound
if evc.archived:
result = "Can't update archived EVC"
log.debug("update result %s %s", result, 405)
raise MethodNotAllowed(["GET"], result)
try:
data = request.get_json()
except BadRequest:
result = "The request body is not a well-formed JSON."
log.debug("update result %s %s", result, 400)
raise BadRequest(result) from BadRequest
if data is None:
result = "The request body mimetype is not application/json."
log.debug("update result %s %s", result, 415)
raise UnsupportedMediaType(result) from UnsupportedMediaType
try:
enable, redeploy = evc.update(
**self._evc_dict_with_instances(data)
)
except ValueError as exception:
log.error(exception)
log.debug("update result %s %s", exception, 400)
raise BadRequest(str(exception)) from BadRequest
if evc.is_active():
if enable is False: # disable if active
with evc.lock:
evc.remove()
elif redeploy is not None: # redeploy if active
with evc.lock:
evc.remove()
evc.deploy()
else:
if enable is True: # enable if inactive
with evc.lock:
evc.deploy()
result = {evc.id: evc.as_dict()}
status = 200
log.debug("update result %s %s", result, status)
emit_event(self.controller, "updated", evc_id=evc.id, data=data)
return jsonify(result), status
@rest("/v2/evc/<circuit_id>", methods=["DELETE"])
def delete_circuit(self, circuit_id):
"""Remove a circuit.
First, the flows are removed from the switches, and then the EVC is
disabled.
"""
log.debug("delete_circuit /v2/evc/%s", circuit_id)
try:
evc = self.circuits[circuit_id]
except KeyError:
result = f"circuit_id {circuit_id} not found"
log.debug("delete_circuit result %s %s", result, 404)
raise NotFound(result) from NotFound
if evc.archived:
result = f"Circuit {circuit_id} already removed"
log.debug("delete_circuit result %s %s", result, 404)
raise NotFound(result) from NotFound
log.info("Removing %s", evc)
with evc.lock:
evc.remove_current_flows()
evc.deactivate()
evc.disable()
self.sched.remove(evc)
evc.archive()
evc.sync()
log.info("EVC removed. %s", evc)
result = {"response": f"Circuit {circuit_id} removed"}
status = 200
log.debug("delete_circuit result %s %s", result, status)
emit_event(self.controller, "deleted", evc_id=evc.id)
return jsonify(result), status
@rest("v2/evc/<circuit_id>/metadata", methods=["GET"])
def get_metadata(self, circuit_id):
"""Get metadata from an EVC."""
try:
return (
jsonify({"metadata": self.circuits[circuit_id].metadata}),
200,
)
except KeyError as error:
raise NotFound(f"circuit_id {circuit_id} not found.") from error
@rest("v2/evc/<circuit_id>/metadata", methods=["POST"])
def add_metadata(self, circuit_id):
"""Add metadata to an EVC."""
try:
metadata = request.get_json()
content_type = request.content_type
except BadRequest as error:
result = "The request body is not a well-formed JSON."
raise BadRequest(result) from error
if content_type is None:
result = "The request body is empty."
raise BadRequest(result)
if metadata is None:
if content_type != "application/json":
result = (
"The content type must be application/json "
f"(received {content_type})."
)
else:
result = "Metadata is empty."
raise UnsupportedMediaType(result)
try:
evc = self.circuits[circuit_id]
except KeyError as error:
raise NotFound(f"circuit_id {circuit_id} not found.") from error
evc.extend_metadata(metadata)
evc.sync()
return jsonify("Operation successful"), 201
@rest("v2/evc/<circuit_id>/metadata/<key>", methods=["DELETE"])
def delete_metadata(self, circuit_id, key):
"""Delete metadata from an EVC."""
try:
evc = self.circuits[circuit_id]
except KeyError as error:
raise NotFound(f"circuit_id {circuit_id} not found.") from error
evc.remove_metadata(key)
evc.sync()
return jsonify("Operation successful"), 200
@rest("/v2/evc/<circuit_id>/redeploy", methods=["PATCH"])
def redeploy(self, circuit_id):
"""Endpoint to force the redeployment of an EVC."""
log.debug("redeploy /v2/evc/%s/redeploy", circuit_id)
try:
evc = self.circuits[circuit_id]
except KeyError:
result = f"circuit_id {circuit_id} not found"
raise NotFound(result) from NotFound
if evc.is_enabled():
with evc.lock:
evc.remove_current_flows()
evc.deploy()
result = {"response": f"Circuit {circuit_id} redeploy received."}
status = 202
else:
result = {"response": f"Circuit {circuit_id} is disabled."}
status = 409
return jsonify(result), status
@rest("/v2/evc/schedule", methods=["GET"])
def list_schedules(self):
"""Endpoint to return all schedules stored for all circuits.
Return a JSON with the following template:
[{"schedule_id": <schedule_id>,
"circuit_id": <circuit_id>,
"schedule": <schedule object>}]
"""
log.debug("list_schedules /v2/evc/schedule")
circuits = self.storehouse.get_data().values()
if not circuits:
result = {}
status = 200
return jsonify(result), status
result = []
status = 200
for circuit in circuits:
circuit_scheduler = circuit.get("circuit_scheduler")
if circuit_scheduler:
for scheduler in circuit_scheduler:
value = {
"schedule_id": scheduler.get("id"),
"circuit_id": circuit.get("id"),
"schedule": scheduler,
}
result.append(value)
log.debug("list_schedules result %s %s", result, status)
return jsonify(result), status
@rest("/v2/evc/schedule/", methods=["POST"])
def create_schedule(self):
"""
Create a new schedule for a given circuit.
This service do no check if there are conflicts with another schedule.
Payload example:
{
"circuit_id":"aa:bb:cc",
"schedule": {
"date": "2019-08-07T14:52:10.967Z",
"interval": "string",
"frequency": "1 * * * *",
"action": "create"
}
}
"""
log.debug("create_schedule /v2/evc/schedule/")
json_data = self._json_from_request("create_schedule")
try:
circuit_id = json_data["circuit_id"]
except TypeError:
result = "The payload should have a dictionary."
log.debug("create_schedule result %s %s", result, 400)
raise BadRequest(result) from BadRequest
except KeyError:
result = "Missing circuit_id."
log.debug("create_schedule result %s %s", result, 400)
raise BadRequest(result) from BadRequest
try:
schedule_data = json_data["schedule"]
except KeyError:
result = "Missing schedule data."
log.debug("create_schedule result %s %s", result, 400)
raise BadRequest(result) from BadRequest
# Get EVC from circuits buffer
circuits = self._get_circuits_buffer()
# get the circuit
evc = circuits.get(circuit_id)
# get the circuit
if not evc:
result = f"circuit_id {circuit_id} not found"
log.debug("create_schedule result %s %s", result, 404)
raise NotFound(result) from NotFound
# Can not modify circuits deleted and archived
if evc.archived:
result = f"Circuit {circuit_id} is archived. Update is forbidden."
log.debug("create_schedule result %s %s", result, 403)
raise Forbidden(result) from Forbidden
# new schedule from dict
new_schedule = CircuitSchedule.from_dict(schedule_data)
# If there is no schedule, create the list
if not evc.circuit_scheduler:
evc.circuit_scheduler = []
# Add the new schedule
evc.circuit_scheduler.append(new_schedule)
# Add schedule job
self.sched.add_circuit_job(evc, new_schedule)
# save circuit to storehouse
evc.sync()
result = new_schedule.as_dict()
status = 201
log.debug("create_schedule result %s %s", result, status)
return jsonify(result), status
@rest("/v2/evc/schedule/<schedule_id>", methods=["PATCH"])
def update_schedule(self, schedule_id):
"""Update a schedule.
Change all attributes from the given schedule from a EVC circuit.
The schedule ID is preserved as default.
Payload example:
{
"date": "2019-08-07T14:52:10.967Z",
"interval": "string",
"frequency": "1 * * *",
"action": "create"
}
"""
log.debug("update_schedule /v2/evc/schedule/%s", schedule_id)
# Try to find a circuit schedule
evc, found_schedule = self._find_evc_by_schedule_id(schedule_id)
# Can not modify circuits deleted and archived
if not found_schedule:
result = f"schedule_id {schedule_id} not found"
log.debug("update_schedule result %s %s", result, 404)
raise NotFound(result) from NotFound
if evc.archived:
result = f"Circuit {evc.id} is archived. Update is forbidden."
log.debug("update_schedule result %s %s", result, 403)
raise Forbidden(result) from Forbidden
data = self._json_from_request("update_schedule")
new_schedule = CircuitSchedule.from_dict(data)
new_schedule.id = found_schedule.id
# Remove the old schedule
evc.circuit_scheduler.remove(found_schedule)
# Append the modified schedule
evc.circuit_scheduler.append(new_schedule)
# Cancel all schedule jobs
self.sched.cancel_job(found_schedule.id)
# Add the new circuit schedule
self.sched.add_circuit_job(evc, new_schedule)
# Save EVC to the storehouse
evc.sync()
result = new_schedule.as_dict()
status = 200
log.debug("update_schedule result %s %s", result, status)
return jsonify(result), status
@rest("/v2/evc/schedule/<schedule_id>", methods=["DELETE"])
def delete_schedule(self, schedule_id):
"""Remove a circuit schedule.
Remove the Schedule from EVC.
Remove the Schedule from cron job.
Save the EVC to the Storehouse.
"""
log.debug("delete_schedule /v2/evc/schedule/%s", schedule_id)
evc, found_schedule = self._find_evc_by_schedule_id(schedule_id)
# Can not modify circuits deleted and archived
if not found_schedule:
result = f"schedule_id {schedule_id} not found"
log.debug("delete_schedule result %s %s", result, 404)
raise NotFound(result)
if evc.archived:
result = f"Circuit {evc.id} is archived. Update is forbidden."
log.debug("delete_schedule result %s %s", result, 403)
raise Forbidden(result)
# Remove the old schedule
evc.circuit_scheduler.remove(found_schedule)
# Cancel all schedule jobs
self.sched.cancel_job(found_schedule.id)
# Save EVC to the storehouse
evc.sync()
result = "Schedule removed"
status = 200
log.debug("delete_schedule result %s %s", result, status)
return jsonify(result), status
def _is_duplicated_evc(self, evc):
"""Verify if the circuit given is duplicated with the stored evcs.
Args:
evc (EVC): circuit to be analysed.
Returns:
boolean: True if the circuit is duplicated, otherwise False.
"""
for circuit in tuple(self.circuits.values()):
if not circuit.archived and circuit.shares_uni(evc):
return True
return False
@listen_to("kytos/topology.link_up")
def on_link_up(self, event):
"""Change circuit when link is up or end_maintenance."""
self.handle_link_up(event)
def handle_link_up(self, event):
"""Change circuit when link is up or end_maintenance."""
log.debug("Event handle_link_up %s", event)
for evc in self.circuits.values():
if evc.is_enabled() and not evc.archived:
with evc.lock:
evc.handle_link_up(event.content["link"])
@listen_to("kytos/topology.link_down")
def on_link_down(self, event):
"""Change circuit when link is down or under_mantenance."""
self.handle_link_down(event)
def handle_link_down(self, event):
"""Change circuit when link is down or under_mantenance."""
log.debug("Event handle_link_down %s", event)
for evc in self.circuits.values():
with evc.lock:
if evc.is_affected_by_link(event.content["link"]):
log.debug(f"Handling evc {evc.id} on link down")
if evc.handle_link_down():
emit_event(
self.controller,
"redeployed_link_down",
evc_id=evc.id,
)
else:
emit_event(
self.controller,
"error_redeploy_link_down",
evc_id=evc.id,
)
def load_all_evcs(self):
"""Try to load all EVCs on startup."""
for circuit_id, circuit in self.storehouse.get_data().items():
if circuit_id not in self.circuits:
self._load_evc(circuit)
def _load_evc(self, circuit_dict):
"""Load one EVC from storehouse to memory."""
try:
evc = self._evc_from_dict(circuit_dict)
except ValueError as exception:
log.error(
f'Could not load EVC {circuit_dict["id"]} '
f"because {exception}"
)
return None
if evc.archived:
return None
evc.deactivate()
evc.sync()
self.circuits.setdefault(evc.id, evc)
self.sched.add(evc)
return evc
@listen_to("kytos/flow_manager.flow.error")
def on_flow_mod_error(self, event):
"""Handle flow mod errors related to an EVC."""
self.handle_flow_mod_error(event)
def handle_flow_mod_error(self, event):
"""Handle flow mod errors related to an EVC."""
flow = event.content["flow"]
command = event.content.get("error_command")
if command != "add":
return
evc = self.circuits.get(EVC.get_id_from_cookie(flow.cookie))
if evc:
evc.remove_current_flows()
def _evc_dict_with_instances(self, evc_dict):
"""Convert some dict values to instance of EVC classes.
This method will convert: [UNI, Link]
"""
data = evc_dict.copy() # Do not modify the original dict
for attribute, value in data.items():
# Get multiple attributes.
# Ex: uni_a, uni_z
if "uni" in attribute:
try:
data[attribute] = self._uni_from_dict(value)
except ValueError:
result = "Error creating UNI: Invalid value"
raise BadRequest(result) from BadRequest
if attribute == "circuit_scheduler":
data[attribute] = []
for schedule in value:
data[attribute].append(CircuitSchedule.from_dict(schedule))
# Get multiple attributes.
# Ex: primary_links,
# backup_links,
# current_links_cache,
# primary_links_cache,
# backup_links_cache
if "links" in attribute:
data[attribute] = [
self._link_from_dict(link) for link in value
]
# Ex: current_path,
# primary_path,
# backup_path
if "path" in attribute and attribute != "dynamic_backup_path":
data[attribute] = Path(
[self._link_from_dict(link) for link in value]
)
return data
def _evc_from_dict(self, evc_dict):
data = self._evc_dict_with_instances(evc_dict)
return EVC(self.controller, **data)
def _uni_from_dict(self, uni_dict):
"""Return a UNI object from python dict."""
if uni_dict is None:
return False
interface_id = uni_dict.get("interface_id")
interface = self.controller.get_interface_by_id(interface_id)
if interface is None:
result = (
"Error creating UNI:"
+ f"Could not instantiate interface {interface_id}"
)
raise ValueError(result) from ValueError
tag_dict = uni_dict.get("tag", None)
if tag_dict:
tag = TAG.from_dict(tag_dict)
else:
tag = None
uni = UNI(interface, tag)
return uni
def _link_from_dict(self, link_dict):
"""Return a Link object from python dict."""
id_a = link_dict.get("endpoint_a").get("id")
id_b = link_dict.get("endpoint_b").get("id")
endpoint_a = self.controller.get_interface_by_id(id_a)
endpoint_b = self.controller.get_interface_by_id(id_b)
link = Link(endpoint_a, endpoint_b)
if "metadata" in link_dict:
link.extend_metadata(link_dict.get("metadata"))
s_vlan = link.get_metadata("s_vlan")
if s_vlan:
tag = TAG.from_dict(s_vlan)
if tag is False:
error_msg = f"Could not instantiate tag from dict {s_vlan}"
raise ValueError(error_msg)
link.update_metadata("s_vlan", tag)
return link
def _find_evc_by_schedule_id(self, schedule_id):
"""
Find an EVC and CircuitSchedule based on schedule_id.
:param schedule_id: Schedule ID
:return: EVC and Schedule
"""
circuits = self._get_circuits_buffer()
found_schedule = None
evc = None
# pylint: disable=unused-variable
for c_id, circuit in circuits.items():
for schedule in circuit.circuit_scheduler:
if schedule.id == schedule_id:
found_schedule = schedule
evc = circuit
break
if found_schedule:
break
return evc, found_schedule
def _get_circuits_buffer(self):
"""
Return the circuit buffer.
If the buffer is empty, try to load data from storehouse.
"""
if not self.circuits:
# Load storehouse circuits to buffer
circuits = self.storehouse.get_data()
for c_id, circuit in circuits.items():
evc = self._evc_from_dict(circuit)
self.circuits[c_id] = evc
return self.circuits
@staticmethod
def _json_from_request(caller):
"""Return a json from request.
If it was not possible to get a json from the request, log, for debug,
who was the caller and the error that ocurred, and raise an
Exception.
"""
try:
json_data = request.get_json()
except ValueError as exception:
log.error(exception)
log.debug(f"{caller} result {exception} 400")
raise BadRequest(str(exception)) from BadRequest
except BadRequest:
result = "The request is not a valid JSON."
log.debug(f"{caller} result {result} 400")
raise BadRequest(result) from BadRequest
if json_data is None:
result = "Content-Type must be application/json"
log.debug(f"{caller} result {result} 415")
raise UnsupportedMediaType(result)
return json_data
