예제 #1
0
    def on_get(self, req, resp, tenant_id, server_id, action_id):
        client = req.sl_client

        try:
            server = client['Virtual_Guest'].getObject(
                id=server_id, mask='id, accountId, createDate')
        except SoftLayer.SoftLayerAPIError as e:
            if e.faultCode == 'SoftLayer_Exception_ObjectNotFound':
                return error_handling.not_found(resp,
                                                'Instance could not be found')
            raise

        actions = client['Event_Log'].getAllObjects(
            filter={
                'userType': {
                    'operation': 'SYSTEM'
                },
                'objectName': {
                    'operation': 'CCI'
                },
                'objectId': {
                    'operation': server_id
                },
                'traceId': {
                    'operation': action_id
                }
            })

        if len(actions) == 0:
            return error_handling.not_found(resp, 'action could not be found')

        resp.body = {'instanceAction': format_action(server, actions[0])}
예제 #2
0
파일: flavors.py 프로젝트: Elu0/jumpgate
    def on_get(self, req, resp, flavor_id, tenant_id=None):
        try:
            flavor_id = int(flavor_id)
        except ValueError:
            return not_found(resp, "Flavor could not be found")

        if flavor_id not in FLAVORS:
            return not_found(resp, "Flavor could not be found")

        flavor = get_flavor_details(self.app, req, FLAVORS[flavor_id], detail=True)
        resp.body = {"flavor": flavor}
예제 #3
0
    def on_get(self, req, resp, flavor_id, tenant_id=None):
        try:
            flavor_id = int(flavor_id)
        except ValueError:
            return error_handling.not_found(resp, 'Flavor could not be found')

        if flavor_id not in self.flavors:
            return error_handling.not_found(resp, 'Flavor could not be found')

        flavor = get_flavor_details(self.app, req, self.flavors[flavor_id],
                                    detail=True)
        resp.body = {'flavor': flavor}
예제 #4
0
    def on_delete(self, req, resp, image_guid=None, tenant_id=None):
        if not image_guid:
            return error_handling.not_found(resp, 'Image could not be found')

        client = req.sl_client
        results = get_image(client, image_guid)

        if not results:
            return error_handling.not_found(resp, 'Image could not be found')

        client['Virtual_Guest_Block_Device_Template_Group'].deleteObject(
            id=results['id'])

        resp.status = 204
예제 #5
0
    def on_delete(self, req, resp, image_guid=None, tenant_id=None):
        if not image_guid:
            return error_handling.not_found(resp, 'Image could not be found')

        client = req.env['sl_client']
        results = get_image(client, image_guid)

        if not results:
            return error_handling.not_found(resp, 'Image could not be found')

        client['Virtual_Guest_Block_Device_Template_Group'].deleteObject(
            id=results['id'])

        resp.status = 204
예제 #6
0
    def on_delete(self, req, resp, image_guid=None, tenant_id=None):
        if not image_guid:
            return not_found(resp, 'Image could not be found')

        client = req.env['sl_client']
        image_obj = SLImages(client)
        results = image_obj.get_image(image_guid)

        if not results:
            return not_found(resp, 'Image could not be found')

        client['Virtual_Guest_Block_Device_Template_Group'].deleteObject(
            id=results['id'])

        resp.status = 204
예제 #7
0
파일: user.py 프로젝트: Neetuj/jumpgate
    def on_get(self, req, resp, user_id, **kwargs):

        if "mask" not in kwargs:
            items = set(["id", "username", "firstName", "accountId", "email"])
            kwargs["mask"] = "mask[%s]" % ",".join(items)

        client = req.env["sl_client"]

        try:
            user = client["User_Customer"].getObject(id=user_id, **kwargs)
        except SoftLayerAPIError as ex:
            if ex.faultCode == "SoftLayer_Exception_ObjectNotFound":
                return not_found(resp, "Invalid User ID specified")
            raise
        fieldMap = {
            # SL-Field : OpenStack-Field
            "id": "id",
            "username": "******",
            "email": "email",
            "accountId": "tenantId",
            "firstName": "name",
        }
        user_detail = {}
        for field in fieldMap.keys():
            if user.get(field, None):
                user_detail[fieldMap[field]] = user[field]
        resp.body = {"user": user_detail}
예제 #8
0
    def on_head(self, req, resp, image_guid, tenant_id=None):
        client = req.env['sl_client']
        image_obj = SLImages(client)
        results = get_v1_image_details_dict(
            self.app, req, image_obj.get_image(image_guid))

        if not results:
            return not_found(resp, 'Image could not be found')

        headers = {
            'x-image-meta-id': image_guid,
            'x-image-meta-status': results['status'].lower(),
            'x-image-meta-owner': 'Need tenant ID here',
            'x-image-meta-name': results['name'],
            'x-image-meta-container_format': results['container_format'],
            'x-image-meta-created_at': results['created'],
            'x-image-meta-min_ram': results['minRam'],
            'x-image-meta-updated_at': results['updated'],
            'location': self.app.get_endpoint_url('image', req, 'v1_image',
                                                  image_guid=image_guid),
            'x-image-meta-deleted': False,
            'x-image-meta-protected': results['protected'],
            'x-image-meta-min_disk': results['minDisk'],
            'x-image-meta-size': results['size'],
            'x-image-meta-is_public': results['is_public'],
            'x-image-meta-disk_format': results['disk_format'],
        }

        resp.set_headers(headers)
