示例#1
0
文件: address.py 项目: osaddon/cimi
    def GET(self, req, *parts):
        """
        Handle GET machine request
        """

        env = self._fresh_env(req)
        env["PATH_INFO"] = concat(self.os_path, "/", parts[0])

        new_req = Request(env)
        res = new_req.get_response(self.app)

        if res.status_int == 200:
            data = json.loads(res.body).get("server")

            body = {}
            body["id"] = concat(self.tenant_id, "/", self.entity_uri, "/", self.machine_id, "/", self.address_key)
            body["resourceURI"] = concat(self.uri_prefix, "/", self.entity_uri)
            body["entries"] = self._get_entry(data)

            if self.res_content_type == "application/xml":
                response_data = {"Collection": body}
            else:
                response_data = body

            new_content = make_response_data(response_data, self.res_content_type, self.metadata, self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers["Content-Type"] = self.res_content_type
            resp.status = 200
            resp.body = new_content

            return resp
        else:
            return res
示例#2
0
文件: address.py 项目: osaddon/cimi
 def _make_entry(entries):
     adds = {}
     match_up(adds, data, "addr", "addresses/" + self.address_key)
     if adds.get("addr"):
         ips = adds.get("addr")
         for addr in ips:
             entry = {}
             name = "MachineNetworkInterfacesAddressesCollectionEntry"
             entry["id"] = concat(
                 self.tenant_id, "/", name, "/", self.machine_id, "/", self.address_key, "/", addr.get("addr")
             )
             entry["resourceURI"] = concat(self.uri_prefix, "/", name)
             name = "MachineNetworkInterfaceAddress"
             entry["address"] = {
                 "href": concat(
                     self.tenant_id,
                     "/",
                     name,
                     "/",
                     self.machine_id,
                     "/",
                     self.address_key,
                     "/",
                     addr.get("addr"),
                 )
             }
             entries.append(entry)
示例#3
0
 def __init__(self, conf, app, req, tenant_id, *args):
     super(VolumeCtrler, self).__init__(conf, app, req, tenant_id,
                                         *args)
     self.os_path = '/%s/volumes/%s' % (tenant_id, args[0])
     self.entity_uri = 'Volume'
     self.metadata = Consts.VOLUME_METADATA
     self.actions = {concat(self.uri_prefix, '/action/restart'): 'reboot',
                     concat(self.uri_prefix, '/action/stop'): 'delete'}
示例#4
0
    def GET(self, req, *parts):
        """
        Handle GET Container (List Objects) request
        """

        env = copy.copy(req.environ)

        env['SCRIPT_NAME'] = self.os_version
        env['PATH_INFO'] = self.os_path
        # we will always use json format to get Nova information
        env['HTTP_ACCEPT'] = 'application/json'

        # need to remove this header, otherwise, it will always take the
        # original request accept content type
        if env.has_key('nova.best_content_type'):
            env.pop('nova.best_content_type')
        new_req = Request(env)

        res = new_req.get_response(self.app)
        if res.status_int == 200:
            content = json.loads(res.body)
            body = {}
            body['resourceURI'] = concat(self.uri_prefix, self.entity_uri)
            body['id'] = concat(self.tenant_id,
                                '/', self.entity_uri)
            body['machineImages'] = []
            images = content.get('images',[])
            for image in images:
                entry = {}
                entry['resourceURI'] = concat(self.uri_prefix,
                                              'MachineImage')
                entry['id'] = '/'.join([self.tenant_id,
                                     'MachineImage',
                                     image['id']])

                body['machineImages'].append(entry)

            body['count'] = len(body['machineImages'])
            if self.res_content_type == 'application/xml':
                response_data = {'Collection': body}
            else:
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)

            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content
            return resp
        else:
            return res
示例#5
0
文件: network.py 项目: zhexuan/cimi
 def _make_entry(key, source_key, entries):
     adds = {}
     match_up(adds, data, 'addr', source_key)
     if adds.get('addr'):
         entry = {}
         name = 'MachineNetworkInterfacesCollectionEntry'
         entry['id'] = concat(self.tenant_id, '/', name,
                              '/', id, '/', key)
         entry['resourceURI'] = concat(self.uri_prefix,
             '/', name,)
         name = 'MachineNetworkInterfaceAddressesCollection'
         entry['addresses'] = {'href': concat(self.tenant_id,
             '/', name, '/', id, '/', key)}
         entries.append(entry)
