src/emuvim/api/openstack/chain_api.py

"""
Copyright (c) 2017 SONATA-NFV and Paderborn University
ALL RIGHTS RESERVED.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Neither the name of the SONATA-NFV, Paderborn University
nor the names of its contributors may be used to endorse or promote
products derived from this software without specific prior written
permission.

This work has been performed in the framework of the SONATA project,
funded by the European Commission under Grant number 671517 through
the Horizon 2020 and 5G-PPP programmes. The authors would like to
acknowledge the contributions of their colleagues of the SONATA
partner consortium (www.sonata-nfv.eu).
"""
import json
import logging
import copy

from mininet.node import OVSSwitch

from flask import Flask
from flask import Response, request
from flask_restful import Api, Resource
from mininet.link import Link
import uuid


class ChainApi(Resource):
    """
    The chain API is a component that is not used in OpenStack.
    It is a custom built REST API that can be used to create network chains and loadbalancers.
    """

    def __init__(self, inc_ip, inc_port, manage):
        # setup Flask
        self.app = Flask(__name__)
        self.api = Api(self.app)
        self.ip = inc_ip
        self.port = inc_port
        self.manage = manage
        self.playbook_file = '/tmp/son-emu-requests.log'
        self.api.add_resource(ChainVersionsList, "/",
                              resource_class_kwargs={'api': self})
        self.api.add_resource(ChainList, "/v1/chain/list",
                              resource_class_kwargs={'api': self})
        self.api.add_resource(ChainVnfInterfaces, "/v1/chain/<src_vnf>/<src_intfs>/<dst_vnf>/<dst_intfs>",
                              resource_class_kwargs={'api': self})
        self.api.add_resource(ChainVnfDcStackInterfaces,
                              "/v1/chain/<src_dc>/<src_stack>/<src_vnf>/<src_intfs>/<dst_dc>/<dst_stack>/<dst_vnf>/<dst_intfs>",
                              resource_class_kwargs={'api': self})
        self.api.add_resource(BalanceHostList, "/v1/lb/list",
                              resource_class_kwargs={'api': self})
        self.api.add_resource(BalanceHost, "/v1/lb/<vnf_src_name>/<vnf_src_interface>",
                              resource_class_kwargs={'api': self})
        self.api.add_resource(BalanceHostDcStack, "/v1/lb/<src_dc>/<src_stack>/<vnf_src_name>/<vnf_src_interface>",
                              resource_class_kwargs={'api': self})
        self.api.add_resource(QueryTopology, "/v1/topo",
                              resource_class_kwargs={'api': self})
        self.api.add_resource(Shutdown, "/shutdown")

        @self.app.after_request
        def add_access_control_header(response):
            response.headers['Access-Control-Allow-Origin'] = '*'
            return response

    def _start_flask(self):
        logging.info("Starting %s endpoint @ http://%s:%d" % ("ChainDummyApi", self.ip, self.port))
        if self.app is not None:
            self.app.before_request(self.dump_playbook)
            self.app.run(self.ip, self.port, debug=True, use_reloader=False)

    def dump_playbook(self):
        with self.manage.lock:
            with open(self.playbook_file, 'a') as logfile:
                if len(request.data) > 0:
                    data = "# CHAIN API\n"
                    data += "curl -X {type} -H \"Content-type: application/json\" -d '{data}' {url}".format(type=request.method,
                                                                                            data=request.data,
                                                                                            url=request.url)
                    logfile.write(data + "\n")


class Shutdown(Resource):
    def get(self):
        logging.debug(("%s is beeing shut down") % (__name__))
        func = request.environ.get('werkzeug.server.shutdown')
        if func is None:
            raise RuntimeError('Not running with the Werkzeug Server')
        func()


class ChainVersionsList(Resource):
    '''
    Entrypoint to find versions of the chain api.
    '''

    def __init__(self, api):
        self.api = api

    def get(self):
        '''
        :return: flask.Response containing the openstack like description of the chain api
        '''
        # at least let it look like an open stack function
        try:
            resp = """
                {
                    "versions": [
                        {
                            "id": "v1",
                            "links": [
                                {
                                    "href": "http://%s:%d/v1/",
                                    "rel": "self"
                                }
                            ],
                            "status": "CURRENT",
                            "version": "1",
                            "min_version": "1",
                            "updated": "2013-07-23T11:33:21Z"
                        }
                    ]
                }
            """ % (self.api.ip, self.api.port)

            return Response(resp, status=200, mimetype="application/json")

        except Exception as ex:
            logging.exception(u"%s: Could not show list of versions." % __name__)
            return ex.message, 500


