def create(self, request, tenant_id, source_block_id, body=None):
source_block = models.IpBlock.find_by(id=source_block_id,
tenant_id=tenant_id)
params = self._extract_required_params(body, 'ip_route')
ip_route = models.IpRoute.create(source_block_id=source_block.id,
**params)
return wsgi.Result(dict(ip_route=ip_route.data()), 201)
def update(self, request, id, tenant_id, body=None):
LOG.info("Updating IP block %(id)s for %(tenant_id)s" % locals())
ip_block = self._find_block(id=id, tenant_id=tenant_id)
params = self._extract_required_params(body, 'ip_block')
ip_block.update(**utils.exclude(params, 'cidr', 'type'))
LOG.debug("Updated IP block %(id)s parameters: %(params)s" % locals())
return wsgi.Result(dict(ip_block=ip_block.data()), 200)
def _paginated_response(self, collection_type, collection_query, request):
elements, next_marker = collection_query.paginated_collection(
**self._extract_limits(request.params))
collection = [element.data() for element in elements]
return wsgi.Result(
pagination.PaginatedDataView(collection_type, collection,
request.url, next_marker))
def create(self, request, ip_block_id, tenant_id, body=None):
ip_block = self._find_block(id=ip_block_id, tenant_id=tenant_id)
params = self._extract_required_params(body, 'subnet')
subnet = ip_block.subnet(**utils.filter_dict(params,
'cidr',
'network_id',
'tenant_id'))
return wsgi.Result(dict(subnet=subnet.data()), 201)
def create(self, request, interface_id, tenant_id, body=None):
params = self._extract_required_params(body, 'allowed_ip')
interface = models.Interface.find_by(vif_id_on_device=interface_id,
tenant_id=tenant_id)
network = models.Network.find_by(id=params['network_id'])
ip = network.find_allocated_ip(address=params['ip_address'],
used_by_tenant_id=tenant_id)
interface.allow_ip(ip)
return wsgi.Result(dict(ip_address=ip.data()), 201)
def create(self, request, body, device_id, interface_id):
params = self._extract_required_params(body, 'network')
interface = models.Interface.find_by(id=interface_id,
device_id=device_id)
network = models.Network.find_by(params.pop('id'),
tenant_id=params.pop('tenant_id'))
ips = network.allocate_ips(interface=interface, **params)
ip_config_view = views.IpConfigurationView(*ips)
return wsgi.Result(dict(ip_addresses=ip_config_view.data()), 201)
def create(self, request, ip_block_id, tenant_id, body=None):
ip_block = self._find_block(id=ip_block_id, tenant_id=tenant_id)
params = self._extract_required_params(body, 'ip_address')
interface = models.Interface.find_or_configure(
virtual_interface_id=params.pop('interface_id', None),
device_id=params.pop('used_by_device', None),
tenant_id=params.pop('tenant_id', tenant_id),
mac_address=params.pop('mac_address', None))
ip_address = ip_block.allocate_ip(interface=interface, **params)
return wsgi.Result(dict(ip_address=ip_address.data()), 201)
def create(self, request, network_id, interface_id, tenant_id, body=None):
network = models.Network.find_or_create_by(network_id, tenant_id)
params = self._extract_required_params(body, 'network')
network_params = utils.filter_dict(params, "addresses")
interface = models.Interface.find_or_configure(
virtual_interface_id=interface_id,
tenant_id=params.get('tenant_id', tenant_id),
device_id=params.get('used_by_device', None),
mac_address=params.get('mac_address', None))
ips = network.allocate_ips(interface=interface, **network_params)
ip_config_view = views.IpConfigurationView(*ips)
return wsgi.Result(dict(ip_addresses=ip_config_view.data()), 201)
def create(self, request, body=None):
params = self._extract_required_params(body, 'interface')
params['virtual_interface_id'] = params.pop('id', None)
network_params = utils.stringify_keys(params.pop('network', None))
LOG.debug("Creating interface with parameters: %s" % params)
interface = models.Interface.create_and_configure(**params)
if network_params:
network = models.Network.find_or_create_by(
network_params.pop('id'), network_params.pop('tenant_id'))
network.allocate_ips(interface=interface, **network_params)
view_data = views.InterfaceConfigurationView(interface).data()
return wsgi.Result(dict(interface=view_data), 201)
def index(self, request):
"""Respond to a request for all OpenStack API versions."""
versions = [Version("v0.1", "CURRENT", request.application_url)]
return wsgi.Result(VersionsDataView(versions))
def test_data_returns_json_specific_input_data(self):
self.assertEqual(wsgi.Result(self.TestData()).data("application/json"),
{'foo': "bar", 'foo2': "bar2"})
def test_data_returns_xml_specific_input_data(self):
self.assertEqual(wsgi.Result(self.TestData()).data("application/xml"),
{'foos': [{'foo': "bar"}, {'foo2': "bar2"}]})
def test_data_returns_back_input_data(self):
self.assertEqual(wsgi.Result("blah").data("application/json"), "blah")
self.assertEqual(wsgi.Result({'x': "blah"}).data("application/json"),
{'x': "blah"})
self.assertEqual(wsgi.Result(["x", "blah"]).data("application/xml"),
["x", "blah"])
def create(self, request, policy_id, tenant_id, body=None):
policy = models.Policy.find_by(id=policy_id, tenant_id=tenant_id)
params = self._extract_required_params(body, 'ip_octet')
ip_octet = policy.create_unusable_ip_octet(**params)
return wsgi.Result(dict(ip_octet=ip_octet.data()), 201)
def create(self, request, tenant_id, body=None):
params = self._extract_required_params(body, 'policy')
policy = models.Policy.create(tenant_id=tenant_id, **params)
return wsgi.Result(dict(policy=policy.data()), 201)
def create(self, request, body=None):
params = self._extract_required_params(body, 'mac_address_range')
LOG.info("Creating MAC address range: %s" % params)
mac_range = models.MacAddressRange.create(**params)
return wsgi.Result(dict(mac_address_range=mac_range.data()), 201)
def create(self, request, tenant_id, body=None):
LOG.info("Creating an IP block for tenant '%s'" % tenant_id)
params = self._extract_required_params(body, 'ip_block')
block = models.IpBlock.create(tenant_id=tenant_id, **params)
LOG.debug("New IP block parameters: %s" % params)
return wsgi.Result(dict(ip_block=block.data()), 201)