예제 #9
0
    def on_head(self, req, resp, image_guid, tenant_id=None):
        client = req.env['sl_client']
        image = get_image(client, image_guid)
        results = get_v1_image_details_dict(self.app, req, image)

        if not results:
            return error_handling.not_found(resp, 'Image could not be found')

        headers = {
            'x-image-meta-id': image_guid,
            'x-image-meta-status': results['status'].lower(),
            'x-image-meta-owner': results.get('owner'),
            'x-image-meta-name': results['name'],
            'x-image-meta-container_format': results['container_format'],
            'x-image-meta-created_at': results['created'],
            'x-image-meta-min_ram': results.get('minRam'),
            'x-image-meta-updated_at': results['updated'],
            'location': self.app.get_endpoint_url('image', req, 'v1_image',
                                                  image_guid=image_guid),
            'x-image-meta-deleted': False,
            'x-image-meta-protected': results['protected'],
            'x-image-meta-min_disk': results.get('minDisk'),
            'x-image-meta-size': results['size'],
            'x-image-meta-is_public': results['is_public'],
            'x-image-meta-disk_format': results['disk_format'],
        }

        resp.set_headers(headers)
        resp.content_type = 'text/html; charset=utf-8'
예제 #10
0
 def on_get(self, req, resp, flavor_id, tenant_id=None):
     for flavor in self.flavors:
         if str(flavor_id) == flavor['id']:
             flavor = get_flavor_details(self.app, req, flavor, detail=True)
             resp.body = {'flavor': flavor}
             return
     return error_handling.not_found(resp, 'Flavor could not be found')
예제 #11
0
    def on_get(self, req, resp, tenant_id, server_id):
        client = req.env['sl_client']

        try:
            server = client['Virtual_Guest'].getObject(
                id=server_id, mask='id, accountId, createDate')
        except SoftLayerAPIError as e:
            if e.faultCode == 'SoftLayer_Exception_ObjectNotFound':
                return not_found(resp, 'Instance could not be found')
            raise

        actions = client['Event_Log'].getAllObjects(
            filter={
                'userType': {
                    'operation': 'SYSTEM'
                },
                'objectName': {
                    'operation': 'CCI'
                },
                'objectId': {
                    'operation': server_id
                }
            })

        resp.body = {
            'instanceActions':
            [format_action(server, action) for action in actions]
        }
예제 #12
0
    def on_get(self, req, resp, user_id, **kwargs):

        if 'mask' not in kwargs:
            items = set([
                'id',
                'username',
                'firstName',
                'accountId',
                'email',
            ])
            kwargs['mask'] = "mask[%s]" % ','.join(items)

        client = req.env['sl_client']

        try:
            user = client['User_Customer'].getObject(id=user_id, **kwargs)
        except SoftLayer.SoftLayerAPIError as ex:
            if ex.faultCode == 'SoftLayer_Exception_ObjectNotFound':
                return error_handling.not_found(resp,
                                                "Invalid User ID specified")
            raise
        fieldMap = {
            # SL-Field : OpenStack-Field
            'id': 'id',
            'username': '******',
            'email': 'email',
            'accountId': 'tenantId',
            'firstName': 'name'
        }
        user_detail = {}
        for field in fieldMap.keys():
            if user.get(field, None):
                user_detail[fieldMap[field]] = user[field]
        resp.body = {'user': user_detail}
예제 #13
0
 def on_get(self, req, resp, flavor_id, tenant_id=None):
     for flavor in self.flavors:
         if str(flavor_id) == flavor['id']:
             flavor = get_flavor_details(self.app, req,
                                         flavor, detail=True)
             resp.body = {'flavor': flavor}
             return
     return error_handling.not_found(resp, 'Flavor could not be found')
예제 #14
0
    def on_delete(self, req, resp, tenant_id, keypair_name):
        # keypair_name
        client = req.env['sl_client']
        mgr = SoftLayer.SshKeyManager(client)
        keys = mgr.list_keys(label=keypair_name)
        if len(keys) == 0:
            return error_handling.not_found(resp, 'KeyPair not Found')

        mgr.delete_key(keys[0]['id'])
        resp.status = 202
예제 #15
0
    def on_get(self, req, resp, tenant_id, keypair_name):
        client = req.env['sl_client']
        mgr = SoftLayer.SshKeyManager(client)
        keys = mgr.list_keys(label=keypair_name)
        if len(keys) == 0:
            return error_handling.not_found(resp, 'KeyPair not found')

        keypair = mgr.get_key(keys[0]['id'])

        resp.body = {'keypair': format_keypair(keypair)}
예제 #16
0
    def on_delete(self, req, resp, tenant_id, keypair_name):
        # keypair_name
        client = req.sl_client
        mgr = SoftLayer.SshKeyManager(client)
        keys = mgr.list_keys(label=keypair_name)
        if len(keys) == 0:
            return error_handling.not_found(resp, 'KeyPair not Found')

        mgr.delete_key(keys[0]['id'])
        resp.status = 202