class ChainList(Resource):
    '''
    Will retrieve all chains including their paths.
    '''

    def __init__(self, api):
        self.api = api

    def get(self):
        '''
        :return: flask.Response containing all live chains
        '''
        # at least let it look like an open stack function
        try:
            resp = {"chains": list()}

            for chain in self.api.manage.full_chain_data.values():
                resp["chains"].append(chain)

            return Response(json.dumps(resp), status=200, mimetype="application/json")

        except Exception as ex:
            logging.exception(u"%s: Could not list all network chains." % __name__)
            return ex.message, 500


class BalanceHostList(Resource):
    '''
    Will retrieve all loadbalance rules including their paths.
    '''

    def __init__(self, api):
        self.api = api

    def get(self):
        '''
        :return: flask.Response containing all live loadbalancer rules
        '''
        # at least let it look like an open stack function
        try:
            resp = {"loadbalancers": list()}

            for lb in self.api.manage.full_lb_data.values():
                resp["loadbalancers"].append(lb)

            return Response(json.dumps(resp), status=200, mimetype="application/json")

        except Exception as ex:
            logging.exception(u"%s: Could not list all live loadbalancers." % __name__)
            return ex.message, 500


class ChainVnfInterfaces(Resource):
    """
    Handles requests targeted at: "/v1/chain/<src_vnf>/<src_intfs>/<dst_vnf>/<dst_intfs>"
    Requests are for tearing down or setting up a chain between two vnfs
    """

    def __init__(self, api):
        self.api = api

    def put(self, src_vnf, src_intfs, dst_vnf, dst_intfs):
        """
        A put request to "/v1/chain/<src_vnf>/<src_intfs>/<dst_vnf>/<dst_intfs>"
        will create a chain between two interfaces at the specified vnfs.

        Note:
           Does not allow a custom path. Uses ``.post``
           Internally just makes a POST request with no POST data!

        :param src_vnf: Name of the source VNF
        :type src_vnf: ``str``
        :param src_intfs: Name of the source VNF interface to chain on
        :type src_intfs: ``str``
        :param dst_vnf: Name of the destination VNF
        :type dst_vnf: ``str``
        :param dst_intfs: Name of the destination VNF interface to chain on
        :type dst_intfs: ``str``
        :return: flask.Response 200 if set up correctly else 500 also returns the cookie as dict {'cookie': value}
         501 if one of the VNF / intfs does not exist
        :rtype: :class:`flask.Response`
        """
        return self.post(src_vnf, src_intfs, dst_vnf, dst_intfs)

    def post(self, src_vnf, src_intfs, dst_vnf, dst_intfs):
        """
         A post request to "/v1/chain/<src_vnf>/<src_intfs>/<dst_vnf>/<dst_intfs>"
         will create a chain between two interfaces at the specified vnfs.
         The POST data contains the path like this.
         { "path": ["dc1.s1", "s1", "dc4.s1"]}
         path specifies the destination vnf and interface and contains a list of switches
         that the path traverses. The path may not contain single hop loops like:
         [s1, s2, s1].
         This is a limitation of Ryu, as Ryu does not allow the `INPUT_PORT` action!

        :param src_vnf: Name of the source VNF
        :type src_vnf: ``str``
        :param src_intfs: Name of the source VNF interface to chain on
        :type src_intfs: ``str``
        :param dst_vnf: Name of the destination VNF
        :type dst_vnf: ``str``
        :param dst_intfs: Name of the destination VNF interface to chain on
        :type dst_intfs: ``str``
        :return: flask.Response 200 if set up correctly else 500 also returns the cookie as dict {'cookie': value}
         501 if one of the VNF / intfs does not exist
        :rtype: :class:`flask.Response`

        """

        if request.is_json:
            path = request.json.get('path')
            layer2 = request.json.get('layer2', True)
        else:
            path = None
            layer2 = True

        # check if both VNFs exist
        if not self.api.manage.check_vnf_intf_pair(src_vnf, src_intfs):
            return Response(u"VNF %s or intfs %s does not exist" % (src_vnf, src_intfs), status=501,
                            mimetype="application/json")
        if not self.api.manage.check_vnf_intf_pair(dst_vnf, dst_intfs):
            return Response(u"VNF %s or intfs %s does not exist" % (dst_vnf, dst_intfs), status=501,
                            mimetype="application/json")
        try:
            cookie = self.api.manage.network_action_start(src_vnf, dst_vnf, vnf_src_interface=src_intfs,
                                                          vnf_dst_interface=dst_intfs, bidirectional=True,
                                                          path=path, layer2=layer2)
            resp = {'cookie': cookie}
            return Response(json.dumps(resp), status=200, mimetype="application/json")

        except Exception as e:
            logging.exception(u"%s: Error setting up the chain.\n %s" % (__name__, e))
            return Response(u"Error setting up the chain", status=500, mimetype="application/json")

    def delete(self, src_vnf, src_intfs, dst_vnf, dst_intfs):
        """
        A DELETE request to "/v1/chain/<src_vnf>/<src_intfs>/<dst_vnf>/<dst_intfs>"
        will delete a previously created chain.

        :param src_vnf: Name of the source VNF
        :type src_vnf: ``str``
        :param src_intfs: Name of the source VNF interface to chain on
        :type src_intfs: ``str``
        :param dst_vnf: Name of the destination VNF
        :type dst_vnf: ``str``
        :param dst_intfs: Name of the destination VNF interface to chain on
        :type dst_intfs: ``str``
        :return: flask.Response 200 if set up correctly else 500\
         also returns the cookie as dict {'cookie': value}
         501 if one of the VNF / intfs does not exist
        :rtype: :class:`flask.Response`

        """
        # check if both VNFs exist
        # check if both VNFs exist
        if not self.api.manage.check_vnf_intf_pair(src_vnf, src_intfs):
            return Response(u"VNF %s or intfs %s does not exist" % (src_vnf, src_intfs), status=501,
                            mimetype="application/json")
        if not self.api.manage.check_vnf_intf_pair(dst_vnf, dst_intfs):
            return Response(u"VNF %s or intfs %s does not exist" % (dst_vnf, dst_intfs), status=501,
                            mimetype="application/json")
        try:
            cookie = self.api.manage.network_action_stop(src_vnf, dst_vnf, vnf_src_interface=src_intfs,
                                                         vnf_dst_interface=dst_intfs, bidirectional=True)
            return Response(json.dumps(cookie), status=200, mimetype="application/json")
        except Exception as e:
            logging.exception(u"%s: Error deleting the chain.\n %s" % (__name__, e))
            return Response(u"Error deleting the chain", status=500, mimetype="application/json")


