← Back to branch summary

~salvatore-orlando/neutron/quantum-api

« back to all changes in this revision

Viewing changes to quantum/api/networks.py

  • Committer: Salvatore Orlando
  • Date: 2011-06-24 13:52:17 UTC
  • mfrom: (6.1.14 quantum-trunk)
  • Revision ID: salvatore.orlando@eu.citrix.com-20110624135217-h6uz1zu3fxxpf3wt
Merge trunk
Resolving conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
quantum/api/networks.py
45
45
        self._resource_name = 'network'
46
46
        super(Controller, self).__init__()
47
47
 
48
 
    def index(self, req, tenant_id):
 
48
    def index(self, request, tenant_id):
49
49
        """ Returns a list of network ids """
50
50
        #TODO: this should be for a given tenant!!!
51
 
        return self._items(req, tenant_id, net_detail=False)
 
51
        return self._items(request, tenant_id, net_detail=False)
52
52
 
53
53
    def _item(self, req, tenant_id, network_id,
54
54
              net_details, port_details):
66
66
                  for network in networks]
67
67
        return dict(networks=result)
68
68
 
69
 
    def show(self, req, tenant_id, id):
 
69
    def show(self, request, tenant_id, id):
70
70
        """ Returns network details for the given network id """
71
71
        try:
72
 
            return self._item(req, tenant_id, id,
 
72
            return self._item(request, tenant_id, id,
73
73
                              net_details=True, port_details=False)
74
74
        except exception.NetworkNotFound as e:
75
75
            return faults.Fault(faults.NetworkNotFound(e))
76
76
 
77
 
    def detail(self, req, **kwargs):
 
77
    def detail(self, request, **kwargs):
78
78
        tenant_id = kwargs.get('tenant_id')
79
79
        network_id = kwargs.get('id')
80
80
        try:
81
81
            if network_id:
82
 
                return self._item(req, tenant_id, network_id,
 
82
                return self._item(request, tenant_id, network_id,
83
83
                                  net_details=True, port_details=True)
84
84
            else:
85
85
                #do like show but with detaik
86
 
                return self._items(req, tenant_id,
 
86
                return self._items(request, tenant_id,
87
87
                                   net_details=True, port_details=False)
88
88
        except exception.NetworkNotFound as e:
89
89
            return faults.Fault(faults.NetworkNotFound(e))
90
90
 
91
 
    def create(self, req, tenant_id):
 
91
    def create(self, request, tenant_id):
92
92
        """ Creates a new network for a given tenant """
93
93
        #look for network name in request
94
94
        try:
95
 
            req_params = \
96
 
                self._parse_request_params(req, self._network_ops_param_list)
 
95
            request_params = \
 
96
                self._parse_request_params(request,
 
97
                                           self._network_ops_param_list)
97
98
        except exc.HTTPError as e:
98
99
            return faults.Fault(e)
99
100
        network = self.network_manager.\
100
 
                       create_network(tenant_id, req_params['network-name'])
101
 
        builder = networks_view.get_view_builder(req)
 
101
                       create_network(tenant_id,
 
102
                                      request_params['network-name'])
 
103
        builder = networks_view.get_view_builder(request)
102
104
        result = builder.build(network)
103
105
        return dict(networks=result)
104
106
 
105
 
    def update(self, req, tenant_id, id):
 
107
    def update(self, request, tenant_id, id):
106
108
        """ Updates the name for the network with the given id """
107
109
        try:
108
 
            req_params = \
109
 
                self._parse_request_params(req, self._network_ops_param_list)
 
110
            request_params = \
 
111
                self._parse_request_params(request,
 
112
                                           self._network_ops_param_list)
110
113
        except exc.HTTPError as e:
111
114
            return faults.Fault(e)
112
115
        try:
113
116
            network = self.network_manager.rename_network(tenant_id,
114
 
                        id, req_params['network-name'])
 
117
                        id, request_params['network-name'])
115
118
 
116
 
            builder = networks_view.get_view_builder(req)
 
119
            builder = networks_view.get_view_builder(request)
117
120
            result = builder.build(network, True)
118
121
            return dict(networks=result)
119
122
        except exception.NetworkNotFound as e:
120
123
            return faults.Fault(faults.NetworkNotFound(e))
121
124
 
122
 
    def delete(self, req, tenant_id, id):
 
125
    def delete(self, request, tenant_id, id):
123
126
        """ Destroys the network with the given id """
124
127
        try:
125
128
            self.network_manager.delete_network(tenant_id, id)