예제 #17
0
    def on_get(self, req, resp, tenant_id, keypair_name):
        client = req.sl_client
        mgr = SoftLayer.SshKeyManager(client)
        keys = mgr.list_keys(label=keypair_name)
        if len(keys) == 0:
            return error_handling.not_found(resp, 'KeyPair not found')

        keypair = mgr.get_key(keys[0]['id'])

        resp.body = {'keypair': format_keypair(keypair)}
예제 #18
0
    def on_get(self, req, resp, image_guid, tenant_id=None):
        client = req.env['sl_client']
        image_obj = SLImages(client)
        results = image_obj.get_image(image_guid)

        if not results:
            return not_found(resp, 'Image could not be found')

        resp.body = {
            'image': get_v1_image_details_dict(self.app, req, results)}
예제 #19
0
    def on_get(self, req, resp, image_guid, tenant_id=None):
        client = req.sl_client
        results = get_image(client, image_guid)

        if not results:
            return error_handling.not_found(resp, 'Image could not be found')

        details = get_v2_image_details_dict(self.app, req, results, tenant_id)

        resp.status = 200
        resp.body = details
예제 #20
0
    def on_get(self, req, resp, image_guid, tenant_id=None):
        client = req.env['sl_client']
        results = get_image(client, image_guid)

        if not results:
            return error_handling.not_found(resp, 'Image could not be found')

        details = get_v1_image_details_dict(self.app, req, results)

        resp.status = 200
        resp.body = {'image': details}
예제 #21
0
    def on_get(self, req, resp, tenant_id, server_id, action_id):
        client = req.env['sl_client']

        try:
            server = client['Virtual_Guest'].getObject(
                id=server_id, mask='id, accountId, createDate')
        except SoftLayerAPIError as e:
            if e.faultCode == 'SoftLayer_Exception_ObjectNotFound':
                return not_found(resp, 'Instance could not be found')
            raise

        actions = client['Event_Log'].getAllObjects(
            filter={
                'userType': {'operation': 'SYSTEM'},
                'objectName': {'operation': 'CCI'},
                'objectId': {'operation': server_id},
                'traceId': {'operation': action_id}})

        if len(actions) == 0:
            return not_found(resp, 'action could not be found')

        resp.body = {'instanceAction': format_action(server, actions[0])}
예제 #22
0
    def on_head(self, req, resp, image_guid, tenant_id=None):
        client = req.sl_client
        image = get_image(client, image_guid)
        results = get_v1_image_details_dict(self.app, req, image)

        if not results:
            return error_handling.not_found(resp, 'Image could not be found')

        headers = {
            'x-image-meta-id':
            image_guid,
            'x-image-meta-status':
            results['status'].lower(),
            'x-image-meta-owner':
            results.get('owner'),
            'x-image-meta-name':
            results['name'],
            'x-image-meta-container_format':
            results['container_format'],
            'x-image-meta-created_at':
            results['created'],
            'x-image-meta-min_ram':
            results.get('minRam'),
            'x-image-meta-updated_at':
            results['updated'],
            'location':
            self.app.get_endpoint_url('image',
                                      req,
                                      'v1_image',
                                      image_guid=image_guid),
            'x-image-meta-deleted':
            False,
            'x-image-meta-protected':
            results['protected'],
            'x-image-meta-min_disk':
            results.get('minDisk'),
            'x-image-meta-size':
            results['size'],
            'x-image-meta-is_public':
            results['is_public'],
            'x-image-meta-disk_format':
            results['disk_format'],
        }

        resp.set_headers(headers)
        resp.content_type = 'text/html; charset=utf-8'
예제 #23
0
    def on_get(self, req, resp, tenant_id, instance_id, volume_id):
        '''Shows details for the specified volume attachment.'''
        try:
            instance_id = int(instance_id)
        except Exception:
            return error_handling.not_found(resp,
                                            "Invalid instance ID specified.")

        if volume_id and len(volume_id) > OPENSTACK_VOLUME_UUID_LEN:
            return error_handling.bad_request(resp,
                                              message="Malformed request body")

        # since detail has the same info as the input request params, we can
        # just return the values back in the response using the request params.
        # But instead we will do sanity check to ensure the volume_id belongs
        # to the instance.
        vg_client = req.sl_client['Virtual_Guest']
        try:
            blkDevices = vg_client.getBlockDevices(mask='id, diskImage.type',
                                                   id=instance_id)
            vols = [
                x for x in blkDevices
                if x['diskImage']['type']['keyName'] != 'SWAP'
            ]
            for vol in vols:
                json_response = None
                vol_disk_id = vol['diskImage']['id']
                if str(vol_disk_id) == volume_id:
                    json_response = {
                        "volumeAttachment": {
                            "device": "",
                            "id": vol_disk_id,
                            "serverId": instance_id,
                            "volumeId": vol_disk_id
                        }
                    }
                    break
            if json_response:
                resp.body = json_response
            else:
                return error_handling.volume_fault(resp,
                                                   'Invalid volume id.',
                                                   code=HTTP.BAD_REQUEST)
        except Exception as e:
            return error_handling.volume_fault(resp, e.faultString)
