← Back to branch summary

~ubuntu-cloud-archive/ubuntu/precise/nova/trunk

« back to all changes in this revision

Viewing changes to nova/api/openstack/v2/contrib/volumes.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Chuck Short, Adam Gandleman
  • Date: 2012-01-13 09:51:10 UTC
  • mfrom: (1.1.40)
  • Revision ID: package-import@ubuntu.com-20120113095110-ffd6163drcg77wez
Tags: 2012.1~e3~20120113.12049-0ubuntu1
https://launchpad.net/bugs/681774
https://launchpad.net/bugs/91379
https://launchpad.net/bugs/907543
[Chuck Short]
* New upstream version.
* debian/nova_sudoers, debian/nova-common.install, 
  Switch out to nova-rootwrap. (LP: #681774)
* Add "get-origsource-git" which allows developers to 
  generate a tarball from github, by doing:
  fakeroot debian/rules get-orig-source-git
* debian/debian/nova-objectstore.logrotate: Dont determine
  if we are running Debian or Ubuntu. (LP: #91379)

[Adam Gandleman]
* Removed python-nova.postinst, let dh_python2 generate instead since
  python-support is not a dependency. (LP: #907543)

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/api/openstack/v2/contrib/volumes.py
84
84
    return d
85
85
 
86
86
 
 
87
def make_volume(elem):
 
88
    elem.set('id')
 
89
    elem.set('status')
 
90
    elem.set('size')
 
91
    elem.set('availabilityZone')
 
92
    elem.set('createdAt')
 
93
    elem.set('displayName')
 
94
    elem.set('displayDescription')
 
95
    elem.set('volumeType')
 
96
    elem.set('snapshotId')
 
97
 
 
98
    attachments = xmlutil.SubTemplateElement(elem, 'attachments')
 
99
    attachment = xmlutil.SubTemplateElement(attachments, 'attachment',
 
100
                                            selector='attachments')
 
101
    make_attachment(attachment)
 
102
 
 
103
    metadata = xmlutil.make_flat_dict('metadata')
 
104
    elem.append(metadata)
 
105
 
 
106
 
 
107
class VolumeTemplate(xmlutil.TemplateBuilder):
 
108
    def construct(self):
 
109
        root = xmlutil.TemplateElement('volume', selector='volume')
 
110
        make_volume(root)
 
111
        return xmlutil.MasterTemplate(root, 1)
 
112
 
 
113
 
 
114
class VolumesTemplate(xmlutil.TemplateBuilder):
 
115
    def construct(self):
 
116
        root = xmlutil.TemplateElement('volumes')
 
117
        elem = xmlutil.SubTemplateElement(root, 'volume', selector='volumes')
 
118
        make_volume(elem)
 
119
        return xmlutil.MasterTemplate(root, 1)
 
120
 
 
121
 
87
122
class VolumeController(object):
88
123
    """The Volumes API controller for the OpenStack API."""
89
124
 
91
126
        self.volume_api = volume.API()
92
127
        super(VolumeController, self).__init__()
93
128
 
 
129
    @wsgi.serializers(xml=VolumeTemplate)
94
130
    def show(self, req, id):
95
131
        """Return data about the given volume."""
96
132
        context = req.environ['nova.context']
114
150
            raise exc.HTTPNotFound()
115
151
        return webob.Response(status_int=202)
116
152
 
 
153
    @wsgi.serializers(xml=VolumesTemplate)
117
154
    def index(self, req):
118
155
        """Returns a summary list of volumes."""
119
156
        return self._items(req, entity_maker=_translate_volume_summary_view)
120
157
 
 
158
    @wsgi.serializers(xml=VolumesTemplate)
121
159
    def detail(self, req):
122
160
        """Returns a detailed list of volumes."""
123
161
        return self._items(req, entity_maker=_translate_volume_detail_view)
131
169
        res = [entity_maker(context, vol) for vol in limited_list]
132
170
        return {'volumes': res}
133
171
 
 
172
    @wsgi.serializers(xml=VolumeTemplate)
134
173
    def create(self, req, body):
135
174
        """Creates a new volume."""
136
175
        context = req.environ['nova.context']
167
206
        return {'volume': retval}
168
207
 
169
208
 
170
 
def make_volume(elem):
171
 
    elem.set('id')
172
 
    elem.set('status')
173
 
    elem.set('size')
174
 
    elem.set('availabilityZone')
175
 
    elem.set('createdAt')
176
 
    elem.set('displayName')
177
 
    elem.set('displayDescription')
178
 
    elem.set('volumeType')
179
 
    elem.set('snapshotId')
180
 
 
181
 
    attachments = xmlutil.SubTemplateElement(elem, 'attachments')
182
 
    attachment = xmlutil.SubTemplateElement(attachments, 'attachment',
183
 
                                            selector='attachments')
184
 
    make_attachment(attachment)
185
 
 
186
 
    metadata = xmlutil.make_flat_dict('metadata')
187
 
    elem.append(metadata)
188
 
 
189
 
 
190
 
class VolumeTemplate(xmlutil.TemplateBuilder):
191
 
    def construct(self):
192
 
        root = xmlutil.TemplateElement('volume', selector='volume')
193
 
        make_volume(root)
194
 
        return xmlutil.MasterTemplate(root, 1)
195
 
 
196
 
 
197
 
class VolumesTemplate(xmlutil.TemplateBuilder):
198
 
    def construct(self):
199
 
        root = xmlutil.TemplateElement('volumes')
200
 
        elem = xmlutil.SubTemplateElement(root, 'volume', selector='volumes')
201
 
        make_volume(elem)
202
 
        return xmlutil.MasterTemplate(root, 1)
203
 
 
204
 
 
205
 
class VolumeSerializer(xmlutil.XMLTemplateSerializer):
206
 
    def default(self):
207
 
        return VolumeTemplate()
208
 
 
209
 
    def index(self):
210
 
        return VolumesTemplate()
211
 
 
212
 
    def detail(self):
213
 
        return VolumesTemplate()
214
 
 
215
 
 
216
209
def _translate_attachment_detail_view(_context, vol):
217
210
    """Maps keys for attachment details view."""
218
211
 
241
234
    return d
242
235
 
243
236
 
 
237
def make_attachment(elem):
 
238
    elem.set('id')
 
239
    elem.set('serverId')
 
240
    elem.set('volumeId')
 
241
    elem.set('device')
 
242
 
 
243
 
 
244
class VolumeAttachmentTemplate(xmlutil.TemplateBuilder):
 
245
    def construct(self):
 
246
        root = xmlutil.TemplateElement('volumeAttachment',
 
247
                                       selector='volumeAttachment')
 
248
        make_attachment(root)
 
249
        return xmlutil.MasterTemplate(root, 1)
 
250
 
 
251
 
 
252
class VolumeAttachmentsTemplate(xmlutil.TemplateBuilder):
 
253
    def construct(self):
 
254
        root = xmlutil.TemplateElement('volumeAttachments')
 
255
        elem = xmlutil.SubTemplateElement(root, 'volumeAttachment',
 
256
                                          selector='volumeAttachments')
 
257
        make_attachment(elem)
 
258
        return xmlutil.MasterTemplate(root, 1)
 
259
 
 
260
 
244
261
class VolumeAttachmentController(object):
245
262
    """The volume attachment API controller for the Openstack API.
246
263
 
254
271
        self.volume_api = volume.API()
255
272
        super(VolumeAttachmentController, self).__init__()
256
273
 
 
274
    @wsgi.serializers(xml=VolumeAttachmentsTemplate)
257
275
    def index(self, req, server_id):
258
276
        """Returns the list of volume attachments for a given instance."""
259
277
        return self._items(req, server_id,
260
278
                           entity_maker=_translate_attachment_summary_view)
261
279
 
 
280
    @wsgi.serializers(xml=VolumeAttachmentTemplate)
262
281
    def show(self, req, server_id, id):
263
282
        """Return data about the given volume attachment."""
264
283
        context = req.environ['nova.context']
278
297
        return {'volumeAttachment': _translate_attachment_detail_view(context,
279
298
                                                                      vol)}
280
299
 
 
300
    @wsgi.serializers(xml=VolumeAttachmentTemplate)
281
301
    def create(self, req, server_id, body):
282
302
        """Attach a volume to an instance."""
283
303
        context = req.environ['nova.context']
356
376
        return {'volumeAttachments': res}
357
377
 
358
378
 
359
 
def make_attachment(elem):
360
 
    elem.set('id')
361
 
    elem.set('serverId')
362
 
    elem.set('volumeId')
363
 
    elem.set('device')
364
 
 
365
 
 
366
 
class VolumeAttachmentTemplate(xmlutil.TemplateBuilder):
367
 
    def construct(self):
368
 
        root = xmlutil.TemplateElement('volumeAttachment',
369
 
                                       selector='volumeAttachment')
370
 
        make_attachment(root)
371
 
        return xmlutil.MasterTemplate(root, 1)
372
 
 
373
 
 
374
 
class VolumeAttachmentsTemplate(xmlutil.TemplateBuilder):
375
 
    def construct(self):
376
 
        root = xmlutil.TemplateElement('volumeAttachments')
377
 
        elem = xmlutil.SubTemplateElement(root, 'volumeAttachment',
378
 
                                          selector='volumeAttachments')
379
 
        make_attachment(elem)
380
 
        return xmlutil.MasterTemplate(root, 1)
381
 
 
382
 
 
383
 
class VolumeAttachmentSerializer(xmlutil.XMLTemplateSerializer):
384
 
    def default(self):
385
 
        return VolumeAttachmentTemplate()
386
 
 
387
 
    def index(self):
388
 
        return VolumeAttachmentsTemplate()
389
 
 
390
 
 
391
379
class BootFromVolumeController(servers.Controller):
392
380
    """The boot from volume API controller for the Openstack API."""
393
381
 
419
407
    return d
420
408
 
421
409
 
 
410
def make_snapshot(elem):
 
411
    elem.set('id')
 
412
    elem.set('status')
 
413
    elem.set('size')
 
414
    elem.set('createdAt')
 
415
    elem.set('displayName')
 
416
    elem.set('displayDescription')
 
417
    elem.set('volumeId')
 
418
 
 
419
 
 
420
class SnapshotTemplate(xmlutil.TemplateBuilder):
 
421
    def construct(self):
 
422
        root = xmlutil.TemplateElement('snapshot', selector='snapshot')
 
423
        make_snapshot(root)
 
424
        return xmlutil.MasterTemplate(root, 1)
 
425
 
 
426
 
 
427
class SnapshotsTemplate(xmlutil.TemplateBuilder):
 
428
    def construct(self):
 
429
        root = xmlutil.TemplateElement('snapshots')
 
430
        elem = xmlutil.SubTemplateElement(root, 'snapshot',
 
431
                                          selector='snapshots')
 
432
        make_snapshot(elem)
 
433
        return xmlutil.MasterTemplate(root, 1)
 
434
 
 
435
 
422
436
class SnapshotController(object):
423
437
    """The Volumes API controller for the OpenStack API."""
424
438
 
426
440
        self.volume_api = volume.API()
427
441
        super(SnapshotController, self).__init__()
428
442
 
 
443
    @wsgi.serializers(xml=SnapshotTemplate)
429
444
    def show(self, req, id):
430
445
        """Return data about the given snapshot."""
431
446
        context = req.environ['nova.context']
449
464
            return exc.HTTPNotFound()
450
465
        return webob.Response(status_int=202)
451
466
 
 
467
    @wsgi.serializers(xml=SnapshotsTemplate)
452
468
    def index(self, req):
453
469
        """Returns a summary list of snapshots."""
454
470
        return self._items(req, entity_maker=_translate_snapshot_summary_view)
455
471
 
 
472
    @wsgi.serializers(xml=SnapshotsTemplate)
456
473
    def detail(self, req):
457
474
        """Returns a detailed list of snapshots."""
458
475
        return self._items(req, entity_maker=_translate_snapshot_detail_view)
466
483
        res = [entity_maker(context, snapshot) for snapshot in limited_list]
467
484
        return {'snapshots': res}
468
485
 
 
486
    @wsgi.serializers(xml=SnapshotTemplate)
469
487
    def create(self, req, body):
470
488
        """Creates a new snapshot."""
471
489
        context = req.environ['nova.context']
495
513
        return {'snapshot': retval}
496
514
 
497
515
 
498
 
def make_snapshot(elem):
499
 
    elem.set('id')
500
 
    elem.set('status')
501
 
    elem.set('size')
502
 
    elem.set('createdAt')
503
 
    elem.set('displayName')
504
 
    elem.set('displayDescription')
505
 
    elem.set('volumeId')
506
 
 
507
 
 
508
 
class SnapshotTemplate(xmlutil.TemplateBuilder):
509
 
    def construct(self):
510
 
        root = xmlutil.TemplateElement('snapshot', selector='snapshot')
511
 
        make_snapshot(root)
512
 
        return xmlutil.MasterTemplate(root, 1)
513
 
 
514
 
 
515
 
class SnapshotsTemplate(xmlutil.TemplateBuilder):
516
 
    def construct(self):
517
 
        root = xmlutil.TemplateElement('snapshots')
518
 
        elem = xmlutil.SubTemplateElement(root, 'snapshot',
519
 
                                          selector='snapshots')
520
 
        make_snapshot(elem)
521
 
        return xmlutil.MasterTemplate(root, 1)
522
 
 
523
 
 
524
 
class SnapshotSerializer(xmlutil.XMLTemplateSerializer):
525
 
    def default(self):
526
 
        return SnapshotTemplate()
527
 
 
528
 
    def index(self):
529
 
        return SnapshotsTemplate()
530
 
 
531
 
    def detail(self):
532
 
        return SnapshotsTemplate()
533
 
 
534
 
 
535
516
class Volumes(extensions.ExtensionDescriptor):
536
517
    """Volumes support"""
537
518
 
538
519
    name = "Volumes"
539
520
    alias = "os-volumes"
540
 
    namespace = "http://docs.openstack.org/ext/volumes/api/v1.1"
 
521
    namespace = "http://docs.openstack.org/compute/ext/volumes/api/v1.1"
541
522
    updated = "2011-03-25T00:00:00+00:00"
542
523
 
543
524
    def get_resources(self):
544
525
        resources = []
545
526
 
546
 
        body_serializers = {
547
 
            'application/xml': VolumeSerializer(),
548
 
            }
549
 
        serializer = wsgi.ResponseSerializer(body_serializers)
550
 
 
551
527
        # NOTE(justinsb): No way to provide singular name ('volume')
552
528
        # Does this matter?
553
529
        res = extensions.ResourceExtension('os-volumes',
554
530
                                        VolumeController(),
555
 
                                        serializer=serializer,
556
531
                                        collection_actions={'detail': 'GET'})
557
532
        resources.append(res)
558
533
 
559
 
        body_serializers = {
560
 
            'application/xml': VolumeAttachmentSerializer(),
561
 
            }
562
 
        serializer = wsgi.ResponseSerializer(body_serializers)
563
 
 
564
534
        res = extensions.ResourceExtension('os-volume_attachments',
565
535
                                           VolumeAttachmentController(),
566
 
                                           serializer=serializer,
567
536
                                           parent=dict(
568
537
                                                member_name='server',
569
538
                                                collection_name='servers'))
570
539
        resources.append(res)
571
540
 
572
 
        headers_serializer = servers.HeadersSerializer()
573
 
        body_serializers = {
574
 
            'application/xml': servers.ServerXMLSerializer(),
575
 
            }
576
 
        serializer = wsgi.ResponseSerializer(body_serializers,
577
 
                                             headers_serializer)
578
 
 
579
 
        body_deserializers = {
580
 
            'application/xml': servers.ServerXMLDeserializer(),
581
 
            }
582
 
        deserializer = wsgi.RequestDeserializer(body_deserializers)
583
 
 
584
541
        res = extensions.ResourceExtension('os-volumes_boot',
585
 
                                           BootFromVolumeController(),
586
 
                                           serializer=serializer,
587
 
                                           deserializer=deserializer)
 
542
                                           BootFromVolumeController())
588
543
        resources.append(res)
589
544
 
590
 
        snapshot_serializers = {
591
 
            'application/xml': SnapshotSerializer(),
592
 
            }
593
 
        snap_serializer = wsgi.ResponseSerializer(snapshot_serializers)
594
 
 
595
545
        res = extensions.ResourceExtension('os-snapshots',
596
546
                                        SnapshotController(),
597
 
                                        serializer=snap_serializer,
598
547
                                        collection_actions={'detail': 'GET'})
599
548
        resources.append(res)
600
549