build.main.Main._get_topology() - Code Metrics - Inspection of "Fix coordinates problem (Fix kytos/#923)" - kytos/topology - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#73)

unknown

created 2019-07-17 15:07 UTC

build.main.Main._get_topology() A

↳ Parent: build.main

Complexity

Conditions

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	1.125

Importance

Changes

Metric	Value
eloc	2
dl	0
loc	3
ccs	1
cts	2
cp	0.5
rs	10
c	0
b	0
f	0
cc	1
nop	1
crap	1.125

"""Main module of kytos/topology Kytos Network Application.

Manage the network topology
"""
from flask import jsonify, request
from kytos.core import KytosEvent, KytosNApp, log, rest
from kytos.core.helpers import listen_to
from kytos.core.interface import Interface
from kytos.core.link import Link
from kytos.core.switch import Switch

# from napps.kytos.topology import settings
from napps.kytos.topology.models import Topology


class Main(KytosNApp):  # pylint: disable=too-many-public-methods
    """Main class of kytos/topology NApp.

    This class is the entry point for this napp.
    """

    def setup(self):
        """Initialize the NApp's links list."""
        self.links = {}
        self.store_items = {}

        self.verify_storehouse('switches')
        self.verify_storehouse('interfaces')
        self.verify_storehouse('links')

    def execute(self):
        """Do nothing."""

    def shutdown(self):
        """Do nothing."""
        log.info('NApp kytos/topology shutting down.')

    def _get_link_or_create(self, endpoint_a, endpoint_b):
        new_link = Link(endpoint_a, endpoint_b)

        for link in self.links.values():
            if new_link == link:
                return link

        self.links[new_link.id] = new_link
        return new_link

    def _get_switches_dict(self):
        """Return a dictionary with the known switches."""
        swi = {'switches': {s.id: s.as_dict() for s in
                            self.controller.switches.values()}}
        for idx, switch_id in enumerate(swi['switches']):
            if ('lat' in swi['switches'][switch_id]['metadata'] and
                    'lng' in swi['switches'][switch_id]['metadata']):
                continue
            # Values are constants so the switches are initialized in the ocean
            swi['switches'][switch_id]['metadata']['lat'] = str(0.0)
            swi['switches'][switch_id]['metadata']['lng'] = str(-30.0+idx*10.0)
        return swi

    def _get_links_dict(self):
        """Return a dictionary with the known links."""
        return {'links': {l.id: l.as_dict() for l in
                          self.links.values()}}

    def _get_topology_dict(self):
        """Return a dictionary with the known topology."""
        return {'topology': {**self._get_switches_dict(),
                             **self._get_links_dict()}}

    def _get_topology(self):
        """Return an object representing the topology."""
        return Topology(self.controller.switches, self.links)

    def _get_link_from_interface(self, interface):
        """Return the link of the interface, or None if it does not exist."""
        for link in self.links.values():
            if interface in (link.endpoint_a, link.endpoint_b):
                return link
        return None

    @rest('v3/')
    def get_topology(self):
        """Return the latest known topology.

        This topology is updated when there are network events.
        """
        return jsonify(self._get_topology_dict())

    # Switch related methods
    @rest('v3/switches')
    def get_switches(self):
        """Return a json with all the switches in the topology."""
        return jsonify(self._get_switches_dict())

    @rest('v3/switches/<dpid>/enable', methods=['POST'])
    def enable_switch(self, dpid):
        """Administratively enable a switch in the topology."""
        try:
            self.controller.switches[dpid].enable()
            return jsonify("Operation successful"), 201
        except KeyError:
            return jsonify("Switch not found"), 404

    @rest('v3/switches/<dpid>/disable', methods=['POST'])
    def disable_switch(self, dpid):
        """Administratively disable a switch in the topology."""
        try:
            self.controller.switches[dpid].disable()
            return jsonify("Operation successful"), 201
        except KeyError:
            return jsonify("Switch not found"), 404

    @rest('v3/switches/<dpid>/metadata')
    def get_switch_metadata(self, dpid):
        """Get metadata from a switch."""
        try:
            return jsonify({"metadata":
                            self.controller.switches[dpid].metadata}), 200
        except KeyError:
            return jsonify("Switch not found"), 404

    @rest('v3/switches/<dpid>/metadata', methods=['POST'])
    def add_switch_metadata(self, dpid):
        """Add metadata to a switch."""
        metadata = request.get_json()
        try:
            switch = self.controller.switches[dpid]
        except KeyError:
            return jsonify("Switch not found"), 404

        switch.extend_metadata(metadata)
        self.notify_metadata_changes(switch, 'added')
        return jsonify("Operation successful"), 201

    @rest('v3/switches/<dpid>/metadata/<key>', methods=['DELETE'])
    def delete_switch_metadata(self, dpid, key):
        """Delete metadata from a switch."""
        try:
            switch = self.controller.switches[dpid]
        except KeyError:
            return jsonify("Switch not found"), 404

        switch.remove_metadata(key)
        self.notify_metadata_changes(switch, 'removed')
        return jsonify("Operation successful"), 200

    # Interface related methods
    @rest('v3/interfaces')
    def get_interfaces(self):
        """Return a json with all the interfaces in the topology."""
        interfaces = {}
        switches = self._get_switches_dict()
        for switch in switches['switches'].values():
            for interface_id, interface in switch['interfaces'].items():
                interfaces[interface_id] = interface

        return jsonify({'interfaces': interfaces})

    @rest('v3/interfaces/<interface_id>/enable', methods=['POST'])

    def enable_interface(self, interface_id):
        """Administratively enable an interface in the topology."""
        switch_id = ":".join(interface_id.split(":")[:-1])
        interface_number = int(interface_id.split(":")[-1])

        try:
            switch = self.controller.switches[switch_id]
        except KeyError:
            return jsonify("Switch not found"), 404

        try:
            switch.interfaces[interface_number].enable()
        except KeyError:
            return jsonify("Interface not found"), 404

        return jsonify("Operation successful"), 201

    @rest('v3/interfaces/<interface_id>/disable', methods=['POST'])

    def disable_interface(self, interface_id):
        """Administratively disable an interface in the topology."""
        switch_id = ":".join(interface_id.split(":")[:-1])
        interface_number = int(interface_id.split(":")[-1])

        try:
            switch = self.controller.switches[switch_id]
        except KeyError:
            return jsonify("Switch not found"), 404

        try:
            switch.interfaces[interface_number].disable()
        except KeyError:
            return jsonify("Interface not found"), 404

        return jsonify("Operation successful"), 201

    @rest('v3/interfaces/<interface_id>/metadata')
    def get_interface_metadata(self, interface_id):
        """Get metadata from an interface."""
        switch_id = ":".join(interface_id.split(":")[:-1])
        interface_number = int(interface_id.split(":")[-1])
        try:
            switch = self.controller.switches[switch_id]
        except KeyError:
            return jsonify("Switch not found"), 404

        try:
            interface = switch.interfaces[interface_number]
        except KeyError:
            return jsonify("Interface not found"), 404

        return jsonify({"metadata": interface.metadata}), 200

    @rest('v3/interfaces/<interface_id>/metadata', methods=['POST'])
    def add_interface_metadata(self, interface_id):
        """Add metadata to an interface."""
        metadata = request.get_json()

        switch_id = ":".join(interface_id.split(":")[:-1])
        interface_number = int(interface_id.split(":")[-1])
        try:
            switch = self.controller.switches[switch_id]
        except KeyError:
            return jsonify("Switch not found"), 404

        try:
            interface = switch.interfaces[interface_number]
        except KeyError:
            return jsonify("Interface not found"), 404

        interface.extend_metadata(metadata)
        self.notify_metadata_changes(interface, 'added')
        return jsonify("Operation successful"), 201

    @rest('v3/interfaces/<interface_id>/metadata/<key>', methods=['DELETE'])
    def delete_interface_metadata(self, interface_id, key):
        """Delete metadata from an interface."""
        switch_id = ":".join(interface_id.split(":")[:-1])
        interface_number = int(interface_id.split(":")[-1])

        try:
            switch = self.controller.switches[switch_id]
        except KeyError:
            return jsonify("Switch not found"), 404

        try:
            interface = switch.interfaces[interface_number]
        except KeyError:
            return jsonify("Interface not found"), 404

        if interface.remove_metadata(key) is False:
            return jsonify("Metadata not found"), 404

        self.notify_metadata_changes(interface, 'removed')
        return jsonify("Operation successful"), 200

    # Link related methods
    @rest('v3/links')
    def get_links(self):
        """Return a json with all the links in the topology.

        Links are connections between interfaces.
        """
        return jsonify(self._get_links_dict()), 200

    @rest('v3/links/<link_id>/enable', methods=['POST'])
    def enable_link(self, link_id):
        """Administratively enable a link in the topology."""
        try:
            self.links[link_id].enable()
        except KeyError:
            return jsonify("Link not found"), 404

        return jsonify("Operation successful"), 201

    @rest('v3/links/<link_id>/disable', methods=['POST'])
    def disable_link(self, link_id):
        """Administratively disable a link in the topology."""
        try:
            self.links[link_id].disable()
        except KeyError:
            return jsonify("Link not found"), 404

        return jsonify("Operation successful"), 201

    @rest('v3/links/<link_id>/metadata')
    def get_link_metadata(self, link_id):
        """Get metadata from a link."""
        try:
            return jsonify({"metadata": self.links[link_id].metadata}), 200
        except KeyError:
            return jsonify("Link not found"), 404

    @rest('v3/links/<link_id>/metadata', methods=['POST'])
    def add_link_metadata(self, link_id):
        """Add metadata to a link."""
        metadata = request.get_json()
        try:
            link = self.links[link_id]
        except KeyError:
            return jsonify("Link not found"), 404

        link.extend_metadata(metadata)
        self.notify_metadata_changes(link, 'added')
        return jsonify("Operation successful"), 201

    @rest('v3/links/<link_id>/metadata/<key>', methods=['DELETE'])
    def delete_link_metadata(self, link_id, key):
        """Delete metadata from a link."""
        try:
            link = self.links[link_id]
        except KeyError:
            return jsonify("Link not found"), 404

        if link.remove_metadata(key) is False:
            return jsonify("Metadata not found"), 404

        self.notify_metadata_changes(link, 'removed')
        return jsonify("Operation successful"), 200

    @listen_to('.*.switch.(new|reconnected)')
    def handle_new_switch(self, event):
        """Create a new Device on the Topology.

        Handle the event of a new created switch and update the topology with
        this new device.
        """
        switch = event.content['switch']
        switch.activate()
        log.debug('Switch %s added to the Topology.', switch.id)
        self.notify_topology_update()
        self.update_instance_metadata(switch)

    @listen_to('.*.connection.lost')
    def handle_connection_lost(self, event):
        """Remove a Device from the topology.

        Remove the disconnected Device and every link that has one of its
        interfaces.
        """
        switch = event.content['source'].switch
        if switch:
            switch.deactivate()
            log.debug('Switch %s removed from the Topology.', switch.id)
            self.notify_topology_update()

    def handle_interface_up(self, event):
        """Update the topology based on a Port Modify event.

        The event notifies that an interface was changed to 'up'.
        """
        interface = event.content['interface']
        interface.activate()
        self.notify_topology_update()
        self.update_instance_metadata(interface)

    @listen_to('.*.switch.interface.created')
    def handle_interface_created(self, event):
        """Update the topology based on a Port Create event."""
        self.handle_interface_up(event)

    def handle_interface_down(self, event):
        """Update the topology based on a Port Modify event.

        The event notifies that an interface was changed to 'down'.
        """
        interface = event.content['interface']
        interface.deactivate()
        self.handle_interface_link_down(event)
        self.notify_topology_update()

    @listen_to('.*.switch.interface.deleted')
    def handle_interface_deleted(self, event):
        """Update the topology based on a Port Delete event."""
        self.handle_interface_down(event)

    @listen_to('.*.switch.interface.link_up')
    def handle_interface_link_up(self, event):
        """Update the topology based on a Port Modify event.

        The event notifies that an interface's link was changed to 'up'.
        """
        interface = event.content['interface']
        link = self._get_link_from_interface(interface)
        if link and not link.is_active():
            link.activate()
            self.notify_topology_update()
            self.update_instance_metadata(interface.link)
            self.notify_link_status_change(link)

    @listen_to('.*.switch.interface.link_down')
    def handle_interface_link_down(self, event):
        """Update the topology based on a Port Modify event.

        The event notifies that an interface's link was changed to 'down'.
        """
        interface = event.content['interface']
        link = self._get_link_from_interface(interface)
        if link and link.is_active():
            link.deactivate()
            self.notify_topology_update()
            self.notify_link_status_change(link)

    @listen_to('.*.interface.is.nni')
    def add_links(self, event):
        """Update the topology with links related to the NNI interfaces."""
        interface_a = event.content['interface_a']
        interface_b = event.content['interface_b']

        link = self._get_link_or_create(interface_a, interface_b)
        interface_a.update_link(link)
        interface_b.update_link(link)

        interface_a.nni = True
        interface_b.nni = True

        self.notify_topology_update()

    # def add_host(self, event):
    #    """Update the topology with a new Host."""

    #    interface = event.content['port']
    #    mac = event.content['reachable_mac']

    #    host = Host(mac)
    #    link = self.topology.get_link(interface.id)
    #    if link is not None:
    #        return

    #    self.topology.add_link(interface.id, host.id)
    #    self.topology.add_device(host)

    #    if settings.DISPLAY_FULL_DUPLEX_LINKS:
    #        self.topology.add_link(host.id, interface.id)

    def notify_topology_update(self):
        """Send an event to notify about updates on the topology."""
        name = 'kytos/topology.updated'
        event = KytosEvent(name=name, content={'topology':
                                               self._get_topology()})
        self.controller.buffers.app.put(event)

    def notify_link_status_change(self, link):
        """Send an event to notify about a status change on a link."""
        name = 'kytos/topology.'
        if link.is_active():
            status = 'link_up'
        else:
            status = 'link_down'
        event = KytosEvent(name=name+status, content={'link': link})
        self.controller.buffers.app.put(event)

    def notify_metadata_changes(self, obj, action):
        """Send an event to notify about metadata changes."""
        if isinstance(obj, Switch):
            entity = 'switch'
            entities = 'switches'
        elif isinstance(obj, Interface):
            entity = 'interface'
            entities = 'interfaces'
        elif isinstance(obj, Link):
            entity = 'link'
            entities = 'links'

        name = f'kytos/topology.{entities}.metadata.{action}'
        event = KytosEvent(name=name, content={entity: obj,

                                               'metadata': obj.metadata})
        self.controller.buffers.app.put(event)
        log.debug(f'Metadata from {obj.id} was {action}.')

    @listen_to('kytos/topology.*.metadata.*')
    def save_metadata_on_store(self, event):
        """Send to storehouse the data updated."""
        name = 'kytos.storehouse.update'
        if 'switch' in event.content:
            store = self.store_items.get('switches')
            obj = event.content.get('switch')
            namespace = 'kytos.topology.switches.metadata'
        elif 'interface' in event.content:
            store = self.store_items.get('interfaces')
            obj = event.content.get('interface')
            namespace = 'kytos.topology.iterfaces.metadata'
        elif 'link' in event.content:
            store = self.store_items.get('links')
            obj = event.content.get('link')
            namespace = 'kytos.topology.links.metadata'

        store.data[obj.id] = obj.metadata

        content = {'namespace': namespace,

                   'box_id': store.box_id,
                   'data': store.data,
                   'callback': self.update_instance}

        event = KytosEvent(name=name, content=content)
        self.controller.buffers.app.put(event)

    @staticmethod
    def update_instance(event, _data, error):
        """Display in Kytos console if the data was updated."""
        entities = event.content.get('namespace', '').split('.')[-2]
        if error:
            log.error(f'Error trying to update storehouse {entities}.')
        else:
            log.debug(f'Storehouse update to entities: {entities}.')

    def verify_storehouse(self, entities):
        """Request a list of box saved by specific entity."""
        name = 'kytos.storehouse.list'
        content = {'namespace': f'kytos.topology.{entities}.metadata',
                   'callback': self.request_retrieve_entities}
        event = KytosEvent(name=name, content=content)
        self.controller.buffers.app.put(event)
        log.info(f'verify data in storehouse for {entities}.')

    def request_retrieve_entities(self, event, data, _error):
        """Create a box or retrieve an existent box from storehouse."""
        msg = ''
        content = {'namespace': event.content.get('namespace'),
                   'callback': self.load_from_store,
                   'data': {}}

        if not data:
            name = 'kytos.storehouse.create'
            msg = 'Create new box in storehouse'
        else:
            name = 'kytos.storehouse.retrieve'
            content['box_id'] = data[0]
            msg = 'Retrieve data from storeohouse.'

        event = KytosEvent(name=name, content=content)
        self.controller.buffers.app.put(event)
        log.debug(msg)

    def load_from_store(self, event, box, error):
        """Save the data retrived from storehouse."""
        entities = event.content.get('namespace', '').split('.')[-2]
        if error:
            log.error('Error while get a box from storehouse.')
        else:
            self.store_items[entities] = box
            log.debug('Data updated')

    def update_instance_metadata(self, obj):
        """Update object instance with saved metadata."""
        metadata = None
        if isinstance(obj, Interface):
            all_metadata = self.store_items.get('interfaces', None)
            if all_metadata:
                metadata = all_metadata.data.get(obj.id)
        elif isinstance(obj, Switch):
            all_metadata = self.store_items.get('switches', None)
            if all_metadata:
                metadata = all_metadata.data.get(obj.id)
        elif isinstance(obj, Link):
            all_metadata = self.store_items.get('links', None)
            if all_metadata:
                metadata = all_metadata.data.get(obj.id)

        if metadata:
            obj.extend_metadata(metadata)
            log.debug(f'Metadata to {obj.id} was updated')


