Initial openvim v0.4.6 upload
Signed-off-by: tierno <alfonso.tiernosepulveda@telefonica.com>
diff --git a/httpserver.py b/httpserver.py
new file mode 100644
index 0000000..2be5164
--- /dev/null
+++ b/httpserver.py
@@ -0,0 +1,2156 @@
+# -*- coding: utf-8 -*-
+
+##
+# Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
+# This file is part of openmano
+# 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.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact with: nfvlabs@tid.es
+##
+
+'''
+This is the thread for the http server North API.
+Two thread will be launched, with normal and administrative permissions.
+'''
+
+__author__="Alfonso Tierno"
+__date__ ="$10-jul-2014 12:07:15$"
+
+import bottle
+import yaml
+import json
+import threading
+import datetime
+from utils import RADclass
+from jsonschema import validate as js_v, exceptions as js_e
+import host_thread as ht
+from vim_schema import host_new_schema, host_edit_schema, tenant_new_schema, \
+ tenant_edit_schema, \
+ flavor_new_schema, flavor_update_schema, \
+ image_new_schema, image_update_schema, \
+ server_new_schema, server_action_schema, network_new_schema, network_update_schema, \
+ port_new_schema, port_update_schema
+
+global my
+global url_base
+global config_dic
+
+url_base="/openvim"
+
+HTTP_Bad_Request = 400
+HTTP_Unauthorized = 401
+HTTP_Not_Found = 404
+HTTP_Forbidden = 403
+HTTP_Method_Not_Allowed = 405
+HTTP_Not_Acceptable = 406
+HTTP_Request_Timeout = 408
+HTTP_Conflict = 409
+HTTP_Service_Unavailable = 503
+HTTP_Internal_Server_Error= 500
+
+
+def check_extended(extended, allow_net_attach=False):
+ '''Makes and extra checking of extended input that cannot be done using jsonschema
+ Attributes:
+ allow_net_attach: for allowing or not the uuid field at interfaces
+ that are allowed for instance, but not for flavors
+ Return: (<0, error_text) if error; (0,None) if not error '''
+ if "numas" not in extended: return 0, None
+ id_s=[]
+ numaid=0
+ for numa in extended["numas"]:
+ nb_formats = 0
+ if "cores" in numa:
+ nb_formats += 1
+ if "cores-id" in numa:
+ if len(numa["cores-id"]) != numa["cores"]:
+ return -HTTP_Bad_Request, "different number of cores-id (%d) than cores (%d) at numa %d" % (len(numa["cores-id"]), numa["cores"],numaid)
+ id_s.extend(numa["cores-id"])
+ if "threads" in numa:
+ nb_formats += 1
+ if "threads-id" in numa:
+ if len(numa["threads-id"]) != numa["threads"]:
+ return -HTTP_Bad_Request, "different number of threads-id (%d) than threads (%d) at numa %d" % (len(numa["threads-id"]), numa["threads"],numaid)
+ id_s.extend(numa["threads-id"])
+ if "paired-threads" in numa:
+ nb_formats += 1
+ if "paired-threads-id" in numa:
+ if len(numa["paired-threads-id"]) != numa["paired-threads"]:
+ return -HTTP_Bad_Request, "different number of paired-threads-id (%d) than paired-threads (%d) at numa %d" % (len(numa["paired-threads-id"]), numa["paired-threads"],numaid)
+ for pair in numa["paired-threads-id"]:
+ if len(pair) != 2:
+ return -HTTP_Bad_Request, "paired-threads-id must contain a list of two elements list at numa %d" % (numaid)
+ id_s.extend(pair)
+ if nb_formats > 1:
+ return -HTTP_Service_Unavailable, "only one of cores, threads, paired-threads are allowed in this version at numa %d" % numaid
+ #check interfaces
+ if "interfaces" in numa:
+ ifaceid=0
+ names=[]
+ vpcis=[]
+ for interface in numa["interfaces"]:
+ if "uuid" in interface and not allow_net_attach:
+ return -HTTP_Bad_Request, "uuid field is not allowed at numa %d interface %s position %d" % (numaid, interface.get("name",""), ifaceid )
+ if "mac_address" in interface and interface["dedicated"]=="yes":
+ return -HTTP_Bad_Request, "mac_address can not be set for dedicated (passthrough) at numa %d, interface %s position %d" % (numaid, interface.get("name",""), ifaceid )
+ if "name" in interface:
+ if interface["name"] in names:
+ return -HTTP_Bad_Request, "name repeated at numa %d, interface %s position %d" % (numaid, interface.get("name",""), ifaceid )
+ names.append(interface["name"])
+ if "vpci" in interface:
+ if interface["vpci"] in vpcis:
+ return -HTTP_Bad_Request, "vpci %s repeated at numa %d, interface %s position %d" % (interface["vpci"], numaid, interface.get("name",""), ifaceid )
+ vpcis.append(interface["vpci"])
+ ifaceid+=1
+ numaid+=1
+ if numaid > 1:
+ return -HTTP_Service_Unavailable, "only one numa can be defined in this version "
+ for a in range(0,len(id_s)):
+ if a not in id_s:
+ return -HTTP_Bad_Request, "core/thread identifiers must start at 0 and gaps are not alloed. Missing id number %d" % a
+
+ return 0, None
+
+#
+# dictionaries that change from HTTP API to database naming
+#
+http2db_host={'id':'uuid'}
+http2db_tenant={'id':'uuid'}
+http2db_flavor={'id':'uuid','imageRef':'image_id'}
+http2db_image={'id':'uuid', 'created':'created_at', 'updated':'modified_at', 'public': 'public'}
+http2db_server={'id':'uuid','hostId':'host_id','flavorRef':'flavor_id','imageRef':'image_id','created':'created_at'}
+http2db_network={'id':'uuid','provider:vlan':'vlan', 'provider:physical': 'provider'}
+http2db_port={'id':'uuid', 'network_id':'net_id', 'mac_address':'mac', 'device_owner':'type','device_id':'instance_id','binding:switch_port':'switch_port','binding:vlan':'vlan', 'bandwidth':'Mbps'}
+
+def remove_extra_items(data, schema):
+ deleted=[]
+ if type(data) is tuple or type(data) is list:
+ for d in data:
+ a= remove_extra_items(d, schema['items'])
+ if a is not None: deleted.append(a)
+ elif type(data) is dict:
+ for k in data.keys():
+ if 'properties' not in schema or k not in schema['properties'].keys():
+ del data[k]
+ deleted.append(k)
+ else:
+ a = remove_extra_items(data[k], schema['properties'][k])
+ if a is not None: deleted.append({k:a})
+ if len(deleted) == 0: return None
+ elif len(deleted) == 1: return deleted[0]
+ else: return deleted
+
+def delete_nulls(var):
+ if type(var) is dict:
+ for k in var.keys():
+ if var[k] is None: del var[k]
+ elif type(var[k]) is dict or type(var[k]) is list or type(var[k]) is tuple:
+ if delete_nulls(var[k]): del var[k]
+ if len(var) == 0: return True
+ elif type(var) is list or type(var) is tuple:
+ for k in var:
+ if type(k) is dict: delete_nulls(k)
+ if len(var) == 0: return True
+ return False
+
+
+class httpserver(threading.Thread):
+ def __init__(self, db_conn, name="http", host='localhost', port=8080, admin=False, config_=None):
+ '''
+ Creates a new thread to attend the http connections
+ Attributes:
+ db_conn: database connection
+ name: name of this thread
+ host: ip or name where to listen
+ port: port where to listen
+ admin: if this has privileges of administrator or not
+ config_: unless the first thread must be provided. It is a global dictionary where to allocate the self variable
+ '''
+ global url_base
+ global config_dic
+
+ #initialization
+ if config_ is not None:
+ config_dic = config_
+ if 'http_threads' not in config_dic:
+ config_dic['http_threads'] = {}
+ threading.Thread.__init__(self)
+ self.host = host
+ self.port = port
+ self.db = db_conn
+ self.admin = admin
+ if name in config_dic:
+ print "httpserver Warning!!! Onether thread with the same name", name
+ n=0
+ while name+str(n) in config_dic:
+ n +=1
+ name +=str(n)
+ self.name = name
+ self.url_preffix = 'http://' + self.host + ':' + str(self.port) + url_base
+ config_dic['http_threads'][name] = self
+
+ #Ensure that when the main program exits the thread will also exit
+ self.daemon = True
+ self.setDaemon(True)
+
+ def run(self):
+ bottle.run(host=self.host, port=self.port, debug=True) #quiet=True
+
+ def gethost(self, host_id):
+ result, content = self.db.get_host(host_id)
+ if result < 0:
+ print "httpserver.gethost error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ elif result==0:
+ print "httpserver.gethost host '%s' not found" % host_id
+ bottle.abort(HTTP_Not_Found, content)
+ else:
+ data={'host' : content}
+ convert_boolean(content, ('admin_state_up',) )
+ change_keys_http2db(content, http2db_host, reverse=True)
+ print data['host']
+ return format_out(data)
+
+@bottle.route(url_base + '/', method='GET')
+def http_get():
+ print
+ return 'works' #TODO: put links or redirection to /openvim???
+
+#
+# Util funcions
+#
+
+def change_keys_http2db(data, http_db, reverse=False):
+ '''Change keys of dictionary data according to the key_dict values
+ This allow change from http interface names to database names.
+ When reverse is True, the change is otherwise
+ Attributes:
+ data: can be a dictionary or a list
+ http_db: is a dictionary with hhtp names as keys and database names as value
+ reverse: by default change is done from http API to database. If True change is done otherwise
+ Return: None, but data is modified'''
+ if type(data) is tuple or type(data) is list:
+ for d in data:
+ change_keys_http2db(d, http_db, reverse)
+ elif type(data) is dict or type(data) is bottle.FormsDict:
+ if reverse:
+ for k,v in http_db.items():
+ if v in data: data[k]=data.pop(v)
+ else:
+ for k,v in http_db.items():
+ if k in data: data[v]=data.pop(k)
+
+
+
+def format_out(data):
+ '''return string of dictionary data according to requested json, yaml, xml. By default json'''
+ if 'application/yaml' in bottle.request.headers.get('Accept'):
+ bottle.response.content_type='application/yaml'
+ return yaml.safe_dump(data, explicit_start=True, indent=4, default_flow_style=False, tags=False, encoding='utf-8', allow_unicode=True) #, canonical=True, default_style='"'
+ else: #by default json
+ bottle.response.content_type='application/json'
+ #return data #json no style
+ return json.dumps(data, indent=4) + "\n"
+
+def format_in(schema):
+ try:
+ error_text = "Invalid header format "
+ format_type = bottle.request.headers.get('Content-Type', 'application/json')
+ if 'application/json' in format_type:
+ error_text = "Invalid json format "
+ #Use the json decoder instead of bottle decoder because it informs about the location of error formats with a ValueError exception
+ client_data = json.load(bottle.request.body)
+ #client_data = bottle.request.json()
+ elif 'application/yaml' in format_type:
+ error_text = "Invalid yaml format "
+ client_data = yaml.load(bottle.request.body)
+ elif format_type == 'application/xml':
+ bottle.abort(501, "Content-Type: application/xml not supported yet.")
+ else:
+ print "HTTP HEADERS: " + str(bottle.request.headers.items())
+ bottle.abort(HTTP_Not_Acceptable, 'Content-Type ' + str(format_type) + ' not supported.')
+ return
+ #if client_data == None:
+ # bottle.abort(HTTP_Bad_Request, "Content error, empty")
+ # return
+ #check needed_items
+
+ #print "HTTP input data: ", str(client_data)
+ error_text = "Invalid content "
+ js_v(client_data, schema)
+
+ return client_data
+ except (ValueError, yaml.YAMLError) as exc:
+ error_text += str(exc)
+ print error_text
+ bottle.abort(HTTP_Bad_Request, error_text)
+ except js_e.ValidationError as exc:
+ print "HTTP validate_in error, jsonschema exception ", exc.message, "at", exc.path
+ print " CONTENT: " + str(bottle.request.body.readlines())
+ error_pos = ""
+ if len(exc.path)>0: error_pos=" at '" + ":".join(map(str, exc.path)) + "'"
+ bottle.abort(HTTP_Bad_Request, error_text + error_pos+": "+exc.message)
+ #except:
+ # bottle.abort(HTTP_Bad_Request, "Content error: Failed to parse Content-Type", error_pos)
+ # raise
+
+def filter_query_string(qs, http2db, allowed):
+ '''Process query string (qs) checking that contains only valid tokens for avoiding SQL injection
+ Attributes:
+ 'qs': bottle.FormsDict variable to be processed. None or empty is considered valid
+ 'allowed': list of allowed string tokens (API http naming). All the keys of 'qs' must be one of 'allowed'
+ 'http2db': dictionary with change from http API naming (dictionary key) to database naming(dictionary value)
+ Return: A tuple with the (select,where,limit) to be use in a database query. All of then transformed to the database naming
+ select: list of items to retrieve, filtered by query string 'field=token'. If no 'field' is present, allowed list is returned
+ where: dictionary with key, value, taken from the query string token=value. Empty if nothing is provided
+ limit: limit dictated by user with the query string 'limit'. 100 by default
+ abort if not permitted, using bottel.abort
+ '''
+ where={}
+ limit=100
+ select=[]
+ if type(qs) is not bottle.FormsDict:
+ print '!!!!!!!!!!!!!!invalid query string not a dictionary'
+ #bottle.abort(HTTP_Internal_Server_Error, "call programmer")
+ else:
+ for k in qs:
+ if k=='field':
+ select += qs.getall(k)
+ for v in select:
+ if v not in allowed:
+ bottle.abort(HTTP_Bad_Request, "Invalid query string at 'field="+v+"'")
+ elif k=='limit':
+ try:
+ limit=int(qs[k])
+ except:
+ bottle.abort(HTTP_Bad_Request, "Invalid query string at 'limit="+qs[k]+"'")
+ else:
+ if k not in allowed:
+ bottle.abort(HTTP_Bad_Request, "Invalid query string at '"+k+"="+qs[k]+"'")
+ if qs[k]!="null": where[k]=qs[k]
+ else: where[k]=None
+ if len(select)==0: select += allowed
+ #change from http api to database naming
+ for i in range(0,len(select)):
+ k=select[i]
+ if k in http2db:
+ select[i] = http2db[k]
+ change_keys_http2db(where, http2db)
+ #print "filter_query_string", select,where,limit
+
+ return select,where,limit
+
+
+def convert_bandwidth(data, reverse=False):
+ '''Check the field bandwidth recursively and when found, it removes units and convert to number
+ It assumes that bandwidth is well formed
+ Attributes:
+ 'data': dictionary bottle.FormsDict variable to be checked. None or empty is considered valid
+ 'reverse': by default convert form str to int (Mbps), if True it convert from number to units
+ Return:
+ None
+ '''
+ if type(data) is dict:
+ for k in data.keys():
+ if type(data[k]) is dict or type(data[k]) is tuple or type(data[k]) is list:
+ convert_bandwidth(data[k], reverse)
+ if "bandwidth" in data:
+ try:
+ value=str(data["bandwidth"])
+ if not reverse:
+ pos = value.find("bps")
+ if pos>0:
+ if value[pos-1]=="G": data["bandwidth"] = int(data["bandwidth"][:pos-1]) * 1000
+ elif value[pos-1]=="k": data["bandwidth"]= int(data["bandwidth"][:pos-1]) / 1000
+ else: data["bandwidth"]= int(data["bandwidth"][:pos-1])
+ else:
+ value = int(data["bandwidth"])
+ if value % 1000 == 0: data["bandwidth"]=str(value/1000) + " Gbps"
+ else: data["bandwidth"]=str(value) + " Mbps"
+ except:
+ print "convert_bandwidth exception for type", type(data["bandwidth"]), " data", data["bandwidth"]
+ return
+ if type(data) is tuple or type(data) is list:
+ for k in data:
+ if type(k) is dict or type(k) is tuple or type(k) is list:
+ convert_bandwidth(k, reverse)
+
+def convert_boolean(data, items):
+ '''Check recursively the content of data, and if there is an key contained in items, convert value from string to boolean
+ It assumes that bandwidth is well formed
+ Attributes:
+ 'data': dictionary bottle.FormsDict variable to be checked. None or empty is consideted valid
+ 'items': tuple of keys to convert
+ Return:
+ None
+ '''
+ if type(data) is dict:
+ for k in data.keys():
+ if type(data[k]) is dict or type(data[k]) is tuple or type(data[k]) is list:
+ convert_boolean(data[k], items)
+ if k in items:
+ if type(data[k]) is str:
+ if data[k]=="false": data[k]=False
+ elif data[k]=="true": data[k]=True
+ if type(data) is tuple or type(data) is list:
+ for k in data:
+ if type(k) is dict or type(k) is tuple or type(k) is list:
+ convert_boolean(k, items)
+
+def convert_datetime2str(var):
+ '''Converts a datetime variable to a string with the format '%Y-%m-%dT%H:%i:%s'
+ It enters recursively in the dict var finding this kind of variables
+ '''
+ if type(var) is dict:
+ for k,v in var.items():
+ if type(v) is datetime.datetime:
+ var[k]= v.strftime('%Y-%m-%dT%H:%M:%S')
+ elif type(v) is dict or type(v) is list or type(v) is tuple:
+ convert_datetime2str(v)
+ if len(var) == 0: return True
+ elif type(var) is list or type(var) is tuple:
+ for v in var:
+ convert_datetime2str(v)
+
+def check_valid_tenant(my, tenant_id):
+ if tenant_id=='any':
+ if not my.admin:
+ return HTTP_Unauthorized, "Needed admin privileges"
+ else:
+ result, _ = my.db.get_table(FROM='tenants', SELECT=('uuid',), WHERE={'uuid': tenant_id})
+ if result<=0:
+ return HTTP_Not_Found, "tenant '%s' not found" % tenant_id
+ return 0, None
+
+def check_valid_uuid(uuid):
+ id_schema = {"type" : "string", "pattern": "^[a-fA-F0-9]{8}(-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}$"}
+ try:
+ js_v(uuid, id_schema)
+ return True
+ except js_e.ValidationError:
+ return False
+
+@bottle.error(400)
+@bottle.error(401)
+@bottle.error(404)
+@bottle.error(403)
+@bottle.error(405)
+@bottle.error(406)
+@bottle.error(408)
+@bottle.error(409)
+@bottle.error(503)
+@bottle.error(500)
+def error400(error):
+ e={"error":{"code":error.status_code, "type":error.status, "description":error.body}}
+ return format_out(e)
+
+@bottle.hook('after_request')
+def enable_cors():
+ #TODO: Alf: Is it needed??
+ bottle.response.headers['Access-Control-Allow-Origin'] = '*'
+
+#
+# HOSTS
+#
+
+@bottle.route(url_base + '/hosts', method='GET')
+def http_get_hosts():
+ select_,where_,limit_ = filter_query_string(bottle.request.query, http2db_host,
+ ('id','name','description','status','admin_state_up') )
+
+ myself = config_dic['http_threads'][ threading.current_thread().name ]
+ result, content = myself.db.get_table(FROM='hosts', SELECT=select_, WHERE=where_, LIMIT=limit_)
+ if result < 0:
+ print "http_get_hosts Error", content
+ bottle.abort(-result, content)
+ else:
+ convert_boolean(content, ('admin_state_up',) )
+ change_keys_http2db(content, http2db_host, reverse=True)
+ for row in content:
+ row['links'] = ( {'href': myself.url_preffix + '/hosts/' + str(row['id']), 'rel': 'bookmark'}, )
+ data={'hosts' : content}
+ return format_out(data)
+
+@bottle.route(url_base + '/hosts/<host_id>', method='GET')
+def http_get_host_id(host_id):
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ return my.gethost(host_id)
+
+@bottle.route(url_base + '/hosts', method='POST')
+def http_post_hosts():
+ '''insert a host into the database. All resources are got and inserted'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check permissions
+ if not my.admin:
+ bottle.abort(HTTP_Unauthorized, "Needed admin privileges")
+
+ #parse input data
+ http_content = format_in( host_new_schema )
+ r = remove_extra_items(http_content, host_new_schema)
+ if r is not None: print "http_post_host_id: Warning: remove extra items ", r
+ change_keys_http2db(http_content['host'], http2db_host)
+
+ host = http_content['host']
+ warning_text=""
+ if 'host-data' in http_content:
+ host.update(http_content['host-data'])
+ ip_name=http_content['host-data']['ip_name']
+ user=http_content['host-data']['user']
+ password=http_content['host-data'].get('password', None)
+ else:
+ ip_name=host['ip_name']
+ user=host['user']
+ password=host.get('password', None)
+
+ #fill rad info
+ rad = RADclass.RADclass()
+ (return_status, code) = rad.obtain_RAD(user, password, ip_name)
+
+ #return
+ if not return_status:
+ print 'http_post_hosts ERROR obtaining RAD', code
+ bottle.abort(HTTP_Bad_Request, code)
+ return
+ warning_text=code
+ rad_structure = yaml.load(rad.to_text())
+ print 'rad_structure\n---------------------'
+ print json.dumps(rad_structure, indent=4)
+ print '---------------------'
+ #return
+ WHERE_={"family":rad_structure['processor']['family'], 'manufacturer':rad_structure['processor']['manufacturer'], 'version':rad_structure['processor']['version']}
+ result, content = my.db.get_table(FROM='host_ranking',
+ SELECT=('ranking',),
+ WHERE=WHERE_)
+ if result > 0:
+ host['ranking'] = content[0]['ranking']
+ else:
+ #error_text= "Host " + str(WHERE_)+ " not found in ranking table. Not valid for VIM management"
+ #bottle.abort(HTTP_Bad_Request, error_text)
+ #return
+ warning_text += "Host " + str(WHERE_)+ " not found in ranking table. Assuming lowest value 100\n"
+ host['ranking'] = 100 #TODO: as not used in this version, set the lowest value
+
+ features = rad_structure['processor'].get('features', ())
+ host['features'] = ",".join(features)
+ host['numas'] = []
+
+ for node in (rad_structure['resource topology']['nodes'] or {}).itervalues():
+ interfaces= []
+ cores = []
+ eligible_cores=[]
+ count = 0
+ for core in node['cpu']['eligible_cores']:
+ eligible_cores.extend(core)
+ for core in node['cpu']['cores']:
+ for thread_id in core:
+ c={'core_id': count, 'thread_id': thread_id}
+ if thread_id not in eligible_cores: c['status'] = 'noteligible'
+ cores.append(c)
+ count = count+1
+
+ if 'nics' in node:
+ for port_k, port_v in node['nics']['nic 0']['ports'].iteritems():
+ if port_v['virtual']:
+ continue
+ else:
+ sriovs = []
+ for port_k2, port_v2 in node['nics']['nic 0']['ports'].iteritems():
+ if port_v2['virtual'] and port_v2['PF_pci_id']==port_k:
+ sriovs.append({'pci':port_k2, 'mac':port_v2['mac'], 'source_name':port_v2['source_name']})
+ if len(sriovs)>0:
+ #sort sriov according to pci and rename them to the vf number
+ new_sriovs = sorted(sriovs, key=lambda k: k['pci'])
+ index=0
+ for sriov in new_sriovs:
+ sriov['source_name'] = index
+ index += 1
+ interfaces.append ({'pci':str(port_k), 'Mbps': port_v['speed']/1000000, 'sriovs': new_sriovs, 'mac':port_v['mac'], 'source_name':port_v['source_name']})
+ #@TODO LA memoria devuelta por el RAD es incorrecta, almenos para IVY1, NFV100
+ memory=node['memory']['node_size'] / (1024*1024*1024)
+ #memory=get_next_2pow(node['memory']['hugepage_nr'])
+ host['numas'].append( {'numa_socket': node['id'], 'hugepages': node['memory']['hugepage_nr'], 'memory':memory, 'interfaces': interfaces, 'cores': cores } )
+ print json.dumps(host, indent=4)
+ #return
+ #
+ #insert in data base
+ result, content = my.db.new_host(host)
+ if result >= 0:
+ if content['admin_state_up']:
+ #create thread
+ host_test_mode = True if config_dic['mode']=='test' or config_dic['mode']=="OF only" else False
+ host_develop_mode = True if config_dic['mode']=='development' else False
+ host_develop_bridge_iface = config_dic.get('development_bridge', None)
+ thread = ht.host_thread(name=host.get('name',ip_name), user=user, host=ip_name, db=config_dic['db'], db_lock=config_dic['db_lock'],
+ test=host_test_mode, image_path=config_dic['image_path'],
+ version=config_dic['version'], host_id=content['uuid'],
+ develop_mode=host_develop_mode, develop_bridge_iface=host_develop_bridge_iface )
+ thread.start()
+ config_dic['host_threads'][ content['uuid'] ] = thread
+
+ #return host data
+ change_keys_http2db(content, http2db_host, reverse=True)
+ if len(warning_text)>0:
+ content["warning"]= warning_text
+ data={'host' : content}
+ return format_out(data)
+ else:
+ bottle.abort(HTTP_Bad_Request, content)
+ return
+
+@bottle.route(url_base + '/hosts/<host_id>', method='PUT')
+def http_put_host_id(host_id):
+ '''modify a host into the database. All resources are got and inserted'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check permissions
+ if not my.admin:
+ bottle.abort(HTTP_Unauthorized, "Needed admin privileges")
+
+ #parse input data
+ http_content = format_in( host_edit_schema )
+ r = remove_extra_items(http_content, host_edit_schema)
+ if r is not None: print "http_post_host_id: Warning: remove extra items ", r
+ change_keys_http2db(http_content['host'], http2db_host)
+
+ #insert in data base
+ result, content = my.db.edit_host(host_id, http_content['host'])
+ if result >= 0:
+ convert_boolean(content, ('admin_state_up',) )
+ change_keys_http2db(content, http2db_host, reverse=True)
+ data={'host' : content}
+
+ #reload thread
+ config_dic['host_threads'][host_id].name = content.get('name',content['ip_name'])
+ config_dic['host_threads'][host_id].user = content['user']
+ config_dic['host_threads'][host_id].host = content['ip_name']
+ config_dic['host_threads'][host_id].insert_task("reload")
+
+ #print data
+ return format_out(data)
+ else:
+ bottle.abort(HTTP_Bad_Request, content)
+ return
+
+
+
+@bottle.route(url_base + '/hosts/<host_id>', method='DELETE')
+def http_delete_host_id(host_id):
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check permissions
+ if not my.admin:
+ bottle.abort(HTTP_Unauthorized, "Needed admin privileges")
+ result, content = my.db.delete_row('hosts', host_id)
+ if result == 0:
+ bottle.abort(HTTP_Not_Found, content)
+ elif result >0:
+ #terminate thread
+ if host_id in config_dic['host_threads']:
+ config_dic['host_threads'][host_id].insert_task("exit")
+ #return data
+ data={'result' : content}
+ return format_out(data)
+ else:
+ print "http_delete_host_id error",result, content
+ bottle.abort(-result, content)
+ return
+
+
+
+#
+# TENANTS
+#
+
+@bottle.route(url_base + '/tenants', method='GET')
+def http_get_tenants():
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ select_,where_,limit_ = filter_query_string(bottle.request.query, http2db_tenant,
+ ('id','name','description','enabled') )
+ result, content = my.db.get_table(FROM='tenants', SELECT=select_,WHERE=where_,LIMIT=limit_)
+ if result < 0:
+ print "http_get_tenants Error", content
+ bottle.abort(-result, content)
+ else:
+ change_keys_http2db(content, http2db_tenant, reverse=True)
+ convert_boolean(content, ('enabled',))
+ data={'tenants' : content}
+ #data['tenants_links'] = dict([('tenant', row['id']) for row in content])
+ return format_out(data)
+
+@bottle.route(url_base + '/tenants/<tenant_id>', method='GET')
+def http_get_tenant_id(tenant_id):
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ result, content = my.db.get_table(FROM='tenants', SELECT=('uuid','name','description', 'enabled'),WHERE={'uuid': tenant_id} )
+ if result < 0:
+ print "http_get_tenant_id error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ elif result==0:
+ print "http_get_tenant_id tenant '%s' not found" % tenant_id
+ bottle.abort(HTTP_Not_Found, "tenant %s not found" % tenant_id)
+ else:
+ change_keys_http2db(content, http2db_tenant, reverse=True)
+ convert_boolean(content, ('enabled',))
+ data={'tenant' : content[0]}
+ #data['tenants_links'] = dict([('tenant', row['id']) for row in content])
+ return format_out(data)
+
+
+@bottle.route(url_base + '/tenants', method='POST')
+def http_post_tenants():
+ '''insert a tenant into the database.'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #parse input data
+ http_content = format_in( tenant_new_schema )
+ r = remove_extra_items(http_content, tenant_new_schema)
+ if r is not None: print "http_post_tenants: Warning: remove extra items ", r
+ change_keys_http2db(http_content['tenant'], http2db_tenant)
+
+ #insert in data base
+ result, content = my.db.new_tenant(http_content['tenant'])
+
+ if result >= 0:
+ return http_get_tenant_id(content)
+ else:
+ bottle.abort(-result, content)
+ return
+
+@bottle.route(url_base + '/tenants/<tenant_id>', method='PUT')
+def http_put_tenant_id(tenant_id):
+ '''update a tenant into the database.'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #parse input data
+ http_content = format_in( tenant_edit_schema )
+ r = remove_extra_items(http_content, tenant_edit_schema)
+ if r is not None: print "http_put_tenant_id: Warning: remove extra items ", r
+ change_keys_http2db(http_content['tenant'], http2db_tenant)
+
+ #insert in data base
+ result, content = my.db.update_rows('tenants', http_content['tenant'], WHERE={'uuid': tenant_id}, log=True )
+ if result >= 0:
+ return http_get_tenant_id(tenant_id)
+ else:
+ bottle.abort(-result, content)
+ return
+
+@bottle.route(url_base + '/tenants/<tenant_id>', method='DELETE')
+def http_delete_tenant_id(tenant_id):
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check permissions
+ r, tenants_flavors = my.db.get_table(FROM='tenants_flavors', SELECT=('flavor_id','tenant_id'), WHERE={'tenant_id': tenant_id})
+ if r<=0:
+ tenants_flavors=()
+ r, tenants_images = my.db.get_table(FROM='tenants_images', SELECT=('image_id','tenant_id'), WHERE={'tenant_id': tenant_id})
+ if r<=0:
+ tenants_images=()
+ result, content = my.db.delete_row('tenants', tenant_id)
+ if result == 0:
+ bottle.abort(HTTP_Not_Found, content)
+ elif result >0:
+ print "alf", tenants_flavors, tenants_images
+ for flavor in tenants_flavors:
+ my.db.delete_row_by_key("flavors", "uuid", flavor['flavor_id'])
+ for image in tenants_images:
+ my.db.delete_row_by_key("images", "uuid", image['image_id'])
+ data={'result' : content}
+ return format_out(data)
+ else:
+ print "http_delete_tenant_id error",result, content
+ bottle.abort(-result, content)
+ return
+
+#
+# FLAVORS
+#
+
+@bottle.route(url_base + '/<tenant_id>/flavors', method='GET')
+def http_get_flavors(tenant_id):
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ #obtain data
+ select_,where_,limit_ = filter_query_string(bottle.request.query, http2db_flavor,
+ ('id','name','description','public') )
+ if tenant_id=='any':
+ from_ ='flavors'
+ else:
+ from_ ='tenants_flavors inner join flavors on tenants_flavors.flavor_id=flavors.uuid'
+ where_['tenant_id'] = tenant_id
+ result, content = my.db.get_table(FROM=from_, SELECT=select_, WHERE=where_, LIMIT=limit_)
+ if result < 0:
+ print "http_get_flavors Error", content
+ bottle.abort(-result, content)
+ else:
+ change_keys_http2db(content, http2db_flavor, reverse=True)
+ for row in content:
+ row['links']=[ {'href': "/".join( (my.url_preffix, tenant_id, 'flavors', str(row['id']) ) ), 'rel':'bookmark' } ]
+ data={'flavors' : content}
+ return format_out(data)
+
+@bottle.route(url_base + '/<tenant_id>/flavors/<flavor_id>', method='GET')
+def http_get_flavor_id(tenant_id, flavor_id):
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ #obtain data
+ select_,where_,limit_ = filter_query_string(bottle.request.query, http2db_flavor,
+ ('id','name','description','ram', 'vcpus', 'extended', 'disk', 'public') )
+ if tenant_id=='any':
+ from_ ='flavors'
+ else:
+ from_ ='tenants_flavors as tf inner join flavors as f on tf.flavor_id=f.uuid'
+ where_['tenant_id'] = tenant_id
+ where_['uuid'] = flavor_id
+ result, content = my.db.get_table(SELECT=select_, FROM=from_, WHERE=where_, LIMIT=limit_)
+
+ if result < 0:
+ print "http_get_flavor_id error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ elif result==0:
+ print "http_get_flavors_id flavor '%s' not found" % str(flavor_id)
+ bottle.abort(HTTP_Not_Found, 'flavor %s not found' % flavor_id)
+ else:
+ change_keys_http2db(content, http2db_flavor, reverse=True)
+ if 'extended' in content[0] and content[0]['extended'] is not None:
+ extended = json.loads(content[0]['extended'])
+ if 'devices' in extended:
+ change_keys_http2db(extended['devices'], http2db_flavor, reverse=True)
+ content[0]['extended']=extended
+ convert_bandwidth(content[0], reverse=True)
+ content[0]['links']=[ {'href': "/".join( (my.url_preffix, tenant_id, 'flavors', str(content[0]['id']) ) ), 'rel':'bookmark' } ]
+ data={'flavor' : content[0]}
+ #data['tenants_links'] = dict([('tenant', row['id']) for row in content])
+ return format_out(data)
+
+
+@bottle.route(url_base + '/<tenant_id>/flavors', method='POST')
+def http_post_flavors(tenant_id):
+ '''insert a flavor into the database, and attach to tenant.'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ http_content = format_in( flavor_new_schema )
+ r = remove_extra_items(http_content, flavor_new_schema)
+ if r is not None: print "http_post_flavors: Warning: remove extra items ", r
+ change_keys_http2db(http_content['flavor'], http2db_flavor)
+ extended_dict = http_content['flavor'].pop('extended', None)
+ if extended_dict is not None:
+ result, content = check_extended(extended_dict)
+ if result<0:
+ print "http_post_flavors wrong input extended error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ return
+ convert_bandwidth(extended_dict)
+ if 'devices' in extended_dict: change_keys_http2db(extended_dict['devices'], http2db_flavor)
+ http_content['flavor']['extended'] = json.dumps(extended_dict)
+ #insert in data base
+ result, content = my.db.new_flavor(http_content['flavor'], tenant_id)
+ if result >= 0:
+ return http_get_flavor_id(tenant_id, content)
+ else:
+ print "http_psot_flavors error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ return
+
+@bottle.route(url_base + '/<tenant_id>/flavors/<flavor_id>', method='DELETE')
+def http_delete_flavor_id(tenant_id, flavor_id):
+ '''Deletes the flavor_id of a tenant. IT removes from tenants_flavors table.'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ return
+ result, content = my.db.delete_image_flavor('flavor', flavor_id, tenant_id)
+ if result == 0:
+ bottle.abort(HTTP_Not_Found, content)
+ elif result >0:
+ data={'result' : content}
+ return format_out(data)
+ else:
+ print "http_delete_flavor_id error",result, content
+ bottle.abort(-result, content)
+ return
+
+@bottle.route(url_base + '/<tenant_id>/flavors/<flavor_id>/<action>', method='POST')
+def http_attach_detach_flavors(tenant_id, flavor_id, action):
+ '''attach/detach an existing flavor in this tenant. That is insert/remove at tenants_flavors table.'''
+ #TODO alf: not tested at all!!!
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ if tenant_id=='any':
+ bottle.abort(HTTP_Bad_Request, "Invalid tenant 'any' with this command")
+ #check valid action
+ if action!='attach' and action != 'detach':
+ bottle.abort(HTTP_Method_Not_Allowed, "actions can be attach or detach")
+ return
+
+ #Ensure that flavor exist
+ from_ ='tenants_flavors as tf right join flavors as f on tf.flavor_id=f.uuid'
+ where_={'uuid': flavor_id}
+ result, content = my.db.get_table(SELECT=('public','tenant_id'), FROM=from_, WHERE=where_)
+ if result==0:
+ if action=='attach':
+ text_error="Flavor '%s' not found" % flavor_id
+ else:
+ text_error="Flavor '%s' not found for tenant '%s'" % (flavor_id, tenant_id)
+ bottle.abort(HTTP_Not_Found, text_error)
+ return
+ elif result>0:
+ flavor=content[0]
+ if action=='attach':
+ if flavor['tenant_id']!=None:
+ bottle.abort(HTTP_Conflict, "Flavor '%s' already attached to tenant '%s'" % (flavor_id, tenant_id))
+ if flavor['public']=='no' and not my.admin:
+ #allow only attaching public flavors
+ bottle.abort(HTTP_Unauthorized, "Needed admin rights to attach a private flavor")
+ return
+ #insert in data base
+ result, content = my.db.new_row('tenants_flavors', {'flavor_id':flavor_id, 'tenant_id': tenant_id})
+ if result >= 0:
+ return http_get_flavor_id(tenant_id, flavor_id)
+ else: #detach
+ if flavor['tenant_id']==None:
+ bottle.abort(HTTP_Not_Found, "Flavor '%s' not attached to tenant '%s'" % (flavor_id, tenant_id))
+ result, content = my.db.delete_row_by_dict(FROM='tenants_flavors', WHERE={'flavor_id':flavor_id, 'tenant_id':tenant_id})
+ if result>=0:
+ if flavor['public']=='no':
+ #try to delete the flavor completely to avoid orphan flavors, IGNORE error
+ my.db.delete_row_by_dict(FROM='flavors', WHERE={'uuid':flavor_id})
+ data={'result' : "flavor detached"}
+ return format_out(data)
+
+ #if get here is because an error
+ print "http_attach_detach_flavors error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ return
+
+@bottle.route(url_base + '/<tenant_id>/flavors/<flavor_id>', method='PUT')
+def http_put_flavor_id(tenant_id, flavor_id):
+ '''update a flavor_id into the database.'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ #parse input data
+ http_content = format_in( flavor_update_schema )
+ r = remove_extra_items(http_content, flavor_update_schema)
+ if r is not None: print "http_put_flavor_id: Warning: remove extra items ", r
+ change_keys_http2db(http_content['flavor'], http2db_flavor)
+ extended_dict = http_content['flavor'].pop('extended', None)
+ if extended_dict is not None:
+ result, content = check_extended(extended_dict)
+ if result<0:
+ print "http_put_flavor_id wrong input extended error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ return
+ convert_bandwidth(extended_dict)
+ if 'devices' in extended_dict: change_keys_http2db(extended_dict['devices'], http2db_flavor)
+ http_content['flavor']['extended'] = json.dumps(extended_dict)
+ #Ensure that flavor exist
+ where_={'uuid': flavor_id}
+ if tenant_id=='any':
+ from_ ='flavors'
+ else:
+ from_ ='tenants_flavors as ti inner join flavors as i on ti.flavor_id=i.uuid'
+ where_['tenant_id'] = tenant_id
+ result, content = my.db.get_table(SELECT=('public',), FROM=from_, WHERE=where_)
+ if result==0:
+ text_error="Flavor '%s' not found" % flavor_id
+ if tenant_id!='any':
+ text_error +=" for tenant '%s'" % flavor_id
+ bottle.abort(HTTP_Not_Found, text_error)
+ return
+ elif result>0:
+ if content[0]['public']=='yes' and not my.admin:
+ #allow only modifications over private flavors
+ bottle.abort(HTTP_Unauthorized, "Needed admin rights to edit a public flavor")
+ return
+ #insert in data base
+ result, content = my.db.update_rows('flavors', http_content['flavor'], {'uuid': flavor_id})
+
+ if result < 0:
+ print "http_put_flavor_id error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ return
+ else:
+ return http_get_flavor_id(tenant_id, flavor_id)
+
+
+
+#
+# IMAGES
+#
+
+@bottle.route(url_base + '/<tenant_id>/images', method='GET')
+def http_get_images(tenant_id):
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ #obtain data
+ select_,where_,limit_ = filter_query_string(bottle.request.query, http2db_image,
+ ('id','name','description','path','public') )
+ if tenant_id=='any':
+ from_ ='images'
+ else:
+ from_ ='tenants_images inner join images on tenants_images.image_id=images.uuid'
+ where_['tenant_id'] = tenant_id
+ result, content = my.db.get_table(SELECT=select_, FROM=from_, WHERE=where_, LIMIT=limit_)
+ if result < 0:
+ print "http_get_images Error", content
+ bottle.abort(-result, content)
+ else:
+ change_keys_http2db(content, http2db_image, reverse=True)
+ #for row in content: row['links']=[ {'href': "/".join( (my.url_preffix, tenant_id, 'images', str(row['id']) ) ), 'rel':'bookmark' } ]
+ data={'images' : content}
+ return format_out(data)
+
+@bottle.route(url_base + '/<tenant_id>/images/<image_id>', method='GET')
+def http_get_image_id(tenant_id, image_id):
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ #obtain data
+ select_,where_,limit_ = filter_query_string(bottle.request.query, http2db_image,
+ ('id','name','description','progress', 'status','path', 'created', 'updated','public') )
+ if tenant_id=='any':
+ from_ ='images'
+ else:
+ from_ ='tenants_images as ti inner join images as i on ti.image_id=i.uuid'
+ where_['tenant_id'] = tenant_id
+ where_['uuid'] = image_id
+ result, content = my.db.get_table(SELECT=select_, FROM=from_, WHERE=where_, LIMIT=limit_)
+
+ if result < 0:
+ print "http_get_images error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ elif result==0:
+ print "http_get_images image '%s' not found" % str(image_id)
+ bottle.abort(HTTP_Not_Found, 'image %s not found' % image_id)
+ else:
+ convert_datetime2str(content)
+ change_keys_http2db(content, http2db_image, reverse=True)
+ if 'metadata' in content[0] and content[0]['metadata'] is not None:
+ metadata = json.loads(content[0]['metadata'])
+ content[0]['metadata']=metadata
+ content[0]['links']=[ {'href': "/".join( (my.url_preffix, tenant_id, 'images', str(content[0]['id']) ) ), 'rel':'bookmark' } ]
+ data={'image' : content[0]}
+ #data['tenants_links'] = dict([('tenant', row['id']) for row in content])
+ return format_out(data)
+
+@bottle.route(url_base + '/<tenant_id>/images', method='POST')
+def http_post_images(tenant_id):
+ '''insert a image into the database, and attach to tenant.'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ http_content = format_in(image_new_schema)
+ r = remove_extra_items(http_content, image_new_schema)
+ if r is not None: print "http_post_images: Warning: remove extra items ", r
+ change_keys_http2db(http_content['image'], http2db_image)
+ metadata_dict = http_content['image'].pop('metadata', None)
+ if metadata_dict is not None:
+ http_content['image']['metadata'] = json.dumps(metadata_dict)
+ #insert in data base
+ result, content = my.db.new_image(http_content['image'], tenant_id)
+ if result >= 0:
+ return http_get_image_id(tenant_id, content)
+ else:
+ print "http_post_images error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ return
+
+@bottle.route(url_base + '/<tenant_id>/images/<image_id>', method='DELETE')
+def http_delete_image_id(tenant_id, image_id):
+ '''Deletes the image_id of a tenant. IT removes from tenants_images table.'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ result, content = my.db.delete_image_flavor('image', image_id, tenant_id)
+ if result == 0:
+ bottle.abort(HTTP_Not_Found, content)
+ elif result >0:
+ data={'result' : content}
+ return format_out(data)
+ else:
+ print "http_delete_image_id error",result, content
+ bottle.abort(-result, content)
+ return
+
+@bottle.route(url_base + '/<tenant_id>/images/<image_id>/<action>', method='POST')
+def http_attach_detach_images(tenant_id, image_id, action):
+ '''attach/detach an existing image in this tenant. That is insert/remove at tenants_images table.'''
+ #TODO alf: not tested at all!!!
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ if tenant_id=='any':
+ bottle.abort(HTTP_Bad_Request, "Invalid tenant 'any' with this command")
+ #check valid action
+ if action!='attach' and action != 'detach':
+ bottle.abort(HTTP_Method_Not_Allowed, "actions can be attach or detach")
+ return
+
+ #Ensure that image exist
+ from_ ='tenants_images as ti right join images as i on ti.image_id=i.uuid'
+ where_={'uuid': image_id}
+ result, content = my.db.get_table(SELECT=('public','tenant_id'), FROM=from_, WHERE=where_)
+ if result==0:
+ if action=='attach':
+ text_error="Image '%s' not found" % image_id
+ else:
+ text_error="Image '%s' not found for tenant '%s'" % (image_id, tenant_id)
+ bottle.abort(HTTP_Not_Found, text_error)
+ return
+ elif result>0:
+ image=content[0]
+ if action=='attach':
+ if image['tenant_id']!=None:
+ bottle.abort(HTTP_Conflict, "Image '%s' already attached to tenant '%s'" % (image_id, tenant_id))
+ if image['public']=='no' and not my.admin:
+ #allow only attaching public images
+ bottle.abort(HTTP_Unauthorized, "Needed admin rights to attach a private image")
+ return
+ #insert in data base
+ result, content = my.db.new_row('tenants_images', {'image_id':image_id, 'tenant_id': tenant_id})
+ if result >= 0:
+ return http_get_image_id(tenant_id, image_id)
+ else: #detach
+ if image['tenant_id']==None:
+ bottle.abort(HTTP_Not_Found, "Image '%s' not attached to tenant '%s'" % (image_id, tenant_id))
+ result, content = my.db.delete_row_by_dict(FROM='tenants_images', WHERE={'image_id':image_id, 'tenant_id':tenant_id})
+ if result>=0:
+ if image['public']=='no':
+ #try to delete the image completely to avoid orphan images, IGNORE error
+ my.db.delete_row_by_dict(FROM='images', WHERE={'uuid':image_id})
+ data={'result' : "image detached"}
+ return format_out(data)
+
+ #if get here is because an error
+ print "http_attach_detach_images error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ return
+
+@bottle.route(url_base + '/<tenant_id>/images/<image_id>', method='PUT')
+def http_put_image_id(tenant_id, image_id):
+ '''update a image_id into the database.'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ #parse input data
+ http_content = format_in( image_update_schema )
+ r = remove_extra_items(http_content, image_update_schema)
+ if r is not None: print "http_put_image_id: Warning: remove extra items ", r
+ change_keys_http2db(http_content['image'], http2db_image)
+ metadata_dict = http_content['image'].pop('metadata', None)
+ if metadata_dict is not None:
+ http_content['image']['metadata'] = json.dumps(metadata_dict)
+ #Ensure that image exist
+ where_={'uuid': image_id}
+ if tenant_id=='any':
+ from_ ='images'
+ else:
+ from_ ='tenants_images as ti inner join images as i on ti.image_id=i.uuid'
+ where_['tenant_id'] = tenant_id
+ result, content = my.db.get_table(SELECT=('public',), FROM=from_, WHERE=where_)
+ if result==0:
+ text_error="Image '%s' not found" % image_id
+ if tenant_id!='any':
+ text_error +=" for tenant '%s'" % image_id
+ bottle.abort(HTTP_Not_Found, text_error)
+ return
+ elif result>0:
+ if content[0]['public']=='yes' and not my.admin:
+ #allow only modifications over private images
+ bottle.abort(HTTP_Unauthorized, "Needed admin rights to edit a public image")
+ return
+ #insert in data base
+ result, content = my.db.update_rows('images', http_content['image'], {'uuid': image_id})
+
+ if result < 0:
+ print "http_put_image_id error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ return
+ else:
+ return http_get_image_id(tenant_id, image_id)
+
+
+#
+# SERVERS
+#
+
+@bottle.route(url_base + '/<tenant_id>/servers', method='GET')
+def http_get_servers(tenant_id):
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ return
+ #obtain data
+ select_,where_,limit_ = filter_query_string(bottle.request.query, http2db_server,
+ ('id','name','description','hostId','imageRef','flavorRef','status', 'tenant_id') )
+ if tenant_id!='any':
+ where_['tenant_id'] = tenant_id
+ result, content = my.db.get_table(SELECT=select_, FROM='instances', WHERE=where_, LIMIT=limit_)
+ if result < 0:
+ print "http_get_servers Error", content
+ bottle.abort(-result, content)
+ else:
+ change_keys_http2db(content, http2db_server, reverse=True)
+ for row in content:
+ tenant_id = row.pop('tenant_id')
+ row['links']=[ {'href': "/".join( (my.url_preffix, tenant_id, 'servers', str(row['id']) ) ), 'rel':'bookmark' } ]
+ data={'servers' : content}
+ return format_out(data)
+
+@bottle.route(url_base + '/<tenant_id>/servers/<server_id>', method='GET')
+def http_get_server_id(tenant_id, server_id):
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ return
+ #obtain data
+ result, content = my.db.get_instance(server_id)
+ if result == 0:
+ bottle.abort(HTTP_Not_Found, content)
+ elif result >0:
+ #change image/flavor-id to id and link
+ convert_bandwidth(content, reverse=True)
+ convert_datetime2str(content)
+ if content["ram"]==0 : del content["ram"]
+ if content["vcpus"]==0 : del content["vcpus"]
+ if 'flavor_id' in content:
+ if content['flavor_id'] is not None:
+ content['flavor'] = {'id':content['flavor_id'],
+ 'links':[{'href': "/".join( (my.url_preffix, content['tenant_id'], 'flavors', str(content['flavor_id']) ) ), 'rel':'bookmark'}]
+ }
+ del content['flavor_id']
+ if 'image_id' in content:
+ if content['image_id'] is not None:
+ content['image'] = {'id':content['image_id'],
+ 'links':[{'href': "/".join( (my.url_preffix, content['tenant_id'], 'images', str(content['image_id']) ) ), 'rel':'bookmark'}]
+ }
+ del content['image_id']
+ change_keys_http2db(content, http2db_server, reverse=True)
+ if 'extended' in content:
+ if 'devices' in content['extended']: change_keys_http2db(content['extended']['devices'], http2db_server, reverse=True)
+
+ data={'server' : content}
+ return format_out(data)
+ else:
+ bottle.abort(-result, content)
+ return
+
+@bottle.route(url_base + '/<tenant_id>/servers', method='POST')
+def http_post_server_id(tenant_id):
+ '''deploys a new server'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ return
+ if tenant_id=='any':
+ bottle.abort(HTTP_Bad_Request, "Invalid tenant 'any' with this command")
+ #chek input
+ http_content = format_in( server_new_schema )
+ r = remove_extra_items(http_content, server_new_schema)
+ if r is not None: print "http_post_serves: Warning: remove extra items ", r
+ change_keys_http2db(http_content['server'], http2db_server)
+ extended_dict = http_content['server'].get('extended', None)
+ if extended_dict is not None:
+ result, content = check_extended(extended_dict, True)
+ if result<0:
+ print "http_post_servers wrong input extended error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ return
+ convert_bandwidth(extended_dict)
+ if 'devices' in extended_dict: change_keys_http2db(extended_dict['devices'], http2db_server)
+
+ server = http_content['server']
+ server_start = server.get('start', 'yes')
+ server['tenant_id'] = tenant_id
+ #check flavor valid and take info
+ result, content = my.db.get_table(FROM='tenants_flavors as tf join flavors as f on tf.flavor_id=f.uuid',
+ SELECT=('ram','vcpus','extended'), WHERE={'uuid':server['flavor_id'], 'tenant_id':tenant_id})
+ if result<=0:
+ bottle.abort(HTTP_Not_Found, 'flavor_id %s not found' % server['flavor_id'])
+ return
+ server['flavor']=content[0]
+ #check image valid and take info
+ result, content = my.db.get_table(FROM='tenants_images as ti join images as i on ti.image_id=i.uuid',
+ SELECT=('path','metadata'), WHERE={'uuid':server['image_id'], 'tenant_id':tenant_id, "status":"ACTIVE"})
+ if result<=0:
+ bottle.abort(HTTP_Not_Found, 'image_id %s not found or not ACTIVE' % server['image_id'])
+ return
+ server['image']=content[0]
+ if "hosts_id" in server:
+ result, content = my.db.get_table(FROM='hosts', SELECT=('uuid',), WHERE={'uuid': server['host_id']})
+ if result<=0:
+ bottle.abort(HTTP_Not_Found, 'hostId %s not found' % server['host_id'])
+ return
+ #print json.dumps(server, indent=4)
+
+ result, content = ht.create_server(server, config_dic['db'], config_dic['db_lock'], config_dic['mode']=='normal')
+
+ if result >= 0:
+ #Insert instance to database
+ nets=[]
+ print
+ print "inserting at DB"
+ print
+ if server_start == 'no':
+ content['status'] = 'INACTIVE'
+ ports_to_free=[]
+ new_instance_result, new_instance = my.db.new_instance(content, nets, ports_to_free)
+ if new_instance_result < 0:
+ print "Error http_post_servers() :", new_instance_result, new_instance
+ bottle.abort(-new_instance_result, new_instance)
+ return
+ print
+ print "inserted at DB"
+ print
+ for port in ports_to_free:
+ r,c = config_dic['host_threads'][ server['host_id'] ].insert_task( 'restore-iface',*port )
+ if r < 0:
+ print ' http_post_servers ERROR RESTORE IFACE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!' + c
+ #updata nets
+ for net in nets:
+ r,c = config_dic['of_thread'].insert_task("update-net", net)
+ if r < 0:
+ print ':http_post_servers ERROR UPDATING NETS !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!' + c
+
+
+
+ #look for dhcp ip address
+ r2, c2 = my.db.get_table(FROM="ports", SELECT=["mac", "net_id"], WHERE={"instance_id": new_instance})
+ if r2 >0 and config_dic.get("dhcp_server"):
+ for iface in c2:
+ if iface["net_id"] in config_dic["dhcp_nets"]:
+ #print "dhcp insert add task"
+ r,c = config_dic['dhcp_thread'].insert_task("add", iface["mac"])
+ if r < 0:
+ print ':http_post_servers ERROR UPDATING dhcp_server !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!' + c
+
+ #Start server
+
+ server['uuid'] = new_instance
+ #server_start = server.get('start', 'yes')
+ if server_start != 'no':
+ server['paused'] = True if server_start == 'paused' else False
+ server['action'] = {"start":None}
+ server['status'] = "CREATING"
+ #Program task
+ r,c = config_dic['host_threads'][ server['host_id'] ].insert_task( 'instance',server )
+ if r<0:
+ my.db.update_rows('instances', {'status':"ERROR"}, {'uuid':server['uuid'], 'last_error':c}, log=True)
+
+ return http_get_server_id(tenant_id, new_instance)
+ else:
+ bottle.abort(HTTP_Bad_Request, content)
+ return
+
+def http_server_action(server_id, tenant_id, action):
+ '''Perform actions over a server as resume, reboot, terminate, ...'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ server={"uuid": server_id, "action":action}
+ where={'uuid': server_id}
+ if tenant_id!='any':
+ where['tenant_id']= tenant_id
+ result, content = my.db.get_table(FROM='instances', WHERE=where)
+ if result == 0:
+ bottle.abort(HTTP_Not_Found, "server %s not found" % server_id)
+ return
+ if result < 0:
+ print "http_post_server_action error getting data %d %s" % (result, content)
+ bottle.abort(HTTP_Internal_Server_Error, content)
+ return
+ server.update(content[0])
+ tenant_id = server["tenant_id"]
+
+ #TODO check a right content
+ new_status = None
+ if 'terminate' in action:
+ new_status='DELETING'
+ elif server['status'] == 'ERROR': #or server['status'] == 'CREATING':
+ if 'terminate' not in action and 'rebuild' not in action:
+ bottle.abort(HTTP_Method_Not_Allowed, "Server is in ERROR status, must be rebuit or deleted ")
+ return
+# elif server['status'] == 'INACTIVE':
+# if 'start' not in action and 'createImage' not in action:
+# bottle.abort(HTTP_Method_Not_Allowed, "The only possible action over an instance in 'INACTIVE' status is 'start'")
+# return
+# if 'start' in action:
+# new_status='CREATING'
+# server['paused']='no'
+# elif server['status'] == 'PAUSED':
+# if 'resume' not in action:
+# bottle.abort(HTTP_Method_Not_Allowed, "The only possible action over an instance in 'PAUSED' status is 'resume'")
+# return
+# elif server['status'] == 'ACTIVE':
+# if 'pause' not in action and 'reboot'not in action and 'shutoff'not in action:
+# bottle.abort(HTTP_Method_Not_Allowed, "The only possible action over an instance in 'ACTIVE' status is 'pause','reboot' or 'shutoff'")
+# return
+
+ if 'start' in action or 'createImage' in action or 'rebuild' in action:
+ #check image valid and take info
+ image_id = server['image_id']
+ if 'createImage' in action:
+ if 'imageRef' in action['createImage']:
+ image_id = action['createImage']['imageRef']
+ elif 'disk' in action['createImage']:
+ result, content = my.db.get_table(FROM='instance_devices',
+ SELECT=('image_id','dev'), WHERE={'instance_id':server['uuid'],"type":"disk"})
+ if result<=0:
+ bottle.abort(HTTP_Not_Found, 'disk not found for server')
+ return
+ elif result>1:
+ disk_id=None
+ if action['createImage']['imageRef']['disk'] != None:
+ for disk in content:
+ if disk['dev'] == action['createImage']['imageRef']['disk']:
+ disk_id = disk['image_id']
+ break
+ if disk_id == None:
+ bottle.abort(HTTP_Not_Found, 'disk %s not found for server' % action['createImage']['imageRef']['disk'])
+ return
+ else:
+ bottle.abort(HTTP_Not_Found, 'more than one disk found for server' )
+ return
+ image_id = disk_id
+ else: #result==1
+ image_id = content[0]['image_id']
+
+ result, content = my.db.get_table(FROM='tenants_images as ti join images as i on ti.image_id=i.uuid',
+ SELECT=('path','metadata'), WHERE={'uuid':image_id, 'tenant_id':tenant_id, "status":"ACTIVE"})
+ if result<=0:
+ bottle.abort(HTTP_Not_Found, 'image_id %s not found or not ACTIVE' % image_id)
+ return
+ if content[0]['metadata'] is not None:
+ try:
+ metadata = json.loads(content[0]['metadata'])
+ except:
+ return -HTTP_Internal_Server_Error, "Can not decode image metadata"
+ content[0]['metadata']=metadata
+ else:
+ content[0]['metadata'] = {}
+ server['image']=content[0]
+ if 'createImage' in action:
+ action['createImage']['source'] = {'image_id': image_id, 'path': content[0]['path']}
+ if 'createImage' in action:
+ #Create an entry in Database for the new image
+ new_image={'status':'BUILD', 'progress': 0 }
+ new_image_metadata=content[0]
+ if 'metadata' in server['image'] and server['image']['metadata'] != None:
+ new_image_metadata.update(server['image']['metadata'])
+ new_image_metadata = {"use_incremental":"no"}
+ if 'metadata' in action['createImage']:
+ new_image_metadata.update(action['createImage']['metadata'])
+ new_image['metadata'] = json.dumps(new_image_metadata)
+ new_image['name'] = action['createImage'].get('name', None)
+ new_image['description'] = action['createImage'].get('description', None)
+ new_image['uuid']=my.db.new_uuid()
+ if 'path' in action['createImage']:
+ new_image['path'] = action['createImage']['path']
+ else:
+ new_image['path']="/provisional/path/" + new_image['uuid']
+ result, image_uuid = my.db.new_image(new_image, tenant_id)
+ if result<=0:
+ bottle.abort(HTTP_Bad_Request, 'Error: ' + image_uuid)
+ return
+ server['new_image'] = new_image
+
+
+ #Program task
+ r,c = config_dic['host_threads'][ server['host_id'] ].insert_task( 'instance',server )
+ if r<0:
+ print "Task queue full at host ", server['host_id']
+ bottle.abort(HTTP_Request_Timeout, c)
+ if 'createImage' in action and result >= 0:
+ return http_get_image_id(tenant_id, image_uuid)
+
+ #Update DB only for CREATING or DELETING status
+ data={'result' : 'in process'}
+ if new_status != None and new_status == 'DELETING':
+ nets=[]
+ ports_to_free=[]
+ #look for dhcp ip address
+ r2, c2 = my.db.get_table(FROM="ports", SELECT=["mac", "net_id"], WHERE={"instance_id": server_id})
+ r,c = my.db.delete_instance(server_id, tenant_id, nets, ports_to_free, "requested by http")
+ for port in ports_to_free:
+ r1,c1 = config_dic['host_threads'][ server['host_id'] ].insert_task( 'restore-iface',*port )
+ if r1 < 0:
+ print ' http_post_server_action error at server deletion ERROR resore-iface !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!' + c1
+ data={'result' : 'deleting in process, but ifaces cannot be restored!!!!!'}
+ for net in nets:
+ r1,c1 = config_dic['of_thread'].insert_task("update-net", net)
+ if r1 < 0:
+ print ' http_post_server_action error at server deletion ERROR UPDATING NETS !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!' + c1
+ data={'result' : 'deleting in process, but openflow rules cannot be deleted!!!!!'}
+ #look for dhcp ip address
+ if r2 >0 and config_dic.get("dhcp_server"):
+ for iface in c2:
+ if iface["net_id"] in config_dic["dhcp_nets"]:
+ r,c = config_dic['dhcp_thread'].insert_task("del", iface["mac"])
+ #print "dhcp insert del task"
+ if r < 0:
+ print ':http_post_servers ERROR UPDATING dhcp_server !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!' + c
+
+ return format_out(data)
+
+
+
+@bottle.route(url_base + '/<tenant_id>/servers/<server_id>', method='DELETE')
+def http_delete_server_id(tenant_id, server_id):
+ '''delete a server'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ return
+
+ return http_server_action(server_id, tenant_id, {"terminate":None} )
+
+
+@bottle.route(url_base + '/<tenant_id>/servers/<server_id>/action', method='POST')
+def http_post_server_action(tenant_id, server_id):
+ '''take an action over a server'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #check valid tenant_id
+ result,content = check_valid_tenant(my, tenant_id)
+ if result != 0:
+ bottle.abort(result, content)
+ return
+ http_content = format_in( server_action_schema )
+ #r = remove_extra_items(http_content, server_action_schema)
+ #if r is not None: print "http_post_server_action: Warning: remove extra items ", r
+
+ return http_server_action(server_id, tenant_id, http_content)
+
+#
+# NETWORKS
+#
+
+
+@bottle.route(url_base + '/networks', method='GET')
+def http_get_networks():
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #obtain data
+ select_,where_,limit_ = filter_query_string(bottle.request.query, http2db_network,
+ ('id','name','tenant_id','type',
+ 'shared','provider:vlan','status','last_error','admin_state_up','provider:physical') )
+ #TODO temporally remove tenant_id
+ if "tenant_id" in where_:
+ del where_["tenant_id"]
+ result, content = my.db.get_table(SELECT=select_, FROM='nets', WHERE=where_, LIMIT=limit_)
+ if result < 0:
+ print "http_get_networks error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ else:
+ convert_boolean(content, ('shared', 'admin_state_up', 'enable_dhcp') )
+ delete_nulls(content)
+ change_keys_http2db(content, http2db_network, reverse=True)
+ data={'networks' : content}
+ return format_out(data)
+
+@bottle.route(url_base + '/networks/<network_id>', method='GET')
+def http_get_network_id(network_id):
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #obtain data
+ where_ = bottle.request.query
+ where_['uuid'] = network_id
+ result, content = my.db.get_table(FROM='nets', WHERE=where_, LIMIT=100)
+
+ if result < 0:
+ print "http_get_networks_id error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ elif result==0:
+ print "http_get_networks_id network '%s' not found" % network_id
+ bottle.abort(HTTP_Not_Found, 'network %s not found' % network_id)
+ else:
+ convert_boolean(content, ('shared', 'admin_state_up', 'enale_dhcp') )
+ change_keys_http2db(content, http2db_network, reverse=True)
+ #get ports
+ result, ports = my.db.get_table(FROM='ports', SELECT=('uuid as port_id',),
+ WHERE={'net_id': network_id}, LIMIT=100)
+ if len(ports) > 0:
+ content[0]['ports'] = ports
+ delete_nulls(content[0])
+ data={'network' : content[0]}
+ return format_out(data)
+
+@bottle.route(url_base + '/networks', method='POST')
+def http_post_networks():
+ '''insert a network into the database.'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #parse input data
+ http_content = format_in( network_new_schema )
+ r = remove_extra_items(http_content, network_new_schema)
+ if r is not None: print "http_post_networks: Warning: remove extra items ", r
+ change_keys_http2db(http_content['network'], http2db_network)
+ network=http_content['network']
+ #check valid tenant_id
+ tenant_id= network.get('tenant_id')
+ if tenant_id!=None:
+ result, _ = my.db.get_table(FROM='tenants', SELECT=('uuid',), WHERE={'uuid': tenant_id,"enabled":True})
+ if result<=0:
+ bottle.abort(HTTP_Not_Found, 'tenant %s not found or not enabled' % tenant_id)
+ return
+ bridge_net = None
+ #check valid params
+ net_provider = network.get('provider')
+ net_type = network.get('type')
+ net_vlan = network.get("vlan")
+ net_bind_net = network.get("bind_net")
+ net_bind_type= network.get("bind_type")
+ name = network["name"]
+
+ #check if network name ends with :<vlan_tag> and network exist in order to make and automated bindning
+ vlan_index =name.rfind(":")
+ if net_bind_net==None and net_bind_type==None and vlan_index > 1:
+ try:
+ vlan_tag = int(name[vlan_index+1:])
+ if vlan_tag >0 and vlan_tag < 4096:
+ net_bind_net = name[:vlan_index]
+ net_bind_type = "vlan:" + name[vlan_index+1:]
+ except:
+ pass
+
+ if net_bind_net != None:
+ #look for a valid net
+ if check_valid_uuid(net_bind_net):
+ net_bind_key = "uuid"
+ else:
+ net_bind_key = "name"
+ result, content = my.db.get_table(FROM='nets', WHERE={net_bind_key: net_bind_net} )
+ if result<0:
+ bottle.abort(HTTP_Internal_Server_Error, 'getting nets from db ' + content)
+ return
+ elif result==0:
+ bottle.abort(HTTP_Bad_Request, "bind_net %s '%s'not found" % (net_bind_key, net_bind_net) )
+ return
+ elif result>1:
+ bottle.abort(HTTP_Bad_Request, "more than one bind_net %s '%s' found, use uuid" % (net_bind_key, net_bind_net) )
+ return
+ network["bind_net"] = content[0]["uuid"]
+ if net_bind_type != None:
+ if net_bind_type[0:5] != "vlan:":
+ bottle.abort(HTTP_Bad_Request, "bad format for 'bind_type', must be 'vlan:<tag>'")
+ return
+ if int(net_bind_type[5:]) > 4095 or int(net_bind_type[5:])<=0 :
+ bottle.abort(HTTP_Bad_Request, "bad format for 'bind_type', must be 'vlan:<tag>' with a tag between 1 and 4095")
+ return
+ network["bind_type"] = net_bind_type
+
+ if net_provider!=None:
+ if net_provider[:9]=="openflow:":
+ if net_type!=None:
+ if net_type!="ptp" and net_type!="data":
+ bottle.abort(HTTP_Bad_Request, "Only 'ptp' or 'data' net types can be bound to 'openflow'")
+ else:
+ net_type='data'
+ else:
+ if net_type!=None:
+ if net_type!="bridge_man" and net_type!="bridge_data":
+ bottle.abort(HTTP_Bad_Request, "Only 'bridge_man' or 'bridge_data' net types can be bound to 'bridge', 'macvtap' or 'default")
+ else:
+ net_type='bridge_man'
+
+ if net_type==None:
+ net_type='bridge_man'
+
+ if net_provider != None:
+ if net_provider[:7]=='bridge:':
+ #check it is one of the pre-provisioned bridges
+ bridge_net_name = net_provider[7:]
+ for brnet in config_dic['bridge_nets']:
+ if brnet[0]==bridge_net_name: # free
+ if brnet[3] != None:
+ bottle.abort(HTTP_Conflict, "invalid 'provider:physical', bridge '%s' is already used" % bridge_net_name)
+ return
+ bridge_net=brnet
+ net_vlan = brnet[1]
+ break
+# if bridge_net==None:
+# bottle.abort(HTTP_Bad_Request, "invalid 'provider:physical', bridge '%s' is not one of the provisioned 'bridge_ifaces' in the configuration file" % bridge_net_name)
+# return
+ elif net_type=='bridge_data' or net_type=='bridge_man':
+ #look for a free precreated nets
+ for brnet in config_dic['bridge_nets']:
+ if brnet[3]==None: # free
+ if bridge_net != None:
+ if net_type=='bridge_man': #look for the smaller speed
+ if brnet[2] < bridge_net[2]: bridge_net = brnet
+ else: #look for the larger speed
+ if brnet[2] > bridge_net[2]: bridge_net = brnet
+ else:
+ bridge_net = brnet
+ net_vlan = brnet[1]
+ if bridge_net==None:
+ bottle.abort(HTTP_Bad_Request, "Max limits of bridge networks reached. Future versions of VIM will overcome this limit")
+ return
+ else:
+ print "using net", bridge_net
+ net_provider = "bridge:"+bridge_net[0]
+ net_vlan = bridge_net[1]
+ if net_vlan==None and (net_type=="data" or net_type=="ptp"):
+ net_vlan = my.db.get_free_net_vlan()
+ if net_vlan < 0:
+ bottle.abort(HTTP_Internal_Server_Error, "Error getting an available vlan")
+ return
+
+ network['provider'] = net_provider
+ network['type'] = net_type
+ network['vlan'] = net_vlan
+ result, content = my.db.new_row('nets', network, True, True)
+
+ if result >= 0:
+ if bridge_net!=None:
+ bridge_net[3] = content
+
+ if config_dic.get("dhcp_server"):
+ if network["name"] in config_dic["dhcp_server"].get("nets", () ):
+ config_dic["dhcp_nets"].append(content)
+ print "dhcp_server: add new net", content
+ elif bridge_net != None and bridge_net[0] in config_dic["dhcp_server"].get("bridge_ifaces", () ):
+ config_dic["dhcp_nets"].append(content)
+ print "dhcp_server: add new net", content
+ return http_get_network_id(content)
+ else:
+ print "http_post_networks error %d %s" % (result, content)
+ bottle.abort(-result, content)
+ return
+
+
+@bottle.route(url_base + '/networks/<network_id>', method='PUT')
+def http_put_network_id(network_id):
+ '''update a network_id into the database.'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #parse input data
+ http_content = format_in( network_update_schema )
+ r = remove_extra_items(http_content, network_update_schema)
+ change_keys_http2db(http_content['network'], http2db_network)
+ network=http_content['network']
+
+ #Look for the previous data
+ where_ = {'uuid': network_id}
+ result, network_old = my.db.get_table(FROM='nets', WHERE=where_)
+ if result < 0:
+ print "http_put_network_id error %d %s" % (result, network_old)
+ bottle.abort(-result, network_old)
+ return
+ elif result==0:
+ print "http_put_network_id network '%s' not found" % network_id
+ bottle.abort(HTTP_Not_Found, 'network %s not found' % network_id)
+ return
+ #get ports
+ nbports, content = my.db.get_table(FROM='ports', SELECT=('uuid as port_id',),
+ WHERE={'net_id': network_id}, LIMIT=100)
+ if result < 0:
+ print "http_put_network_id error %d %s" % (result, network_old)
+ bottle.abort(-result, content)
+ return
+ if nbports>0:
+ if 'type' in network and network['type'] != network_old[0]['type']:
+ bottle.abort(HTTP_Method_Not_Allowed, "Can not change type of network while having ports attached")
+ if 'vlan' in network and network['vlan'] != network_old[0]['vlan']:
+ bottle.abort(HTTP_Method_Not_Allowed, "Can not change vlan of network while having ports attached")
+
+ #check valid params
+ net_provider = network.get('provider', network_old[0]['provider'])
+ net_type = network.get('type', network_old[0]['type'])
+ net_bind_net = network.get("bind_net")
+ net_bind_type= network.get("bind_type")
+ if net_bind_net != None:
+ #look for a valid net
+ if check_valid_uuid(net_bind_net):
+ net_bind_key = "uuid"
+ else:
+ net_bind_key = "name"
+ result, content = my.db.get_table(FROM='nets', WHERE={net_bind_key: net_bind_net} )
+ if result<0:
+ bottle.abort(HTTP_Internal_Server_Error, 'getting nets from db ' + content)
+ return
+ elif result==0:
+ bottle.abort(HTTP_Bad_Request, "bind_net %s '%s'not found" % (net_bind_key, net_bind_net) )
+ return
+ elif result>1:
+ bottle.abort(HTTP_Bad_Request, "more than one bind_net %s '%s' found, use uuid" % (net_bind_key, net_bind_net) )
+ return
+ network["bind_net"] = content[0]["uuid"]
+ if net_bind_type != None:
+ if net_bind_type[0:5] != "vlan:":
+ bottle.abort(HTTP_Bad_Request, "bad format for 'bind_type', must be 'vlan:<tag>'")
+ return
+ if int(net_bind_type[5:]) > 4095 or int(net_bind_type[5:])<=0 :
+ bottle.abort(HTTP_Bad_Request, "bad format for 'bind_type', must be 'vlan:<tag>' with a tag between 1 and 4095")
+ return
+ if net_provider!=None:
+ if net_provider[:9]=="openflow:":
+ if net_type!="ptp" and net_type!="data":
+ bottle.abort(HTTP_Bad_Request, "Only 'ptp' or 'data' net types can be bound to 'openflow'")
+ else:
+ if net_type!="bridge_man" and net_type!="bridge_data":
+ bottle.abort(HTTP_Bad_Request, "Only 'bridge_man' or 'bridge_data' net types can be bound to 'bridge', 'macvtap' or 'default")
+
+ #insert in data base
+ result, content = my.db.update_rows('nets', network, WHERE={'uuid': network_id}, log=True )
+ if result >= 0:
+ if result>0: # and nbports>0 and 'admin_state_up' in network and network['admin_state_up'] != network_old[0]['admin_state_up']:
+ r,c = config_dic['of_thread'].insert_task("update-net", network_id)
+ if r < 0:
+ print "http_put_network_id error while launching openflow rules"
+ bottle.abort(HTTP_Internal_Server_Error, c)
+ if config_dic.get("dhcp_server"):
+ if network_id in config_dic["dhcp_nets"]:
+ config_dic["dhcp_nets"].remove(network_id)
+ print "dhcp_server: delete net", network_id
+ if network.get("name", network_old["name"]) in config_dic["dhcp_server"].get("nets", () ):
+ config_dic["dhcp_nets"].append(network_id)
+ print "dhcp_server: add new net", network_id
+ else:
+ net_bind = network.get("bind", network_old["bind"] )
+ if net_bind and net_bind[:7]=="bridge:" and net_bind[7:] in config_dic["dhcp_server"].get("bridge_ifaces", () ):
+ config_dic["dhcp_nets"].append(network_id)
+ print "dhcp_server: add new net", network_id
+ return http_get_network_id(network_id)
+ else:
+ bottle.abort(-result, content)
+ return
+
+
+@bottle.route(url_base + '/networks/<network_id>', method='DELETE')
+def http_delete_network_id(network_id):
+ '''delete a network_id from the database.'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+
+ #delete from the data base
+ result, content = my.db.delete_row('nets', network_id )
+
+ if result == 0:
+ bottle.abort(HTTP_Not_Found, content)
+ elif result >0:
+ for brnet in config_dic['bridge_nets']:
+ if brnet[3]==network_id:
+ brnet[3]=None
+ break
+ if config_dic.get("dhcp_server") and network_id in config_dic["dhcp_nets"]:
+ config_dic["dhcp_nets"].remove(network_id)
+ print "dhcp_server: delete net", network_id
+ data={'result' : content}
+ return format_out(data)
+ else:
+ print "http_delete_network_id error",result, content
+ bottle.abort(-result, content)
+ return
+#
+# OPENFLOW
+#
+@bottle.route(url_base + '/networks/<network_id>/openflow', method='GET')
+def http_get_openflow_id(network_id):
+ '''To obtain the list of openflow rules of a network
+ '''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #ignore input data
+ if network_id=='all':
+ where_={}
+ else:
+ where_={"net_id": network_id}
+ result, content = my.db.get_table(SELECT=("name","net_id","priority","vlan_id","ingress_port","src_mac","dst_mac","actions"),
+ WHERE=where_, FROM='of_flows')
+ if result < 0:
+ bottle.abort(-result, content)
+ return
+ data={'openflow-rules' : content}
+ return format_out(data)
+
+@bottle.route(url_base + '/networks/<network_id>/openflow', method='PUT')
+def http_put_openflow_id(network_id):
+ '''To make actions over the net. The action is to reinstall the openflow rules
+ network_id can be 'all'
+ '''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ if not my.admin:
+ bottle.abort(HTTP_Unauthorized, "Needed admin privileges")
+ return
+ #ignore input data
+ if network_id=='all':
+ where_={}
+ else:
+ where_={"uuid": network_id}
+ result, content = my.db.get_table(SELECT=("uuid","type"), WHERE=where_, FROM='nets')
+ if result < 0:
+ bottle.abort(-result, content)
+ return
+
+ for net in content:
+ if net["type"]!="ptp" and net["type"]!="data":
+ result-=1
+ continue
+ r,c = config_dic['of_thread'].insert_task("update-net", net['uuid'])
+ if r < 0:
+ print "http_put_openflow_id error while launching openflow rules"
+ bottle.abort(HTTP_Internal_Server_Error, c)
+ data={'result' : str(result)+" nets updates"}
+ return format_out(data)
+
+@bottle.route(url_base + '/networks/openflow/clear', method='DELETE')
+@bottle.route(url_base + '/networks/clear/openflow', method='DELETE')
+def http_clear_openflow_rules():
+ '''To make actions over the net. The action is to delete ALL openflow rules
+ '''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ if not my.admin:
+ bottle.abort(HTTP_Unauthorized, "Needed admin privileges")
+ return
+ #ignore input data
+ r,c = config_dic['of_thread'].insert_task("clear-all")
+ if r < 0:
+ print "http_delete_openflow_id error while launching openflow rules"
+ bottle.abort(HTTP_Internal_Server_Error, c)
+ return
+
+ data={'result' : " Clearing openflow rules in process"}
+ return format_out(data)
+
+@bottle.route(url_base + '/networks/openflow/ports', method='GET')
+def http_get_openflow_ports():
+ '''Obtain switch ports names of openflow controller
+ '''
+ data={'ports' : config_dic['of_thread'].OF_connector.pp2ofi}
+ return format_out(data)
+
+
+#
+# PORTS
+#
+
+@bottle.route(url_base + '/ports', method='GET')
+def http_get_ports():
+ #obtain data
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ select_,where_,limit_ = filter_query_string(bottle.request.query, http2db_port,
+ ('id','name','tenant_id','network_id','vpci','mac_address','device_owner','device_id',
+ 'binding:switch_port','binding:vlan','bandwidth','status','admin_state_up','ip_address') )
+ #result, content = my.db.get_ports(where_)
+ result, content = my.db.get_table(SELECT=select_, WHERE=where_, FROM='ports',LIMIT=limit_)
+ if result < 0:
+ print "http_get_ports Error", result, content
+ bottle.abort(-result, content)
+ return
+ else:
+ convert_boolean(content, ('admin_state_up',) )
+ delete_nulls(content)
+ change_keys_http2db(content, http2db_port, reverse=True)
+ data={'ports' : content}
+ return format_out(data)
+
+@bottle.route(url_base + '/ports/<port_id>', method='GET')
+def http_get_port_id(port_id):
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #obtain data
+ result, content = my.db.get_table(WHERE={'uuid': port_id}, FROM='ports')
+ if result < 0:
+ print "http_get_ports error", result, content
+ bottle.abort(-result, content)
+ elif result==0:
+ print "http_get_ports port '%s' not found" % str(port_id)
+ bottle.abort(HTTP_Not_Found, 'port %s not found' % port_id)
+ else:
+ convert_boolean(content, ('admin_state_up',) )
+ delete_nulls(content)
+ change_keys_http2db(content, http2db_port, reverse=True)
+ data={'port' : content[0]}
+ return format_out(data)
+
+
+@bottle.route(url_base + '/ports', method='POST')
+def http_post_ports():
+ '''insert an external port into the database.'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ if not my.admin:
+ bottle.abort(HTTP_Unauthorized, "Needed admin privileges")
+ #parse input data
+ http_content = format_in( port_new_schema )
+ r = remove_extra_items(http_content, port_new_schema)
+ if r is not None: print "http_post_ports: Warning: remove extra items ", r
+ change_keys_http2db(http_content['port'], http2db_port)
+ port=http_content['port']
+
+ port['type'] = 'external'
+ if 'net_id' in port and port['net_id'] == None:
+ del port['net_id']
+
+ if 'net_id' in port:
+ #check that new net has the correct type
+ result, new_net = my.db.check_target_net(port['net_id'], None, 'external' )
+ if result < 0:
+ bottle.abort(HTTP_Bad_Request, new_net)
+ return
+ #insert in data base
+ result, uuid = my.db.new_row('ports', port, True, True)
+ if result > 0:
+ if 'net_id' in port:
+ r,c = config_dic['of_thread'].insert_task("update-net", port['net_id'])
+ if r < 0:
+ print "http_post_ports error while launching openflow rules"
+ bottle.abort(HTTP_Internal_Server_Error, c)
+ return http_get_port_id(uuid)
+ else:
+ bottle.abort(-result, uuid)
+ return
+
+@bottle.route(url_base + '/ports/<port_id>', method='PUT')
+def http_put_port_id(port_id):
+ '''update a port_id into the database.'''
+
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ #parse input data
+ http_content = format_in( port_update_schema )
+ change_keys_http2db(http_content['port'], http2db_port)
+ port_dict=http_content['port']
+
+ #Look for the previous port data
+ where_ = {'uuid': port_id}
+ result, content = my.db.get_table(FROM="ports",WHERE=where_)
+ if result < 0:
+ print "http_put_port_id error", result, content
+ bottle.abort(-result, content)
+ return
+ elif result==0:
+ print "http_put_port_id port '%s' not found" % port_id
+ bottle.abort(HTTP_Not_Found, 'port %s not found' % port_id)
+ return
+ print port_dict
+ for k in ('vlan','switch_port','mac_address', 'tenant_id'):
+ if k in port_dict and not my.admin:
+ bottle.abort(HTTP_Unauthorized, "Needed admin privileges for changing " + k)
+ return
+
+ port=content[0]
+ #change_keys_http2db(port, http2db_port, reverse=True)
+ nets = []
+ host_id = None
+ result=1
+ if 'net_id' in port_dict:
+ #change of net.
+ old_net = port.get('net_id', None)
+ new_net = port_dict['net_id']
+ if old_net != new_net:
+
+ if new_net is not None: nets.append(new_net) #put first the new net, so that new openflow rules are created before removing the old ones
+ if old_net is not None: nets.append(old_net)
+ if port['type'] == 'instance:bridge':
+ bottle.abort(HTTP_Forbidden, "bridge interfaces cannot be attached to a different net")
+ return
+ elif port['type'] == 'external':
+ if not my.admin:
+ bottle.abort(HTTP_Unauthorized, "Needed admin privileges")
+ return
+ else:
+ if new_net != None:
+ #check that new net has the correct type
+ result, new_net_dict = my.db.check_target_net(new_net, None, port['type'] )
+
+ #change VLAN for SR-IOV ports
+ if result>=0 and port["type"]=="instance:data" and port["model"]=="VF": #TODO consider also VFnotShared
+ if new_net == None:
+ port_dict["vlan"] = None
+ else:
+ port_dict["vlan"] = new_net_dict["vlan"]
+ #get host where this VM is allocated
+ result, content = my.db.get_table(FROM="instances",WHERE={"uuid":port["instance_id"]})
+ if result<0:
+ print "http_put_port_id database error", content
+ elif result>0:
+ host_id = content[0]["host_id"]
+
+ #insert in data base
+ if result >= 0:
+ result, content = my.db.update_rows('ports', port_dict, WHERE={'uuid': port_id}, log=False )
+
+ #Insert task to complete actions
+ if result > 0:
+ for net_id in nets:
+ r,v = config_dic['of_thread'].insert_task("update-net", net_id)
+ if r<0: print "Error ********* http_put_port_id update_of_flows: ", v
+ #TODO Do something if fails
+ if host_id != None:
+ config_dic['host_threads'][host_id].insert_task("edit-iface", port_id, old_net, new_net)
+
+ if result >= 0:
+ return http_get_port_id(port_id)
+ else:
+ bottle.abort(HTTP_Bad_Request, content)
+ return
+
+
+@bottle.route(url_base + '/ports/<port_id>', method='DELETE')
+def http_delete_port_id(port_id):
+ '''delete a port_id from the database.'''
+ my = config_dic['http_threads'][ threading.current_thread().name ]
+ if not my.admin:
+ bottle.abort(HTTP_Unauthorized, "Needed admin privileges")
+ return
+
+ #Look for the previous port data
+ where_ = {'uuid': port_id, "type": "external"}
+ result, ports = my.db.get_table(WHERE=where_, FROM='ports',LIMIT=100)
+
+ if result<=0:
+ print "http_delete_port_id port '%s' not found" % port_id
+ bottle.abort(HTTP_Not_Found, 'port %s not found or device_owner is not external' % port_id)
+ return
+ #delete from the data base
+ result, content = my.db.delete_row('ports', port_id )
+
+ if result == 0:
+ bottle.abort(HTTP_Not_Found, content)
+ elif result >0:
+ network = ports[0].get('net_id', None)
+ if network is not None:
+ #change of net.
+ r,c = config_dic['of_thread'].insert_task("update-net", network)
+ if r<0: print "!!!!!! http_delete_port_id update_of_flows error", r, c
+ data={'result' : content}
+ return format_out(data)
+ else:
+ print "http_delete_port_id error",result, content
+ bottle.abort(-result, content)
+ return
+