("container_format", "containerFormat")\r
]\r
\r
+ def __init__(self):\r
+ super(Alarms, self).__init__()\r
+ self._logger = logger\r
+\r
def get(self, request, vimid="", tenantid="", alarmid=""):\r
logger.debug("alarms--get::> %s" % request.data)\r
try:\r
("extra_specs", "extraSpecs"),
]
+ def __init__(self):
+ super(Flavors, self).__init__()
+ self._logger = logger
+
def _convert_extra_specs(self, extra_specs_vfc, extra_specs_openstack, reverse=False):
if reverse == False:
- #from extraSpecs to extra_specs
+ # from extraSpecs to extra_specs
for spec in extra_specs_vfc:
extra_specs_openstack[spec['keyName']] = spec['value']
else:
else:
wanted = None
- #check if query contains name="flavorname"
+ # check if query contains name="flavorname"
if query:
for queryone in query.split('&'):
k,v = queryone.split('=')
if wanted == flavor["name"]:
content["flavors"].append(flavor)
- #iterate each flavor to get extra_specs
+ # iterate each flavor to get extra_specs
for flavor in content["flavors"]:
extraResp = self._get_flavor_extra_specs(sess, flavor["id"])
extraContent = extraResp.json()
VimDriverUtils.replace_key_by_mapping(flavor,
self.keys_mapping)
- #add extra keys
+ # add extra keys
vim_dict = {
"vimName": vim["name"],
"vimId": vim["vimId"],
return resp
-
class APIv1Flavors(Flavors):
+ def __init__(self):
+ super(APIv1Flavors, self).__init__()
+ self._logger = logger
+
def get(self, request, cloud_owner="", cloud_region_id="", tenantid="", flavorid=""):
self._logger.info("%s, %s" % (cloud_owner, cloud_region_id))
("host", "name"),
]
+ def __init__(self):
+ super(Hosts, self).__init__()
+ self._logger = logger
+
def get(self, request, vimid="", tenantid="", hostname=""):
logger.info("vimid, tenantid, hostname = %s,%s,%s" % (vimid, tenantid, hostname))
if request.data:
VimDriverUtils.replace_key_by_mapping(host,
self.hosts_keys_mapping)
else:
- #restructure host data model
+ # restructure host data model
old_host = content["host"]
content["host"] = []
# convert the key naming in resources
class APIv1Hosts(Hosts):
+ def __init__(self):
+ super(APIv1Hosts, self).__init__()
+ self._logger = logger
+
def get(self, request, cloud_owner="", cloud_region_id="", tenantid="", hostname=""):
self._logger.info("%s, %s" % (cloud_owner, cloud_region_id))
running_threads = {}\r
running_thread_lock = threading.Lock()\r
\r
+\r
class Hypervisors(APIView):\r
service = {'service_type': 'compute',\r
'interface': 'public'}\r
("container_format", "containerFormat")\r
]\r
\r
+ def __init__(self):\r
+ super(Hypervisors, self).__init__()\r
+ self._logger = logger\r
\r
def get(self, request, vimid="", tenantid="", hypervisorid=""):\r
logger.info("vimid, tenantid, hypervisorid = %s,%s,%s" % (vimid, tenantid, hypervisorid))\r
return Response(data={'error': str(e)},\r
status=status.HTTP_500_INTERNAL_SERVER_ERROR)\r
\r
-\r
def get_hypervisors(self, query="", vimid="", tenantid="", hypervisorid=""):\r
\r
req_resource = "/os-hypervisors"\r
\r
class APIv1Hypervisors(Hypervisors):\r
\r
+ def __init__(self):\r
+ super(APIv1Hypervisors, self).__init__()\r
+ self._logger = logger\r
+\r
def get(self, request, cloud_owner="", cloud_region_id="", tenantid="", hypervisorid=""):\r
self._logger.info("%s, %s" % (cloud_owner, cloud_region_id))\r
\r
running_threads = {}
running_thread_lock = threading.Lock()
-class imageThread (threading.Thread):
+
+class ImageThread (threading.Thread):
service = {'service_type': 'image',
'interface': 'public'}
+
def __init__(self, vimid, tenantid, imageid, imagefd):
threading.Thread.__init__(self)
self.vimid = vimid
self.imagefd = imagefd
def run(self):
- logger.debug("start imagethread %s, %s, %s" % (self.vimid, self.tenantid, self.imageid))
+ logger.debug("start ImageThread %s, %s, %s" % (self.vimid, self.tenantid, self.imageid))
self.transfer_image(self.vimid, self.tenantid, self.imageid, self.imagefd)
- logger.debug("stop imagethread %s, %s, %s" % (self.vimid, self.tenantid, self.imageid))
+ logger.debug("stop ImageThread %s, %s, %s" % (self.vimid, self.tenantid, self.imageid))
running_thread_lock.acquire()
running_threads.pop(self.imageid)
running_thread_lock.release()
if vim.get('openstack_region_id')\
else vim['cloud_region_id']
- #open imageurl
+ # open imageurl
logger.info("making image put request with URI:%s" % req_resouce)
resp = sess.put(req_resouce, endpoint_filter=self.service, data=imagefd.read(),
headers={"Content-Type": "application/octet-stream",
("container_format", "containerFormat")
]
+ def __init__(self):
+ super(Images, self).__init__()
+ self._logger = logger
+
def get(self, request, vimid="", tenantid="", imageid=""):
logger.info("vimid, tenantid, imageid = %s,%s,%s" % (vimid, tenantid, imageid))
try:
self.keys_mapping)
else:
# convert the key naming in the image specified by id
- #image = content.pop("image", None)
+ # image = content.pop("image", None)
VimDriverUtils.replace_key_by_mapping(content,
self.keys_mapping)
- #content.update(image)
+ # content.update(image)
return content, resp.status_code
logger.debug("With data = %s" % request.data)
pass
try:
- #check if created already: check name
+ # check if created already: check name
query = "name=%s" % request.data["name"]
content, status_code = self._get_images(query, vimid, tenantid)
existed = False
if not imageurl:
return Response(data={'error': 'imagePath is not specified'}, status=500)
- #valid image url
+ # valid image url
imagefd = urllib.request.urlopen(imageurl)
if not imagefd:
logger.debug("image is not available at %s" % imageurl)
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": image})
req_body = json.JSONEncoder().encode(image)
self.service['region_name'] = vim['openstack_region_id'] \
logger.debug("with data:%s" % req_body)
resp = sess.post(req_resouce, data=req_body,
endpoint_filter=self.service)
- #resp_body = resp.json()["image"]
+ # resp_body = resp.json()["image"]
resp_body = resp.json()
VimDriverUtils.replace_key_by_mapping(resp_body, self.keys_mapping)
vim_dict = {
}
resp_body.update(vim_dict)
- #launch a thread to download image and upload to VIM
+ # 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)
+ tmp_thread = ImageThread(vimid, tenantid,imageid,imagefd)
running_thread_lock.acquire()
running_threads[imageid] = tmp_thread
running_thread_lock.release()
class APIv1Images(Images):
+ def __init__(self):
+ super(APIv1Images, self).__init__()
+ self._logger = logger
+
def get(self, request, cloud_owner="", cloud_region_id="", tenantid="", imageid=""):
self._logger.info("%s, %s" % (cloud_owner, cloud_region_id))
service_volume = {'service_type': 'volumev2',
'interface': 'public'}
+ def __init__(self):
+ super(Limits, self).__init__()
+ self._logger = logger
+
def get(self, request, vimid="", tenantid=""):
logger.info("vimid, tenantid = %s,%s" % (vimid, tenantid))
if request.data:
logger.debug("With data = %s" % request.data)
pass
try:
- #get limits first
+ # get limits first
# prepare request resource to vim instance
req_resouce = "/limits"
vim = VimDriverUtils.get_vim_info(vimid)
}
content_all.update(vim_dict)
- #now get quota
+ # now get quota
# prepare request resource to vim instance
req_resouce = "/v2.0/quotas/%s" % tenantid
content = resp.json()
content_all.update(content['quota'])
- #now get volume limits
+ # now get volume limits
# prepare request resource to vim instance
req_resouce = "/limits"
class APIv1Limits(Limits):
+ def __init__(self):
+ super(APIv1Limits, self).__init__()
+ self._logger = logger
+
def get(self, request, cloud_owner="", cloud_region_id="", tenantid=""):
self._logger.info("%s, %s" % (cloud_owner, cloud_region_id))
("project_id", "tenantId"),
]
+ def __init__(self):
+ super(Networks, self).__init__()
+ self._logger = logger
+
def get(self, request, vimid="", tenantid="", networkid=""):
logger.info("vimid, tenantid, networkid = %s,%s,%s" % (vimid, tenantid, networkid))
if request.data:
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
class APIv1Networks(Networks):
+ def __init__(self):
+ super(APIv1Networks, self).__init__()
+ self._logger = logger
+
def get(self, request, cloud_owner="", cloud_region_id="", tenantid="", networkid=""):
self._logger.info("%s, %s" % (cloud_owner, cloud_region_id))
logger = logging.getLogger(__name__)
-
running_threads = {}
running_thread_lock = threading.Lock()
-#assume volume is attached on server creation
+# assume volume is attached on server creation
class ServerVolumeAttachThread (threading.Thread):
service = {'service_type': 'compute',
'interface': 'public'}
+
def __init__(self, vimid, tenantid, serverid, is_attach, *volumeids):
threading.Thread.__init__(self)
self.vimid = vimid
def run(self):
logger.debug("start server thread %s, %s, %s" % (self.vimid, self.tenantid, self.serverid))
- if (self.is_attach):
+ if self.is_attach:
self.attach_volume(self.vimid, self.tenantid, self.serverid, *self.volumeids)
else:
self.detach_volume(self.vimid, self.tenantid, self.serverid, *self.volumeids)
if vim.get('openstack_region_id') \
else vim['cloud_region_id']
- #check if server is ready to attach
+ # 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:
content = resp.json()
if content and content["server"] and content["server"]["status"] == "ACTIVE":
- break;
+ break
for volumeid in volumeids:
req_resouce = "servers/%s/os-volume_attachments" % serverid
if vim.get('openstack_region_id') \
else vim['cloud_region_id']
- #wait server to be ready to detach volume
+ # wait server to be ready to detach volume
# assume attachment id is the same as volume id
for volumeid in volumeids:
("os-extended-volumes:volumes_attached", "volumeArray"),
]
- def _attachVolume(self, vimid, tenantid, serverId, *volumeIds):
- #has to be async mode to wait server is ready to attach volume
+ def __init__(self):
+ super(Servers, self).__init__()
+ self._logger = logger
+
+ def _attach_volume(self, vimid, tenantid, serverId, *volumeIds):
+ # has to be async mode to wait server is ready to attach volume
logger.debug("launch thread to attach volume: %s" % serverId)
tmp_thread = ServerVolumeAttachThread(vimid, tenantid, serverId, True, *volumeIds)
running_thread_lock.acquire()
for volumeid in volumeIds:
req_resouce = "servers/%s/os-volume_attachments/%s" % (serverId, volumeid)
- logger.debug("Servers--dettachVolume::>%s" % (req_resouce))
+ logger.debug("Servers--dettachVolume::>%s" % req_resouce)
logger.info("making request with URI:%s" % req_resouce)
resp = sess.delete(req_resouce,
endpoint_filter=self.service,
logger.info("request returns with status %s" % resp.status_code)
logger.debug("Servers--dettachVolume resp status::>%s" % resp.status_code)
- #def _convert_metadata(self, metadata_vfc, metadata_openstack, reverse=True):
+ # def _convert_metadata(self, metadata_vfc, metadata_openstack, reverse=True):
# if not reverse:
# # from vfc format to openstack format
# for spec in metadata_vfc:
# metadata_vfc.append(spec)
def _convert_resp(self, server):
- #convert volumeArray
+ # convert volumeArray
volumeArray = server.pop("volumeArray", None)
tmpVolumeArray = []
if volumeArray and len(volumeArray) > 0:
tmpVolumeArray.append({"volumeId": vol["id"]})
server["volumeArray"] = tmpVolumeArray if len(tmpVolumeArray) > 0 else None
- #convert flavor
+ # convert flavor
flavor = server.pop("flavor", None)
server["flavorId"] = flavor["id"] if flavor else None
- #convert nicArray
+ # convert nicArray
- #convert boot
+ # convert boot
imageObj = server.pop("image", None)
imageId = imageObj.pop("id", None) if imageObj else None
if imageId:
server["boot"] = {"type":2, "imageId": imageId}
else:
- server["boot"] = {"type":1, "volumeId":tmpVolumeArray.pop(0)["volumeId"] if len(tmpVolumeArray) > 0 else None}
+ server["boot"] = {
+ "type": 1,
+ "volumeId": tmpVolumeArray.pop(0)["volumeId"]
+ if len(tmpVolumeArray) > 0 else None
+ }
- #convert OS-EXT-AZ:availability_zone
+ # convert OS-EXT-AZ:availability_zone
server["availabilityZone"] = server.pop("OS-EXT-AZ:availability_zone", None)
def get(self, request, vimid="", tenantid="", serverid=""):
logger.error("response with status = %s" % e.status_code)
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()))
+ 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())
logger.debug("with content:%s" % resp.json())
pass
ports = resp.json()
- if ports and ports["interfaceAttachments"] and len(ports["interfaceAttachments"]) > 0:
- return [{"portId":port["port_id"]} for port in ports["interfaceAttachments"]]
+ if ports and ports["interfaceAttachments"] \
+ and len(ports["interfaceAttachments"]) > 0:
+ return [{"portId":port["port_id"]}
+ for port in ports["interfaceAttachments"]]
return None
def _get_servers(self, query="", vimid="", tenantid="", serverid=None):
-
# prepare request resource to vim instance
req_resouce = "servers"
if serverid:
if not serverid:
# convert the key naming in servers
for server in content["servers"]:
- #metadata_openstack = server.pop("metadata", None)
- #if metadata_openstack:
+ # metadata_openstack = server.pop("metadata", None)
+ # if metadata_openstack:
# metadata_vfc = []
# self._convert_metadata(metadata_vfc, metadata_openstack, True)
# server["metadata"] = metadata_vfc
else:
# convert the key naming in the server specified by id
server = content.pop("server", None)
- #metadata_openstack = server.pop("metadata", None)
- #if metadata_openstack:
+ # metadata_openstack = server.pop("metadata", None)
+ # if metadata_openstack:
# metadata_vfc = []
# self._convert_metadata(metadata_vfc, metadata_openstack, True)
# server["metadata"] = metadata_vfc
if len(networks) > 0:
server["networks"] = networks
- #metadata_vfc = server.pop("metadata", None)
- #if metadata_vfc:
+ # metadata_vfc = server.pop("metadata", None)
+ # if metadata_vfc:
# metadata_openstack = {}
# self._convert_metadata(metadata_vfc, metadata_openstack, True)
# server["metadata"] = metadata_openstack
server["personality"] = personalities
logger.info("Personalities %s" % personalities)
else:
- logger.error("contextarray %s format is not right.", contextarray)
- return Response(data={'error': str(e)},
+ errmsg = "contextarray %s format is not right." % contextarray
+ logger.error(errmsg)
+ return Response(data={'error': errmsg},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
VimDriverUtils.replace_key_by_mapping(server,
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)
+ self._attach_volume(vimid, tenantid, resp_body["id"], *volumeIds)
- #metadata_openstack = resp_body.pop("metadata", None)
- #if metadata_openstack:
+ # metadata_openstack = resp_body.pop("metadata", None)
+ # if metadata_openstack:
# metadata_vfc = []
# self._convert_metadata(metadata_vfc, metadata_openstack, True)
# resp_body["metadata"] = metadata_vfc
if vim.get('openstack_region_id') \
else vim['cloud_region_id']
- #check and dettach them if volumes attached to server
+ # 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._dettach_volume(vimid, tenantid, serverid, *volumeIds)
- #delete server now
+ # delete server now
req_resouce = "servers"
if serverid:
req_resouce += "/%s" % serverid
class APIv1Servers(Servers):
+ def __init__(self):
+ super(APIv1Servers, self).__init__()
+ self._logger = logger
+
def get(self, request, cloud_owner="", cloud_region_id="", tenantid="", serverid=""):
self._logger.info("%s, %s" % (cloud_owner, cloud_region_id))
class ServerAction(APIView):
service = {'service_type': 'compute',
'interface': 'public'}
+
+ def __init__(self):
+ super(ServerAction, self).__init__()
+ self._logger = logger
+
def post(self, request, vimid="", tenantid="", serverid=""):
logger.debug("ServerAction--post::> %s" % request.data)
logger.debug("vimid=%s, tenantid=%s, serverid=%s", vimid, tenantid, serverid)
resp_body = resp.json()
return Response(data=resp_body, status=resp.status_code)
- except VimDriverKiloException as e:
+ 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()))
class APIv1ServerAction(ServerAction):
+
+ def __init__(self):
+ super(APIv1ServerAction, self).__init__()
+ self._logger = logger
+
def post(self, request, cloud_owner="", cloud_region_id="", tenantid="", serverid=""):
self._logger.info("%s, %s" % (cloud_owner, cloud_region_id))
class ServerOsInterface(APIView):
service = {'service_type': 'compute',
'interface': 'public'}
+
+
+ def __init__(self):
+ super(ServerOsInterface, self).__init__()
+ self._logger = logger
+
def post(self, request, vimid="", tenantid="", serverid=""):
logger.debug("ServerOsInterface--post::> %s" % request.data)
logger.debug("vimid=%s, tenantid=%s, serverid=%s", vimid, tenantid, serverid)
resp_body = resp.json()
return Response(data=resp_body, status=resp.status_code)
- except VimDriverKiloException as e:
+ 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()))
class APIv1ServerOsInterface(ServerOsInterface):
+
+ def __init__(self):
+ super(APIv1ServerOsInterface, self).__init__()
+ self._logger = logger
+
def post(self, request, cloud_owner="", cloud_region_id="", tenantid="", serverid=""):
self._logger.info("%s, %s" % (cloud_owner, cloud_region_id))
class ServerOsInterfacePort(APIView):
service = {'service_type': 'compute',
'interface': 'public'}
+
+ def __init__(self):
+ super(ServerOsInterfacePort, self).__init__()
+ self._logger = logger
+
def delete(self, request, vimid="", tenantid="", serverid="", portid=""):
logger.debug("ServerOsInterfacePort--delete::portid=%s", portid)
logger.debug("vimid=%s, tenantid=%s, serverid=%s", vimid, tenantid, serverid)
resp_body = {}
return Response(data=resp_body, status=resp.status_code)
- except VimDriverKiloException as e:
+ 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()))
class APIv1ServerOsInterfacePort(ServerOsInterfacePort):
+
+ def __init__(self):
+ super(APIv1ServerOsInterfacePort, self).__init__()
+ self._logger = logger
+
def delete(self, request, cloud_owner="", cloud_region_id="", tenantid="", serverid="", portid=""):
self._logger.info("%s, %s" % (cloud_owner, cloud_region_id))
("allocation_pools", "allocationPools"),
]
+ def __init__(self):
+ super(Subnets, self).__init__()
+ self._logger = logger
+
def get(self, request, vimid="", tenantid="", subnetid=""):
logger.info("vimid, tenantid, subnetid = %s,%s,%s" % (vimid, tenantid, subnetid))
if request.data:
class APIv1Subnets(Subnets):
+ def __init__(self):
+ super(APIv1Subnets, self).__init__()
+ self._logger = logger
+
def get(self, request, cloud_owner="", cloud_region_id="", tenantid="", subnetid=""):
self._logger.info("%s, %s" % (cloud_owner, cloud_region_id))
("projects", "tenants"),
]
+ def __init__(self):
+ super(Tenants, self).__init__()
+ self._logger = logger
+
def get(self, request, vimid=""):
- logger.info("vimid = %s" % vimid)
+ self._logger.info("vimid = %s" % vimid)
if request.data:
- logger.debug("With data = %s" % request.data)
+ self._logger.debug("With data = %s" % request.data)
pass
try:
#prepare request resource to vim instance
if vim.get('openstack_region_id') \
else vim['cloud_region_id']
- logger.info("making request with URI:%s" % req_resouce)
+ self._logger.info("making request with URI:%s" % req_resouce)
resp = sess.get(req_resouce, endpoint_filter=self.service)
- logger.info("request returns with status %s" % resp.status_code)
+ self._logger.info("request returns with status %s" % resp.status_code)
if resp.status_code == status.HTTP_200_OK:
- logger.debug("with content:%s" % resp.json())
+ self._logger.debug("with content:%s" % resp.json())
pass
content = resp.json()
for tenant in tmp:
if tenantname == tenant['name']:
content["tenants"].append(tenant)
- logger.info("response with status = %s" % resp.status_code)
+ self._logger.info("response with status = %s" % resp.status_code)
return Response(data=content, status=resp.status_code)
except VimDriverNewtonException as e:
- logger.error("response with status = %s" % e.status_code)
+ self._logger.error("response with status = %s" % e.status_code)
return Response(
data={'error': e.content}, status=e.status_code)
except HttpError as e:
- logger.error("HttpError: status:%s, response:%s" % (
+ self._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())
+ self._logger.error(traceback.format_exc())
return Response(
data={'error': str(e)},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
class APIv1Tenants(Tenants):
+ def __init__(self):
+ super(APIv1Tenants, self).__init__()
+ self._logger = logger
+
def get(self, request, cloud_owner="", cloud_region_id=""):
self._logger.info("registration with : %s, %s" % (cloud_owner, cloud_region_id))
\r
from common.exceptions import VimDriverNewtonException\r
from newton_base.util import VimDriverUtils\r
+from common.msapi import extsys\r
\r
logger = logging.getLogger(__name__)\r
\r
("container_format", "containerFormat")\r
]\r
\r
+ def __init__(self):\r
+ super(VMlist, self).__init__()\r
+ self._logger = logger\r
+\r
def get(self, request, vimid="", tenantid="", serverid=""):\r
logger.info("vimid, tenantid, flavorid = %s,%s,%s" % (vimid, tenantid, flavorid))\r
if request.data:\r
return content, resp.status_code\r
\r
\r
+class APIv1VMlist(VMlist):\r
+\r
+ def __init__(self):\r
+ super(APIv1VMlist, self).__init__()\r
+ self._logger = logger\r
+\r
+ def get(self, request, cloud_owner="", cloud_region_id="", tenantid="", serverid=""):\r
+ self._logger.info("%s, %s" % (cloud_owner, cloud_region_id))\r
+\r
+ vimid = extsys.encode_vim_id(cloud_owner, cloud_region_id)\r
+ return super(APIv1VMlist, self).get(request, vimid, tenantid, serverid)\r
("attachment_id", "attachmentId"),
]
+ def __init__(self):
+ super(Volumes, self).__init__()
+ self._logger = logger
+
def get(self, request, vimid="", tenantid="", volumeid=""):
logger.info("vimid, tenantid, volumeid = %s,%s,%s" % (vimid, tenantid, volumeid))
if request.data:
class APIv1Volumes(Volumes):
+ def __init__(self):
+ super(APIv1Volumes, self).__init__()
+ self._logger = logger
+
def get(self, request, cloud_owner="", cloud_region_id="", tenantid="", volumeid=""):
self._logger.info("%s, %s" % (cloud_owner, cloud_region_id))
("ip_address", "ip"),
]
+ def __init__(self):
+ super(Vports, self).__init__()
+ self._logger = logger
+
def get(self, request, vimid="", tenantid="", portid=""):
logger.info("vimid, tenantid, portid = %s,%s,%s" % (vimid, tenantid, portid))
if request.data:
class APIv1Vports(Vports):
+ def __init__(self):
+ super(APIv1Vports, self).__init__()
+ self._logger = logger
+
def get(self, request, cloud_owner="", cloud_region_id="", tenantid="", portid=""):
self._logger.info("%s, %s" % (cloud_owner, cloud_region_id))
Code Review / multicloud / openstack.git / commitdiff