class ChainVnfDcStackInterfaces(Resource):
    '''
    Handles requests targeted at: "/v1/chain/<src_dc>/<src_stack>/<src_vnf>/<src_intfs>/<dst_dc>/<dst_stack>/<dst_vnf>/<dst_intfs>"
    Handles tearing down or setting up a chain between two vnfs for stacks.
    '''

    def __init__(self, api):
        self.api = api

    def put(self, src_dc, src_stack, src_vnf, src_intfs, dst_dc, dst_stack, dst_vnf, dst_intfs):
        """
        A PUT request to "/v1/chain/<src_dc>/<src_stack>/<src_vnf>/<src_intfs>/<dst_dc>/<dst_stack>/<dst_vnf>/<dst_intfs>"
        will set up chain.

        :Note: PUT Requests can not set up custom paths!

        :param src_dc: Name of the source datacenter
        :type src_dc: `str`
        :param src_stack: Name of the source stack
        :type src_stack: `str`
        :param src_vnf: Name of the source VNF
        :type src_vnf: ``str``
        :param src_intfs: Name of the source VNF interface to chain on
        :type src_intfs: ``str``
        :param dst_dc: Name of the destination datacenter
        :type dst_dc: ``str``
        :param dst_stack: Name of the destination stack
        :type dst_stack: ``str``
        :param dst_vnf: Name of the destination VNF
        :type dst_vnf: ``str``
        :param dst_intfs: Name of the destination VNF interface to chain on
        :type dst_intfs: ``str``
        :return: flask.Response 200 if set up correctly else 500\
         also returns the cookie as dict {'cookie': value}
         501 if VNF or intfs does not exist
        :rtype: :class:`flask.Response`

        """
        # search for real names
        real_names = self._findNames(src_dc, src_stack, src_vnf, src_intfs, dst_dc, dst_stack, dst_vnf, dst_intfs)
        if type(real_names) is not tuple:
            # something went wrong
            return real_names

        container_src, container_dst, interface_src, interface_dst = real_names

        # check if both VNFs exist
        if not self.api.manage.check_vnf_intf_pair(container_src, interface_src):
            return Response(u"VNF %s or intfs %s does not exist" % (container_src, interface_src), status=501,
                            mimetype="application/json")
        if not self.api.manage.check_vnf_intf_pair(container_dst, interface_dst):
            return Response(u"VNF %s or intfs %s does not exist" % (container_dst, interface_dst), status=501,
                            mimetype="application/json")

        try:
            cookie = self.api.manage.network_action_start(container_src, container_dst, vnf_src_interface=interface_src,
                                                          vnf_dst_interface=interface_dst, bidirectional=True,
                                                          layer2=True)
            resp = {'cookie': cookie}
            return Response(json.dumps(resp), status=200, mimetype="application/json")

        except Exception as e:
            logging.exception(u"%s: Error setting up the chain.\n %s" % (__name__, e))
            return Response(u"Error setting up the chain", status=500, mimetype="application/json")

    def post(self, src_dc, src_stack, src_vnf, src_intfs, dst_dc, dst_stack, dst_vnf, dst_intfs):
        """
         A post request to "/v1/chain/<src_dc>/<src_stack>/<src_vnf>/<src_intfs>/<dst_dc>/<dst_stack>/<dst_vnf>/<dst_intfs>"
         will create a chain between two interfaces at the specified vnfs.
         The POST data contains the path like this.
         { "path": ["dc1.s1", "s1", "dc4.s1"]}
         path specifies the destination vnf and interface and contains a list of switches
         that the path traverses. The path may not contain single hop loops like:
         [s1, s2, s1].
         This is a limitation of Ryu, as Ryu does not allow the `INPUT_PORT` action!

        :param src_vnf: Name of the source VNF
        :type src_vnf: ``str``
        :param src_intfs: Name of the source VNF interface to chain on
        :type src_intfs: ``str``
        :param dst_vnf: Name of the destination VNF
        :type dst_vnf: ``str``
        :param dst_intfs: Name of the destination VNF interface to chain on
        :type dst_intfs: ``str``
        :return: flask.Response 200 if set up correctly else 500 also returns the cookie as dict {'cookie': value}
         501 if vnf / intfs do not exist
        :rtype: :class:`flask.Response`

        """
        if request.is_json:
            path = request.json.get('path')
            layer2 = request.json.get('layer2', True)
        else:
            path = None
            layer2 = True

        # search for real names
        real_names = self._findNames(src_dc, src_stack, src_vnf, src_intfs, dst_dc, dst_stack, dst_vnf, dst_intfs)
        if type(real_names) is not tuple:
            # something went wrong
            return real_names

        container_src, container_dst, interface_src, interface_dst = real_names

        try:
            cookie = self.api.manage.network_action_start(container_src, container_dst, vnf_src_interface=interface_src,
                                                          vnf_dst_interface=interface_dst, bidirectional=True,
                                                          path=path, layer2=layer2)
            resp = {'cookie': cookie}
            return Response(json.dumps(resp), status=200, mimetype="application/json")

        except Exception as e:
            logging.exception(u"%s: Error setting up the chain.\n %s" % (__name__, e))
            return Response(u"Error setting up the chain", status=500, mimetype="application/json")

    def delete(self, src_dc, src_stack, src_vnf, src_intfs, dst_dc, dst_stack, dst_vnf, dst_intfs):
        """
        A DELETE request to "/v1/chain/<src_dc>/<src_stack>/<src_vnf>/<src_intfs>/<dst_dc>/<dst_stack>/<dst_vnf>/<dst_intfs>"
        will delete a previously created chain.

        :param src_dc: Name of the source datacenter
        :type src_dc: `str`
        :param src_stack: Name of the source stack
        :type src_stack: `str`
        :param src_vnf: Name of the source VNF
        :type src_vnf: ``str``
        :param src_intfs: Name of the source VNF interface to chain on
        :type src_intfs: ``str``
        :param dst_dc: Name of the destination datacenter
        :type dst_dc: ``str``
        :param dst_stack: Name of the destination stack
        :type dst_stack: ``str``
        :param dst_vnf: Name of the destination VNF
        :type dst_vnf: ``str``
        :param dst_intfs: Name of the destination VNF interface to chain on
        :type dst_intfs: ``str``
        :return: flask.Response 200 if set up correctly else 500\
         also returns the cookie as dict {'cookie': value}
         501 if one of the VNF / intfs does not exist
        :rtype: :class:`flask.Response`

        """
        # search for real names
        real_names = self._findNames(src_dc, src_stack, src_vnf, src_intfs, dst_dc, dst_stack, dst_vnf, dst_intfs)
        if type(real_names) is not tuple:
            # something went wrong, real_names is a Response object
            return real_names

        container_src, container_dst, interface_src, interface_dst = real_names

        try:
            cookie = self.api.manage.network_action_stop(container_src, container_dst, vnf_src_interface=interface_src,
                                                         vnf_dst_interface=interface_dst, bidirectional=True)
            return Response(json.dumps(cookie), status=200, mimetype="application/json")
        except Exception as e:
            logging.exception(u"%s: Error deleting the chain.\n %s" % (__name__, e))
            return Response(u"Error deleting the chain", status=500, mimetype="application/json")

    # Tries to find real container and interface names according to heat template names
    # Returns a tuple of 4 or a Response object
    def _findNames(self, src_dc, src_stack, src_vnf, src_intfs, dst_dc, dst_stack, dst_vnf, dst_intfs):
        # search for datacenters
        if src_dc not in self.api.manage.net.dcs or dst_dc not in self.api.manage.net.dcs:
            return Response(u"At least one DC does not exist", status=500, mimetype="application/json")
        dc_src = self.api.manage.net.dcs[src_dc]
        dc_dst = self.api.manage.net.dcs[dst_dc]
        # search for related OpenStackAPIs
        api_src = None
        api_dst = None
        from openstack_api_endpoint import OpenstackApiEndpoint
        for api in OpenstackApiEndpoint.dc_apis:
            if api.compute.dc == dc_src:
                api_src = api
            if api.compute.dc == dc_dst:
                api_dst = api
        if api_src is None or api_dst is None:
            return Response(u"At least one OpenStackAPI does not exist", status=500, mimetype="application/json")
        # search for stacks
        stack_src = None
        stack_dst = None
        for stack in api_src.compute.stacks.values():
            if stack.stack_name == src_stack:
                stack_src = stack
        for stack in api_dst.compute.stacks.values():
            if stack.stack_name == dst_stack:
                stack_dst = stack
        if stack_src is None or stack_dst is None:
            return Response(u"At least one Stack does not exist", status=500, mimetype="application/json")
        # search for servers
        server_src = None
        server_dst = None
        for server in stack_src.servers.values():
            if server.template_name == src_vnf:
                server_src = server
                break
        for server in stack_dst.servers.values():
            if server.template_name == dst_vnf:
                server_dst = server
                break
        if server_src is None or server_dst is None:
            return Response(u"At least one VNF does not exist", status=500, mimetype="application/json")

        container_src = server_src.name
        container_dst = server_dst.name

        # search for ports
        port_src = None
        port_dst = None
        if src_intfs in server_src.port_names:
            port_src = stack_src.ports[src_intfs]
        if dst_intfs in server_dst.port_names:
            port_dst = stack_dst.ports[dst_intfs]
        if port_src is None or port_dst is None:
            return Response(u"At least one Port does not exist", status=500, mimetype="application/json")

        interface_src = port_src.intf_name
        interface_dst = port_dst.intf_name

        return container_src, container_dst, interface_src, interface_dst


