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 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 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 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 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 create_flavor(self, sess, request):
logger.debug("Flavors--create::> %s" % request.data)
# prepare request resource to vim instance
req_resouce = "/flavors"
flavor = request.data
VimDriverUtils.replace_key_by_mapping(flavor, self.keys_mapping, True)
req_body = json.JSONEncoder().encode({"flavor": flavor})
return sess.post(req_resouce,
data=req_body,
endpoint_filter=self.service)
pass
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 create_flavor(self, sess, request):
logger.debug("Flavors--create::> %s" % request.data)
# prepare request resource to vim instance
req_resouce = "/flavors"
flavor = request.data
VimDriverUtils.replace_key_by_mapping(flavor, self.keys_mapping, True)
req_body = json.JSONEncoder().encode({"flavor": flavor})
# logger.debug("SBI:%s" % req_body)
return sess.post(req_resouce,
data=req_body,
endpoint_filter=self.service,
headers={
"Content-Type": "application/json",
"Accept": "application/json"
})
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 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 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 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 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_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 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_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 get(self, request, vimid="", tenantid="", subnetid=""):
logger.debug("Subnets--get::> %s" % request.data)
try:
# prepare request resource to vim instance
query = VimDriverUtils.get_query_part(request)
content, status_code = self.get_subnets(query, vimid, tenantid, subnetid)
return Response(data=content, status=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)
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_flavor(self, sess, request, flavorid=""):
logger.debug("Flavors--get basic")
if not sess:
return {}
else:
# prepare request resource to vim instance
req_resouce = "/flavors"
if flavorid:
req_resouce += "/%s" % flavorid
else:
req_resouce += "/detail"
query = VimDriverUtils.get_query_part(request)
if query:
req_resouce += "?%s" % query
resp = sess.get(req_resouce, endpoint_filter=self.service)
return resp
pass
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 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