예제 #24
0
    def on_delete(self, req, resp, tenant_id, instance_id, volume_id):
        """Detach the requested volume from the specified instance."""
        try:
            instance_id = int(instance_id)
        except Exception:
            return error_handling.not_found(resp,
                                            "Invalid instance ID specified.")

        if volume_id and len(volume_id) > OPENSTACK_VOLUME_UUID_LEN:
            return error_handling.bad_request(resp,
                                              message="Malformed request body")

        vdi_client = req.env['sl_client']['Virtual_Disk_Image']

        # first let's check if the volume is already attached
        try:
            volinfo = vdi_client.getObject(id=volume_id, mask='blockDevices')
            blkDevices = volinfo['blockDevices']
            if len(blkDevices) > 0:
                guestId_list = [blkDevice['guestId'] for blkDevice
                                in blkDevices]
                for guest_id in guestId_list:
                    if guest_id == instance_id:
                        try:
                            # detach the volume here
                            vg_client = req.env['sl_client']['Virtual_Guest']
                            vg_client.detachDiskImage(volume_id,
                                                      id=instance_id)
                            break
                        except Exception as e:
                            error_handling.volume_fault(resp,
                                                        e.faultString)
                    else:
                        return error_handling.volume_fault(
                            resp,
                            'The requested disk image is attached to another '
                            'guest and cannot be detached.',
                            code=HTTP.BAD_REQUEST)

        except Exception as e:
            return error_handling.volume_fault(resp, e.faultString,
                                               code=500)

        resp.status = HTTP.ACCEPTED
예제 #25
0
    def on_delete(self, req, resp, tenant_id, instance_id, volume_id):
        """Detach the requested volume from the specified instance."""
        try:
            instance_id = int(instance_id)
        except Exception:
            return error_handling.not_found(resp,
                                            "Invalid instance ID specified.")

        if volume_id and len(volume_id) > OPENSTACK_VOLUME_UUID_LEN:
            return error_handling.bad_request(resp,
                                              message="Malformed request body")

        vdi_client = req.sl_client['Virtual_Disk_Image']

        # first let's check if the volume is already attached
        try:
            volinfo = vdi_client.getObject(id=volume_id, mask='blockDevices')
            blkDevices = volinfo['blockDevices']
            if len(blkDevices) > 0:
                guestId_list = [
                    blkDevice['guestId'] for blkDevice in blkDevices
                ]
                for guest_id in guestId_list:
                    if guest_id == instance_id:
                        try:
                            # detach the volume here
                            vg_client = req.sl_client['Virtual_Guest']
                            vg_client.detachDiskImage(volume_id,
                                                      id=instance_id)
                            break
                        except Exception as e:
                            error_handling.volume_fault(resp, e.faultString)
                    else:
                        return error_handling.volume_fault(
                            resp,
                            'The requested disk image is attached to another '
                            'guest and cannot be detached.',
                            code=HTTP.BAD_REQUEST)

        except Exception as e:
            return error_handling.volume_fault(resp, e.faultString, code=500)

        resp.status = HTTP.ACCEPTED
예제 #26
0
    def on_get(self, req, resp, tenant_id, server_id, network_label):
        network_label = network_label.lower()

        network_mask = None
        if network_label == 'public':
            network_mask = 'primaryIpAddress'
        elif network_label == 'private':
            network_mask = 'primaryBackendIpAddress'
        else:
            return not_found(resp, message='Network does not exist')

        client = req.env['sl_client']
        cci = CCIManager(client)
        instance = cci.get_instance(server_id, mask='id, ' + network_mask)

        resp.body = {
            network_label: [
                {'version': 4, 'addr': instance[network_mask]},
            ]
        }
예제 #27
0
    def on_get(self, req, resp, tenant_id, instance_id):
        '''Lists volume attachments for the instance.'''
        vg_client = req.sl_client['Virtual_Guest']
        try:
            instance_id = int(instance_id)
        except Exception:
            return error_handling.not_found(resp,
                                            "Invalid instance ID specified.")

        try:
            blkDevices = vg_client.getBlockDevices(mask='id, diskImage.type',
                                                   id=instance_id)

            vols = [
                format_volume_attachment(vol['diskImage']['id'], instance_id,
                                         '') for vol in blkDevices
                if vol['diskImage']['type']['keyName'] != 'SWAP'
            ]
            resp.body = {"volumeAttachments": vols}
        except Exception as e:
            error_handling.volume_fault(resp, e.faultString)
예제 #28
0
    def on_get(self, req, resp, tenant_id, server_id, network_label):
        network_label = network_label.lower()

        network_mask = None
        if network_label == 'public':
            network_mask = 'primaryIpAddress'
        elif network_label == 'private':
            network_mask = 'primaryBackendIpAddress'
        else:
            return error_handling.not_found(resp,
                                            message='Network does not exist')

        client = req.env['sl_client']
        cci = SoftLayer.CCIManager(client)
        instance = cci.get_instance(server_id, mask='id, ' + network_mask)

        resp.body = {
            network_label: [
                {'version': 4, 'addr': instance[network_mask]},
            ]
        }
