src/emuvim/api/rest/compute.py

   1 """
   2 Copyright (c) 2015 SONATA-NFV and Paderborn University
   3 ALL RIGHTS RESERVED.
   4
   5 Licensed under the Apache License, Version 2.0 (the "License");
   6 you may not use this file except in compliance with the License.
   7 You may obtain a copy of the License at
   8
   9     http://www.apache.org/licenses/LICENSE-2.0
  10
  11 Unless required by applicable law or agreed to in writing, software
  12 distributed under the License is distributed on an "AS IS" BASIS,
  13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 See the License for the specific language governing permissions and
  15 limitations under the License.
  16
  17 Neither the name of the SONATA-NFV [, ANY ADDITIONAL AFFILIATION]
  18 nor the names of its contributors may be used to endorse or promote
  19 products derived from this software without specific prior written
  20 permission.
  21
  22 This work has been performed in the framework of the SONATA project,
  23 funded by the European Commission under Grant number 671517 through
  24 the Horizon 2020 and 5G-PPP programmes. The authors would like to
  25 acknowledge the contributions of their colleagues of the SONATA
  26 partner consortium (www.sonata-nfv.eu).
  27 """
  28 import logging
  29 from flask_restful import Resource
  30 from flask import request
  31 import json
  32
  33 logging.basicConfig(level=logging.INFO)
  34
  35 dcs = {}
  36
  37 class ComputeStart(Resource):
  38     """
  39     Start a new compute instance: A docker container (note: zerorpc does not support keyword arguments)
  40     :param dc_label: name of the DC
  41     :param compute_name: compute container name
  42     :param image: image name
  43     :param command: command to execute
  44     :param network: list of all interface of the vnf, with their parameters (id=id1,ip=x.x.x.x/x),...
  45     example networks list({"id":"input","ip": "10.0.0.254/8"}, {"id":"output","ip": "11.0.0.254/24"})
  46     :return: docker inspect dict of deployed docker
  47     """
  48     global dcs
  49
  50     def put(self, dc_label, compute_name):
  51         logging.debug("API CALL: compute start")
  52         try:
  53             #check if json data is a dict
  54             data = request.json
  55             if data is None:
  56                 data = {}
  57             elif type(data) is not dict:
  58                 data = json.loads(request.json)
  59
  60             network = data.get("network")
  61             nw_list = self._parse_network(network)
  62             image = data.get("image")
  63             command = data.get("docker_command")
  64
  65             c = dcs.get(dc_label).startCompute(
  66                 compute_name, image= image, command= command, network= nw_list)
  67             # return docker inspect dict
  68             return c.getStatus(), 200
  69         except Exception as ex:
  70             logging.exception("API error.")
  71             return ex.message, 500
  72
  73     def _parse_network(self, network_str):
  74         '''
  75         parse the options for all network interfaces of the vnf
  76         :param network_str: (id=x,ip=x.x.x.x/x), ...
  77         :return: list of dicts [{"id":x,"ip":"x.x.x.x/x"}, ...]
  78         '''
  79         nw_list = list()
  80
  81         # TODO make this more robust with regex check
  82         if network_str is None :
  83             return nw_list
  84
  85         networks = network_str[1:-1].split('),(')
  86         for nw in networks:
  87             nw_dict = dict(tuple(e.split('=')) for e in nw.split(','))
  88             nw_list.append(nw_dict)
  89
  90         return nw_list
  91
  92 class ComputeStop(Resource):
  93
  94     global dcs
  95
  96     def get(self, dc_label, compute_name):
  97         logging.debug("API CALL: compute stop")
  98         try:
  99             return dcs.get(dc_label).stopCompute(compute_name), 200
 100         except Exception as ex:
 101             logging.exception("API error.")
 102             return ex.message,500
 103
 104
 105 class ComputeList(Resource):
 106
 107     global dcs
 108
 109     def get(self, dc_label=None):
 110         logging.debug("API CALL: compute list")
 111         try:
 112             if dc_label is None:
 113                 # return list with all compute nodes in all DCs
 114                 all_containers = []
 115                 for dc in dcs.itervalues():
 116                     all_containers += dc.listCompute()
 117                 return [(c.name, c.getStatus()) for c in all_containers], 200
 118             else:
 119                 # return list of compute nodes for specified DC
 120                 return [(c.name, c.getStatus())
 121                     for c in dcs.get(dc_label).listCompute()], 200
 122         except Exception as ex:
 123             logging.exception("API error.")
 124             return ex.message, 500
 125
 126
 127 class ComputeStatus(Resource):
 128
 129     global dcs
 130
 131     def get(self, dc_label, compute_name):
 132
 133         logging.debug("API CALL: compute list")
 134
 135         try:
 136             return dcs.get(dc_label).containers.get(compute_name).getStatus(), 200
 137         except Exception as ex:
 138             logging.exception("API error.")
 139             return ex.message, 500
 140
 141 class DatacenterList(Resource):
 142
 143     global dcs
 144
 145     def get(self):
 146         logging.debug("API CALL: datacenter list")
 147         try:
 148             return [d.getStatus() for d in dcs.itervalues()], 200
 149         except Exception as ex:
 150             logging.exception("API error.")
 151             return ex.message, 500
 152
 153 class DatacenterStatus(Resource):
 154
 155     global dcs
 156
 157     def get(self, dc_label):
 158         logging.debug("API CALL: datacenter status")
 159         try:
 160             return dcs.get(dc_label).getStatus(), 200
 161         except Exception as ex:
 162             logging.exception("API error.")
 163             return ex.message, 500
 164
 165