class BalanceHostDcStack(Resource):
    """
    Handles requests to "/v1/lb/<src_dc>/<src_stack>/<vnf_src_name>/<vnf_src_interface>"
    Sets up LoadBalancers for VNFs that are belonging to a certain stack.
    """

    def __init__(self, api):
        self.api = api

    def post(self, src_dc, src_stack, vnf_src_name, vnf_src_interface):
        """
        A POST request to "/v1/lb/<src_dc>/<src_stack>/<vnf_src_name>/<vnf_src_interface>"
        will set up a loadbalancer. The target VNFs and interfaces are in the post data.

        :Example:
            See :class:`heat.chain_api.BalanceHost.post`

        :param src_dc: Name of the source VNF
        :type src_dc: ``str``
        :param src_stack: Name of the source VNF interface to chain on
        :type src_stack: ``str``
         * src_stack == "floating" sets up a new floating node, so only use this name if you know what you are doing.
        :param vnf_src_name:
        :type vnf_src_name: ``str``
        :param vnf_src_interface:
        :type vnf_src_interface: ``str``
        :return: flask.Response 200 if set up correctly else 500
        :rtype: :class:`flask.Response`

        """
        try:
            req = request.json
            if req is None or len(req) == 0 or "dst_vnf_interfaces" not in req:
                return Response(u"You have to specify destination vnfs via the POST data.",
                                status=500, mimetype="application/json")

            dst_vnfs = req.get('dst_vnf_interfaces')
            container_src = None
            interface_src = None

            # check src vnf/port
            if src_stack != "floating":
                real_src = self._findName(src_dc, src_stack, vnf_src_name, vnf_src_interface)
                if type(real_src) is not tuple:
                    # something went wrong, real_src is a Response object
                    return real_src

                container_src, interface_src = real_src

            real_dst_dict = {}
            for dst_vnf in dst_vnfs:
                dst_dc = dst_vnf.get('pop', None)
                dst_stack = dst_vnf.get('stack', None)
                dst_server = dst_vnf.get('server', None)
                dst_port = dst_vnf.get('port', None)
                if dst_dc is not None and dst_stack is not None and dst_server is not None and dst_port is not None:
                    real_dst = self._findName(dst_dc, dst_stack, dst_server, dst_port)
                    if type(real_dst) is not tuple:
                        # something went wrong, real_dst is a Response object
                        return real_dst
                    real_dst_dict[real_dst[0]] = real_dst[1]

            input_object = {"dst_vnf_interfaces": real_dst_dict, "path": req.get("path", None)}

            if src_stack != "floating":
                self.api.manage.add_loadbalancer(container_src, interface_src, lb_data=input_object)
                return Response(u"Loadbalancer set up at %s:%s" % (container_src, interface_src),
                                status=200, mimetype="application/json")
            else:
                cookie, floating_ip = self.api.manage.add_floating_lb(src_dc, lb_data=input_object)

                return Response(json.dumps({"cookie": "%d" % cookie, "floating_ip": "%s" % floating_ip}),
                                status=200, mimetype="application/json")

        except Exception as e:
            logging.exception(u"%s: Error setting up the loadbalancer at %s %s %s:%s.\n %s" %
                              (__name__, src_dc, src_stack, vnf_src_name, vnf_src_interface, e))
            return Response(u"%s: Error setting up the loadbalancer at %s %s %s:%s.\n %s" %
                            (__name__, src_dc, src_stack, vnf_src_name, vnf_src_interface, e), status=500,
                            mimetype="application/json")

    def delete(self, src_dc, src_stack, vnf_src_name, vnf_src_interface):
        """
        Will delete a load balancer that sits behind a specified interface at a vnf for a specific stack

        :param src_dc: Name of the source VNF
        :type src_dc: ``str``
        :param src_stack: Name of the source VNF interface to chain on
        :type src_stack: ``str``
        :param vnf_src_name:
        :type vnf_src_name: ``str``
        :param vnf_src_interface:
        :type vnf_src_interface: ``str``
        :return: flask.Response 200 if set up correctly else 500
        :rtype: :class:`flask.Response`

        """
        try:
            # check src vnf/port
            if src_stack != "floating":
                real_src = self._findName(src_dc, src_stack, vnf_src_name, vnf_src_interface)
                if type(real_src) is not tuple:
                    # something went wrong, real_src is a Response object
                    return real_src

                container_src, interface_src = real_src

                self.api.manage.delete_loadbalancer(container_src, interface_src)
                return Response(u"Loadbalancer deleted at %s:%s" % (vnf_src_name, vnf_src_interface),
                                status=200, mimetype="application/json")
            else:
                cookie = vnf_src_name
                self.api.manage.delete_floating_lb(cookie)
                return Response(u"Floating loadbalancer with cookie %s deleted" % (cookie),
                                status=200, mimetype="application/json")

        except Exception as e:
            logging.exception(u"%s: Error deleting the loadbalancer at %s %s %s%s.\n %s" %
                              (__name__, src_dc, src_stack, vnf_src_name, vnf_src_interface, e))
            return Response(u"%s: Error deleting the loadbalancer at %s %s %s%s." %
                            (__name__, src_dc, src_stack, vnf_src_name, vnf_src_interface), status=500,
                            mimetype="application/json")

    # Tries to find real container and port name according to heat template names
    # Returns a string or a Response object
    def _findName(self, dc, stack, vnf, port):
        # search for datacenters
        if dc not in self.api.manage.net.dcs:
            return Response(u"DC does not exist", status=500, mimetype="application/json")
        dc_real = self.api.manage.net.dcs[dc]
        # search for related OpenStackAPIs
        api_real = None
        from openstack_api_endpoint import OpenstackApiEndpoint
        for api in OpenstackApiEndpoint.dc_apis:
            if api.compute.dc == dc_real:
                api_real = api
        if api_real is None:
            return Response(u"OpenStackAPI does not exist", status=500, mimetype="application/json")
        # search for stacks
        stack_real = None
        for stackObj in api_real.compute.stacks.values():
            if stackObj.stack_name == stack:
                stack_real = stackObj
        if stack_real is None:
            return Response(u"Stack does not exist", status=500, mimetype="application/json")
        # search for servers
        server_real = None
        for server in stack_real.servers.values():
            if server.template_name == vnf:
                server_real = server
                break
        if server_real is None:
            return Response(u"VNF does not exist", status=500, mimetype="application/json")

        container_real = server_real.name

        # search for ports
        port_real = None
        if port in server_real.port_names:
            port_real = stack_real.ports[port]
        if port_real is None:
            return Response(u"At least one Port does not exist", status=500, mimetype="application/json")

        interface_real = port_real.intf_name

        return container_real, interface_real