示例#6
0
    def GET(self, req, *parts):
        """
        Handle GET Container (List Objects) request
        """

        env = self._fresh_env(req)
        env['PATH_INFO'] = concat(self.os_path,
                                  '/', '/'.join(parts))

        new_req = Request(env)
        res = new_req.get_response(self.app)
        if res.status_int == 200:
            flavor = json.loads(res.body).get('flavor')
            if flavor:
                body = {}
                body['resourceURI'] = concat(self.uri_prefix, self.entity_uri)
                body['id'] = concat(self.tenant_id,
                                '/', self.entity_uri,
                                '/', self.config_id)
                match_up(body, flavor, 'name', 'name')
                match_up(body, flavor, 'cpu', 'vcpus')
                match_up(body, flavor, 'memory', 'ram')
                body['disks'] = []
                body['disks'].append({'capacity': flavor.get('disk'),
                                      'units': 'gb'})

            if self.res_content_type == 'application/xml':
                body.pop('resourceURI')
                response_data = {self.entity_uri: body}
            else:
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content
            return resp
        else:
            return res

        return res
示例#7
0
文件: address.py 项目: zhexuan/cimi
    def GET(self, req, *parts):
        """
        Handle GET machine request
        """

        env = self._fresh_env(req)
        env['PATH_INFO'] = concat(self.os_path, '/', parts[0])

        new_req = Request(env)
        res = new_req.get_response(self.app)

        if res.status_int == 200:
            data = json.loads(res.body).get('server')

            body = {}
            body['id'] = concat(self.tenant_id, '/',
                                self.entity_uri, '/',
                                self.machine_id, '/',
                                self.address_key, '/',
                                self.machine_ip)
            adds = {}
            match_up(adds, data, 'addr', 'addresses/'+self.address_key)
            ips = adds.get('addr')
            if ips:
                for ip in ips:
                    if self.machine_ip == ip.get('addr'):
                        body['ip'] = self.machine_ip

            if self.res_content_type == 'application/xml':
                response_data = {'Address': body}
            else:
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content

            return resp
        else:
            return res
示例#8
0
文件: machine.py 项目: zhexuan/cimi
    def GET(self, req, *parts):
        """
        Handle GET machine request
        """

        new_req = self._fresh_request(req)

        res = new_req.get_response(self.app)
        if res.status_int == 200:
            content = json.loads(res.body)
            body = {}
            body['resourceURI'] = concat(self.uri_prefix, self.entity_uri)
            body['id'] = concat(self.tenant_id,
                                '/', self.entity_uri)
            body['machines'] = []
            machines = content.get('servers',[])
            for machine in machines:
                entry = {}
                entry['resourceURI'] = concat(self.uri_prefix,
                                            'Machine')
                entry['id'] = concat(self.tenant_id, '/',
                                     'machine/',
                                     machine['id'])

                body['machines'].append(entry)

            body['count'] = len(body['machines'])
            if self.res_content_type == 'application/xml':
                response_data = {'Collection': body}
            else:
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content

            return resp
        else:
            return res
示例#9
0
文件: address.py 项目: zhexuan/cimi
 def _make_entry(entries):
     adds = {}
     match_up(adds, data, 'addr', 'addresses/'+self.address_key)
     if adds.get('addr'):
         ips = adds.get('addr')
         for addr in ips:
             entry = {}
             name = 'MachineNetworkInterfacesAddressesCollectionEntry'
             entry['id'] = concat(self.tenant_id, '/', name,
                  '/', self.machine_id, '/', self.address_key,
                              '/', addr.get('addr'))
             entry['resourceURI'] = concat(self.uri_prefix,
                 '/', name,)
             name = 'MachineNetworkInterfaceAddress'
             entry['address'] = {'href': concat(self.tenant_id,
                 '/', name, '/', self.machine_id, '/',
                 self.address_key, '/', addr.get('addr'))}
             entries.append(entry)
示例#10
0
 def _make_entry(key, source_key, entries):
     adds = {}
     match_up(adds, data, 'addr', source_key)
     if adds.get('addr'):
         entry = {}
         name = 'MachineNetworkInterfacesCollectionEntry'
         entry['id'] = concat(self.tenant_id, '/', name, '/', id, '/',
                              key)
         entry['resourceURI'] = concat(
             self.uri_prefix,
             '/',
             name,
         )
         name = 'MachineNetworkInterfaceAddressesCollection'
         entry['addresses'] = {
             'href': concat(self.tenant_id, '/', name, '/', id, '/',
                            key)
         }
         entries.append(entry)
示例#11
0
文件: machine.py 项目: zhexuan/cimi
 def __init__(self, conf, app, req, tenant_id, *args):
     super(MachineCtrler, self).__init__(conf, app, req, tenant_id,
                                         *args)
     self.os_path = '/%s/servers' % (tenant_id)
     self.entity_uri = 'Machine'
     self.metadata = {'attributes': {'property': 'key',
                                     'volumes': 'href',
                                     'networkInterfaces': 'href',
                                     'Entry': 'resourceURI',
                                     'operation': ['rel', 'href']},
                      'plurals': {'entries': 'Entry'},
                      'sequence': {'Machine':
                                   ['id', 'name', 'description',
                                    'created', 'updated', 'property',
                                    'state', 'cpu', 'memory', 'disks',
                                    'networkInterfaces',
                                    'operations']}}
     self.actions = {concat(self.uri_prefix, 'action/restart'): 'reboot',
                     concat(self.uri_prefix, 'action/stop'): 'delete'}
