def delete(self, request, vimid="", tenantid="", serverid=""): logger.debug("Servers--delete::> %s" % request.data) try: # prepare request resource to vim instance vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) #check and dettach them if volumes attached to server server, status_code = self.get_servers("", vimid, tenantid, serverid) volumearray = server.pop("volumeArray", None) if volumearray and len(volumearray) > 0: volumeIds = [ extraVolume["volumeId"] for extraVolume in volumearray ] self.dettachVolume(vimid, tenantid, serverid, *volumeIds) #delete server now req_resouce = "servers" if serverid: req_resouce += "/%s" % serverid resp = sess.delete(req_resouce, endpoint_filter=self.service) return Response(status=resp.status_code) except VimDriverKiloException as e: return Response(data={'error': e.content}, status=e.status_code) except HttpError as e: logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json())) return Response(data=e.response.json(), status=e.http_status) except Exception as e: logger.error(traceback.format_exc()) return Response(data={'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) pass
def delete(self, request, vimid="", tenantid="", subnetid=""): logger.debug("Subnets--delete::> %s" % request.data) try: # prepare request resource to vim instance req_resouce = "v2.0/subnets" if subnetid: req_resouce += "/%s" % subnetid query = VimDriverUtils.get_query_part(request) if query: req_resouce += "?%s" % query vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) resp = sess.delete(req_resouce, endpoint_filter=self.service) return Response(status=resp.status_code) except VimDriverKiloException as e: return Response(data={'error': e.content}, status=e.status_code) except HttpError as e: logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json())) return Response(data=e.response.json(), status=e.http_status) except Exception as e: logger.error(traceback.format_exc()) return Response(data={'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) pass
def delete(self, request, vimid="", tenantid="", flavorid=""): logger.debug("Flavors--delete::> %s" % request.data) try: # prepare request resource to vim instance vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) #delete extra specs one by one resp = self.delete_flavor_extra_specs(sess, flavorid) #delete flavor resp = self.delete_flavor(sess, flavorid) #return results return Response(status=resp.status_code) except VimDriverKiloException as e: return Response(data={'error': e.content}, status=e.status_code) except HttpError as e: logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json())) return Response(data=e.response.json(), status=e.http_status) except Exception as e: logger.error(traceback.format_exc()) return Response(data={'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) pass
def get_subnets(self, query="", vimid="", tenantid="", subnetid=""): logger.debug("Subnets--get_subnets::> %s" % subnetid) # prepare request resource to vim instance req_resouce = "v2.0/subnets" if subnetid: req_resouce += "/%s" % subnetid if query: req_resouce += "?%s" % query vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) resp = sess.get(req_resouce, endpoint_filter=self.service) content = resp.json() vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, } content.update(vim_dict) if not subnetid: # convert the key naming in subnets for subnet in content["subnets"]: VimDriverUtils.replace_key_by_mapping(subnet, self.keys_mapping) else: # convert the key naming in the subnet specified by id subnet = content.pop("subnet", None) VimDriverUtils.replace_key_by_mapping(subnet, self.keys_mapping) content.update(subnet) return content, resp.status_code
def get_networks(self, query, vimid="", tenantid="", networkid=""): logger.debug("Networks--get_networks::> %s" % networkid) # prepare request resource to vim instance req_resouce = "v2.0/networks" if networkid: req_resouce += "/%s" % networkid if query: req_resouce += "?%s" % query vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) resp = sess.get(req_resouce, endpoint_filter=self.service) content = resp.json() vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, } content.update(vim_dict) if not networkid: # convert the key naming in networks for network in content["networks"]: VimDriverUtils.replace_key_by_mapping(network, self.keys_mapping) else: # convert the key naming in the network specified by id network = content.pop("network", None) VimDriverUtils.replace_key_by_mapping(network, self.keys_mapping) content.update(network) return content, resp.status_code
def transfer_image(self, vimid, tenantid, imageid, imagefd): logger.debug("Images--transfer_image::> %s" % (imageid)) try: # prepare request resource to vim instance req_resouce = "v2/images/%s/file" % imageid vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) #open imageurl resp = sess.put(req_resouce, endpoint_filter=self.service, data=imagefd.read(), headers={ "Content-Type": "application/octet-stream", "Accept": "" }) logger.debug("response status code of transfer_image %s" % resp.status_code) return None except HttpError as e: logger.error("transfer_image, HttpError: status:%s, response:%s" % (e.http_status, e.response.json())) return None except Exception as e: logger.error(traceback.format_exc()) logger.debug("Failed to transfer_image:%s" % str(e)) return None pass
def get_volumes(self, query="", vimid="", tenantid="", volumeid=None): logger.debug("Volumes--get_volumes::> %s,%s" % (tenantid, volumeid)) # prepare request resource to vim instance req_resouce = "volumes" if volumeid: req_resouce += "/%s" % volumeid else: req_resouce += "/detail" if query: req_resouce += "?%s" % query vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) resp = sess.get(req_resouce, endpoint_filter=self.service) content = resp.json() vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, } content.update(vim_dict) if not volumeid: # convert the key naming in volumes for volume in content["volumes"]: VimDriverUtils.replace_key_by_mapping(volume, self.keys_mapping) else: # convert the key naming in the volume specified by id volume = content.pop("volume", None) VimDriverUtils.replace_key_by_mapping(volume, self.keys_mapping) content.update(volume) return content, resp.status_code
def get_images(self, query="", vimid="", tenantid="", imageid=""): logger.debug("Images--get_images::> %s" % imageid) # prepare request resource to vim instance req_resouce = "v2/images" if imageid: req_resouce += "/%s" % imageid elif query: req_resouce += "?%s" % query vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) resp = sess.get(req_resouce, endpoint_filter=self.service) content = resp.json() vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, } content.update(vim_dict) if not imageid: # convert the key naming in images for image in content["images"]: VimDriverUtils.replace_key_by_mapping(image, self.keys_mapping) else: # convert the key naming in the image specified by id #image = content.pop("image", None) VimDriverUtils.replace_key_by_mapping(content, self.keys_mapping) #content.update(image) return content, resp.status_code
def detach_volume(self, vimid, tenantid, serverid, *volumeids): logger.debug("Server--detach_volume::> %s, %s" % (serverid, volumeids)) try: # prepare request resource to vim instance vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) #wait server to be ready to detach volume # assume attachment id is the same as volume id for volumeid in volumeids: req_resouce = "servers/%s/os-volume_attachments/%s" % ( serverid, volumeid) logger.debug("Servers--dettachVolume::>%s" % (req_resouce)) resp = sess.delete(req_resouce, endpoint_filter=self.service, headers={ "Content-Type": "application/json", "Accept": "application/json" }) logger.debug("Servers--dettachVolume resp::>%s" % resp.json()) return None except HttpError as e: logger.error("detach_volume, HttpError: status:%s, response:%s" % (e.http_status, e.response.json())) return None except Exception as e: logger.error(traceback.format_exc()) logger.debug("Failed to detach_volume:%s" % str(e)) return None pass
def get_ports(self, query="", vimid="", tenantid="", portid=""): logger.debug("Ports--get_ports::> %s" % portid) vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) if sess: # prepare request resource to vim instance req_resouce = "v2.0/ports" if portid: req_resouce += "/%s" % portid if query: req_resouce += "?%s" % query vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) resp = sess.get(req_resouce, endpoint_filter=self.service) content = resp.json() vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, } content.update(vim_dict) if not portid: # convert the key naming in ports for port in content["ports"]: # use only 1st entry of fixed_ips tmpips = port.pop("fixed_ips", None) if port else None port.update(tmpips[0]) if tmpips and len(tmpips) > 0 else None VimDriverUtils.replace_key_by_mapping(port, self.keys_mapping) else: # convert the key naming in the port specified by id port = content.pop("port", None) #use only 1st entry of fixed_ips tmpips = port.pop("fixed_ips", None) if port else None port.update(tmpips[0]) if tmpips and len(tmpips) > 0 else None VimDriverUtils.replace_key_by_mapping(port, self.keys_mapping) content.update(port) return content, resp.status_code return {}, 500
def post(self, request, vimid="", tenantid="", volumeid=""): logger.debug("Volumes--post::> %s" % request.data) try: #check if created already: check name query = "name=%s" % request.data["name"] content, status_code = self.get_volumes(query, vimid, tenantid) existed = False if status_code == 200: for volume in content["volumes"]: if volume["name"] == request.data["name"]: existed = True break pass if existed == True: vim_dict = { "returnCode": 0, } volume.update(vim_dict) return Response(data=volume, status=status_code) # prepare request resource to vim instance req_resouce = "volumes" vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) volume = request.data VimDriverUtils.replace_key_by_mapping(volume, self.keys_mapping, True) req_body = json.JSONEncoder().encode({"volume": volume}) resp = sess.post(req_resouce, data=req_body, endpoint_filter=self.service, headers={ "Content-Type": "application/json", "Accept": "application/json" }) resp_body = resp.json()["volume"] VimDriverUtils.replace_key_by_mapping(resp_body, self.keys_mapping) vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, "returnCode": 1, } resp_body.update(vim_dict) return Response(data=resp_body, status=resp.status_code) except VimDriverKiloException as e: return Response(data={'error': e.content}, status=e.status_code) except HttpError as e: logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json())) return Response(data=e.response.json(), status=e.http_status) except Exception as e: logger.error(traceback.format_exc()) return Response(data={'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) pass
def get_servers(self, query="", vimid="", tenantid="", serverid=None): logger.debug("Servers--get_servers::> %s,%s" % (tenantid, serverid)) # prepare request resource to vim instance req_resouce = "servers" if serverid: req_resouce += "/%s" % serverid else: req_resouce += "/detail" if query: req_resouce += "?%s" % query vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) resp = sess.get(req_resouce, endpoint_filter=self.service) content = resp.json() vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, } content.update(vim_dict) if not serverid: # convert the key naming in servers for server in content["servers"]: metadata = server.pop("metadata", None) if metadata: meta_data = [] self.convertMetadata(metadata, meta_data, True) server["metadata"] = meta_data VimDriverUtils.replace_key_by_mapping(server, self.keys_mapping) self.convert_resp(server) server["nicArray"] = self.get_ports(vimid, tenantid, server["id"]) else: # convert the key naming in the server specified by id server = content.pop("server", None) metadata = server.pop("metadata", None) if metadata: meta_data = [] self.convertMetadata(metadata, meta_data, True) server["metadata"] = meta_data VimDriverUtils.replace_key_by_mapping(server, self.keys_mapping) self.convert_resp(server) server["nicArray"] = self.get_ports(vimid, tenantid, serverid) content.update(server) return content, resp.status_code
def get_ports(self, vimid="", tenantid="", serverid=None): # query attached ports vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) req_resouce = "servers/%s/os-interface" % serverid resp = sess.get(req_resouce, endpoint_filter=self.service) ports = resp.json() if ports and ports["interfaceAttachments"] and len( ports["interfaceAttachments"]) > 0: return [{ "portId": port["port_id"] } for port in ports["interfaceAttachments"]] else: return None
def get(self, request, vimid=""): logger.debug("Tenants--get::> %s" % request.data) try: #prepare request resource to vim instance query = VimDriverUtils.get_query_part(request) vim = VimDriverUtils.get_vim_info(vimid) if '/v2' in vim["url"]: req_resouce = "/v2.0/tenants" elif '/v3' in vim["url"]: req_resouce = "/projects" else: req_resouce = "/projects" sess = VimDriverUtils.get_session(vim) resp = sess.get(req_resouce, endpoint_filter=self.service) content = resp.json() vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], } content.update(vim_dict) VimDriverUtils.replace_key_by_mapping(content, self.keys_mapping) if query: _, tenantname = query.split('=') if tenantname: tmp = content["tenants"] content["tenants"] = [] # convert the key naming in hosts for tenant in tmp: if tenantname == tenant['name']: content["tenants"].append(tenant) return Response(data=content, status=resp.status_code) except VimDriverNewtonException as e: return Response(data={'error': e.content}, status=e.status_code) except HttpError as e: logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json())) return Response(data=e.response.json(), status=e.http_status) except Exception as e: logger.error(traceback.format_exc()) return Response(data={'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def get(self, request, vimid="", tenantid="", hostname=""): logger.debug("Hosts--get::> %s" % request.data) try: #prepare request resource to vim instance req_resouce = "/os-hosts" if hostname: req_resouce += "/%s" % hostname vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) resp = sess.get(req_resouce, endpoint_filter=self.service) content = resp.json() vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, } content.update(vim_dict) if not hostname: # convert the key naming in hosts for host in content["hosts"]: VimDriverUtils.replace_key_by_mapping(host, self.hosts_keys_mapping) else: #restructure host data model old_host = content["host"] content["host"] = [] # convert the key naming in resources for res in old_host: VimDriverUtils.replace_key_by_mapping(res['resource'], self.host_keys_mapping) content["host"].append(res['resource']) return Response(data=content, status=resp.status_code) except VimDriverNewtonException as e: return Response(data={'error': e.content}, status=e.status_code) except HttpError as e: logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json())) return Response(data=e.response.json(), status=e.http_status) except Exception as e: logger.error(traceback.format_exc()) return Response(data={'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def attach_volume(self, vimid, tenantid, serverid, *volumeids): logger.debug("Server--attach_volume::> %s, %s" % (serverid, volumeids)) try: # prepare request resource to vim instance vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) #check if server is ready to attach logger.debug( "Servers--attach_volume, wait for server to be ACTIVE::>%s" % serverid) req_resouce = "servers/%s" % serverid while True: resp = sess.get(req_resouce, endpoint_filter=self.service) content = resp.json() if content and content["server"] and content["server"][ "status"] == "ACTIVE": break for volumeid in volumeids: req_resouce = "servers/%s/os-volume_attachments" % serverid req_data = {"volumeAttachment": {"volumeId": volumeid}} logger.debug("Servers--attach_volume::>%s, %s" % (req_resouce, req_data)) req_body = json.JSONEncoder().encode(req_data) resp = sess.post(req_resouce, data=req_body, endpoint_filter=self.service, headers={ "Content-Type": "application/json", "Accept": "application/json" }) logger.debug("Servers--attach_volume resp::>%s" % resp.json()) return None except HttpError as e: logger.error("attach_volume, HttpError: status:%s, response:%s" % (e.http_status, e.response.json())) return None except Exception as e: logger.error(traceback.format_exc()) logger.debug("Failed to attach_volume:%s" % str(e)) return None pass
def get(self, request, vimid="", tenantid=""): logger.debug("Limits--get::> %s" % request.data) try: #get limits first # prepare request resource to vim instance req_resouce = "/limits" vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) resp = sess.get(req_resouce, endpoint_filter=self.service) content = resp.json() content_all = content['limits']['absolute'] vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, } content_all.update(vim_dict) #now get quota # prepare request resource to vim instance req_resouce = "/v2.0/quotas/%s" % tenantid resp = sess.get(req_resouce, endpoint_filter=self.service_network) content = resp.json() content_all.update(content['quota']) #now get volume limits # prepare request resource to vim instance req_resouce = "/limits" resp = sess.get(req_resouce, endpoint_filter=self.service_volume) content = resp.json() content_all.update(content['limits']['absolute']) return Response(data=content_all, status=resp.status_code) except VimDriverNewtonException as e: return Response(data={'error': e.content}, status=e.status_code) except HttpError as e: logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json())) return Response(data=e.response.json(), status=e.http_status) except Exception as e: logger.error(traceback.format_exc()) return Response(data={'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def dettachVolume(self, vimid, tenantid, serverId, *volumeIds): # assume attachment id is the same as volume id vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) for volumeid in volumeIds: req_resouce = "servers/%s/os-volume_attachments/%s" % (serverId, volumeid) logger.debug("Servers--dettachVolume::>%s" % (req_resouce)) resp = sess.delete(req_resouce, endpoint_filter=self.service, headers={ "Content-Type": "application/json", "Accept": "application/json" }) logger.debug("Servers--dettachVolume resp status::>%s" % resp.status_code) pass
def create_port(self, request, vimid, tenantid): logger.debug("Ports--create::> %s" % request.data) vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) if sess: # prepare request resource to vim instance req_resouce = "v2.0/ports" port = request.data #handle ip and subnetId tmpip = port.pop("ip", None) tmpsubnet = port.pop("subnetId", None) if tmpip and tmpsubnet: fixed_ip = { "ip_address": tmpip, "subnet_id": tmpsubnet, } port["fixed_ips"] = [] port["fixed_ips"].append(fixed_ip) VimDriverUtils.replace_key_by_mapping(port, self.keys_mapping, True) req_body = json.JSONEncoder().encode({"port": port}) resp = sess.post(req_resouce, data=req_body, endpoint_filter=self.service) resp_body = resp.json()["port"] #use only 1 fixed_ip tmpips = resp_body.pop("fixed_ips", None) if tmpips and len(tmpips) > 0: resp_body.update(tmpips[0]) VimDriverUtils.replace_key_by_mapping(resp_body, self.keys_mapping) vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, "returnCode": 1, } resp_body.update(vim_dict) return Response(data=resp_body, status=resp.status_code) return {}
def post(self, request, vimid="", tenantid="", imageid=""): logger.debug("Images--post::> %s" % request.data) try: #check if created already: check name query = "name=%s" % request.data["name"] content, status_code = self.get_images(query, vimid, tenantid) existed = False if status_code == 200: for image in content["images"]: if image["name"] == request.data["name"]: existed = True break pass if existed == True: vim_dict = { "returnCode": 0, } image.update(vim_dict) return Response(data=image, status=status_code) imageurl = request.data.pop("imagePath", None) imagefd = None if not imageurl: return Response(data={'error': 'imagePath is not specified'}, status=500) #valid image url imagefd = urllib2.urlopen(imageurl) if not imagefd: logger.debug("image is not available at %s" % imageurl) return Response( data={'error': 'cannot access to specified imagePath'}, status=500) # prepare request resource to vim instance req_resouce = "v2/images" vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) image = request.data VimDriverUtils.replace_key_by_mapping(image, self.keys_mapping, True) #req_body = json.JSONEncoder().encode({"image": image}) req_body = json.JSONEncoder().encode(image) resp = sess.post(req_resouce, data=req_body, endpoint_filter=self.service) #resp_body = resp.json()["image"] resp_body = resp.json() VimDriverUtils.replace_key_by_mapping(resp_body, self.keys_mapping) vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, "returnCode": 1, } resp_body.update(vim_dict) #launch a thread to download image and upload to VIM if resp.status_code == 201: imageid = resp_body["id"] logger.debug("launch thread to upload image: %s" % imageid) tmp_thread = imageThread(vimid, tenantid, imageid, imagefd) running_thread_lock.acquire() running_threads[imageid] = tmp_thread running_thread_lock.release() tmp_thread.start() else: logger.debug("resp.status_code: %s" % resp.status_code) pass return Response(data=resp_body, status=resp.status_code) except VimDriverKiloException as e: return Response(data={'error': e.content}, status=e.status_code) except urllib2.URLError as e: return Response( data={'error': 'image is not accessible:%s' % str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) except HttpError as e: logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json())) return Response(data=e.response.json(), status=e.http_status) except Exception as e: logger.error(traceback.format_exc()) return Response(data={'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) pass
def post(self, request, vimid="", tenantid="", flavorid=""): logger.debug("Flavors--post::> %s" % request.data) sess = None resp = None resp_body = None try: # prepare request resource to vim instance vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) #check if the flavor is already created: name or id tmpresp = self.get_flavor(sess, request) content = tmpresp.json() #iterate each flavor to get extra_specs existed = False for flavor in content["flavors"]: if flavor["name"] == request.data["name"]: existed = True break elif hasattr(request.data, "id") and flavor["id"] == request.data["id"]: existed = True break pass if existed == True: extraResp = self.get_flavor_extra_specs(sess, flavor["id"]) extraContent = extraResp.json() if extraContent["extra_specs"]: extraSpecs = [] self.convertExtraSpecs(extraSpecs, extraContent["extra_specs"], True) flavor["extraSpecs"] = extraSpecs VimDriverUtils.replace_key_by_mapping(flavor, self.keys_mapping) vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, "returnCode": 0, } flavor.update(vim_dict) return Response(data=flavor, status=tmpresp.status_code) extraSpecs = request.data.pop("extraSpecs", None) #create flavor first resp = self.create_flavor(sess, request) if resp.status_code == 200: resp_body = resp.json()["flavor"] else: return resp flavorid = resp_body['id'] if extraSpecs: extra_specs = {} self.convertExtraSpecs(extraSpecs, extra_specs, False) # logger.debug("extraSpecs:%s" % extraSpecs) # logger.debug("extra_specs:%s" % extra_specs) extraResp = self.create_flavor_extra_specs( sess, extra_specs, flavorid) if extraResp.status_code == 200: #combine the response body and return tmpSpecs = [] tmpRespBody = extraResp.json() self.convertExtraSpecs(tmpSpecs, tmpRespBody['extra_specs'], True) resp_body.update({"extraSpecs": tmpSpecs}) else: #rollback delete_flavor(self, request, vimid, tenantid, flavorid) return extraResp VimDriverUtils.replace_key_by_mapping(resp_body, self.keys_mapping) vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, "returnCode": 1, } resp_body.update(vim_dict) return Response(data=resp_body, status=resp.status_code) except VimDriverKiloException as e: if sess and resp and resp.status_code == 200: self.delete_flavor(sess, flavorid) return Response(data={'error': e.content}, status=e.status_code) except HttpError as e: logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json())) return Response(data=e.response.json(), status=e.http_status) except Exception as e: logger.error(traceback.format_exc()) if sess and resp and resp.status_code == 200: self.delete_flavor(sess, flavorid) return Response(data={'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) pass
def get(self, request, vimid="", tenantid="", flavorid=""): logger.debug("Flavors--get::> %s" % request.data) try: # prepare request resource to vim instance query = VimDriverUtils.get_query_part(request) vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) resp = self.get_flavor(sess, request, flavorid) content = resp.json() if flavorid: flavor = content.pop("flavor", None) extraResp = self.get_flavor_extra_specs(sess, flavor["id"]) extraContent = extraResp.json() if extraContent["extra_specs"]: extraSpecs = [] self.convertExtraSpecs(extraSpecs, extraContent["extra_specs"], True) flavor["extraSpecs"] = extraSpecs VimDriverUtils.replace_key_by_mapping(flavor, self.keys_mapping) content.update(flavor) else: wanted = None #check if query contains name="flavorname" if query: for queryone in query.split('&'): k, v = queryone.split('=') if k == "name": wanted = v break pass if wanted: oldFlavors = content.pop("flavors", None) content["flavors"] = [] for flavor in oldFlavors: if wanted == flavor["name"]: content["flavors"].append(flavor) pass #iterate each flavor to get extra_specs for flavor in content["flavors"]: extraResp = self.get_flavor_extra_specs(sess, flavor["id"]) extraContent = extraResp.json() if extraContent["extra_specs"]: extraSpecs = [] self.convertExtraSpecs(extraSpecs, extraContent["extra_specs"], True) flavor["extraSpecs"] = extraSpecs VimDriverUtils.replace_key_by_mapping( flavor, self.keys_mapping) #add extra keys vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, } content.update(vim_dict) return Response(data=content, status=resp.status_code) except VimDriverKiloException as e: return Response(data={'error': e.content}, status=e.status_code) except HttpError as e: logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json())) return Response(data=e.response.json(), status=e.http_status) except Exception as e: logger.error(traceback.format_exc()) return Response(data={'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) pass
def post(self, request, vimid="", tenantid="", serverid=""): logger.debug("Servers--post::> %s" % request.data) try: # check if created already: check name servername = request.data["name"] query = "name=%s" % servername content, status_code = self.get_servers(query, vimid, tenantid) existed = False if status_code == 200: for server in content["servers"]: if server["name"] == request.data["name"]: existed = True break pass if existed == True and server: vim_dict = { "returnCode": 0, } server.update(vim_dict) return Response(data=server, status=status_code) # prepare request resource to vim instance req_resouce = "servers" vim = VimDriverUtils.get_vim_info(vimid) sess = VimDriverUtils.get_session(vim, tenantid) server = request.data # convert parameters boot = server.pop("boot", None) if not boot: return Response(data={'error': "missing boot paramters"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) if boot["type"] == 1: # boot from volume server["block_device_mapping_v2"] = [{ "uuid": boot["volumeId"], "source_type": "volume", "destination_type": "volume", "delete_on_termination": "false", "boot_index": "0" }] else: # boot from image server["imageRef"] = boot["imageId"] nicarray = server.pop("nicArray", None) if not nicarray: return Response(data={'error': "missing nicArray paramters"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) else: networks = [] for nic in nicarray: networks.append({"port": nic["portId"]}) if len(networks) > 0: server["networks"] = networks meta_data = server.pop("metadata", None) if meta_data: metadata = {} self.convertMetadata(metadata, meta_data, False) server["metadata"] = metadata contextarray = server.pop("contextArray", None) if contextarray: # now set "contextArray" array personalities = [] for context in contextarray: personalities.append({ "path": context["fileName"], "contents": context["fileData"] }) if len(personalities) > 0: server["personality"] = personalities pass volumearray = server.pop("volumeArray", None) VimDriverUtils.replace_key_by_mapping(server, self.keys_mapping, True) req_body = json.JSONEncoder().encode({"server": server}) resp = sess.post(req_resouce, data=req_body, endpoint_filter=self.service, headers={ "Content-Type": "application/json", "Accept": "application/json" }) resp_body = resp.json().pop("server", None) logger.debug("Servers--post status::>%s, %s" % (resp_body["id"], resp.status_code)) if resp.status_code == 200 or resp.status_code == 201 or resp.status_code == 202: if volumearray and len(volumearray) > 0: # server is created, now attach volumes volumeIds = [ extraVolume["volumeId"] for extraVolume in volumearray ] self.attachVolume(vimid, tenantid, resp_body["id"], *volumeIds) pass pass metadata = resp_body.pop("metadata", None) if metadata: meta_data = [] self.convertMetadata(metadata, meta_data, True) resp_body["metadata"] = meta_data VimDriverUtils.replace_key_by_mapping(resp_body, self.keys_mapping) vim_dict = { "vimName": vim["name"], "vimId": vim["vimId"], "tenantId": tenantid, "returnCode": 1, } resp_body.update(vim_dict) resp_body["boot"] = boot resp_body["volumeArray"] = volumearray resp_body["nicArray"] = nicarray resp_body["contextArray"] = contextarray resp_body["name"] = servername return Response(data=resp_body, status=resp.status_code) except VimDriverKiloException as e: return Response(data={'error': e.content}, status=e.status_code) except HttpError as e: logger.error("HttpError: status:%s, response:%s" % (e.http_status, e.response.json())) return Response(data=e.response.json(), status=e.http_status) except Exception as e: logger.error(traceback.format_exc()) return Response(data={'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) pass