class BalanceHost(Resource):
    """
    Handles requests at "/v1/lb/<vnf_src_name>/<vnf_src_interface>"
    to set up or delete Load Balancers.
    """

    def __init__(self, api):
        self.api = api

    def post(self, vnf_src_name, vnf_src_interface):
        """
        Will set up a Load balancer behind an interface at a specified vnf
        We need both to avoid naming conflicts as interface names are not unique

        :param vnf_src_name: Name of the source VNF
        :type vnf_src_name: ``str``
        :param vnf_src_interface: Name of the source VNF interface to chain on
        :type vnf_src_interface: ``str``
        :return: flask.Response 200 if set up correctly else 500
         501 if VNF or intfs does not exist
        :rtype: :class:`flask.Response`

        """
        try:
            req = request.json
            if req is None or len(req) == 0 or "dst_vnf_interfaces" not in req:
                return Response(u"You have to specify destination vnfs via the POST data.",
                                status=500, mimetype="application/json")

            if vnf_src_name != "floating":
                # check if VNF exist
                if not self.api.manage.check_vnf_intf_pair(vnf_src_name, vnf_src_interface):
                    return Response(u"VNF %s or intfs %s does not exist" % (vnf_src_name, vnf_src_interface),
                                    status=501,
                                    mimetype="application/json")
                self.api.manage.add_loadbalancer(vnf_src_name, vnf_src_interface, lb_data=req)

                return Response(u"Loadbalancer set up at %s:%s" % (vnf_src_name, vnf_src_interface),
                                status=200, mimetype="application/json")
            else:
                cookie, floating_ip = self.api.manage.add_floating_lb(vnf_src_interface, lb_data=req)

                return Response(json.dumps({"cookie": "%d" % cookie, "floating_ip": "%s" % floating_ip}),
                                status=200, mimetype="application/json")
        except Exception as e:
            logging.exception(u"%s: Error setting up the loadbalancer at %s:%s.\n %s" %
                              (__name__, vnf_src_name, vnf_src_interface, e))
            return Response(u"%s: Error setting up the loadbalancer at %s:%s.\n %s" %
                            (__name__, vnf_src_name, vnf_src_interface, e), status=500, mimetype="application/json")

    def delete(self, vnf_src_name, vnf_src_interface):
        """
        Will delete a load balancer that sits behind a specified interface at a vnf

        :param vnf_src_name: Name of the source VNF
        :type vnf_src_name: ``str``
        :param vnf_src_interface: Name of the source VNF interface to chain on
        :type vnf_src_interface: ``str``
        :return: flask.Response 200 if set up correctly else 500
         501 if VNF or intfs does not exist
        :rtype: :class:`flask.Response`

        """
        # check if VNF exist
        if not self.api.manage.check_vnf_intf_pair(vnf_src_name, vnf_src_interface):
            return Response(u"VNF %s or intfs %s does not exist" % (vnf_src_name, vnf_src_interface), status=501,
                            mimetype="application/json")
        try:
            logging.debug("Deleting loadbalancer at %s: interface: %s" % (vnf_src_name, vnf_src_interface))
            net = self.api.manage.net

            if vnf_src_name != "floating":
                # check if VNF exists
                if vnf_src_name not in net:
                    return Response(u"Source VNF or interface can not be found." % vnf_src_name,
                                    status=404, mimetype="application/json")

                self.api.manage.delete_loadbalancer(vnf_src_name, vnf_src_interface)

                return Response(u"Loadbalancer deleted at %s:%s" % (vnf_src_name, vnf_src_interface),
                                status=200, mimetype="application/json")
            else:
                cookie = vnf_src_name
                self.api.manage.delete_floating_lb(cookie)
                return Response(u"Floating loadbalancer with cookie %s removed" % (cookie),
                                status=200, mimetype="application/json")
        except Exception as e:
            logging.exception(u"%s: Error deleting the loadbalancer at %s%s.\n %s" %
                              (__name__, vnf_src_name, vnf_src_interface, e))
            return Response(u"%s: Error deleting the loadbalancer at %s%s." %
                            (__name__, vnf_src_name, vnf_src_interface), status=500, mimetype="application/json")