1			"""Main module of kytos/topology Kytos Network Application.
2
3			Manage the network topology
4			"""
5	1		from flask import jsonify, request
6	1		from kytos.core import KytosEvent, KytosNApp, log, rest
7	1		from kytos.core.helpers import listen_to
8	1		from kytos.core.interface import Interface
9	1		from kytos.core.link import Link
10	1		from kytos.core.switch import Switch
11
12			# from napps.kytos.topology import settings
13	1		from napps.kytos.topology.models import Topology
14
15
16	1		class Main(KytosNApp): # pylint: disable=too-many-public-methods
17			"""Main class of kytos/topology NApp.
18
19			This class is the entry point for this napp.
20			"""
21
22	1		def setup(self):
23			"""Initialize the NApp's links list."""
24	1		self.links = {}
25	1		self.store_items = {}
26
27	1		self.verify_storehouse('switches')
28	1		self.verify_storehouse('interfaces')
29	1		self.verify_storehouse('links')
30
31	1		def execute(self):
32			"""Do nothing."""
33
34	1		def shutdown(self):
35			"""Do nothing."""
36			log.info('NApp kytos/topology shutting down.')
37
38	1		def _get_link_or_create(self, endpoint_a, endpoint_b):
39			new_link = Link(endpoint_a, endpoint_b)
40
41			for link in self.links.values():
42			if new_link == link:
43			return link
44
45			self.links[new_link.id] = new_link
46			return new_link
47
48	1		def _get_switches_dict(self):
49			"""Return a dictionary with the known switches."""
50			swi = {'switches': {s.id: s.as_dict() for s in
51			self.controller.switches.values()}}
52			for idx, switch_id in enumerate(swi['switches']):
53			if ('lat' in swi['switches'][switch_id]['metadata'] and
54			'lng' in swi['switches'][switch_id]['metadata']):
55			continue
56			# Values are constants so the switches are initialized in the ocean
57			swi['switches'][switch_id]['metadata']['lat'] = str(0.0)
58			swi['switches'][switch_id]['metadata']['lng'] = str(-30.0+idx*10.0)
59			return swi
60
61	1		def _get_links_dict(self):
62			"""Return a dictionary with the known links."""
63			return {'links': {l.id: l.as_dict() for l in
64			self.links.values()}}
65
66	1		def _get_topology_dict(self):
67			"""Return a dictionary with the known topology."""
68			return {'topology': {**self._get_switches_dict(),
69			**self._get_links_dict()}}
70
71	1		def _get_topology(self):
72			"""Return an object representing the topology."""
73			return Topology(self.controller.switches, self.links)
74
75	1		def _get_link_from_interface(self, interface):
76			"""Return the link of the interface, or None if it does not exist."""
77			for link in self.links.values():
78			if interface in (link.endpoint_a, link.endpoint_b):
79			return link
80			return None
81
82	1		@rest('v3/')
83			def get_topology(self):
84			"""Return the latest known topology.
85
86			This topology is updated when there are network events.
87			"""
88			return jsonify(self._get_topology_dict())
89
90			# Switch related methods
91	1		@rest('v3/switches')
92			def get_switches(self):
93			"""Return a json with all the switches in the topology."""
94			return jsonify(self._get_switches_dict())
95
96	1		@rest('v3/switches/<dpid>/enable', methods=['POST'])
97			def enable_switch(self, dpid):
98			"""Administratively enable a switch in the topology."""
99			try:
100			self.controller.switches[dpid].enable()
101			return jsonify("Operation successful"), 201
102			except KeyError:
103			return jsonify("Switch not found"), 404
104
105	1		@rest('v3/switches/<dpid>/disable', methods=['POST'])
106			def disable_switch(self, dpid):
107			"""Administratively disable a switch in the topology."""
108			try:
109			self.controller.switches[dpid].disable()
110			return jsonify("Operation successful"), 201
111			except KeyError:
112			return jsonify("Switch not found"), 404
113
114	1		@rest('v3/switches/<dpid>/metadata')
115			def get_switch_metadata(self, dpid):
116			"""Get metadata from a switch."""
117			try:
118			return jsonify({"metadata":
119			self.controller.switches[dpid].metadata}), 200
120			except KeyError:
121			return jsonify("Switch not found"), 404
122
123	1		@rest('v3/switches/<dpid>/metadata', methods=['POST'])
124			def add_switch_metadata(self, dpid):
125			"""Add metadata to a switch."""
126			metadata = request.get_json()
127			try:
128			switch = self.controller.switches[dpid]
129			except KeyError:
130			return jsonify("Switch not found"), 404
131
132			switch.extend_metadata(metadata)
133			self.notify_metadata_changes(switch, 'added')
134			return jsonify("Operation successful"), 201
135
136	1		@rest('v3/switches/<dpid>/metadata/<key>', methods=['DELETE'])
137			def delete_switch_metadata(self, dpid, key):
138			"""Delete metadata from a switch."""
139			try:
140			switch = self.controller.switches[dpid]
141			except KeyError:
142			return jsonify("Switch not found"), 404
143
144			switch.remove_metadata(key)
145			self.notify_metadata_changes(switch, 'removed')
146			return jsonify("Operation successful"), 200
147
148			# Interface related methods
149	1		@rest('v3/interfaces')
150			def get_interfaces(self):
151			"""Return a json with all the interfaces in the topology."""
152			interfaces = {}
153			switches = self._get_switches_dict()
154			for switch in switches['switches'].values():
155			for interface_id, interface in switch['interfaces'].items():
156			interfaces[interface_id] = interface
157
158			return jsonify({'interfaces': interfaces})
159
160	1	View Code Duplication	@rest('v3/interfaces/<interface_id>/enable', methods=['POST'])
			0 ignored issues – show Duplication introduced 2019-02-27 14:03 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
