+"""
+Copyright (c) 2015 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 [, ANY ADDITIONAL AFFILIATION]
+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 logging
-import threading
-from flask import Flask, request
-from flask_restful import Resource,Api
+from flask_restful import Resource
+from flask import request
import json
-
-
logging.basicConfig(level=logging.INFO)
-
dcs = {}
-class RestApiEndpoint(object):
-
- """
- Simple API endpoint that offers a REST
- interface. This interface will be used by the
- default command line client.
- """
- global dcs
-
- def __init__(self, listenip, port):
- self.ip = listenip
- self.port = port
-
- # setup Flask
- self.app = Flask(__name__)
- self.api = Api(self.app)
-
- # setup endpoints
- self.api.add_resource(ComputeList, "/restapi/compute/<dc_label>")
- self.api.add_resource(ComputeStart, "/restapi/compute/<dc_label>/<compute_name>/start")
- self.api.add_resource(ComputeStop, "/restapi/compute/<dc_label>/<compute_name>/stop")
- self.api.add_resource(ComputeStatus, "/restapi/compute/<dc_label>/<compute_name>")
- self.api.add_resource(DatacenterList, "/restapi/datacenter")
- self.api.add_resource(DatacenterStatus, "/restapi/datacenter/<dc_label>")
-
- logging.debug("Created API endpoint %s(%s:%d)" % (self.__class__.__name__, self.ip, self.port))
-
-
- def connectDatacenter(self, dc):
- dcs[dc.label] = dc
- logging.info("Connected DC(%s) to API endpoint %s(%s:%d)" % (dc.label, self.__class__.__name__, self.ip, self.port))
-
- def start(self):
- thread = threading.Thread(target= self._start_flask, args=())
- thread.daemon = True
- thread.start()
- logging.info("Started API endpoint @ http://%s:%d" % (self.ip, self.port))
-
-
- def _start_flask(self):
- self.app.run(self.ip, self.port, debug=True, use_reloader=False)
-
-
class ComputeStart(Resource):
"""
Start a new compute instance: A docker container (note: zerorpc does not support keyword arguments)
:param image: image name
:param command: command to execute
:param network: list of all interface of the vnf, with their parameters (id=id1,ip=x.x.x.x/x),...
- :return: networks list({"id":"input","ip": "10.0.0.254/8"}, {"id":"output","ip": "11.0.0.254/24"})
+ example networks list({"id":"input","ip": "10.0.0.254/8"}, {"id":"output","ip": "11.0.0.254/24"})
+ :return: docker inspect dict of deployed docker
"""
global dcs
def put(self, dc_label, compute_name):
logging.debug("API CALL: compute start")
try:
+ #check if json data is a dict
+ data = request.json
+ if data is None:
+ data = {}
+ elif type(data) is not dict:
+ data = json.loads(request.json)
+
+ network = data.get("network")
+ nw_list = self._parse_network(network)
+ image = data.get("image")
+ command = data.get("docker_command")
- image = json.loads(request.json).get("image")
- network = json.loads(request.json).get("network")
- command = json.loads(request.json).get("docker_command")
c = dcs.get(dc_label).startCompute(
- compute_name, image= image, command= command, network= network)
+ compute_name, image= image, command= command, network= nw_list)
# return docker inspect dict
- return c. getStatus(), 200
+ return c.getStatus(), 200
except Exception as ex:
logging.exception("API error.")
return ex.message, 500
+ def _parse_network(self, network_str):
+ '''
+ parse the options for all network interfaces of the vnf
+ :param network_str: (id=x,ip=x.x.x.x/x), ...
+ :return: list of dicts [{"id":x,"ip":"x.x.x.x/x"}, ...]
+ '''
+ nw_list = list()
+
+ # TODO make this more robust with regex check
+ if network_str is None :
+ return nw_list
+
+ networks = network_str[1:-1].split('),(')
+ for nw in networks:
+ nw_dict = dict(tuple(e.split('=')) for e in nw.split(','))
+ nw_list.append(nw_dict)
+
+ return nw_list
+
class ComputeStop(Resource):
global dcs
except Exception as ex:
logging.exception("API error.")
return ex.message, 500
+
+
projects / osm / vim-emu.git / blobdiff