Esempio n. 1
0
    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
Esempio n. 2
0
    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
Esempio n. 3
0
    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
Esempio n. 4
0
    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
Esempio n. 5
0
    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
Esempio n. 6
0
    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
Esempio n. 7
0
    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
Esempio n. 8
0
    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
Esempio n. 9
0
    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
Esempio n. 10
0
    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
Esempio n. 11
0
    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
Esempio n. 12
0
    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
Esempio n. 13
0
 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
Esempio n. 14
0
    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)
Esempio n. 15
0
    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)
Esempio n. 16
0
    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
Esempio n. 17
0
    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)
Esempio n. 18
0
    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
Esempio n. 19
0
    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 {}
Esempio n. 20
0
    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
Esempio n. 21
0
    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
Esempio n. 22
0
    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
Esempio n. 23
0
    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