← Back to branch summary

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

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2011-06-17 13:29:16 UTC
  • mto: (94.1.1 raring-proposed)
  • mto: This revision was merged to the branch mainline in revision 27.
  • Revision ID: james.westby@ubuntu.com-20110617132916-u3vv6rxmtvnfn4cj
Tags: upstream-2011.3~d2~20110617.1191
Import upstream version 2011.3~d2~20110617.1191

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/api/openstack/images.py
18
18
from nova import compute
19
19
from nova import exception
20
20
from nova import flags
 
21
import nova.image
21
22
from nova import log
22
23
from nova import utils
23
24
from nova.api.openstack import common
24
25
from nova.api.openstack import faults
25
26
from nova.api.openstack.views import images as images_view
 
27
from nova.api.openstack import wsgi
26
28
 
27
29
 
28
30
LOG = log.getLogger('nova.api.openstack.images')
31
33
SUPPORTED_FILTERS = ['name', 'status']
32
34
 
33
35
 
34
 
class Controller(common.OpenstackController):
35
 
    """Base `wsgi.Controller` for retrieving/displaying images."""
36
 
 
37
 
    _serialization_metadata = {
38
 
        'application/xml': {
39
 
            "attributes": {
40
 
                "image": ["id", "name", "updated", "created", "status",
41
 
                          "serverId", "progress"],
42
 
                "link": ["rel", "type", "href"],
43
 
            },
44
 
        },
45
 
    }
 
36
class Controller(object):
 
37
    """Base controller for retrieving/displaying images."""
46
38
 
47
39
    def __init__(self, image_service=None, compute_service=None):
48
40
        """Initialize new `ImageController`.
49
41
 
50
42
        :param compute_service: `nova.compute.api:API`
51
43
        :param image_service: `nova.image.service:BaseImageService`
 
44
 
52
45
        """
53
 
        _default_service = utils.import_object(flags.FLAGS.image_service)
54
 
 
55
46
        self._compute_service = compute_service or compute.API()
56
 
        self._image_service = image_service or _default_service
57
 
 
58
 
    def index(self, req):
59
 
        """Return an index listing of images available to the request.
60
 
 
61
 
        :param req: `wsgi.Request` object
62
 
        """
63
 
        context = req.environ['nova.context']
64
 
        filters = self._get_filters(req)
65
 
        images = self._image_service.index(context, filters)
66
 
        images = common.limited(images, req)
67
 
        builder = self.get_builder(req).build
68
 
        return dict(images=[builder(image, detail=False) for image in images])
69
 
 
70
 
    def detail(self, req):
71
 
        """Return a detailed index listing of images available to the request.
72
 
 
73
 
        :param req: `wsgi.Request` object.
74
 
        """
75
 
        context = req.environ['nova.context']
76
 
        filters = self._get_filters(req)
77
 
        images = self._image_service.detail(context, filters)
78
 
        images = common.limited(images, req)
79
 
        builder = self.get_builder(req).build
80
 
        return dict(images=[builder(image, detail=True) for image in images])
 
47
        self._image_service = image_service or \
 
48
                nova.image.get_default_image_service()
81
49
 
82
50
    def _get_filters(self, req):
83
51
        """
97
65
        """Return detailed information about a specific image.
98
66
 
99
67
        :param req: `wsgi.Request` object
100
 
        :param id: Image identifier (integer)
 
68
        :param id: Image identifier
101
69
        """
102
70
        context = req.environ['nova.context']
103
71
 
104
72
        try:
105
 
            image_id = int(id)
106
 
        except ValueError:
 
73
            image = self._image_service.show(context, id)
 
74
        except (exception.NotFound, exception.InvalidImageRef):
107
75
            explanation = _("Image not found.")
108
76
            raise faults.Fault(webob.exc.HTTPNotFound(explanation=explanation))
109
77
 
110
 
        try:
111
 
            image = self._image_service.show(context, image_id)
112
 
        except exception.NotFound:
113
 
            explanation = _("Image '%d' not found.") % (image_id)
114
 
            raise faults.Fault(webob.exc.HTTPNotFound(explanation=explanation))
115
 
 
116
78
        return dict(image=self.get_builder(req).build(image, detail=True))
117
79
 
118
80
    def delete(self, req, id):
121
83
        :param req: `wsgi.Request` object
122
84
        :param id: Image identifier (integer)
123
85
        """
124
 
        image_id = id
125
86
        context = req.environ['nova.context']
126
 
        self._image_service.delete(context, image_id)
 
87
        self._image_service.delete(context, id)
127
88
        return webob.exc.HTTPNoContent()
128
89
 
129
 
    def create(self, req):
 
90
    def create(self, req, body):
130
91
        """Snapshot a server instance and save the image.
131
92
 
132
93
        :param req: `wsgi.Request` object
133
94
        """
