← Back to branch summary

~ubuntu-branches/ubuntu/raring/nova/raring-proposed

« back to all changes in this revision

Viewing changes to nova/api/openstack/compute/__init__.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Adam Gandelman, Chuck Short
  • Date: 2012-11-23 09:04:58 UTC
  • mfrom: (1.1.66)
  • Revision ID: package-import@ubuntu.com-20121123090458-91565o7aev1i1h71
Tags: 2013.1~g1-0ubuntu1
https://launchpad.net/bugs/1073289
https://launchpad.net/bugs/1076442
[ Adam Gandelman ]
* debian/control: Ensure novaclient is upgraded with nova,
  require python-keystoneclient >= 1:2.9.0. (LP: #1073289)
* debian/patches/{ubuntu/*, rbd-security.patch}: Dropped, applied
  upstream.
* debian/control: Add python-testtools to Build-Depends.

[ Chuck Short ]
* New upstream version.
* Refreshed debian/patches/avoid_setuptools_git_dependency.patch.
* debian/rules: FTBFS if missing binaries.
* debian/nova-scheudler.install: Add missing rabbit-queues and
  nova-rpc-zmq-receiver.
* Remove nova-volume since it doesnt exist anymore, transition to cinder-*.
* debian/rules: install apport hook in the right place.
* debian/patches/ubuntu-show-tests.patch: Display test failures.
* debian/control: Add depends on genisoimage
* debian/control: Suggest guestmount.
* debian/control: Suggest websockify. (LP: #1076442)
* debian/nova.conf: Disable nova-volume service.
* debian/control: Depend on xen-system-* rather than the hypervisor.
* debian/control, debian/mans/nova-conductor.8, debian/nova-conductor.init,
  debian/nova-conductor.install, debian/nova-conductor.logrotate
  debian/nova-conductor.manpages, debian/nova-conductor.postrm
  debian/nova-conductor.upstart.in: Add nova-conductor service.
* debian/control: Add python-fixtures as a build deps.

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/api/openstack/compute/__init__.py
31
31
from nova.api.openstack.compute import server_metadata
32
32
from nova.api.openstack.compute import servers
33
33
from nova.api.openstack.compute import versions
34
 
from nova import flags
35
34
from nova.openstack.common import cfg
36
35
from nova.openstack.common import log as logging
37
36
 
42
41
        default=True,
43
42
        help='Permit instance snapshot operations.')
44
43
 
45
 
FLAGS = flags.FLAGS
46
 
FLAGS.register_opt(allow_instance_snapshots_opt)
 
44
CONF = cfg.CONF
 
45
CONF.register_opt(allow_instance_snapshots_opt)
47
46
 
48
47
 
49
48
class APIRouter(nova.api.openstack.APIRouter):
53
52
    """
54
53
    ExtensionManager = extensions.ExtensionManager
55
54
 
56
 
    def _setup_routes(self, mapper, ext_mgr):
57
 
        self.resources['versions'] = versions.create_resource()
58
 
        mapper.connect("versions", "/",
59
 
                    controller=self.resources['versions'],
60
 
                    action='show')
 
55
    def _setup_routes(self, mapper, ext_mgr, init_only):
 
56
        if init_only is None or 'versions' in init_only:
 
57
            self.resources['versions'] = versions.create_resource()
 
58
            mapper.connect("versions", "/",
 
59
                        controller=self.resources['versions'],
 
60
                        action='show')
61
61
 
62
62
        mapper.redirect("", "/")
63
63
 
64
 
        self.resources['consoles'] = consoles.create_resource()
65
 
        mapper.resource("console", "consoles",
66
 
                    controller=self.resources['consoles'],
67
 
                    parent_resource=dict(member_name='server',
68
 
                    collection_name='servers'))
69
 
 
70
 
        self.resources['servers'] = servers.create_resource(ext_mgr)
71
 
        mapper.resource("server", "servers",
72
 
                        controller=self.resources['servers'],
73
 
                        collection={'detail': 'GET'},
74
 
                        member={'action': 'POST'})
75
 
 
76
 
        self.resources['ips'] = ips.create_resource()
77
 
        mapper.resource("ip", "ips", controller=self.resources['ips'],
78
 
                        parent_resource=dict(member_name='server',
79
 
                                             collection_name='servers'))
80
 
 
81
 
        self.resources['images'] = images.create_resource()
82
 
        mapper.resource("image", "images",
83
 
                        controller=self.resources['images'],
84
 
                        collection={'detail': 'GET'})
85
 
 
86
 
        self.resources['limits'] = limits.create_resource()
87
 
        mapper.resource("limit", "limits",
88
 
                        controller=self.resources['limits'])
89
 
 
90
 
        self.resources['flavors'] = flavors.create_resource()
91
 
        mapper.resource("flavor", "flavors",
92
 
                        controller=self.resources['flavors'],
93
 
                        collection={'detail': 'GET'},
94
 
                        member={'action': 'POST'})
95
 
 
96
 
        self.resources['image_metadata'] = image_metadata.create_resource()
97
 
        image_metadata_controller = self.resources['image_metadata']
98
 
 
99
 
        mapper.resource("image_meta", "metadata",
100
 
                        controller=image_metadata_controller,
101
 
                        parent_resource=dict(member_name='image',
102
 
                        collection_name='images'))
103
 
 
104
 
        mapper.connect("metadata", "/{project_id}/images/{image_id}/metadata",
105
 
                       controller=image_metadata_controller,
106
 
                       action='update_all',
107
 
                       conditions={"method": ['PUT']})
108
 
 
109
 
        self.resources['server_metadata'] = server_metadata.create_resource()
110
 
        server_metadata_controller = self.resources['server_metadata']
111
 
 
112
 
        mapper.resource("server_meta", "metadata",
113
 
                        controller=server_metadata_controller,
 
64
        if init_only is None or 'consoles' in init_only:
 
65
            self.resources['consoles'] = consoles.create_resource()
 
66
            mapper.resource("console", "consoles",
 
67
                        controller=self.resources['consoles'],
114
68
                        parent_resource=dict(member_name='server',
115
69
                        collection_name='servers'))
116
70
 
117
 
        mapper.connect("metadata",
118
 
                       "/{project_id}/servers/{server_id}/metadata",
119
 
                       controller=server_metadata_controller,
120
 
                       action='update_all',
121
 
                       conditions={"method": ['PUT']})
 
71
        if init_only is None or 'consoles' in init_only or \
 
72
                'servers' in init_only or ips in init_only:
 
73
            self.resources['servers'] = servers.create_resource(ext_mgr)
 
74
            mapper.resource("server", "servers",
 
75
                            controller=self.resources['servers'],
 
76
                            collection={'detail': 'GET'},
 
77
                            member={'action': 'POST'})
 
78
 
 
79
        if init_only is None or 'ips' in init_only:
 
80
            self.resources['ips'] = ips.create_resource()
 
81
            mapper.resource("ip", "ips", controller=self.resources['ips'],
 
82
                            parent_resource=dict(member_name='server',
 
83
                                                 collection_name='servers'))
 
84
 
 
85
        if init_only is None or 'images' in init_only:
 
86
            self.resources['images'] = images.create_resource()
 
87
            mapper.resource("image", "images",
 
88
                            controller=self.resources['images'],
 
89
                            collection={'detail': 'GET'})
 
90
 
 
91
        if init_only is None or 'limits' in init_only:
 
92
            self.resources['limits'] = limits.create_resource()
 
93
            mapper.resource("limit", "limits",
 
94
                            controller=self.resources['limits'])
 
95
 
 
96
        if init_only is None or 'flavors' in init_only:
 
97
            self.resources['flavors'] = flavors.create_resource()
 
98
            mapper.resource("flavor", "flavors",
 
99
                            controller=self.resources['flavors'],
 
100
                            collection={'detail': 'GET'},
 
101
                            member={'action': 'POST'})
 
102
 
 
103
        if init_only is None or 'image_metadata' in init_only:
 
104
            self.resources['image_metadata'] = image_metadata.create_resource()
 
105
            image_metadata_controller = self.resources['image_metadata']
 
106
 
 
107
            mapper.resource("image_meta", "metadata",
 
108
                            controller=image_metadata_controller,
 
109
                            parent_resource=dict(member_name='image',
 
110
                            collection_name='images'))
 
111
 
 
112
            mapper.connect("metadata",
 
113
                           "/{project_id}/images/{image_id}/metadata",
 
114
                           controller=image_metadata_controller,
 
115
                           action='update_all',
 
116
                           conditions={"method": ['PUT']})
 
117
 
 
118
        if init_only is None or 'server_metadata' in init_only:
 
119
            self.resources['server_metadata'] = \
 
120
                server_metadata.create_resource()
 
121
            server_metadata_controller = self.resources['server_metadata']
 
122
 
 
123
            mapper.resource("server_meta", "metadata",
 
124
                            controller=server_metadata_controller,
 
125
                            parent_resource=dict(member_name='server',
 
126
                            collection_name='servers'))
 
127
 
 
128
            mapper.connect("metadata",
 
129
                           "/{project_id}/servers/{server_id}/metadata",
 
130
                           controller=server_metadata_controller,
 
131
                           action='update_all',
 
132
                           conditions={"method": ['PUT']})