示例#12
0
    def GET(self, req, *parts):
        """
        Handle GET machine request
        """

        env = self._fresh_env(req)
        env['PATH_INFO'] = concat(self.os_path, '/', parts[0])

        new_req = Request(env)
        res = new_req.get_response(self.app)

        if res.status_int == 200:
            data = json.loads(res.body).get('server')

            body = {}
            body['id'] = concat(self.tenant_id, '/', self.entity_uri, '/',
                                self.machine_id, '/', self.address_key, '/',
                                self.machine_ip)
            adds = {}
            match_up(adds, data, 'addr', 'addresses/' + self.address_key)
            ips = adds.get('addr')
            if ips:
                for ip in ips:
                    if self.machine_ip == ip.get('addr'):
                        body['ip'] = self.machine_ip

            if self.res_content_type == 'application/xml':
                response_data = {'Address': body}
            else:
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata, self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content

            return resp
        else:
            return res
示例#13
0
文件: volume.py 项目: zhexuan/cimi
 def _delete(self, req, request_data, *parts):
     """
     Handle the stop machine request
     """
     env = self._fresh_env(req)
     env['PATH_INFO'] = concat(self.os_path, '/', parts[0])
     env['REQUEST_METHOD'] = 'DELETE'
     new_req = Request(env)
     res = new_req.get_response(self.app)
     return res
示例#14
0
    def GET(self, req, *parts):
        """
        Handle GET Container (List Objects) request
        """

        env = self._fresh_env(req)
        env['PATH_INFO'] = concat(self.os_path, '/', self.image_id)

        new_req = Request(env)
        res = new_req.get_response(self.app)
        if res.status_int == 200:
            image = json.loads(res.body).get('image')
            if image:
                body = {}
                body['id'] = concat(self.tenant_id,
                                '/', self.entity_uri,
                                '/', self.image_id)
                match_up(body, image, 'name', 'name')
                match_up(body, image, 'created', 'created')
                match_up(body, image, 'updated', 'updated')
                body['imageLocation'] = body['id']

            if self.res_content_type == 'application/xml':
                response_data = {self.entity_uri: body}
            else:
                body['resourceURI'] = concat(self.uri_prefix, self.entity_uri)
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content
            return resp
        else:
            return res

        return res
