src/emuvim/api/openstack/chain_api.py

   1 # Copyright (c) 2015 SONATA-NFV and Paderborn University
   2 # ALL RIGHTS RESERVED.
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at
   7 #
   8 #    http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15 #
  16 # Neither the name of the SONATA-NFV, Paderborn University
  17 # nor the names of its contributors may be used to endorse or promote
  18 # products derived from this software without specific prior written
  19 # permission.
  20 #
  21 # This work has been performed in the framework of the SONATA project,
  22 # funded by the European Commission under Grant number 671517 through
  23 # the Horizon 2020 and 5G-PPP programmes. The authors would like to
  24 # acknowledge the contributions of their colleagues of the SONATA
  25 # partner consortium (www.sonata-nfv.eu).
  26 import json
  27 import logging
  28 import copy
  29
  30 # from gevent import monkey
  31 from gevent.pywsgi import WSGIServer
  32
  33 from mininet.node import OVSSwitch
  34
  35 from flask import Flask
  36 from flask import Response, request
  37 from flask_restful import Api, Resource
  38
  39 # monkey.patch_all()
  40
  41
  42 class ChainApi(Resource):
  43     """
  44     The chain API is a component that is not used in OpenStack.
  45     It is a custom built REST API that can be used to create network chains and loadbalancers.
  46     """
  47
  48     def __init__(self, inc_ip, inc_port, manage):
  49         # setup Flask
  50         self.app = Flask(__name__)
  51         self.api = Api(self.app)
  52         self.ip = inc_ip
  53         self.port = inc_port
  54         self.manage = manage
  55         self.playbook_file = '/tmp/son-emu-requests.log'
  56         self.api.add_resource(ChainVersionsList, "/",
  57                               resource_class_kwargs={'api': self})
  58         self.api.add_resource(ChainList, "/v1/chain/list",
  59                               resource_class_kwargs={'api': self})
  60         self.api.add_resource(ChainVnfInterfaces, "/v1/chain/<src_vnf>/<src_intfs>/<dst_vnf>/<dst_intfs>",
  61                               resource_class_kwargs={'api': self})
  62         self.api.add_resource(ChainVnfDcStackInterfaces,
  63                               "/v1/chain/<src_dc>/<src_stack>/<src_vnf>/<src_intfs>/<dst_dc>/<dst_stack>/<dst_vnf>/<dst_intfs>",
  64                               resource_class_kwargs={'api': self})
  65         self.api.add_resource(BalanceHostList, "/v1/lb/list",
  66                               resource_class_kwargs={'api': self})
  67         self.api.add_resource(BalanceHost, "/v1/lb/<vnf_src_name>/<vnf_src_interface>",
  68                               resource_class_kwargs={'api': self})
  69         self.api.add_resource(BalanceHostDcStack, "/v1/lb/<src_dc>/<src_stack>/<vnf_src_name>/<vnf_src_interface>",
  70                               resource_class_kwargs={'api': self})
  71         self.api.add_resource(QueryTopology, "/v1/topo",
  72                               resource_class_kwargs={'api': self})
  73
  74         @self.app.after_request
  75         def add_access_control_header(response):
  76             response.headers['Access-Control-Allow-Origin'] = '*'
  77             return response
  78
  79     def _start_flask(self):
  80         logging.info("Starting %s endpoint @ http://%s:%d" %
  81                      ("ChainDummyApi", self.ip, self.port))
  82         self.http_server = WSGIServer(
  83             (self.ip, self.port),
  84             self.app,
  85             log=open("/dev/null", "w")  # don't show http logs
  86         )
  87         self.http_server.serve_forever(stop_timeout=1)
  88         logging.info('Stopped %s' % self.__class__.__name__)
  89
  90     def stop(self):
  91         if self.http_server:
  92             logging.info('Stopping %s' % self.__class__.__name__)
  93             self.http_server.stop(timeout=1)
  94
  95     def dump_playbook(self):
  96         with self.manage.lock:
  97             with open(self.playbook_file, 'a') as logfile:
  98                 if len(request.data) > 0:
  99                     data = "# CHAIN API\n"
 100                     data += "curl -X {type} -H \"Content-type: application/json\" -d '{data}' {url}".format(type=request.method,
 101                                                                                                             data=request.data,
 102                                                                                                             url=request.url)
 103                     logfile.write(data + "\n")
 104
 105
 106 class ChainVersionsList(Resource):
 107     '''
 108     Entrypoint to find versions of the chain api.
 109     '''
 110
 111     def __init__(self, api):
 112         self.api = api
 113
 114     def get(self):
 115         '''
 116         :return: flask.Response containing the openstack like description of the chain api
 117         '''
 118         # at least let it look like an open stack function
 119         try:
 120             resp = """
 121                 {
 122                     "versions": [
 123                         {
 124                             "id": "v1",
 125                             "links": [
 126                                 {
 127                                     "href": "http://%s:%d/v1/",
 128                                     "rel": "self"
 129                                 }
 130                             ],
 131                             "status": "CURRENT",
 132                             "version": "1",
 133                             "min_version": "1",
 134                             "updated": "2013-07-23T11:33:21Z"
 135                         }
 136                     ]
 137                 }
 138             """ % (self.api.ip, self.api.port)
 139
 140             return Response(resp, status=200, mimetype="application/json")
 141
 142         except Exception as ex:
 143             logging.exception(
 144                 u"%s: Could not show list of versions." % __name__)
 145             return ex.message, 500
 146
 147
 148 class ChainList(Resource):
 149     '''
 150     Will retrieve all chains including their paths.
 151     '''
 152
 153     def __init__(self, api):
 154         self.api = api
 155
 156     def get(self):
 157         '''
 158         :return: flask.Response containing all live chains
 159         '''
 160         # at least let it look like an open stack function
 161         try:
 162             resp = {"chains": list()}
 163
 164             for chain in self.api.manage.full_chain_data.values():
 165                 resp["chains"].append(chain)
 166
 167             return Response(json.dumps(resp), status=200,
 168                             mimetype="application/json")
 169
 170         except Exception as ex:
 171             logging.exception(
 172                 u"%s: Could not list all network chains." % __name__)
 173             return ex.message, 500
 174
 175
 176 class BalanceHostList(Resource):
 177     '''
 178     Will retrieve all loadbalance rules including their paths.
 179     '''
 180
 181     def __init__(self, api):
 182         self.api = api
 183
 184     def get(self):
 185         '''
 186         :return: flask.Response containing all live loadbalancer rules
 187         '''
 188         # at least let it look like an open stack function
 189         try:
 190             resp = {"loadbalancers": list()}
 191
 192             for lb in self.api.manage.full_lb_data.values():
 193                 resp["loadbalancers"].append(lb)
 194
 195             return Response(json.dumps(resp), status=200,
 196                             mimetype="application/json")
 197
 198         except Exception as ex:
 199             logging.exception(
 200                 u"%s: Could not list all live loadbalancers." % __name__)
 201             return ex.message, 500
 202
 203
 204 class ChainVnfInterfaces(Resource):
 205     """
 206     Handles requests targeted at: "/v1/chain/<src_vnf>/<src_intfs>/<dst_vnf>/<dst_intfs>"
 207     Requests are for tearing down or setting up a chain between two vnfs
 208     """
 209
 210     def __init__(self, api):
 211         self.api = api
 212
 213     def put(self, src_vnf, src_intfs, dst_vnf, dst_intfs):
 214         """
 215         A put request to "/v1/chain/<src_vnf>/<src_intfs>/<dst_vnf>/<dst_intfs>"
 216         will create a chain between two interfaces at the specified vnfs.
 217
 218         Note:
 219            Does not allow a custom path. Uses ``.post``
 220            Internally just makes a POST request with no POST data!
 221
 222         :param src_vnf: Name of the source VNF
 223         :type src_vnf: ``str``
 224         :param src_intfs: Name of the source VNF interface to chain on
 225         :type src_intfs: ``str``
 226         :param dst_vnf: Name of the destination VNF
 227         :type dst_vnf: ``str``
 228         :param dst_intfs: Name of the destination VNF interface to chain on
 229         :type dst_intfs: ``str``
 230         :return: flask.Response 200 if set up correctly else 500 also returns the cookie as dict {'cookie': value}
 231          501 if one of the VNF / intfs does not exist
 232         :rtype: :class:`flask.Response`
 233         """
 234         return self.post(src_vnf, src_intfs, dst_vnf, dst_intfs)
 235
 236     def post(self, src_vnf, src_intfs, dst_vnf, dst_intfs):
 237         """
 238          A post request to "/v1/chain/<src_vnf>/<src_intfs>/<dst_vnf>/<dst_intfs>"
 239          will create a chain between two interfaces at the specified vnfs.
 240          The POST data contains the path like this.
 241          { "path": ["dc1.s1", "s1", "dc4.s1"]}
 242          path specifies the destination vnf and interface and contains a list of switches
 243          that the path traverses. The path may not contain single hop loops like:
 244          [s1, s2, s1].
 245          This is a limitation of Ryu, as Ryu does not allow the `INPUT_PORT` action!
 246
 247         :param src_vnf: Name of the source VNF
 248         :type src_vnf: ``str``
 249         :param src_intfs: Name of the source VNF interface to chain on
 250         :type src_intfs: ``str``
 251         :param dst_vnf: Name of the destination VNF
 252         :type dst_vnf: ``str``
 253         :param dst_intfs: Name of the destination VNF interface to chain on
 254         :type dst_intfs: ``str``
 255         :return: flask.Response 200 if set up correctly else 500 also returns the cookie as dict {'cookie': value}
 256          501 if one of the VNF / intfs does not exist
 257         :rtype: :class:`flask.Response`
 258
 259         """
 260
 261         if request.is_json:
 262             path = request.json.get('path')
 263             layer2 = request.json.get('layer2', True)
 264         else:
 265             path = None
 266             layer2 = True
 267
 268         # check if both VNFs exist
 269         if not self.api.manage.check_vnf_intf_pair(src_vnf, src_intfs):
 270             return Response(u"VNF %s or intfs %s does not exist" % (src_vnf, src_intfs), status=501,
 271                             mimetype="application/json")
 272         if not self.api.manage.check_vnf_intf_pair(dst_vnf, dst_intfs):
 273             return Response(u"VNF %s or intfs %s does not exist" % (dst_vnf, dst_intfs), status=501,
 274                             mimetype="application/json")
 275         try:
 276             cookie = self.api.manage.network_action_start(src_vnf, dst_vnf, vnf_src_interface=src_intfs,
 277                                                           vnf_dst_interface=dst_intfs, bidirectional=True,
 278                                                           path=path, layer2=layer2)
 279             resp = {'cookie': cookie}
 280             return Response(json.dumps(resp), status=200,
 281                             mimetype="application/json")
 282
 283         except Exception as e:
 284             logging.exception(
 285                 u"%s: Error setting up the chain.\n %s" % (__name__, e))
 286             return Response(u"Error setting up the chain",
 287                             status=500, mimetype="application/json")
 288
 289     def delete(self, src_vnf, src_intfs, dst_vnf, dst_intfs):
 290         """
 291         A DELETE request to "/v1/chain/<src_vnf>/<src_intfs>/<dst_vnf>/<dst_intfs>"
 292         will delete a previously created chain.
 293
 294         :param src_vnf: Name of the source VNF
 295         :type src_vnf: ``str``
 296         :param src_intfs: Name of the source VNF interface to chain on
 297         :type src_intfs: ``str``
 298         :param dst_vnf: Name of the destination VNF
 299         :type dst_vnf: ``str``
 300         :param dst_intfs: Name of the destination VNF interface to chain on
 301         :type dst_intfs: ``str``
 302         :return: flask.Response 200 if set up correctly else 500\
 303          also returns the cookie as dict {'cookie': value}
 304          501 if one of the VNF / intfs does not exist
 305         :rtype: :class:`flask.Response`
 306
 307         """
 308         # check if both VNFs exist
 309         # check if both VNFs exist
 310         if not self.api.manage.check_vnf_intf_pair(src_vnf, src_intfs):
 311             return Response(u"VNF %s or intfs %s does not exist" % (src_vnf, src_intfs), status=501,
 312                             mimetype="application/json")
 313         if not self.api.manage.check_vnf_intf_pair(dst_vnf, dst_intfs):
 314             return Response(u"VNF %s or intfs %s does not exist" % (dst_vnf, dst_intfs), status=501,
 315                             mimetype="application/json")
 316         try:
 317             cookie = self.api.manage.network_action_stop(src_vnf, dst_vnf, vnf_src_interface=src_intfs,
 318                                                          vnf_dst_interface=dst_intfs, bidirectional=True)
 319             return Response(json.dumps(cookie), status=200,
 320                             mimetype="application/json")
 321         except Exception as e:
 322             logging.exception(
 323                 u"%s: Error deleting the chain.\n %s" % (__name__, e))
 324             return Response(u"Error deleting the chain",
 325                             status=500, mimetype="application/json")
 326
 327
 328 class ChainVnfDcStackInterfaces(Resource):
 329     '''
 330     Handles requests targeted at: "/v1/chain/<src_dc>/<src_stack>/<src_vnf>/<src_intfs>/<dst_dc>/<dst_stack>/<dst_vnf>/<dst_intfs>"
 331     Handles tearing down or setting up a chain between two vnfs for stacks.
 332     '''
 333
 334     def __init__(self, api):
 335         self.api = api
 336
 337     def put(self, src_dc, src_stack, src_vnf, src_intfs,
 338             dst_dc, dst_stack, dst_vnf, dst_intfs):
 339         """
 340         A PUT request to "/v1/chain/<src_dc>/<src_stack>/<src_vnf>/<src_intfs>/<dst_dc>/<dst_stack>/<dst_vnf>/<dst_intfs>"
 341         will set up chain.
 342
 343         :Note: PUT Requests can not set up custom paths!
 344
 345         :param src_dc: Name of the source datacenter
 346         :type src_dc: `str`
 347         :param src_stack: Name of the source stack
 348         :type src_stack: `str`
 349         :param src_vnf: Name of the source VNF
 350         :type src_vnf: ``str``
 351         :param src_intfs: Name of the source VNF interface to chain on
 352         :type src_intfs: ``str``
 353         :param dst_dc: Name of the destination datacenter
 354         :type dst_dc: ``str``
 355         :param dst_stack: Name of the destination stack
 356         :type dst_stack: ``str``
 357         :param dst_vnf: Name of the destination VNF
 358         :type dst_vnf: ``str``
 359         :param dst_intfs: Name of the destination VNF interface to chain on
 360         :type dst_intfs: ``str``
 361         :return: flask.Response 200 if set up correctly else 500\
 362          also returns the cookie as dict {'cookie': value}
 363          501 if VNF or intfs does not exist
 364         :rtype: :class:`flask.Response`
 365
 366         """
 367         # search for real names
 368         real_names = self._findNames(
 369             src_dc, src_stack, src_vnf, src_intfs, dst_dc, dst_stack, dst_vnf, dst_intfs)
 370         if not isinstance(real_names, tuple):
 371             # something went wrong
 372             return real_names
 373
 374         container_src, container_dst, interface_src, interface_dst = real_names
 375
 376         # check if both VNFs exist
 377         if not self.api.manage.check_vnf_intf_pair(
 378                 container_src, interface_src):
 379             return Response(u"VNF %s or intfs %s does not exist" % (container_src, interface_src), status=501,
 380                             mimetype="application/json")
 381         if not self.api.manage.check_vnf_intf_pair(
 382                 container_dst, interface_dst):
 383             return Response(u"VNF %s or intfs %s does not exist" % (container_dst, interface_dst), status=501,
 384                             mimetype="application/json")
 385
 386         try:
 387             cookie = self.api.manage.network_action_start(container_src, container_dst, vnf_src_interface=interface_src,
 388                                                           vnf_dst_interface=interface_dst, bidirectional=True,
 389                                                           layer2=True)
 390             resp = {'cookie': cookie}
 391             return Response(json.dumps(resp), status=200,
 392                             mimetype="application/json")
 393
 394         except Exception as e:
 395             logging.exception(
 396                 u"%s: Error setting up the chain.\n %s" % (__name__, e))
 397             return Response(u"Error setting up the chain",
 398                             status=500, mimetype="application/json")
 399
 400     def post(self, src_dc, src_stack, src_vnf, src_intfs,
 401              dst_dc, dst_stack, dst_vnf, dst_intfs):
 402         """
 403          A post request to "/v1/chain/<src_dc>/<src_stack>/<src_vnf>/<src_intfs>/<dst_dc>/<dst_stack>/<dst_vnf>/<dst_intfs>"
 404          will create a chain between two interfaces at the specified vnfs.
 405          The POST data contains the path like this.
 406          { "path": ["dc1.s1", "s1", "dc4.s1"]}
 407          path specifies the destination vnf and interface and contains a list of switches
 408          that the path traverses. The path may not contain single hop loops like:
 409          [s1, s2, s1].
 410          This is a limitation of Ryu, as Ryu does not allow the `INPUT_PORT` action!
 411
 412         :param src_vnf: Name of the source VNF
 413         :type src_vnf: ``str``
 414         :param src_intfs: Name of the source VNF interface to chain on
 415         :type src_intfs: ``str``
 416         :param dst_vnf: Name of the destination VNF
 417         :type dst_vnf: ``str``
 418         :param dst_intfs: Name of the destination VNF interface to chain on
 419         :type dst_intfs: ``str``
 420         :return: flask.Response 200 if set up correctly else 500 also returns the cookie as dict {'cookie': value}
 421          501 if vnf / intfs do not exist
 422         :rtype: :class:`flask.Response`
 423
 424         """
 425         if request.is_json:
 426             path = request.json.get('path')
 427             layer2 = request.json.get('layer2', True)
 428         else:
 429             path = None
 430             layer2 = True
 431
 432         # search for real names
 433         real_names = self._findNames(
 434             src_dc, src_stack, src_vnf, src_intfs, dst_dc, dst_stack, dst_vnf, dst_intfs)
 435         if not isinstance(real_names, tuple):
 436             # something went wrong
 437             return real_names
 438
 439         container_src, container_dst, interface_src, interface_dst = real_names
 440
 441         try:
 442             cookie = self.api.manage.network_action_start(container_src, container_dst, vnf_src_interface=interface_src,
 443                                                           vnf_dst_interface=interface_dst, bidirectional=True,
 444                                                           path=path, layer2=layer2)
 445             resp = {'cookie': cookie}
 446             return Response(json.dumps(resp), status=200,
 447                             mimetype="application/json")
 448
 449         except Exception as e:
 450             logging.exception(
 451                 u"%s: Error setting up the chain.\n %s" % (__name__, e))
 452             return Response(u"Error setting up the chain",
 453                             status=500, mimetype="application/json")
 454
 455     def delete(self, src_dc, src_stack, src_vnf, src_intfs,
 456                dst_dc, dst_stack, dst_vnf, dst_intfs):
 457         """
 458         A DELETE request to "/v1/chain/<src_dc>/<src_stack>/<src_vnf>/<src_intfs>/<dst_dc>/<dst_stack>/<dst_vnf>/<dst_intfs>"
 459         will delete a previously created chain.
 460
 461         :param src_dc: Name of the source datacenter
 462         :type src_dc: `str`
 463         :param src_stack: Name of the source stack
 464         :type src_stack: `str`
 465         :param src_vnf: Name of the source VNF
 466         :type src_vnf: ``str``
 467         :param src_intfs: Name of the source VNF interface to chain on
 468         :type src_intfs: ``str``
 469         :param dst_dc: Name of the destination datacenter
 470         :type dst_dc: ``str``
 471         :param dst_stack: Name of the destination stack
 472         :type dst_stack: ``str``
 473         :param dst_vnf: Name of the destination VNF
 474         :type dst_vnf: ``str``
 475         :param dst_intfs: Name of the destination VNF interface to chain on
 476         :type dst_intfs: ``str``
 477         :return: flask.Response 200 if set up correctly else 500\
 478          also returns the cookie as dict {'cookie': value}
 479          501 if one of the VNF / intfs does not exist
 480         :rtype: :class:`flask.Response`
 481
 482         """
 483         # search for real names
 484         real_names = self._findNames(
 485             src_dc, src_stack, src_vnf, src_intfs, dst_dc, dst_stack, dst_vnf, dst_intfs)
 486         if not isinstance(real_names, tuple):
 487             # something went wrong, real_names is a Response object
 488             return real_names
 489
 490         container_src, container_dst, interface_src, interface_dst = real_names
 491
 492         try:
 493             cookie = self.api.manage.network_action_stop(container_src, container_dst, vnf_src_interface=interface_src,
 494                                                          vnf_dst_interface=interface_dst, bidirectional=True)
 495             return Response(json.dumps(cookie), status=200,
 496                             mimetype="application/json")
 497         except Exception as e:
 498             logging.exception(
 499                 u"%s: Error deleting the chain.\n %s" % (__name__, e))
 500             return Response(u"Error deleting the chain",
 501                             status=500, mimetype="application/json")
 502
 503     # Tries to find real container and interface names according to heat template names
 504     # Returns a tuple of 4 or a Response object
 505     def _findNames(self, src_dc, src_stack, src_vnf, src_intfs,
 506                    dst_dc, dst_stack, dst_vnf, dst_intfs):
 507         # search for datacenters
 508         if src_dc not in self.api.manage.net.dcs or dst_dc not in self.api.manage.net.dcs:
 509             return Response(u"At least one DC does not exist",
 510                             status=500, mimetype="application/json")
 511         dc_src = self.api.manage.net.dcs[src_dc]
 512         dc_dst = self.api.manage.net.dcs[dst_dc]
 513         # search for related OpenStackAPIs
 514         api_src = None
 515         api_dst = None
 516         from openstack_api_endpoint import OpenstackApiEndpoint
 517         for api in OpenstackApiEndpoint.dc_apis:
 518             if api.compute.dc == dc_src:
 519                 api_src = api
 520             if api.compute.dc == dc_dst:
 521                 api_dst = api
 522         if api_src is None or api_dst is None:
 523             return Response(u"At least one OpenStackAPI does not exist",
 524                             status=500, mimetype="application/json")
 525         # search for stacks
 526         stack_src = None
 527         stack_dst = None
 528         for stack in api_src.compute.stacks.values():
 529             if stack.stack_name == src_stack:
 530                 stack_src = stack
 531         for stack in api_dst.compute.stacks.values():
 532             if stack.stack_name == dst_stack:
 533                 stack_dst = stack
 534         if stack_src is None or stack_dst is None:
 535             return Response(u"At least one Stack does not exist",
 536                             status=500, mimetype="application/json")
 537         # search for servers
 538         server_src = None
 539         server_dst = None
 540         for server in stack_src.servers.values():
 541             if server.template_name == src_vnf:
 542                 server_src = server
 543                 break
 544         for server in stack_dst.servers.values():
 545             if server.template_name == dst_vnf:
 546                 server_dst = server
 547                 break
 548         if server_src is None or server_dst is None:
 549             return Response(u"At least one VNF does not exist",
 550                             status=500, mimetype="application/json")
 551
 552         container_src = server_src.name
 553         container_dst = server_dst.name
 554
 555         # search for ports
 556         port_src = None
 557         port_dst = None
 558         if src_intfs in server_src.port_names:
 559             port_src = stack_src.ports[src_intfs]
 560         if dst_intfs in server_dst.port_names:
 561             port_dst = stack_dst.ports[dst_intfs]
 562         if port_src is None or port_dst is None:
 563             return Response(u"At least one Port does not exist",
 564                             status=500, mimetype="application/json")
 565
 566         interface_src = port_src.intf_name
 567         interface_dst = port_dst.intf_name
 568
 569         return container_src, container_dst, interface_src, interface_dst
 570
 571
 572 class BalanceHostDcStack(Resource):
 573     """
 574     Handles requests to "/v1/lb/<src_dc>/<src_stack>/<vnf_src_name>/<vnf_src_interface>"
 575     Sets up LoadBalancers for VNFs that are belonging to a certain stack.
 576     """
 577
 578     def __init__(self, api):
 579         self.api = api
 580
 581     def post(self, src_dc, src_stack, vnf_src_name, vnf_src_interface):
 582         """
 583         A POST request to "/v1/lb/<src_dc>/<src_stack>/<vnf_src_name>/<vnf_src_interface>"
 584         will set up a loadbalancer. The target VNFs and interfaces are in the post data.
 585
 586         :Example:
 587             See :class:`heat.chain_api.BalanceHost.post`
 588
 589         :param src_dc: Name of the source VNF
 590         :type src_dc: ``str``
 591         :param src_stack: Name of the source VNF interface to chain on
 592         :type src_stack: ``str``
 593          * src_stack == "floating" sets up a new floating node, so only use this name if you know what you are doing.
 594         :param vnf_src_name:
 595         :type vnf_src_name: ``str``
 596         :param vnf_src_interface:
 597         :type vnf_src_interface: ``str``
 598         :return: flask.Response 200 if set up correctly else 500
 599         :rtype: :class:`flask.Response`
 600
 601         """
 602         try:
 603             req = request.json
 604             if req is None or len(req) == 0 or "dst_vnf_interfaces" not in req:
 605                 return Response(u"You have to specify destination vnfs via the POST data.",
 606                                 status=500, mimetype="application/json")
 607
 608             dst_vnfs = req.get('dst_vnf_interfaces')
 609             container_src = None
 610             interface_src = None
 611
 612             # check src vnf/port
 613             if src_stack != "floating":
 614                 real_src = self._findName(
 615                     src_dc, src_stack, vnf_src_name, vnf_src_interface)
 616                 if not isinstance(real_src, tuple):
 617                     # something went wrong, real_src is a Response object
 618                     return real_src
 619
 620                 container_src, interface_src = real_src
 621
 622             real_dst_dict = {}
 623             for dst_vnf in dst_vnfs:
 624                 dst_dc = dst_vnf.get('pop', None)
 625                 dst_stack = dst_vnf.get('stack', None)
 626                 dst_server = dst_vnf.get('server', None)
 627                 dst_port = dst_vnf.get('port', None)
 628                 if dst_dc is not None and dst_stack is not None and dst_server is not None and dst_port is not None:
 629                     real_dst = self._findName(
 630                         dst_dc, dst_stack, dst_server, dst_port)
 631                     if not isinstance(real_dst, tuple):
 632                         # something went wrong, real_dst is a Response object
 633                         return real_dst
 634                     real_dst_dict[real_dst[0]] = real_dst[1]
 635
 636             input_object = {"dst_vnf_interfaces": real_dst_dict,
 637                             "path": req.get("path", None)}
 638
 639             if src_stack != "floating":
 640                 self.api.manage.add_loadbalancer(
 641                     container_src, interface_src, lb_data=input_object)
 642                 return Response(u"Loadbalancer set up at %s:%s" % (container_src, interface_src),
 643                                 status=200, mimetype="application/json")
 644             else:
 645                 cookie, floating_ip = self.api.manage.add_floating_lb(
 646                     src_dc, lb_data=input_object)
 647
 648                 return Response(json.dumps({"cookie": "%d" % cookie, "floating_ip": "%s" % floating_ip}),
 649                                 status=200, mimetype="application/json")
 650
 651         except Exception as e:
 652             logging.exception(u"%s: Error setting up the loadbalancer at %s %s %s:%s.\n %s" %
 653                               (__name__, src_dc, src_stack, vnf_src_name, vnf_src_interface, e))
 654             return Response(u"%s: Error setting up the loadbalancer at %s %s %s:%s.\n %s" %
 655                             (__name__, src_dc, src_stack, vnf_src_name,
 656                              vnf_src_interface, e), status=500,
 657                             mimetype="application/json")
 658
 659     def delete(self, src_dc, src_stack, vnf_src_name, vnf_src_interface):
 660         """
 661         Will delete a load balancer that sits behind a specified interface at a vnf for a specific stack
 662
 663         :param src_dc: Name of the source VNF
 664         :type src_dc: ``str``
 665         :param src_stack: Name of the source VNF interface to chain on
 666         :type src_stack: ``str``
 667         :param vnf_src_name:
 668         :type vnf_src_name: ``str``
 669         :param vnf_src_interface:
 670         :type vnf_src_interface: ``str``
 671         :return: flask.Response 200 if set up correctly else 500
 672         :rtype: :class:`flask.Response`
 673
 674         """
 675         try:
 676             # check src vnf/port
 677             if src_stack != "floating":
 678                 real_src = self._findName(
 679                     src_dc, src_stack, vnf_src_name, vnf_src_interface)
 680                 if not isinstance(real_src, tuple):
 681                     # something went wrong, real_src is a Response object
 682                     return real_src
 683
 684                 container_src, interface_src = real_src
 685
 686                 self.api.manage.delete_loadbalancer(
 687                     container_src, interface_src)
 688                 return Response(u"Loadbalancer deleted at %s:%s" % (vnf_src_name, vnf_src_interface),
 689                                 status=200, mimetype="application/json")
 690             else:
 691                 cookie = vnf_src_name
 692                 self.api.manage.delete_floating_lb(cookie)
 693                 return Response(u"Floating loadbalancer with cookie %s deleted" % (cookie),
 694                                 status=200, mimetype="application/json")
 695
 696         except Exception as e:
 697             logging.exception(u"%s: Error deleting the loadbalancer at %s %s %s%s.\n %s" %
 698                               (__name__, src_dc, src_stack, vnf_src_name, vnf_src_interface, e))
 699             return Response(u"%s: Error deleting the loadbalancer at %s %s %s%s." %
 700                             (__name__, src_dc, src_stack, vnf_src_name,
 701                              vnf_src_interface), status=500,
 702                             mimetype="application/json")
 703
 704     # Tries to find real container and port name according to heat template names
 705     # Returns a string or a Response object
 706     def _findName(self, dc, stack, vnf, port):
 707         # search for datacenters
 708         if dc not in self.api.manage.net.dcs:
 709             return Response(u"DC does not exist", status=500,
 710                             mimetype="application/json")
 711         dc_real = self.api.manage.net.dcs[dc]
 712         # search for related OpenStackAPIs
 713         api_real = None
 714         from openstack_api_endpoint import OpenstackApiEndpoint
 715         for api in OpenstackApiEndpoint.dc_apis:
 716             if api.compute.dc == dc_real:
 717                 api_real = api
 718         if api_real is None:
 719             return Response(u"OpenStackAPI does not exist",
 720                             status=500, mimetype="application/json")
 721         # search for stacks
 722         stack_real = None
 723         for stackObj in api_real.compute.stacks.values():
 724             if stackObj.stack_name == stack:
 725                 stack_real = stackObj
 726         if stack_real is None:
 727             return Response(u"Stack does not exist", status=500,
 728                             mimetype="application/json")
 729         # search for servers
 730         server_real = None
 731         for server in stack_real.servers.values():
 732             if server.template_name == vnf:
 733                 server_real = server
 734                 break
 735         if server_real is None:
 736             return Response(u"VNF does not exist", status=500,
 737                             mimetype="application/json")
 738
 739         container_real = server_real.name
 740
 741         # search for ports
 742         port_real = None
 743         if port in server_real.port_names:
 744             port_real = stack_real.ports[port]
 745         if port_real is None:
 746             return Response(u"At least one Port does not exist",
 747                             status=500, mimetype="application/json")
 748
 749         interface_real = port_real.intf_name
 750
 751         return container_real, interface_real
 752
 753
 754 class BalanceHost(Resource):
 755     """
 756     Handles requests at "/v1/lb/<vnf_src_name>/<vnf_src_interface>"
 757     to set up or delete Load Balancers.
 758     """
 759
 760     def __init__(self, api):
 761         self.api = api
 762
 763     def post(self, vnf_src_name, vnf_src_interface):
 764         """
 765         Will set up a Load balancer behind an interface at a specified vnf
 766         We need both to avoid naming conflicts as interface names are not unique
 767
 768         :param vnf_src_name: Name of the source VNF
 769         :type vnf_src_name: ``str``
 770         :param vnf_src_interface: Name of the source VNF interface to chain on
 771         :type vnf_src_interface: ``str``
 772         :return: flask.Response 200 if set up correctly else 500
 773          501 if VNF or intfs does not exist
 774         :rtype: :class:`flask.Response`
 775
 776         """
 777         try:
 778             req = request.json
 779             if req is None or len(req) == 0 or "dst_vnf_interfaces" not in req:
 780                 return Response(u"You have to specify destination vnfs via the POST data.",
 781                                 status=500, mimetype="application/json")
 782
 783             if vnf_src_name != "floating":
 784                 # check if VNF exist
 785                 if not self.api.manage.check_vnf_intf_pair(
 786                         vnf_src_name, vnf_src_interface):
 787                     return Response(u"VNF %s or intfs %s does not exist" % (vnf_src_name, vnf_src_interface),
 788                                     status=501,
 789                                     mimetype="application/json")
 790                 self.api.manage.add_loadbalancer(
 791                     vnf_src_name, vnf_src_interface, lb_data=req)
 792
 793                 return Response(u"Loadbalancer set up at %s:%s" % (vnf_src_name, vnf_src_interface),
 794                                 status=200, mimetype="application/json")
 795             else:
 796                 cookie, floating_ip = self.api.manage.add_floating_lb(
 797                     vnf_src_interface, lb_data=req)
 798
 799                 return Response(json.dumps({"cookie": "%d" % cookie, "floating_ip": "%s" % floating_ip}),
 800                                 status=200, mimetype="application/json")
 801         except Exception as e:
 802             logging.exception(u"%s: Error setting up the loadbalancer at %s:%s.\n %s" %
 803                               (__name__, vnf_src_name, vnf_src_interface, e))
 804             return Response(u"%s: Error setting up the loadbalancer at %s:%s.\n %s" %
 805                             (__name__, vnf_src_name, vnf_src_interface, e), status=500, mimetype="application/json")
 806
 807     def delete(self, vnf_src_name, vnf_src_interface):
 808         """
 809         Will delete a load balancer that sits behind a specified interface at a vnf
 810
 811         :param vnf_src_name: Name of the source VNF
 812         :type vnf_src_name: ``str``
 813         :param vnf_src_interface: Name of the source VNF interface to chain on
 814         :type vnf_src_interface: ``str``
 815         :return: flask.Response 200 if set up correctly else 500
 816          501 if VNF or intfs does not exist
 817         :rtype: :class:`flask.Response`
 818
 819         """
 820         # check if VNF exist
 821         if not self.api.manage.check_vnf_intf_pair(
 822                 vnf_src_name, vnf_src_interface):
 823             return Response(u"VNF %s or intfs %s does not exist" % (vnf_src_name, vnf_src_interface), status=501,
 824                             mimetype="application/json")
 825         try:
 826             logging.debug("Deleting loadbalancer at %s: interface: %s" %
 827                           (vnf_src_name, vnf_src_interface))
 828             net = self.api.manage.net
 829
 830             if vnf_src_name != "floating":
 831                 # check if VNF exists
 832                 if vnf_src_name not in net:
 833                     return Response(u"Source VNF or interface can not be found." % vnf_src_name,
 834                                     status=404, mimetype="application/json")
 835
 836                 self.api.manage.delete_loadbalancer(
 837                     vnf_src_name, vnf_src_interface)
 838
 839                 return Response(u"Loadbalancer deleted at %s:%s" % (vnf_src_name, vnf_src_interface),
 840                                 status=200, mimetype="application/json")
 841             else:
 842                 cookie = vnf_src_name
 843                 self.api.manage.delete_floating_lb(cookie)
 844                 return Response(u"Floating loadbalancer with cookie %s removed" % (cookie),
 845                                 status=200, mimetype="application/json")
 846         except Exception as e:
 847             logging.exception(u"%s: Error deleting the loadbalancer at %s%s.\n %s" %
 848                               (__name__, vnf_src_name, vnf_src_interface, e))
 849             return Response(u"%s: Error deleting the loadbalancer at %s%s." %
 850                             (__name__, vnf_src_name, vnf_src_interface), status=500, mimetype="application/json")
 851
 852
 853 class QueryTopology(Resource):
 854     """
 855     Handles requests at "/v1/topo/"
 856     """
 857
 858     def __init__(self, api):
 859         self.api = api
 860
 861     def get(self):
 862         """
 863         Answers GET requests for the current network topology at "/v1/topo".
 864         This will only return switches and datacenters and ignore currently deployed VNFs.
 865
 866         :return: 200 if successful with the network graph as json dict, else 500
 867
 868         """
 869         try:
 870             logging.debug("Querying topology")
 871             graph = self.api.manage.net.DCNetwork_graph
 872             net = self.api.manage.net
 873             # root node is nodes
 874             topology = {"nodes": list()}
 875
 876             for n in graph:
 877                 # remove root node as well as the floating switch fs1
 878                 if n != "root" and n != "fs1":
 879                     # we only want to return switches!
 880                     if not isinstance(net[n], OVSSwitch):
 881                         continue
 882                     node = dict()
 883
 884                     # get real datacenter label
 885                     for dc in self.api.manage.net.dcs.values():
 886                         if str(dc.switch) == str(n):
 887                             node["name"] = str(n)
 888                             node["type"] = "Datacenter"
 889                             node["label"] = str(dc.label)
 890                             break
 891
 892                     # node is not a datacenter. It has to be a switch
 893                     if node.get("type", "") != "Datacenter":
 894                         node["name"] = str(n)
 895                         node["type"] = "Switch"
 896
 897                     node["links"] = list()
 898                     # add links to the topology
 899                     for graph_node, data in graph[n].items():
 900                         # only add links to the topology that connect switches
 901                         if isinstance(net[graph_node], OVSSwitch):
 902                             # we allow multiple edges between switches, so add them all
 903                             # with their unique keys
 904                             link = copy.copy(data)
 905                             for edge in link:
 906                                 # do not add any links to the floating switch
 907                                 # to the topology!
 908                                 if graph_node == "fs1":
 909                                     continue
 910                                 # the translator wants everything as a string!
 911                                 for key, value in link[edge].items():
 912                                     link[edge][key] = str(value)
 913                                 # name of the destination
 914                                 link[edge]["name"] = graph_node
 915                                 node["links"].append(link)
 916
 917                     topology["nodes"].append(node)
 918
 919             return Response(json.dumps(topology),
 920                             status=200, mimetype="application/json")
 921         except Exception as e:
 922             logging.exception(u"%s: Error querying topology.\n %s" %
 923                               (__name__, e))
 924             return Response(u"%s: Error querying topology.\n %s" %
 925                             (__name__, e), status=500, mimetype="application/json")