← 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/volumetypes.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/volumetypes.py
27
27
from nova.volume import volume_types
28
28
 
29
29
 
 
30
def make_voltype(elem):
 
31
    elem.set('id')
 
32
    elem.set('name')
 
33
    extra_specs = xmlutil.make_flat_dict('extra_specs', selector='extra_specs')
 
34
    elem.append(extra_specs)
 
35
 
 
36
 
 
37
class VolumeTypeTemplate(xmlutil.TemplateBuilder):
 
38
    def construct(self):
 
39
        root = xmlutil.TemplateElement('volume_type', selector='volume_type')
 
40
        make_voltype(root)
 
41
        return xmlutil.MasterTemplate(root, 1)
 
42
 
 
43
 
 
44
class VolumeTypesTemplate(xmlutil.TemplateBuilder):
 
45
    def construct(self):
 
46
        root = xmlutil.TemplateElement('volume_types')
 
47
        sel = lambda obj, do_raise=False: obj.values()
 
48
        elem = xmlutil.SubTemplateElement(root, 'volume_type', selector=sel)
 
49
        make_voltype(elem)
 
50
        return xmlutil.MasterTemplate(root, 1)
 
51
 
 
52
 
30
53
class VolumeTypesController(object):
31
54
    """ The volume types API controller for the Openstack API """
32
55
 
 
56
    @wsgi.serializers(xml=VolumeTypesTemplate)
33
57
    def index(self, req):
34
58
        """ Returns the list of volume types """
35
59
        context = req.environ['nova.context']
36
60
        return volume_types.get_all_types(context)
37
61
 
 
62
    @wsgi.serializers(xml=VolumeTypeTemplate)
38
63
    def create(self, req, body):
39
64
        """Creates a new volume type."""
40
65
        context = req.environ['nova.context']
62
87
 
63
88
        return {'volume_type': vol_type}
64
89
 
 
90
    @wsgi.serializers(xml=VolumeTypeTemplate)
65
91
    def show(self, req, id):
66
92
        """ Return a single volume type item """
67
93
        context = req.environ['nova.context']
90
116
        raise error
91
117
 
92
118
 
93
 
def make_voltype(elem):
94
 
    elem.set('id')
95
 
    elem.set('name')
96
 
    extra_specs = xmlutil.make_flat_dict('extra_specs', selector='extra_specs')
97
 
    elem.append(extra_specs)
98
 
 
99
 
 
100
 
class VolumeTypeTemplate(xmlutil.TemplateBuilder):
101
 
    def construct(self):
102
 
        root = xmlutil.TemplateElement('volume_type', selector='volume_type')
103
 
        make_voltype(root)
104
 
        return xmlutil.MasterTemplate(root, 1)
105
 
 
106
 
 
107
 
class VolumeTypesTemplate(xmlutil.TemplateBuilder):
108
 
    def construct(self):
109
 
        root = xmlutil.TemplateElement('volume_types')
110
 
        sel = lambda obj, do_raise=False: obj.values()
111
 
        elem = xmlutil.SubTemplateElement(root, 'volume_type', selector=sel)
112
 
        make_voltype(elem)
113
 
        return xmlutil.MasterTemplate(root, 1)
114
 
 
115
 
 
116
 
class VolumeTypesSerializer(xmlutil.XMLTemplateSerializer):
117
 
    def index(self):
118
 
        return VolumeTypesTemplate()
119
 
 
120
 
    def default(self):
121
 
        return VolumeTypeTemplate()
 
119
class VolumeTypeExtraSpecsTemplate(xmlutil.TemplateBuilder):
 
120
    def construct(self):
 
121
        root = xmlutil.make_flat_dict('extra_specs', selector='extra_specs')
 
122
        return xmlutil.MasterTemplate(root, 1)
 
123
 
 
124
 
 
125
class VolumeTypeExtraSpecTemplate(xmlutil.TemplateBuilder):
 
126
    def construct(self):
 
127
        tagname = xmlutil.Selector('key')
 
128
 
 
129
        def extraspec_sel(obj, do_raise=False):
 
130
            # Have to extract the key and value for later use...
 
131
            key, value = obj.items()[0]
 
132
            return dict(key=key, value=value)
 
133
 
 
134
        root = xmlutil.TemplateElement(tagname, selector=extraspec_sel)
 
135
        root.text = 'value'
 
136
        return xmlutil.MasterTemplate(root, 1)
122
137
 
123
138
 
124
139
class VolumeTypeExtraSpecsController(object):
132
147
        return dict(extra_specs=specs_dict)