161			def enable_interface(self, interface_id):
162			"""Administratively enable an interface in the topology."""
163			switch_id = ":".join(interface_id.split(":")[:-1])
164			interface_number = int(interface_id.split(":")[-1])
165
166			try:
167			switch = self.controller.switches[switch_id]
168			except KeyError:
169			return jsonify("Switch not found"), 404
170
171			try:
172			switch.interfaces[interface_number].enable()
173			except KeyError:
174			return jsonify("Interface not found"), 404
175
176			return jsonify("Operation successful"), 201
177
178	1	View Code Duplication	@rest('v3/interfaces/<interface_id>/disable', methods=['POST'])
			0 ignored issues – show Duplication introduced 2019-02-27 14:03 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
179			def disable_interface(self, interface_id):
180			"""Administratively disable an interface in the topology."""
181			switch_id = ":".join(interface_id.split(":")[:-1])
182			interface_number = int(interface_id.split(":")[-1])
183
184			try:
185			switch = self.controller.switches[switch_id]
186			except KeyError:
187			return jsonify("Switch not found"), 404
188
189			try:
190			switch.interfaces[interface_number].disable()
191			except KeyError:
192			return jsonify("Interface not found"), 404
193
194			return jsonify("Operation successful"), 201
195
196	1		@rest('v3/interfaces/<interface_id>/metadata')
197			def get_interface_metadata(self, interface_id):
198			"""Get metadata from an interface."""
199			switch_id = ":".join(interface_id.split(":")[:-1])
200			interface_number = int(interface_id.split(":")[-1])
201			try:
202			switch = self.controller.switches[switch_id]
203			except KeyError:
204			return jsonify("Switch not found"), 404
205
206			try:
207			interface = switch.interfaces[interface_number]
208			except KeyError:
209			return jsonify("Interface not found"), 404
210
211			return jsonify({"metadata": interface.metadata}), 200
212
213	1		@rest('v3/interfaces/<interface_id>/metadata', methods=['POST'])
214			def add_interface_metadata(self, interface_id):
215			"""Add metadata to an interface."""
216			metadata = request.get_json()
217
218			switch_id = ":".join(interface_id.split(":")[:-1])
219			interface_number = int(interface_id.split(":")[-1])
220			try:
221			switch = self.controller.switches[switch_id]
222			except KeyError:
223			return jsonify("Switch not found"), 404
224
225			try:
226			interface = switch.interfaces[interface_number]
227			except KeyError:
228			return jsonify("Interface not found"), 404
229
230			interface.extend_metadata(metadata)
231			self.notify_metadata_changes(interface, 'added')
232			return jsonify("Operation successful"), 201
233
234	1		@rest('v3/interfaces/<interface_id>/metadata/<key>', methods=['DELETE'])
235			def delete_interface_metadata(self, interface_id, key):
236			"""Delete metadata from an interface."""
237			switch_id = ":".join(interface_id.split(":")[:-1])
238			interface_number = int(interface_id.split(":")[-1])
239
240			try:
241			switch = self.controller.switches[switch_id]
242			except KeyError:
243			return jsonify("Switch not found"), 404
244
245			try:
246			interface = switch.interfaces[interface_number]
247			except KeyError:
248			return jsonify("Interface not found"), 404
249
250			if interface.remove_metadata(key) is False:
251			return jsonify("Metadata not found"), 404
252
253			self.notify_metadata_changes(interface, 'removed')
254			return jsonify("Operation successful"), 200
255
256			# Link related methods
257	1		@rest('v3/links')
258			def get_links(self):
259			"""Return a json with all the links in the topology.
260
261			Links are connections between interfaces.
262			"""
263			return jsonify(self._get_links_dict()), 200
264
265	1		@rest('v3/links/<link_id>/enable', methods=['POST'])
266			def enable_link(self, link_id):
267			"""Administratively enable a link in the topology."""
268			try:
269			self.links[link_id].enable()
270			except KeyError:
271			return jsonify("Link not found"), 404
272
273			return jsonify("Operation successful"), 201
274
275	1		@rest('v3/links/<link_id>/disable', methods=['POST'])
276			def disable_link(self, link_id):
277			"""Administratively disable a link in the topology."""
278			try:
279			self.links[link_id].disable()
280			except KeyError:
281			return jsonify("Link not found"), 404
282
283			return jsonify("Operation successful"), 201
284
285	1		@rest('v3/links/<link_id>/metadata')
286			def get_link_metadata(self, link_id):
287			"""Get metadata from a link."""
288			try:
289			return jsonify({"metadata": self.links[link_id].metadata}), 200
290			except KeyError:
291			return jsonify("Link not found"), 404
292
293	1		@rest('v3/links/<link_id>/metadata', methods=['POST'])
294			def add_link_metadata(self, link_id):
295			"""Add metadata to a link."""
296			metadata = request.get_json()
297			try:
298			link = self.links[link_id]
299			except KeyError:
300			return jsonify("Link not found"), 404
301
302			link.extend_metadata(metadata)
303			self.notify_metadata_changes(link, 'added')
304			return jsonify("Operation successful"), 201
305
306	1		@rest('v3/links/<link_id>/metadata/<key>', methods=['DELETE'])
307			def delete_link_metadata(self, link_id, key):
308			"""Delete metadata from a link."""
309			try:
310			link = self.links[link_id]
311			except KeyError:
312			return jsonify("Link not found"), 404
313
314			if link.remove_metadata(key) is False:
315			return jsonify("Metadata not found"), 404
316
317			self.notify_metadata_changes(link, 'removed')
318			return jsonify("Operation successful"), 200
319
320	1		@listen_to('.*.switch.(new\|reconnected)')
321			def handle_new_switch(self, event):
322			"""Create a new Device on the Topology.
323
324			Handle the event of a new created switch and update the topology with
325			this new device.
326			"""
327			switch = event.content['switch']
328			switch.activate()
329			log.debug('Switch %s added to the Topology.', switch.id)
330			self.notify_topology_update()
331			self.update_instance_metadata(switch)
332
333	1		@listen_to('.*.connection.lost')
334			def handle_connection_lost(self, event):
335			"""Remove a Device from the topology.
336
337			Remove the disconnected Device and every link that has one of its
338			interfaces.
339			"""
340			switch = event.content['source'].switch
341			if switch:
342			switch.deactivate()
343			log.debug('Switch %s removed from the Topology.', switch.id)
344			self.notify_topology_update()
345
346	1		def handle_interface_up(self, event):
347			"""Update the topology based on a Port Modify event.
348
349			The event notifies that an interface was changed to 'up'.
350			"""
351			interface = event.content['interface']
352			interface.activate()
353			self.notify_topology_update()
354			self.update_instance_metadata(interface)
355
356	1		@listen_to('.*.switch.interface.created')
357			def handle_interface_created(self, event):
358			"""Update the topology based on a Port Create event."""
359			self.handle_interface_up(event)
360
361	1		def handle_interface_down(self, event):
362			"""Update the topology based on a Port Modify event.
363
364			The event notifies that an interface was changed to 'down'.
365			"""
366			interface = event.content['interface']
367			interface.deactivate()
368			self.handle_interface_link_down(event)
369			self.notify_topology_update()
370
371	1		@listen_to('.*.switch.interface.deleted')
372			def handle_interface_deleted(self, event):
373			"""Update the topology based on a Port Delete event."""
374			self.handle_interface_down(event)
375
376	1		@listen_to('.*.switch.interface.link_up')
377			def handle_interface_link_up(self, event):
378			"""Update the topology based on a Port Modify event.
379
380			The event notifies that an interface's link was changed to 'up'.
381			"""
382			interface = event.content['interface']
383			link = self._get_link_from_interface(interface)
384			if link and not link.is_active():
385			link.activate()
386			self.notify_topology_update()
387			self.update_instance_metadata(interface.link)
388			self.notify_link_status_change(link)
389
390	1		@listen_to('.*.switch.interface.link_down')
391			def handle_interface_link_down(self, event):
392			"""Update the topology based on a Port Modify event.
393
394			The event notifies that an interface's link was changed to 'down'.
395			"""
396			interface = event.content['interface']
397			link = self._get_link_from_interface(interface)
398			if link and link.is_active():
399			link.deactivate()
400			self.notify_topology_update()
401			self.notify_link_status_change(link)
402
403	1		@listen_to('.*.interface.is.nni')
404			def add_links(self, event):
405			"""Update the topology with links related to the NNI interfaces."""
406			interface_a = event.content['interface_a']
407			interface_b = event.content['interface_b']
408
409			link = self._get_link_or_create(interface_a, interface_b)
410			interface_a.update_link(link)
411			interface_b.update_link(link)
412
413			interface_a.nni = True
414			interface_b.nni = True
415
416			self.notify_topology_update()
417
418			# def add_host(self, event):
419			# """Update the topology with a new Host."""
420
421			# interface = event.content['port']
422			# mac = event.content['reachable_mac']
423
424			# host = Host(mac)
425			# link = self.topology.get_link(interface.id)
426			# if link is not None:
427			# return
428
429			# self.topology.add_link(interface.id, host.id)
430			# self.topology.add_device(host)
431
432			# if settings.DISPLAY_FULL_DUPLEX_LINKS:
433			# self.topology.add_link(host.id, interface.id)
434
435	1		def notify_topology_update(self):
436			"""Send an event to notify about updates on the topology."""
437			name = 'kytos/topology.updated'
438			event = KytosEvent(name=name, content={'topology':
439			self._get_topology()})
440			self.controller.buffers.app.put(event)
441
442	1		def notify_link_status_change(self, link):
443			"""Send an event to notify about a status change on a link."""
444			name = 'kytos/topology.'
445			if link.is_active():
446			status = 'link_up'
447			else:
448			status = 'link_down'
449			event = KytosEvent(name=name+status, content={'link': link})
450			self.controller.buffers.app.put(event)
451
452	1		def notify_metadata_changes(self, obj, action):
453			"""Send an event to notify about metadata changes."""
454			if isinstance(obj, Switch):
455			entity = 'switch'
456			entities = 'switches'
457			elif isinstance(obj, Interface):
458			entity = 'interface'
459			entities = 'interfaces'
460			elif isinstance(obj, Link):
461			entity = 'link'
462			entities = 'links'
463
464			name = f'kytos/topology.{entities}.metadata.{action}'
465			event = KytosEvent(name=name, content={entity: obj,
			0 ignored issues – show introduced 2019-02-27 14:03 UTC by Report Bug Copy Issue Report The variable `entity` does not seem to be defined for all execution paths. Loading history...
466			'metadata': obj.metadata})
467			self.controller.buffers.app.put(event)
468			log.debug(f'Metadata from {obj.id} was {action}.')
469
470	1		@listen_to('kytos/topology..metadata.')
471			def save_metadata_on_store(self, event):
472			"""Send to storehouse the data updated."""
473			name = 'kytos.storehouse.update'
474			if 'switch' in event.content:
475			store = self.store_items.get('switches')
476			obj = event.content.get('switch')
477			namespace = 'kytos.topology.switches.metadata'
478			elif 'interface' in event.content:
479			store = self.store_items.get('interfaces')
480			obj = event.content.get('interface')
481			namespace = 'kytos.topology.iterfaces.metadata'
482			elif 'link' in event.content:
483			store = self.store_items.get('links')
484			obj = event.content.get('link')
485			namespace = 'kytos.topology.links.metadata'
486
487			store.data[obj.id] = obj.metadata
			0 ignored issues – show introduced 2019-02-27 14:03 UTC by Report Bug Copy Issue Report The variable `store` does not seem to be defined for all execution paths. Loading history... introduced 2019-02-27 14:03 UTC by Report Bug Copy Issue Report The variable `obj` does not seem to be defined for all execution paths. Loading history...