示例#15
0
文件: address.py 项目: osaddon/cimi
    def GET(self, req, *parts):
        """
        Handle GET machine request
        """

        env = self._fresh_env(req)
        env["PATH_INFO"] = concat(self.os_path, "/", parts[0])

        new_req = Request(env)
        res = new_req.get_response(self.app)

        if res.status_int == 200:
            data = json.loads(res.body).get("server")

            body = {}
            body["id"] = concat(
                self.tenant_id, "/", self.entity_uri, "/", self.machine_id, "/", self.address_key, "/", self.machine_ip
            )
            adds = {}
            match_up(adds, data, "addr", "addresses/" + self.address_key)
            ips = adds.get("addr")
            if ips:
                for ip in ips:
                    if self.machine_ip == ip.get("addr"):
                        body["ip"] = self.machine_ip

            if self.res_content_type == "application/xml":
                response_data = {"Address": body}
            else:
                response_data = body

            new_content = make_response_data(response_data, self.res_content_type, self.metadata, self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers["Content-Type"] = self.res_content_type
            resp.status = 200
            resp.body = new_content

            return resp
        else:
            return res
示例#16
0
    def GET(self, req, *parts):
        """
        Handle GET Container (List Objects) request
        """
        body = {}
        body['id'] = concat(self.tenant_id, '/', self.entity_uri)
        body['name'] = self.entity_uri
        body['description'] = 'Cloud Entry Point'
        body['baseURI'] = concat(req.host_url, self.request_prefix, '/')

        body['machineConfigs'] = {
            'href':
            '/'.join([self.tenant_id, 'MachineConfigurationCollection'])
        }

        body['machines'] = {
            'href': '/'.join([self.tenant_id, 'MachineCollection'])
        }

        body['machineImages'] = {
            'href': '/'.join([self.tenant_id, 'MachineImageCollection'])
        }

        body['volumes'] = {
            'href': '/'.join([self.tenant_id, 'VolumeCollection'])
        }

        if self.res_content_type == 'application/xml':
            response_data = {'CloudEntryPoint': body}
        else:
            body['resourceURI'] = '/'.join([self.uri_prefix, self.entity_uri])
            response_data = body

        new_content = make_response_data(response_data, self.res_content_type,
                                         self.metadata, self.uri_prefix)
        resp = Response()
        self._fixup_cimi_header(resp)
        resp.headers['Content-Type'] = self.res_content_type
        resp.status = 200
        resp.body = new_content
        return resp
示例#17
0
文件: address.py 项目: zhexuan/cimi
    def GET(self, req, *parts):
        """
        Handle GET machine request
        """

        env = self._fresh_env(req)
        env['PATH_INFO'] = concat(self.os_path, '/', parts[0])

        new_req = Request(env)
        res = new_req.get_response(self.app)

        if res.status_int == 200:
            data = json.loads(res.body).get('server')

            body = {}
            body['id'] = concat(self.tenant_id, '/',
                                self.entity_uri, '/',
                                self.machine_id, '/',
                                self.address_key)
            body['resourceURI'] = concat(self.uri_prefix, self.entity_uri)
            body['entries'] = self._get_entry(data)

            if self.res_content_type == 'application/xml':
                response_data = {'Collection': body}
            else:
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content

            return resp
        else:
            return res
示例#18
0
    def GET(self, req, *parts):
        """
        Handle GET Container (List Objects) request
        """
        body = {}
        body['id'] = concat(self.tenant_id,
                            '/', self.entity_uri)
        body['name'] = self.entity_uri
        body['description'] = 'Cloud Entry Point'
        body['baseURI'] = concat(req.host_url, self.request_prefix, '/')

        body['machineConfigs'] = {'href':
                '/'.join([self.tenant_id, 'MachineConfigurationCollection'])}

        body['machines'] = {'href':
                '/'.join([self.tenant_id, 'MachineCollection'])}

        body['machineImages'] = {'href':
                '/'.join([self.tenant_id, 'MachineImageCollection'])}

        body['volumes'] = {'href':
                '/'.join([self.tenant_id, 'VolumeCollection'])}

        if self.res_content_type == 'application/xml':
            response_data = {'CloudEntryPoint': body}
        else:
            body['resourceURI'] = concat(self.uri_prefix,
                                   self.entity_uri)
            response_data = body

        new_content = make_response_data(response_data,
                                         self.res_content_type,
                                         self.metadata,
                                         self.uri_prefix)
        resp = Response()
        self._fixup_cimi_header(resp)
        resp.headers['Content-Type'] = self.res_content_type
        resp.status = 200
        resp.body = new_content
        return resp
示例#19
0
    def GET(self, req, *parts):
        """
        Handle GET machine request
        """

        env = self._fresh_env(req)
        env['PATH_INFO'] = concat(self.os_path, '/', parts[0])

        new_req = Request(env)
        res = new_req.get_response(self.app)

        if res.status_int == 200:
            data = json.loads(res.body).get('server')

            body = {}
            body['id'] = concat(self.tenant_id,
                                '/networkInterfacesCollection/', parts[0])
            body['resourceURI'] = concat(self.uri_prefix, '/', self.entity_uri)
            body['entries'] = self._get_entry(data, parts[0])

            if self.res_content_type == 'application/xml':
                response_data = {'Collection': body}
            else:
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata, self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content

            return resp
        else:
            return res
示例#20
0
 def _make_entry(entries):
     adds = {}
     match_up(adds, data, 'addr', 'addresses/' + self.address_key)
     if adds.get('addr'):
         ips = adds.get('addr')
         for addr in ips:
             entry = {}
             name = 'MachineNetworkInterfacesAddressesCollectionEntry'
             entry['id'] = concat(self.tenant_id, '/', name, '/',
                                  self.machine_id,
                                  '/', self.address_key, '/',
                                  addr.get('addr'))
             entry['resourceURI'] = concat(
                 self.uri_prefix,
                 '/',
                 name,
             )
             name = 'MachineNetworkInterfaceAddress'
             entry['address'] = {
                 'href':
                 concat(self.tenant_id, '/', name, '/', self.machine_id,
                        '/', self.address_key, '/', addr.get('addr'))
             }
             entries.append(entry)
示例#21
0
    def DELETE(self, req, *parts):
        """
        handle volume detach operation
        """
        #parts is /server_id/attach_id

        if len(parts) < 2:
            return get_err_response('BadRequest')

        env = self._fresh_env(req)
        env['PATH_INFO'] = concat(self.os_path, '/', parts[0],
                                  '/os-volume_attachments/', parts[1])
        env['CONTENT_TYPE'] = 'application/json'
        new_req = Request(env)
        res = new_req.get_response(self.app)

        return res
示例#22
0
    def GET(self, req, *parts):
        """
        Handle GET Container (List Objects) request
        """

        env = self._fresh_env(req)
        env['PATH_INFO'] = concat(self.os_path, '/', '/'.join(parts))

        new_req = Request(env)
        res = new_req.get_response(self.app)
        if res.status_int == 200:
            flavor = json.loads(res.body).get('flavor')
            if flavor:
                body = {}
                body['resourceURI'] = '/'.join(
                    [self.uri_prefix, self.entity_uri])
                body['id'] = '/'.join(
                    [self.tenant_id, self.entity_uri, self.config_id])
                match_up(body, flavor, 'name', 'name')
                match_up(body, flavor, 'cpu', 'vcpus')
                body['memory'] = int(flavor.get('ram')) * 1000
                body['disks'] = [{
                    'capacity': int(flavor.get('disk')) * 1000,
                    'format': 'UNKNOWN'
                }]

            if self.res_content_type == 'application/xml':
                response_data = {self.entity_uri: body}
                remove_member(response_data, 'resourceURI')
            else:
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata, self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content
            return resp
        else:
            return res

        return res
示例#23
0
文件: volume.py 项目: zhexuan/cimi
    def _reboot(self, req, request_data, *parts):
        """
        Handle the machine reboot request
        """
        data = {}
        force = request_data.get('force', False)
        if isinstance(force, str):
            force = 'HARD' if force.lower() == 'true' else 'SOFT'
        else:
            force = 'HARD' if force else 'SOFT'
        data['reboot'] = {'type': force}
        env = self._fresh_env(req)
        env['PATH_INFO'] = concat(self.os_path, '/', parts[0], '/action')
        env['CONTENT_TYPE'] = 'application/json'
        new_req = Request(env)
        new_req.body = json.dumps(data)
        res = new_req.get_response(self.app)

        return res
示例#24
0
文件: volume.py 项目: zhexuan/cimi
    def GET(self, req, *parts):
        """
        Handle GET Container (List Objects) request
        """

        env = self._fresh_env(req)
        env['PATH_INFO'] = concat(self.os_path,
                                  '/', '/'.join(parts))
        new_req = Request(env)
        res = new_req.get_response(self.app)

        if res.status_int == 200:
            data = json.loads(res.body).get('server')

            body = {}
            body['id'] = concat(self.tenant_id, '/machine/',
                                parts[0])
            match_up(body, data, 'name', 'name')
            match_up(body, data, 'created', 'created')
            match_up(body, data, 'updated', 'updated')
            match_up(body, data, 'state', 'status')
            body['networkInterfaces'] = {'href': concat(self.tenant_id,
                    '/networkInterfacesCollection/', parts[0])}

            # Send a request to get the details on flavor
            env = self._fresh_env(req)
            env['PATH_INFO'] = '/%s/flavors/%s' % (self.tenant_id, 
                                                   data['flavor']['id'])
            new_req = Request(env)
            res = new_req.get_response(self.app)
            if res.status_int == 200:
                flavor = json.loads(res.body).get('flavor')
                match_up(body, flavor, 'cpu', 'vcpus')
                ram = {}
                match_up(ram, flavor, 'quantity', 'ram')
                ram['units'] = 'MB'
                body['memory'] = ram
                disks = []
                disks.append({'capacity': int(flavor.get('disk')) * 1000})
                body['disks'] = disks

            # deal with machine operations
            operations = []
            name = concat(self.uri_prefix, 'action/stop')
            operations.append(self._create_op(name, parts[0]))
            name = concat(self.uri_prefix, 'action/restart')
            operations.append(self._create_op(name, parts[0]))
            body['operations'] = operations

            if self.res_content_type == 'application/xml':
                response_data = {'Machine': body}
            else:
                body['resourceURI'] = concat(self.uri_prefix, self.entity_uri)
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content
            return resp
        else:
            return res
示例#25
0
文件: volume.py 项目: zhexuan/cimi
 def _create_op(self, name, id):
     entry = {}
     entry['rel'] = name
     entry['href'] = concat(self.tenant_id, '/machine/', id)
     return entry
示例#26
0
文件: machine.py 项目: chrrrles/cimi
    def GET(self, req, *parts):
        """
        Handle GET Container (List Objects) request
        """

        env = self._fresh_env(req)
        env['PATH_INFO'] = concat(self.os_path,
                                  '/', '/'.join(parts))
        new_req = Request(env)
        res = new_req.get_response(self.app)

        if res.status_int == 200:
            data = json.loads(res.body).get('server')

            body = {}
            body['id'] = concat(self.tenant_id, '/Machine/',
                                parts[0])
            match_up(body, data, 'name', 'name')
            match_up(body, data, 'created', 'created')
            match_up(body, data, 'updated', 'updated')
            body['state'] = map_machine_state(data['status'])

            body['networkInterfaces'] = {'href': '/'.join([self.tenant_id,
                'NetworkInterfacesCollection', parts[0]])}

            body['volumes'] = {'href': '/'.join([self.tenant_id,
                'MachineVolumeCollection', parts[0]])}
            body['disks'] = {'href': '/'.join([self.tenant_id,
                'MachineDiskCollection', parts[0]])}


            # Send a request to get the details on flavor
            env = self._fresh_env(req)
            env['PATH_INFO'] = '/%s/flavors/%s' % (self.tenant_id,
                                                   data['flavor']['id'])
            new_req = Request(env)
            res = new_req.get_response(self.app)
            if res.status_int == 200:
                flavor = json.loads(res.body).get('flavor')
                match_up(body, flavor, 'cpu', 'vcpus')
                body['memory'] = int(flavor.get('ram')) * 1000

            # deal with machine operations
            operations = []
            action_url = '/'.join([self.tenant_id, 'Machine', parts[0]])

            action_name = '/'.join([self.uri_prefix, 'action/start'])
            operations.append(self._create_op(action_name, action_url))

            action_name = '/'.join([self.uri_prefix, 'action/stop'])
            operations.append(self._create_op(action_name, action_url))

            action_name = '/'.join([self.uri_prefix, 'action/restart'])
            operations.append(self._create_op(action_name, action_url))

            action_name = '/'.join([self.uri_prefix, 'action/pause'])
            operations.append(self._create_op(action_name, action_url))

            action_name = '/'.join([self.uri_prefix, 'action/suspend'])
            operations.append(self._create_op(action_name, action_url))

            action_name = 'delete'
            operations.append(self._create_op(action_name, action_url))

            body['operations'] = operations

            if self.res_content_type == 'application/xml':
                response_data = {'Machine': body}
                remove_member(response_data, 'resourceURI')
            else:
                body['resourceURI'] = '/'.join([self.uri_prefix,
                                               self.entity_uri])
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content
            return resp
        else:
            return res
示例#27
0
    def POST(self, req, *parts):
        """
        Handle POST machineVolumeCollection request which will attach an volume
        """
        try:
            request_data = get_request_data(req.body, self.req_content_type)
        except Exception as error:
            return get_err_response('MalformedBody')

        if request_data:
            data = request_data.get('body').get('MachineVolume')
            if not data:
                data = request_data.get('body')
            if data:

                volume_url = data.get('volume', {}).get('href')
                if volume_url:
                    volume_id = volume_url.strip('/').split('/')[-1]
                else:
                    return get_err_response('MalformedBody')

                device = data.get('initialLocation')
                if not device:
                    return get_err_response('MalformedBody')

                reqdata = {}
                reqdata['volumeAttachment'] = {'volumeId': volume_id,
                                            'device': device}
                env = self._fresh_env(req)
                env['PATH_INFO'] = concat(self.os_path, '/', parts[0],
                                          '/os-volume_attachments')
                env['CONTENT_TYPE'] = 'application/json'
                new_req = Request(env)
                new_req.body = json.dumps(reqdata)
                res = new_req.get_response(self.app)
                if res.status_int == 200:
                    data = json.loads(res.body).get('volumeAttachment')
                    attach_id = data.get('id')
                    server_id = data.get('serverId')
                    volume_id = data.get('volumeId')

                    body = {}
                    match_up(body, data, 'initialLocation', 'device')

                    body['id'] = concat(self.tenant_id, '/machinevolume/',
                                        server_id, '/', attach_id)
                    location = '/'.join([self.request_prefix, body['id']])

                    body['volume'] = {'href': concat(self.tenant_id,
                                                    '/volume/', volume_id)}

                    # deal with volume attach operations
                    operations = []
                    operations.append(self._create_op('edit', body['id']))

                    operations.append(self._create_op('delete', body['id']))
                    body['operations'] = operations
                    body['state'] = 'ATTACHING'

                    if self.res_content_type == 'application/xml':
                        response_data = {'MachineVolume': body}
                    else:
                        body['resourceURI'] = concat(self.uri_prefix,
                                                    '/MachineVolume')
                        response_data = body

                    new_content = make_response_data(response_data,
                                                 self.res_content_type,
                                                 self.machine_volume_metadata,
                                                 self.uri_prefix)
                    resp = Response()
                    self._fixup_cimi_header(resp)
                    resp.headers['Content-Type'] = self.res_content_type
                    resp.headers['Location'] = location
                    resp.status = 201
                    resp.body = new_content
                    return resp
                else:
                    return res

            else:
                return get_err_response('BadRequest')
        else:
            return get_err_response('BadRequest')
示例#28
0
    def GET(self, req, *parts):
        """
        Handle GET machineVolumeCollection request
        """

        env = self._fresh_env(req)

        env['PATH_INFO'] = concat(self.os_path, '/',
                                  parts[0], '/os-volume_attachments')
        new_req = Request(env)
        res = new_req.get_response(self.app)

        if res.status_int == 200:
            content = json.loads(res.body)
            body = {}
            body['id'] = concat(self.tenant_id,
                                '/', self.entity_uri, '/', parts[0])
            body['resourceURI'] = concat(self.uri_prefix, '/',
                                            self.entity_uri)

            body['machineVolumes'] = []
            volumeAttachments = content.get('volumeAttachments', [])
            for data in volumeAttachments:
                entry = {}
                if self.res_content_type == 'application/json':
                    entry['resourceURI'] = concat(self.uri_prefix,
                                            '/MachineVolume')
                entry['id'] = concat(self.tenant_id, '/',
                                     'machineVolume/',
                                     data['serverId'], '/',
                                     data['id'])
                entry['initialLocation'] = data['device']
                entry['volume'] = {'href': concat(self.tenant_id,
                    '/Volume/', data['volumeId'])}

                operations = []
                operations.append(self._create_op('edit', entry['id']))
                operations.append(self._create_op('delete', entry['id']))
                entry['operations'] = operations

                body['machineVolumes'].append(entry)

            body['count'] = len(body['machineVolumes'])
            # deal with machinevolume operations
            operations = []
            operations.append(self._create_op('add', body['id']))
            body['operations'] = operations

            if self.res_content_type == 'application/xml':
                response_data = {'Collection': body}
                remove_member(response_data, 'resourceURI')
            else:
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content

            return resp
        else:
            return res
示例#29
0
文件: machine.py 项目: chrrrles/cimi
    def GET(self, req, *parts):
        """
        Handle GET machine request
        """

        new_req = self._fresh_request(req)

        res = new_req.get_response(self.app)
        if res.status_int == 200:
            content = json.loads(res.body)
            body = {}
            body['id'] = concat(self.tenant_id,
                                '/', self.entity_uri)
            body['resourceURI'] = '/'.join([self.uri_prefix,
                                            self.entity_uri])

            env = self._fresh_env(req)
            env['PATH_INFO'] = '/%s/flavors/detail' % (self.tenant_id)
            new_req = Request(env)
            res = new_req.get_response(self.app)
            if res.status_int == 200:
                flavors = json.loads(res.body).get('flavors')
            else:
                flavors = []

            keyed_flavors = {}
            for flavor in flavors:
                keyed_flavors[flavor['id']] = flavor

            body['machines'] = []
            machines = content.get('servers', [])
            for machine in machines:
                entry = {}
                if self.res_content_type != 'application/xml':
                    entry['resourceURI'] = '/'.join([self.uri_prefix,
                                                 'Machine'])
                entry['id'] = concat(self.tenant_id, '/',
                                     'machine/',
                                     machine['id'])
                entry['name'] = machine['name']
                #entry['property'] = machine['metadata']
                entry['created'] = machine['created']
                entry['updated'] = machine['updated']
                entry['state'] = map_machine_state(machine['status'])
                flavor = keyed_flavors[machine['flavor']['id']]
                entry['cpu'] = flavor['vcpus']
                entry['memory'] = int(flavor['ram']) * 1000

                entry['volumes'] = {'href': '/'.join([self.tenant_id,
                    'MachineVolumeCollection', machine['id']])}
                entry['networkInterfaces'] = {'href': '/'.join([self.tenant_id,
                    'NetworkInterfacesCollection', machine['id']])}
                entry['disks'] = {'href': '/'.join([self.tenant_id,
                    'MachineDiskCollection', machine['id']])}

                body['machines'].append(entry)

            body['count'] = len(body['machines'])
            # deal with machine operations
            operations = []
            operations.append(self._create_op('add',
                                              '/'.join([self.tenant_id,
                                                       'machineCollection'])))
            body['operations'] = operations

            if self.res_content_type == 'application/xml':
                body['resourceURI'] = '/'.join([self.uri_prefix,
                                                'MachineCollection'])
                response_data = {'Collection': body}
            else:
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content

            return resp
        else:
            return res
示例#30
0
    def GET(self, req, *parts):
        """
        Handle GET Container (List Objects) request
        """

        env = self._fresh_env(req)
        env['PATH_INFO'] = concat(self.os_path, '/',
                                  parts[0], '/os-volume_attachments/',
                                  parts[1])
        new_req = Request(env)
        res = new_req.get_response(self.app)

        if res.status_int == 200:
            data = json.loads(res.body).get('volumeAttachment')

            body = {}
            body['id'] = concat(self.tenant_id, '/MachineVolume/',
                                data['serverId'], '/', data['id'])
            match_up(body, data, 'initialLocation', 'device')

            body['volume'] = {'href': concat(self.tenant_id,
                    '/Volume/', data['volumeId'])}

            # deal with machinevolume operations
            operations = []
            operations.append(self._create_op('edit', body['id']))
            operations.append(self._create_op('delete', body['id']))
            body['operations'] = operations

            # Try to get the volume state
            env = self._fresh_env(req)
            env['SERVER_PORT'] = self.conf.get('volume_endpoint_port')
            env['SCRIPT_NAME'] = '/v1'
            env['HTTP_HOST'] = '%s:%s' % \
                (self.conf.get('volume_endpoint_host'),
                 self.conf.get('volume_endpoint_port'))
            env['CONTENT_LENGTH'] = 0

            volume_path = '/'.join(['/v1', self.tenant_id, 'volumes',
                                    data['volumeId']])
            status, headers, volume_body, status_code = \
                access_resource(env, 'GET',
                                volume_path, True, None, None)

            if status:
                volume_data = json.loads(volume_body).get('volume')
                body['state'] = map_volume_state(volume_data['status'])

            if self.res_content_type == 'application/xml':
                response_data = {'MachineVolume': body}
            else:
                body['resourceURI'] = concat(self.uri_prefix, '/',
                                      self.entity_uri)
                response_data = body

            new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.metadata,
                                             self.uri_prefix)
            resp = Response()
            self._fixup_cimi_header(resp)
            resp.headers['Content-Type'] = self.res_content_type
            resp.status = 200
            resp.body = new_content
            return resp
        else:
            return res
