← Back to branch summary

~rlane/nova/lp773690

« back to all changes in this revision

Viewing changes to nova/api/openstack/servers.py

  • Committer: rlane at wikimedia
  • Date: 2011-04-29 22:30:40 UTC
  • mfrom: (382.1.655 nova)
  • Revision ID: rlane@wikimedia.org-20110429223040-i0x3ds9eqwrabyru
Merge from trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/api/openstack/servers.py
40
40
from nova.scheduler import api as scheduler_api
41
41
 
42
42
 
43
 
LOG = logging.getLogger('server')
 
43
LOG = logging.getLogger('nova.api.openstack.servers')
44
44
FLAGS = flags.FLAGS
45
45
 
46
46
 
118
118
 
119
119
        context = req.environ['nova.context']
120
120
 
 
121
        password = self._get_server_admin_password(env['server'])
 
122
 
121
123
        key_name = None
122
124
        key_data = None
123
125
        key_pairs = auth_manager.AuthManager.get_key_pairs(context)
127
129
            key_data = key_pair['public_key']
128
130
 
129
131
        requested_image_id = self._image_id_from_req_data(env)
130
 
        image_id = common.get_image_id_from_image_hash(self._image_service,
131
 
            context, requested_image_id)
 
132
        try:
 
133
            image_id = common.get_image_id_from_image_hash(self._image_service,
 
134
                context, requested_image_id)
 
135
        except:
 
136
            msg = _("Can not find requested image")
 
137
            return faults.Fault(exc.HTTPBadRequest(msg))
 
138
 
132
139
        kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image(
133
140
            req, image_id)
134
141
 
135
 
        # Metadata is a list, not a Dictionary, because we allow duplicate keys
136
 
        # (even though JSON can't encode this)
137
 
        # In future, we may not allow duplicate keys.
138
 
        # However, the CloudServers API is not definitive on this front,
139
 
        #  and we want to be compatible.
140
 
        metadata = []
141
 
        if env['server'].get('metadata'):
142
 
            for k, v in env['server']['metadata'].items():
143
 
                metadata.append({'key': k, 'value': v})
144
 
 
145
142
        personality = env['server'].get('personality')
146
143
        injected_files = []
147
144
        if personality:
170
167
                display_description=name,
171
168
                key_name=key_name,
172
169
                key_data=key_data,
173
 
                metadata=metadata,
 
170
                metadata=env['server'].get('metadata', {}),
174
171
                injected_files=injected_files)
175
172
        except quota.QuotaError as error:
176
173
            self._handle_quota_error(error)
180
177
 
181
178
        builder = self._get_view_builder(req)
182
179
        server = builder.build(inst, is_detail=True)
183
 
        password = utils.generate_password(16)
184
180
        server['server']['adminPass'] = password
185
181
        self.compute_api.set_admin_password(context, server['server']['id'],
186
182
                                            password)
242
238
        # if the original error is okay, just reraise it
243
239
        raise error
244
240
 
 
241
    def _get_server_admin_password(self, server):
 
242
        """ Determine the admin password for a server on creation """
 
243
        return utils.generate_password(16)
 
244
 
245
245
    @scheduler_api.redirect_handler
246
246
    def update(self, req, id):
247
247
        """ Updates the server name or password """
321
321
        return exc.HTTPAccepted()
322
322
 
323
323
    def _action_rebuild(self, input_dict, req, id):
 
324
        LOG.debug(_("Rebuild server action is not implemented"))
324
325
        return faults.Fault(exc.HTTPNotImplemented())
325
326
 
326
327
    def _action_resize(self, input_dict, req, id):
336
337
        except Exception, e:
337
338
            LOG.exception(_("Error in resize %s"), e)
338
339
            return faults.Fault(exc.HTTPBadRequest())
339
 
        return faults.Fault(exc.HTTPAccepted())
 
340
        return exc.HTTPAccepted()
340
341
 
341
342
    def _action_reboot(self, input_dict, req, id):
342
 
        try:
 
343
        if 'reboot' in input_dict and 'type' in input_dict['reboot']:
343
344
            reboot_type = input_dict['reboot']['type']
344
 
        except Exception:
345
 
            raise faults.Fault(exc.HTTPNotImplemented())
 
345
        else:
 
346
            LOG.exception(_("Missing argument 'type' for reboot"))
 
347
            return faults.Fault(exc.HTTPUnprocessableEntity())
346
348
        try:
347
349
            # TODO(gundlach): pass reboot_type, support soft reboot in
348
350
            # virt driver
349
351
            self.compute_api.reboot(req.environ['nova.context'], id)
350
 
        except:
 
352
        except Exception, e:
 
353
            LOG.exception(_("Error in reboot %s"), e)
351
354
            return faults.Fault(exc.HTTPUnprocessableEntity())
352
355
        return exc.HTTPAccepted()
353
356
 
561
564
        """
562
565
        image_id = image_meta['id']
563
566
        if image_meta['status'] != 'active':
564
 
            raise exception.Invalid(
565
 
                _("Cannot build from image %(image_id)s, status not active") %
566
 
                  locals())
 
567
            raise exception.ImageUnacceptable(image_id=image_id,
 
568
                                              reason=_("status is not active"))
567
569
 
568
570
        if image_meta.get('container_format') != 'ami':
569
571
            return None, None
571
573
        try:
572
574
            kernel_id = image_meta['properties']['kernel_id']
573
575
        except KeyError:
574
 
            raise exception.NotFound(
575
 
                _("Kernel not found for image %(image_id)s") % locals())
 
576
            raise exception.KernelNotFoundForImage(image_id=image_id)
576
577
 
577
578
        try:
578
579
            ramdisk_id = image_meta['properties']['ramdisk_id']
579
580
        except KeyError:
580
 
            raise exception.NotFound(
581
 
                _("Ramdisk not found for image %(image_id)s") % locals())
 
581
            raise exception.RamdiskNotFoundForImage(image_id=image_id)
582
582
 
583
583
        return kernel_id, ramdisk_id
584
584
 
648
648
    def _limit_items(self, items, req):
649
649
        return common.limited_by_marker(items, req)
650
650
 
 
651
    def _get_server_admin_password(self, server):
 
652
        """ Determine the admin password for a server on creation """
 
653
        password = server.get('adminPass')
 
654
        if password is None:
 
655
            return utils.generate_password(16)
 
656
        if not isinstance(password, basestring) or password == '':
 
657
            msg = _("Invalid adminPass")
 
658
            raise exc.HTTPBadRequest(msg)
 
659
        return password
 
660
 
651
661
    def get_default_xmlns(self, req):
652
662
        return common.XML_NS_V11
653
663