488			content = {'namespace': namespace,
			0 ignored issues – show introduced 2019-02-27 14:03 UTC by Report Bug Copy Issue Report The variable `namespace` does not seem to be defined for all execution paths. Loading history...
489			'box_id': store.box_id,
490			'data': store.data,
491			'callback': self.update_instance}
492
493			event = KytosEvent(name=name, content=content)
494			self.controller.buffers.app.put(event)
495
496	1		@staticmethod
497			def update_instance(event, _data, error):
498			"""Display in Kytos console if the data was updated."""
499			entities = event.content.get('namespace', '').split('.')[-2]
500			if error:
501			log.error(f'Error trying to update storehouse {entities}.')
502			else:
503			log.debug(f'Storehouse update to entities: {entities}.')
504
505	1		def verify_storehouse(self, entities):
506			"""Request a list of box saved by specific entity."""
507	1		name = 'kytos.storehouse.list'
508	1		content = {'namespace': f'kytos.topology.{entities}.metadata',
509			'callback': self.request_retrieve_entities}
510	1		event = KytosEvent(name=name, content=content)
511	1		self.controller.buffers.app.put(event)
512	1		log.info(f'verify data in storehouse for {entities}.')
513
514	1		def request_retrieve_entities(self, event, data, _error):
515			"""Create a box or retrieve an existent box from storehouse."""
516			msg = ''
517			content = {'namespace': event.content.get('namespace'),
518			'callback': self.load_from_store,
519			'data': {}}
520
521			if not data:
522			name = 'kytos.storehouse.create'
523			msg = 'Create new box in storehouse'
524			else:
525			name = 'kytos.storehouse.retrieve'
526			content['box_id'] = data[0]
527			msg = 'Retrieve data from storeohouse.'
528
529			event = KytosEvent(name=name, content=content)
530			self.controller.buffers.app.put(event)
531			log.debug(msg)
532
533	1		def load_from_store(self, event, box, error):
534			"""Save the data retrived from storehouse."""
535			entities = event.content.get('namespace', '').split('.')[-2]
536			if error:
537			log.error('Error while get a box from storehouse.')
538			else:
539			self.store_items[entities] = box
540			log.debug('Data updated')
541
542	1		def update_instance_metadata(self, obj):
543			"""Update object instance with saved metadata."""
544			metadata = None
545			if isinstance(obj, Interface):
546			all_metadata = self.store_items.get('interfaces', None)
547			if all_metadata:
548			metadata = all_metadata.data.get(obj.id)
549			elif isinstance(obj, Switch):
550			all_metadata = self.store_items.get('switches', None)
551			if all_metadata:
552			metadata = all_metadata.data.get(obj.id)
553			elif isinstance(obj, Link):
554			all_metadata = self.store_items.get('links', None)
555			if all_metadata:
556			metadata = all_metadata.data.get(obj.id)
557
558			if metadata:
559			obj.extend_metadata(metadata)
560			log.debug(f'Metadata to {obj.id} was updated')
561

kytos / topology

Pull Request — master (#73)

build.main.Main._get_topology() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like