"attributes": {
"network": ["id", "name"],
"port": ["id", "state"],
++ "attachment": ["id"]
},
"plurals": {"networks": "network"}
},
# concerning logical ports as well.
network = self._plugin.get_network_details(
tenant_id, network_id)
++ port_list = self._plugin.get_all_ports(
++ tenant_id, network_id)
++ ports_data = [self._plugin.get_port_details(
++ tenant_id, network_id, port['port-id'])
++ for port in port_list]
builder = networks_view.get_view_builder(req)
-- result = builder.build(network, net_details, port_details)['network']
++ result = builder.build(network, net_details,
++ ports_data, port_details)['network']
return dict(network=result)
-- def _items(self, req, tenant_id, net_details=False, port_details=False):
++ def _items(self, req, tenant_id, net_details=False):
""" Returns a list of networks. """
networks = self._plugin.get_all_networks(tenant_id)
builder = networks_view.get_view_builder(req)
-- result = [builder.build(network, net_details, port_details)['network']
++ result = [builder.build(network, net_details)['network']
for network in networks]
return dict(networks=result)
def detail(self, request, **kwargs):
tenant_id = kwargs.get('tenant_id')
network_id = kwargs.get('id')
-- try:
-- if network_id:
-- # show details for a given network
-- return self._item(request, tenant_id, network_id,
-- net_details=True, port_details=True)
-- else:
-- # show details for all networks
-- return self._items(request, tenant_id,
-- net_details=True, port_details=False)
-- network = self._plugin.get_network_details(
-- tenant_id, id)
-- builder = networks_view.get_view_builder(request)
-- #build response with details
-- result = builder.build(network, True)
-- return dict(networks=result)
-- except exception.NetworkNotFound as e:
-- return faults.Fault(faults.NetworkNotFound(e))
++ if network_id:
++ # show details for a given network
++ return self._item(request, tenant_id, network_id,
++ net_details=True, port_details=True)
++ else:
++ # show details for all networks
++ return self._items(request, tenant_id, net_details=True)
def create(self, request, tenant_id):
""" Creates a new network for a given tenant """
# License for the specific language governing permissions and limitations
# under the License.
--from quantum.api.views import ports as ports_view
++import logging
++LOG = logging.getLogger('quantum.api.views.networks')
def get_view_builder(req):
base_url = req.application_url
"""
self.base_url = base_url
-- def build(self, network_data, net_detail=False, port_detail=False):
++ def build(self, network_data, net_detail=False, ports_data=None, port_detail=False):
"""Generic method used to generate a network entity."""
if net_detail:
network = self._build_detail(network_data)
else:
network = self._build_simple(network_data)
if port_detail:
-- builder = ports_view.ViewBuilder(self.base_url)
-- ports = [builder.build(port_data, port_detail)['port']
-- for port_data in network_data['net-ports'].values()]
-- network['ports'] = ports
++ ports = [self._build_port(port_data) for port_data in ports_data]
++ network['network']['ports'] = ports
++ LOG.debug("NETWORK:%s", network)
return network
def _build_simple(self, network_data):
def _build_port(self, port_data):
"""Return details about a specific logical port."""
-- return dict(port=dict(id=port_data['port-id'],
-- state=port_data['port-state'],
- attachment=port_data['attachment-id']))
- attachment=port_data['attachment']))
++ port_dict = dict(id=port_data['port-id'],
++ state=port_data['port-state'])
++ if port_data['attachment-id']:
++ port_dict['attachment'] = dict(id=port_data['attachment-id'])
++ return port_dict
if expected_res_status == 200:
network_data = Serializer().deserialize(network_res.body,
content_type)
-- return network_data['networks']['network']['id']
++ return network_data['network']['id']
def _create_port(self, network_id, port_state, format,
custom_req_body=None, expected_res_status=200):
self.assertEqual(port_res.status_int, expected_res_status)
if expected_res_status == 200:
port_data = Serializer().deserialize(port_res.body, content_type)
-- return port_data['ports']['port']['id']
++ return port_data['port']['id']
def _test_create_network(self, format):
LOG.debug("_test_create_network - format:%s - START", format)
self.assertEqual(show_network_res.status_int, 200)
network_data = Serializer().deserialize(show_network_res.body,
content_type)
-- self.assertEqual(network_id,
-- network_data['network']['id'])
++ self.assertEqual(network_id, network_data['network']['id'])
LOG.debug("_test_create_network - format:%s - END", format)
def _test_create_network_badrequest(self, format):
new_name,
format)
update_network_res = update_network_req.get_response(self.api)
-- self.assertEqual(update_network_res.status_int, 202)
++ self.assertEqual(update_network_res.status_int, 204)
show_network_req = testlib.show_network_request(self.tenant_id,
network_id,
format)
network_id,
format)
delete_network_res = delete_network_req.get_response(self.api)
-- self.assertEqual(delete_network_res.status_int, 202)
++ self.assertEqual(delete_network_res.status_int, 204)
list_network_req = testlib.network_list_request(self.tenant_id,
format)
list_network_res = list_network_req.get_response(self.api)
port_id,
attachment_id)
attachment_res = attachment_req.get_response(self.api)
-- self.assertEquals(attachment_res.status_int, 202)
++ self.assertEquals(attachment_res.status_int, 204)
LOG.debug("Deleting network %(network_id)s"\
" of tenant %(tenant_id)s", locals())
network_id, port_id,
format)
delete_port_res = delete_port_req.get_response(self.api)
-- self.assertEqual(delete_port_res.status_int, 202)
++ self.assertEqual(delete_port_res.status_int, 204)
list_port_req = testlib.port_list_request(self.tenant_id, network_id,
format)
list_port_res = list_port_req.get_response(self.api)
port_id,
attachment_id)
attachment_res = attachment_req.get_response(self.api)
-- self.assertEquals(attachment_res.status_int, 202)
++ self.assertEquals(attachment_res.status_int, 204)
LOG.debug("Deleting port %(port_id)s for network %(network_id)s"\
" of tenant %(tenant_id)s", locals())
delete_port_req = testlib.port_delete_request(self.tenant_id,
new_port_state,
format)
update_port_res = update_port_req.get_response(self.api)
-- self.assertEqual(update_port_res.status_int, 200)
++ self.assertEqual(update_port_res.status_int, 204)
show_port_req = testlib.show_port_request(self.tenant_id,
network_id, port_id,
format)
interface_id,
format)
put_attachment_res = put_attachment_req.get_response(self.api)
-- self.assertEqual(put_attachment_res.status_int, 202)
++ self.assertEqual(put_attachment_res.status_int, 204)
get_attachment_req = testlib.get_attachment_request(self.tenant_id,
network_id,
port_id,
get_attachment_res = get_attachment_req.get_response(self.api)
attachment_data = Serializer().deserialize(get_attachment_res.body,
content_type)
-- self.assertEqual(attachment_data['attachment'], interface_id)
++ self.assertEqual(attachment_data['attachment']['id'], interface_id)
LOG.debug("_test_show_attachment - format:%s - END", format)
def _test_show_attachment_networknotfound(self, format):
interface_id,
format)
put_attachment_res = put_attachment_req.get_response(self.api)
-- self.assertEqual(put_attachment_res.status_int, 202)
++ self.assertEqual(put_attachment_res.status_int, 204)
LOG.debug("_test_put_attachment - format:%s - END", format)
def _test_put_attachment_networknotfound(self, format):
interface_id,
format)
put_attachment_res = put_attachment_req.get_response(self.api)
-- self.assertEqual(put_attachment_res.status_int, 202)
++ self.assertEqual(put_attachment_res.status_int, 204)
del_attachment_req = testlib.delete_attachment_request(self.tenant_id,
network_id,
port_id,
format)
del_attachment_res = del_attachment_req.get_response(self.api)
-- self.assertEqual(del_attachment_res.status_int, 202)
++ self.assertEqual(del_attachment_res.status_int, 204)
LOG.debug("_test_delete_attachment - format:%s - END", format)
def _test_delete_attachment_networknotfound(self, format):
format='xml', custom_req_body=None):
method = 'POST'
path = "/tenants/%(tenant_id)s/networks.%(format)s" % locals()
-- data = custom_req_body or {'network': {'net-name': '%s' % network_name}}
++ data = custom_req_body or {'network': {'name': '%s' % network_name}}
content_type = "application/%s" % format
body = Serializer().serialize(data, content_type)
return create_request(path, body, content_type, method)
method = 'PUT'
path = "/tenants/%(tenant_id)s/networks" \
"/%(network_id)s.%(format)s" % locals()
-- data = custom_req_body or {'network': {'net-name': '%s' % network_name}}
++ data = custom_req_body or {'network': {'name': '%s' % network_name}}
content_type = "application/%s" % format
body = Serializer().serialize(data, content_type)
return create_request(path, body, content_type, method)
method = 'POST'
path = "/tenants/%(tenant_id)s/networks/" \
"%(network_id)s/ports.%(format)s" % locals()
- data = custom_req_body or {'port': {'port-state': '%s' % port_state}}
+ data = custom_req_body or port_state and \
- {'port': {'port-state': '%s' % port_state}}
++ {'port': {'state': '%s' % port_state}}
content_type = "application/%s" % format
- body = Serializer().serialize(data, content_type)
+ body = data and Serializer().serialize(data, content_type)
return create_request(path, body, content_type, method)
method = 'PUT'
path = "/tenants/%(tenant_id)s/networks" \
"/%(network_id)s/ports/%(port_id)s.%(format)s" % locals()
-- data = custom_req_body or {'port': {'port-state': '%s' % port_state}}
++ data = custom_req_body or {'port': {'state': '%s' % port_state}}
content_type = "application/%s" % format
body = Serializer().serialize(data, content_type)
return create_request(path, body, content_type, method)
method = 'PUT'
path = "/tenants/%(tenant_id)s/networks/" \
"%(network_id)s/ports/%(port_id)s/attachment.%(format)s" % locals()
-- data = {'port': {'attachment-id': attachment_id}}
++ data = {'attachment': {'id': attachment_id}}
content_type = "application/%s" % format
body = Serializer().serialize(data, content_type)
return create_request(path, body, content_type, method)