예제 #29
0
    def on_get(self, req, resp, tenant_id, instance_id):
        '''Lists volume attachments for the instance.'''
        vg_client = req.env['sl_client']['Virtual_Guest']
        try:
            instance_id = int(instance_id)
        except Exception:
            return error_handling.not_found(resp,
                                            "Invalid instance ID specified.")

        try:
            blkDevices = vg_client.getBlockDevices(mask='id, diskImage.type',
                                                   id=instance_id)

            vols = [format_volume_attachment(vol['diskImage']['id'],
                                             instance_id,
                                             '')
                    for vol in blkDevices
                    if vol['diskImage']['type']['keyName'] != 'SWAP']
            resp.body = {"volumeAttachments": vols}
        except Exception as e:
            error_handling.volume_fault(resp, e.faultString)
예제 #30
0
    def on_get(self, req, resp, tenant_id, instance_id, volume_id):
        '''Shows details for the specified volume attachment.'''
        try:
            instance_id = int(instance_id)
        except Exception:
            return error_handling.not_found(resp,
                                            "Invalid instance ID specified.")

        if volume_id and len(volume_id) > OPENSTACK_VOLUME_UUID_LEN:
            return error_handling.bad_request(resp,
                                              message="Malformed request body")

        # since detail has the same info as the input request params, we can
        # just return the values back in the response using the request params.
        # But instead we will do sanity check to ensure the volume_id belongs
        # to the instance.
        vg_client = req.env['sl_client']['Virtual_Guest']
        try:
            blkDevices = vg_client.getBlockDevices(mask='id, diskImage.type',
                                                   id=instance_id)
            vols = [x for x in blkDevices
                    if x['diskImage']['type']['keyName'] != 'SWAP']
            for vol in vols:
                json_response = None
                vol_disk_id = vol['diskImage']['id']
                if str(vol_disk_id) == volume_id:
                    json_response = {"volumeAttachment":
                                     {"device": "", "id": vol_disk_id,
                                      "serverId": instance_id,
                                      "volumeId": vol_disk_id}}
                    break
            if json_response:
                resp.body = json_response
            else:
                error_handling.volume_fault(resp, 'Invalid volume id.',
                                            code=HTTP.BAD_REQUEST)
        except Exception as e:
            error_handling.volume_fault(resp, e.faultString)
예제 #31
0
파일: user.py 프로젝트: LiuZhiyan/jumpgate
    def on_get(self, req, resp, user_id, **kwargs):

        if 'mask' not in kwargs:
            items = set([
                'id',
                'username',
                'firstName',
                'accountId',
                'email',
            ])
            kwargs['mask'] = "mask[%s]" % ','.join(items)

        client = req.env['sl_client']

        try:
            user = client['User_Customer'].getObject(id=user_id,
                                                     **kwargs)
        except SoftLayer.SoftLayerAPIError as ex:
            if ex.faultCode == 'SoftLayer_Exception_ObjectNotFound':
                return error_handling.not_found(resp,
                                                "Invalid User ID specified")
            raise

        fieldMap = {
            # SL-Field : OpenStack-Field
            'id': 'id',
            'username': '******',
            'email': 'email',
            'accountId': 'tenantId',
            'firstName': 'name'
        }
        user_detail = {}
        for field in fieldMap.keys():
            if user.get(field, None):
                user_detail[fieldMap[field]] = user[field]
        resp.body = {
            'user': user_detail
        }
예제 #32
0
    def on_post(self, req, resp, tenant_id, instance_id):
        '''Attaches a specified volume to a specified server.'''
        vs_mgr = SoftLayer.VSManager(req.sl_client)

        try:
            instance_id = int(instance_id)
        except Exception:
            # If the instance ID is not valid an exception will be sent
            return error_handling.not_found(resp,
                                            "Invalid instance ID specified.")
        # Get the instance to verify it exists;  also using info from
        # instance to fill out the response object
        try:
            instance = vs_mgr.get_instance(instance_id)
        except Exception as e:
            # If the instance is not found an exception will be sent
            return error_handling.volume_fault(
                resp,
                'The requested instance was not found',
                code=HTTP.NOT_FOUND)

        if not instance:
            return error_handling.volume_fault(
                resp,
                'The requested instance was not found',
                code=HTTP.NOT_FOUND)

        # Get the volume ID from the request body
        body = json.loads(req.stream.read().decode())

        CREATE_VOLUME_ATTACHMENT_VALIDATOR.validate(body)

        volume_id = body['volumeAttachment']['volumeId']

        # first let's check if the volume is already attached
        block_mgr = SoftLayer.BlockStorageManager(req.sl_client)
        blk_devices = []

        try:
            # get the volume info to see if there are any attachments
            # it also verifies that the volume exists

            items = {'id', 'allowedVirtualGuests[allowedHost[credential]]'}
            al_mask = ','.join(items)
            access_list = block_mgr.get_block_volume_access_list(volume_id,
                                                                 mask=al_mask)
            blk_devices = access_list['allowedVirtualGuests']

        except Exception as e:
            return error_handling.volume_fault(
                resp,
                'The requested volume was not found',
                code=HTTP.NOT_FOUND)

        if len(blk_devices) > 0:
            return error_handling.volume_fault(
                resp, 'The requested volume is already attached to '
                'a guest.',
                code=HTTP.BAD_REQUEST)

        try:

            # attach the volume;  authorizing the host to the volume
            block_mgr.authorize_host_to_volume(volume_id,
                                               virtual_guest_ids=[instance_id])
            volume_att = {
                'device': "",
                'serverId': instance_id,
                'volumeId': volume_id
            }
            resp.body = {"volumeAttachment": volume_att}

            resp.status = HTTP.OK

        except Exception as e:
            return error_handling.volume_fault(resp,
                                               message=str(e),
                                               code=HTTP.BAD_REQUEST)