示例#31
0
文件: machine.py 项目: chrrrles/cimi
    def POST(self, req, *parts):
        """
        Handle POST machine request which will create a machine
        """

        try:
            request_data = get_request_data(req.body, self.req_content_type)
        except Exception as error:
            return get_err_response('MalformedBody')

        if request_data:
            data = request_data.get('body').get('MachineCreate')
            if not data:
                data = request_data.get('body')
            if data:
                new_body = {}
                match_up(new_body, data, 'name', 'name')

                if (data.get('machineTemplate') is None or
                    data.get('machineTemplate').get('machineImage') is None or
                    data.get('machineTemplate').get('machineConfig') is None):
                    return get_err_response('BadRequest')

                match_up(new_body, data, 'imageRef',
                         'machineTemplate/machineImage/href')

                match_up(new_body, data, 'flavorRef',
                         'machineTemplate/machineConfig/href')

                if (new_body.get('flavorRef') is None or
                    new_body.get('imageRef') is None):
                    return get_err_response('BadRequest')

                new_body['imageRef'] = new_body.get('imageRef').split('/')[-1]
                new_body['flavorRef'] = \
                    new_body.get('flavorRef').split('/')[-1]

                adminPass = data.get('credentials', {}).get('password')
                if adminPass:
                    new_body['adminPass'] = adminPass

                self.os_path = '/%s/servers' % (self.tenant_id)
                new_req = self._fresh_request(req)

                new_req.body = json.dumps({'server': new_body})
                resp = new_req.get_response(self.app)
                if resp.status_int == 201:
                    # resource created successfully, we redirect the request
                    # to query machine
                    resp_data = json.loads(resp.body)
                    id = resp_data.get('server').get('id')
                    env = self._fresh_env(req)
                    env['PATH_INFO'] = concat(self.request_prefix,
                                              '/', self.tenant_id,
                                              '/servers/', id)
                    env['REQUEST_METHOD'] = 'GET'
                    new_req = Request(env)
                    resp = new_req.get_response(self.app)
                    resp_data = {}
                    resp.headers['Location'] = \
                        '/'.join([self.request_prefix, self.tenant_id,
                                  'Machine', id])
                    resp.status = 201
                elif resp.status_int == 202:
                    resp_body_data = json.loads(resp.body).get('server')
                    id = resp_body_data.get('id')
                    resp_data = {}
                    resp_data['resourceURI'] = '/'.join([self.uri_prefix,
                                            'Machine'])
                    match_up(resp_data, data, 'name', 'name')
                    resp_data['id'] = concat(self.tenant_id, '/Machine/', id)
                    resp_data['credentials'] = {'userName': '******',
                        'password': resp_body_data.get('adminPass')}
                    if self.res_content_type == 'application/xml':
                        response_data = {'Machine': resp_data}
                        remove_member(response_data, 'resourceURI')
                    else:
                        response_data = resp_data

                    new_content = make_response_data(response_data,
                                             self.res_content_type,
                                             self.machine_metadata,
                                             self.uri_prefix)
                    resp = Response()
                    self._fixup_cimi_header(resp)
                    resp.headers['Content-Type'] = self.res_content_type
                    resp.headers['Location'] = \
                        '/'.join([self.request_prefix, self.tenant_id,
                                  'Machine', id])
                    resp.status = 202
                    resp.body = new_content
                return resp
            else:
                return get_err_response('BadRequest')
        else:
            return get_err_response('BadRequest')