134
95
        context = req.environ['nova.context']
135
96
        content_type = req.get_content_type()
136
 
        image = self._deserialize(req.body, content_type)
137
97
 
138
 
        if not image:
 
98
        if not body:
139
99
            raise webob.exc.HTTPBadRequest()
140
100
 
141
101
        try:
142
 
            server_id = image["image"]["serverId"]
143
 
            image_name = image["image"]["name"]
 
102
            server_id = self._server_id_from_req_data(body)
 
103
            image_name = body["image"]["name"]
144
104
        except KeyError:
145
105
            raise webob.exc.HTTPBadRequest()
146
106
 
151
111
        """Indicates that you must use a Controller subclass."""
152
112
        raise NotImplementedError
153
113
 
 
114
    def _server_id_from_req_data(self, data):
 
115
        raise NotImplementedError()
 
116
 
154
117
 
155
118
class ControllerV10(Controller):
156
119
    """Version 1.0 specific controller logic."""
160
123
        base_url = request.application_url
161
124
        return images_view.ViewBuilderV10(base_url)
162
125
 
 
126
    def index(self, req):
 
127
        """Return an index listing of images available to the request.
 
128
 
 
129
        :param req: `wsgi.Request` object
 
130
 
 
131
        """
 
132
        context = req.environ['nova.context']
 
133
        filters = self._get_filters(req)
 
134
        images = self._image_service.index(context, filters)
 
135
        images = common.limited(images, req)
 
136
        builder = self.get_builder(req).build
 
137
        return dict(images=[builder(image, detail=False) for image in images])
 
138
 
 
139
    def detail(self, req):
 
140
        """Return a detailed index listing of images available to the request.
 
141
 
 
142
        :param req: `wsgi.Request` object.
 
143
 
 
144
        """
 
145
        context = req.environ['nova.context']
 
146
        filters = self._get_filters(req)
 
147
        images = self._image_service.detail(context, filters)
 
148
        images = common.limited(images, req)
 
149
        builder = self.get_builder(req).build
 
150
        return dict(images=[builder(image, detail=True) for image in images])
 
151
 
 
152
    def _server_id_from_req_data(self, data):
 
153
        return data['image']['serverId']
 
154
 
163
155
 
164
156
class ControllerV11(Controller):
165
157
    """Version 1.1 specific controller logic."""
169
161
        base_url = request.application_url
170
162
        return images_view.ViewBuilderV11(base_url)
171
163
 
172
 
    def get_default_xmlns(self, req):
173
 
        return common.XML_NS_V11
 
164
    def index(self, req):
 
165
        """Return an index listing of images available to the request.
 
166
 
 
167
        :param req: `wsgi.Request` object
 
168
 
 
169
        """
 
170
        context = req.environ['nova.context']
 
171
        filters = self._get_filters(req)
 
172
        (marker, limit) = common.get_pagination_params(req)
 
173
        images = self._image_service.index(
 
174
            context, filters=filters, marker=marker, limit=limit)
 
175
        builder = self.get_builder(req).build
 
176
        return dict(images=[builder(image, detail=False) for image in images])
 
177
 
 
178
    def detail(self, req):
 
179
        """Return a detailed index listing of images available to the request.
 
180
 
 
181
        :param req: `wsgi.Request` object.
 
182
 
 
183
        """
 
184
        context = req.environ['nova.context']
 
185
        filters = self._get_filters(req)
 
186
        (marker, limit) = common.get_pagination_params(req)
 
187
        images = self._image_service.detail(
 
188
            context, filters=filters, marker=marker, limit=limit)
 
189
        builder = self.get_builder(req).build
 
190
        return dict(images=[builder(image, detail=True) for image in images])
 
191
 
 
192
    def _server_id_from_req_data(self, data):
 
193
        return data['image']['serverRef']
 
194
 
 
195
 
 
196
def create_resource(version='1.0'):
 
197
    controller = {
 
198
        '1.0': ControllerV10,
 
199
        '1.1': ControllerV11,
 
200
    }[version]()
 
201
 
 
202
    xmlns = {
 
203
        '1.0': wsgi.XMLNS_V10,
 
204
        '1.1': wsgi.XMLNS_V11,
 
205
    }[version]
 
206
 
 
207
    metadata = {
 
208
        "attributes": {
 
209
            "image": ["id", "name", "updated", "created", "status",
 
210
                      "serverId", "progress", "serverRef"],
 
211
            "link": ["rel", "type", "href"],
 
212
        },
 
213
    }
 
214
 
 
215
    serializers = {
 
216
        'application/xml': wsgi.XMLDictSerializer(xmlns=xmlns,
 
217
                                                  metadata=metadata),
 
218
    }
 
219
 
 
220
    return wsgi.Resource(controller, serializers=serializers)