예제 #33
0
    def on_get(self, req, resp, tenant_id, alias):
        if alias not in EXTENSIONS:
            return error_handling.not_found(
                resp, 'No extension exists with given alias.')

        resp.body = {'extension': EXTENSIONS[alias]}
예제 #34
0
파일: servers.py 프로젝트: schivuk/jumpgate
    def on_post(self, req, resp, tenant_id, instance_id):
        body = json.loads(req.stream.read().decode())

        if len(body) == 0:
            return error_handling.bad_request(resp,
                                              message="Malformed request body")

        vg_client = req.env['sl_client']['Virtual_Guest']
        cci = SoftLayer.CCIManager(req.env['sl_client'])

        try:
            instance_id = int(instance_id)
        except Exception:
            return error_handling.not_found(resp,
                                            "Invalid instance ID specified.")

        instance = cci.get_instance(instance_id)

        if 'pause' in body or 'suspend' in body:
            try:
                vg_client.pause(id=instance_id)
            except SoftLayer.SoftLayerAPIError as e:
                if 'Unable to pause instance' in e.faultString:
                    return error_handling.duplicate(resp, e.faultString)
                raise
            resp.status = 202
            return
        elif 'unpause' in body or 'resume' in body:
            vg_client.resume(id=instance_id)
            resp.status = 202
            return
        elif 'reboot' in body:
            if body['reboot'].get('type') == 'SOFT':
                vg_client.rebootSoft(id=instance_id)
            elif body['reboot'].get('type') == 'HARD':
                vg_client.rebootHard(id=instance_id)
            else:
                vg_client.rebootDefault(id=instance_id)
            resp.status = 202
            return
        elif 'os-stop' in body:
            vg_client.powerOff(id=instance_id)
            resp.status = 202
            return
        elif 'os-start' in body:
            vg_client.powerOn(id=instance_id)
            resp.status = 202
            return
        elif 'createImage' in body:
            image_name = body['createImage']['name']
            disks = []

            for disk in filter(lambda x: x['device'] == '0',
                               instance['blockDevices']):
                disks.append(disk)

            try:
                vg_client.createArchiveTransaction(
                    image_name,
                    disks,
                    "Auto-created by OpenStack compatibility layer",
                    id=instance_id,
                )
                # Workaround for not having an image guid until the image is
                # fully created. TODO(nbeitenmiller): Fix this
                cci.wait_for_transaction(instance_id, 300)
                _filter = {
                    'privateBlockDeviceTemplateGroups': {
                        'name': {'operation': image_name},
                        'createDate': {
                            'operation': 'orderBy',
                            'options': [{'name': 'sort', 'value': ['DESC']}],
                        }
                    }}

                acct = req.env['sl_client']['Account']
                matching_image = acct.getPrivateBlockDeviceTemplateGroups(
                    mask='id, globalIdentifier', filter=_filter, limit=1)
                image_guid = matching_image.get('globalIdentifier')

                url = self.app.get_endpoint_url('image', req, 'v2_image',
                                                image_guid=image_guid)

                resp.status = 202
                resp.set_header('location', url)
            except SoftLayer.SoftLayerAPIError as e:
                error_handling.compute_fault(resp, e.faultString)
            return
        elif 'os-getConsoleOutput' in body:
            resp.status = 501
            return
        elif 'resize' in body:
            flavor_id = int(body['resize'].get('flavorRef'))
            if flavor_id not in flavors.FLAVORS:
                return error_handling.bad_request(
                    resp, message="Invalid flavor id in the request body")
            flavor = flavors.FLAVORS[flavor_id]
            cci.upgrade(instance_id, cpus=flavor['cpus'],
                        memory=flavor['ram'] / 1024)
            resp.status = 202
            return
        elif 'confirmResize' in body:
            resp.status = 204
            return

        return error_handling.bad_request(
            resp,
            message="There is no such action: %s" % list(body.keys()),
            code=400)