class QueryTopology(Resource):
    """
    Handles requests at "/v1/topo/"
    """

    def __init__(self, api):
        self.api = api

    def get(self):
        """
        Answers GET requests for the current network topology at "/v1/topo".
        This will only return switches and datacenters and ignore currently deployed VNFs.

        :return: 200 if successful with the network graph as json dict, else 500

        """
        try:
            logging.debug("Querying topology")
            graph = self.api.manage.net.DCNetwork_graph
            net = self.api.manage.net
            # root node is nodes
            topology = {"nodes": list()}

            for n in graph:
                # remove root node as well as the floating switch fs1
                if n != "root" and n != "fs1":
                    # we only want to return switches!
                    if not isinstance(net[n], OVSSwitch):
                        continue
                    node = dict()

                    # get real datacenter label
                    for dc in self.api.manage.net.dcs.values():
                        if str(dc.switch) == str(n):
                            node["name"] = str(n)
                            node["type"] = "Datacenter"
                            node["label"] = str(dc.label)
                            break

                    # node is not a datacenter. It has to be a switch
                    if node.get("type", "") != "Datacenter":
                        node["name"] = str(n)
                        node["type"] = "Switch"

                    node["links"] = list()
                    # add links to the topology
                    for graph_node, data in graph[n].items():
                        # only add links to the topology that connect switches
                        if isinstance(net[graph_node], OVSSwitch):
                            # we allow multiple edges between switches, so add them all
                            # with their unique keys
                            link = copy.copy(data)
                            for edge in link:
                                # do not add any links to the floating switch to the topology!
                                if graph_node == "fs1":
                                    continue
                                # the translator wants everything as a string!
                                for key, value in link[edge].items():
                                    link[edge][key] = str(value)
                                # name of the destination
                                link[edge]["name"] = graph_node
                                node["links"].append(link)

                    topology["nodes"].append(node)

            return Response(json.dumps(topology),
                            status=200, mimetype="application/json")
        except Exception as e:
            logging.exception(u"%s: Error querying topology.\n %s" %
                              (__name__, e))
            return Response(u"%s: Error querying topology.\n %s" %
                            (__name__, e), status=500, mimetype="application/json")