133
148
 
134
149
    def _check_body(self, body):
135
 
        if body == None or body == "":
 
150
        if body is None or body == "":
136
151
            expl = _('No Request Body')
137
152
            raise exc.HTTPBadRequest(explanation=expl)
138
153
 
 
154
    @wsgi.serializers(xml=VolumeTypeExtraSpecsTemplate)
139
155
    def index(self, req, vol_type_id):
140
156
        """ Returns the list of extra specs for a given volume type """
141
157
        context = req.environ['nova.context']
142
158
        return self._get_extra_specs(context, vol_type_id)
143
159
 
 
160
    @wsgi.serializers(xml=VolumeTypeExtraSpecsTemplate)
144
161
    def create(self, req, vol_type_id, body):
145
162
        self._check_body(body)
146
163
        context = req.environ['nova.context']
153
170
            self._handle_quota_error(error)
154
171
        return body
155
172
 
 
173
    @wsgi.serializers(xml=VolumeTypeExtraSpecTemplate)
156
174
    def update(self, req, vol_type_id, id, body):
157
175
        self._check_body(body)
158
176
        context = req.environ['nova.context']
171
189
 
172
190
        return body
173
191
 
 
192
    @wsgi.serializers(xml=VolumeTypeExtraSpecTemplate)
174
193
    def show(self, req, vol_type_id, id):
175
194
        """ Return a single extra spec item """
176
195
        context = req.environ['nova.context']
192
211
        raise error
193
212
 
194
213
 
195
 
class VolumeTypeExtraSpecsTemplate(xmlutil.TemplateBuilder):
196
 
    def construct(self):
197
 
        root = xmlutil.make_flat_dict('extra_specs', selector='extra_specs')
198
 
        return xmlutil.MasterTemplate(root, 1)
199
 
 
200
 
 
201
 
class VolumeTypeExtraSpecTemplate(xmlutil.TemplateBuilder):
202
 
    def construct(self):
203
 
        tagname = xmlutil.Selector('key')
204
 
 
205
 
        def extraspec_sel(obj, do_raise=False):
206
 
            # Have to extract the key and value for later use...
207
 
            key, value = obj.items()[0]
208
 
            return dict(key=key, value=value)
209
 
 
210
 
        root = xmlutil.TemplateElement(tagname, selector=extraspec_sel)
211
 
        root.text = 'value'
212
 
        return xmlutil.MasterTemplate(root, 1)
213
 
 
214
 
 
215
 
class VolumeTypeExtraSpecsSerializer(xmlutil.XMLTemplateSerializer):
216
 
    def index(self):
217
 
        return VolumeTypeExtraSpecsTemplate()
218
 
 
219
 
    def create(self):
220
 
        return VolumeTypeExtraSpecsTemplate()
221
 
 
222
 
    def update(self):
223
 
        return VolumeTypeExtraSpecTemplate()
224
 
 
225
 
    def show(self):
226
 
        return VolumeTypeExtraSpecTemplate()
227
 
 
228
 
 
229
214
class Volumetypes(extensions.ExtensionDescriptor):
230
215
    """Volume types support"""
231
216
 
232
217
    name = "VolumeTypes"
233
218
    alias = "os-volume-types"
234
 
    namespace = "http://docs.openstack.org/ext/volume_types/api/v1.1"
 
219
    namespace = "http://docs.openstack.org/compute/ext/volume_types/api/v1.1"
235
220
    updated = "2011-08-24T00:00:00+00:00"
236
221
 
237
222
    def get_resources(self):
238
223
        resources = []
239
224
 
240
 
        body_serializers = {
241
 
            'application/xml': VolumeTypesSerializer(),
242
 
            }
243
 
        serializer = wsgi.ResponseSerializer(body_serializers)
244
 
 
245
225
        res = extensions.ResourceExtension(
246
226
                    'os-volume-types',
247
 
                    VolumeTypesController(),
248
 
                    serializer=serializer)
 
227
                    VolumeTypesController())
249
228
        resources.append(res)
250
229
 
251
 
        body_serializers = {
252
 
            'application/xml': VolumeTypeExtraSpecsSerializer(),
253
 
            }
254
 
        serializer = wsgi.ResponseSerializer(body_serializers)
255
 
 
256
230
        res = extensions.ResourceExtension('extra_specs',
257
231
                            VolumeTypeExtraSpecsController(),
258
 
                            serializer=serializer,
259
232
                            parent=dict(
260
233
                                member_name='vol_type',
261
234
                                collection_name='os-volume-types'))