예제 #35
0
    def on_post(self, req, resp, tenant_id, instance_id):
        '''Attaches a specified volume to a specified server.'''
        body = json.loads(req.stream.read().decode())

        if (len(body) == 0 or 'volumeAttachment' not in body
                or 'volumeId' not in body['volumeAttachment']):
            return error_handling.bad_request(resp,
                                              message="Malformed "
                                              "request body")

        vg_client = req.env['sl_client']['Virtual_Guest']

        try:
            instance_id = int(instance_id)
        except Exception:
            return error_handling.not_found(resp,
                                            "Invalid instance ID specified.")

        volume_id = body['volumeAttachment']['volumeId']
        if volume_id and len(volume_id) > OPENSTACK_VOLUME_UUID_LEN:
            return error_handling.bad_request(resp,
                                              message="Malformed "
                                              "request body")

        vdi_client = req.env['sl_client']['Virtual_Disk_Image']
        volinfo = None

        # first let's check if the volume is already attached
        try:
            volinfo = vdi_client.getObject(id=volume_id, mask='blockDevices')
            blkDevices = volinfo['blockDevices']
            if (len(blkDevices) > 0):
                guestId_list = [
                    blkDevice['guestId'] for blkDevice in blkDevices
                ]
                for guest_id in guestId_list:
                    if (guest_id == instance_id):
                        return error_handling.volume_fault(
                            resp,
                            'The requested disk image is already attached to '
                            'this guest.',
                            code=HTTP.BAD_REQUEST)
                    else:
                        return error_handling.volume_fault(
                            resp,
                            'The requested disk image is already attached to '
                            'another guest.',
                            code=HTTP.BAD_REQUEST)
        except Exception as e:
            return error_handling.volume_fault(resp,
                                               e.faultString,
                                               code=HTTP.NOT_FOUND)

        try:
            # providing different size doesn't seem to have any impact on the
            # outcome hence using 10 as default size.
            disk_check = vg_client.checkHostDiskAvailability(10,
                                                             id=instance_id)
        except Exception:
            disk_check = True

        try:
            if disk_check:
                sl_transaction = vg_client.attachDiskImage(volume_id,
                                                           id=instance_id)
                resp.body = {
                    "volumeAttachment": {
                        "device": "",
                        "id": sl_transaction['id'],
                        "serverId": instance_id,
                        "volumeId": volume_id
                    }
                }
                resp.status = HTTP.ACCEPTED
            else:
                return error_handling.volume_fault(
                    resp,
                    'Action causes migration to a new host. Migration is not '
                    'allowed.',
                    code=HTTP.BAD_REQUEST)
        except Exception as e:
            error_handling.volume_fault(resp, e.faultString)
예제 #36
0
파일: servers.py 프로젝트: amol/jumpgate
    def on_post(self, req, resp, tenant_id, instance_id):
        body = json.loads(req.stream.read().decode())

        if len(body) == 0:
            return bad_request(resp, message="Malformed request body")

        vg_client = req.env['sl_client']['Virtual_Guest']
        cci = CCIManager(req.env['sl_client'])

        try:
            instance_id = int(instance_id)
        except ValueError:
            return not_found(resp, "Invalid instance ID specified.")

        instance = cci.get_instance(instance_id)

        if 'pause' in body or 'suspend' in body:
            try:
                vg_client.pause(id=instance_id)
            except SoftLayerAPIError as e:
                if 'Unable to pause instance' in e.faultString:
                    return duplicate(resp, e.faultString)
                raise
            resp.status = 202
            return
        elif 'unpause' in body or 'resume' in body:
            vg_client.resume(id=instance_id)
            resp.status = 202
            return
        elif 'reboot' in body:
            if body['reboot'].get('type') == 'SOFT':
                vg_client.rebootSoft(id=instance_id)
            elif body['reboot'].get('type') == 'HARD':
                vg_client.rebootHard(id=instance_id)
            else:
                vg_client.rebootDefault(id=instance_id)
            resp.status = 202
            return
        elif 'os-stop' in body:
            vg_client.powerOff(id=instance_id)
            resp.status = 202
            return
        elif 'os-start' in body:
            vg_client.powerOn(id=instance_id)
            resp.status = 202
            return
        elif 'createImage' in body:
            image_name = body['createImage']['name']
            disks = []

            for disk in filter(lambda x: x['device'] == '0',
                               instance['blockDevices']):
                disks.append(disk)

            try:
                vg_client.createArchiveTransaction(
                    image_name,
                    disks,
                    "Auto-created by OpenStack compatibility layer",
                    id=instance_id,
                )
                # Workaround for not having an image guid until the image is
                # fully created. TODO: Fix this
                cci.wait_for_transaction(instance_id, 300)
                _filter = {
                    'privateBlockDeviceTemplateGroups': {
                        'name': {
                            'operation': image_name
                        },
                        'createDate': {
                            'operation': 'orderBy',
                            'options': [{
                                'name': 'sort',
                                'value': ['DESC']
                            }],
                        }
                    }
                }

                acct = req.env['sl_client']['Account']
                matching_image = acct.getPrivateBlockDeviceTemplateGroups(
                    mask='id, globalIdentifier', filter=_filter, limit=1)
                image_guid = matching_image.get('globalIdentifier')

                url = self.app.get_endpoint_url('image',
                                                req,
                                                'v2_image',
                                                image_guid=image_guid)

                resp.status = 202
                resp.set_header('location', url)
            except SoftLayerAPIError as e:
                compute_fault(resp, e.faultString)
            return
        elif 'os-getConsoleOutput' in body:
            resp.status = 501
            return

        return bad_request(resp,
                           message="There is no such action: %s" %
                           list(body.keys()),
                           code=400)
예제 #37
0
    def on_get(self, req, resp, tenant_id, alias):
        if alias not in EXTENSIONS:
            return not_found(resp, 'No extension exists with given alias.')

        resp.body = {'extension': EXTENSIONS[alias]}
예제 #38
0
    def on_post(self, req, resp, tenant_id, instance_id):
        '''Attaches a specified volume to a specified server.'''
        body = json.loads(req.stream.read().decode())

        if any([len(body) == 0,
                'volumeAttachment' not in body,
                'volumeId' not in body['volumeAttachment']]):
            return error_handling.bad_request(resp,
                                              message="Malformed request body")

        vg_client = req.env['sl_client']['Virtual_Guest']

        try:
            instance_id = int(instance_id)
        except Exception:
            return error_handling.not_found(resp,
                                            "Invalid instance ID specified.")

        volume_id = body['volumeAttachment']['volumeId']
        if volume_id and len(volume_id) > OPENSTACK_VOLUME_UUID_LEN:
            return error_handling.bad_request(resp,
                                              message="Malformed request body")

        vdi_client = req.env['sl_client']['Virtual_Disk_Image']
        volinfo = None

        # first let's check if the volume is already attached
        try:
            volinfo = vdi_client.getObject(id=volume_id,
                                           mask='blockDevices')
            blkDevices = volinfo['blockDevices']
            if (len(blkDevices) > 0):
                guestId_list = [blkDevice['guestId'] for blkDevice
                                in blkDevices]
                for guest_id in guestId_list:
                    if (guest_id == instance_id):
                        return error_handling.volume_fault(
                            resp,
                            'The requested disk image is already attached to '
                            'this guest.',
                            code=HTTP.BAD_REQUEST)
                    else:
                        return error_handling.volume_fault(
                            resp,
                            'The requested disk image is already attached to '
                            'another guest.',
                            code=HTTP.BAD_REQUEST)
        except Exception as e:
            return error_handling.volume_fault(resp,
                                               e.faultString,
                                               code=HTTP.NOT_FOUND)

        try:
            # providing different size doesn't seem to have any impact on the
            # outcome hence using 10 as default size.
            disk_check = vg_client.checkHostDiskAvailability(10,
                                                             id=instance_id)
        except Exception:
            disk_check = True

        try:
            if disk_check:
                sl_transaction = vg_client.attachDiskImage(volume_id,
                                                           id=instance_id)
                resp.body = {"volumeAttachment":
                             {"device": "",
                              "id": sl_transaction['id'],
                              "serverId": instance_id,
                              "volumeId": volume_id}}
                resp.status = HTTP.ACCEPTED
            else:
                return error_handling.volume_fault(
                    resp,
                    'Action causes migration to a new host. Migration is not '
                    'allowed.',
                    code=HTTP.BAD_REQUEST)
        except Exception as e:
            error_handling.volume_fault(resp, e.faultString)
예제 #39
0
파일: servers.py 프로젝트: Neetuj/jumpgate
    def on_post(self, req, resp, tenant_id, instance_id):
        body = json.loads(req.stream.read().decode())

        if len(body) == 0:
            return bad_request(resp, message="Malformed request body")

        vg_client = req.env["sl_client"]["Virtual_Guest"]
        cci = CCIManager(req.env["sl_client"])

        try:
            instance_id = int(instance_id)
        except ValueError:
            return not_found(resp, "Invalid instance ID specified.")

        instance = cci.get_instance(instance_id)

        if "pause" in body or "suspend" in body:
            try:
                vg_client.pause(id=instance_id)
            except SoftLayerAPIError as e:
                if "Unable to pause instance" in e.faultString:
                    return duplicate(resp, e.faultString)
                raise
            resp.status = 202
            return
        elif "unpause" in body or "resume" in body:
            vg_client.resume(id=instance_id)
            resp.status = 202
            return
        elif "reboot" in body:
            if body["reboot"].get("type") == "SOFT":
                vg_client.rebootSoft(id=instance_id)
            elif body["reboot"].get("type") == "HARD":
                vg_client.rebootHard(id=instance_id)
            else:
                vg_client.rebootDefault(id=instance_id)
            resp.status = 202
            return
        elif "os-stop" in body:
            vg_client.powerOff(id=instance_id)
            resp.status = 202
            return
        elif "os-start" in body:
            vg_client.powerOn(id=instance_id)
            resp.status = 202
            return
        elif "createImage" in body:
            image_name = body["createImage"]["name"]
            disks = []

            for disk in filter(lambda x: x["device"] == "0", instance["blockDevices"]):
                disks.append(disk)

            try:
                vg_client.createArchiveTransaction(
                    image_name, disks, "Auto-created by OpenStack compatibility layer", id=instance_id
                )
                # Workaround for not having an image guid until the image is
                # fully created. TODO: Fix this
                cci.wait_for_transaction(instance_id, 300)
                _filter = {
                    "privateBlockDeviceTemplateGroups": {
                        "name": {"operation": image_name},
                        "createDate": {"operation": "orderBy", "options": [{"name": "sort", "value": ["DESC"]}]},
                    }
                }

                acct = req.env["sl_client"]["Account"]
                matching_image = acct.getPrivateBlockDeviceTemplateGroups(
                    mask="id, globalIdentifier", filter=_filter, limit=1
                )
                image_guid = matching_image.get("globalIdentifier")

                url = self.app.get_endpoint_url("image", req, "v2_image", image_guid=image_guid)

                resp.status = 202
                resp.set_header("location", url)
            except SoftLayerAPIError as e:
                compute_fault(resp, e.faultString)
            return
        elif "os-getConsoleOutput" in body:
            resp.status = 501
            return

        return bad_request(resp, message="There is no such action: %s" % list(body.keys()), code=400)