def test_subnet_deprecated(self):
t = self._test_subnet(resolve_neutron=False)
stack = utils.parse_stack(t)
rsrc = self.create_subnet(t, stack, "sub_net")
neutronV20.find_resourceid_by_name_or_id(mox.IsA(neutronclient.Client), "network", "None").AndReturn("None")
neutronV20.find_resourceid_by_name_or_id(mox.IsA(neutronclient.Client), "router", "None").AndReturn("None")
self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
rsrc.validate()
ref_id = rsrc.FnGetRefId()
self.assertEqual("91e47a57-7508-46fe-afc9-fc454e8580e1", ref_id)
self.assertIsNone(rsrc.FnGetAtt("network_id"))
self.assertEqual("fc68ea2c-b60b-4b4f-bd82-94ec81110766", rsrc.FnGetAtt("network_id"))
self.assertEqual("8.8.8.8", rsrc.FnGetAtt("dns_nameservers")[0])
# assert the dependency (implicit or explicit) between the ports
# and the subnet
self.assertIn(stack["port"], stack.dependencies[stack["sub_net"]])
self.assertIn(stack["port2"], stack.dependencies[stack["sub_net"]])
self.assertIsNone(scheduler.TaskRunner(rsrc.delete)())
rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, "to delete again")
self.assertIsNone(scheduler.TaskRunner(rsrc.delete)())
self.m.VerifyAll()
def test_missing_subnet_id(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), "network", "net1234"
).MultipleTimes().AndReturn("net1234")
neutronclient.Client.create_port(
{
"port": {
"network_id": u"net1234",
"fixed_ips": [{"ip_address": u"10.0.3.21"}],
"name": utils.PhysName("test_stack", "port"),
"admin_state_up": True,
"device_owner": u"network:dhcp",
}
}
).AndReturn({"port": {"status": "BUILD", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"}})
neutronclient.Client.show_port("fc68ea2c-b60b-4b4f-bd82-94ec81110766").AndReturn(
{"port": {"status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"}}
)
self.m.ReplayAll()
t = template_format.parse(neutron_port_template)
t["resources"]["port"]["properties"]["fixed_ips"][0].pop("subnet")
stack = utils.parse_stack(t)
port = stack["port"]
scheduler.TaskRunner(port.create)()
self.m.VerifyAll()
def test_allowed_address_pair(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), "network", "abcd1234"
).MultipleTimes().AndReturn("abcd1234")
neutronclient.Client.create_port(
{
"port": {
"network_id": u"abcd1234",
"allowed_address_pairs": [{"ip_address": u"10.0.3.21", "mac_address": u"00-B0-D0-86-BB-F7"}],
"name": utils.PhysName("test_stack", "port"),
"admin_state_up": True,
}
}
).AndReturn({"port": {"status": "BUILD", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"}})
neutronclient.Client.show_port("fc68ea2c-b60b-4b4f-bd82-94ec81110766").AndReturn(
{"port": {"status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"}}
)
self.m.ReplayAll()
t = template_format.parse(neutron_port_with_address_pair_template)
stack = utils.parse_stack(t)
port = stack["port"]
scheduler.TaskRunner(port.create)()
self.m.VerifyAll()
def test_ip_address_is_cidr(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'abcd1234'
).MultipleTimes().AndReturn('abcd1234')
neutronclient.Client.create_port({'port': {
'network_id': u'abcd1234',
'allowed_address_pairs': [{
'ip_address': u'10.0.3.0/24',
'mac_address': u'00-B0-D0-86-BB-F7'
}],
'name': utils.PhysName('test_stack', 'port'),
'admin_state_up': True}}
).AndReturn({'port': {
"status": "BUILD",
"id": "2e00180a-ff9d-42c4-b701-a0606b243447"
}})
neutronclient.Client.show_port(
'2e00180a-ff9d-42c4-b701-a0606b243447'
).AndReturn({'port': {
"status": "ACTIVE",
"id": "2e00180a-ff9d-42c4-b701-a0606b243447"
}})
self.m.ReplayAll()
t = template_format.parse(neutron_port_with_address_pair_template)
t['resources']['port']['properties'][
'allowed_address_pairs'][0]['ip_address'] = '10.0.3.0/24'
stack = utils.parse_stack(t)
port = stack['port']
scheduler.TaskRunner(port.create)()
self.m.VerifyAll()
def test_port_security_enabled(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), "network", "abcd1234"
).MultipleTimes().AndReturn("abcd1234")
neutronclient.Client.create_port(
{
"port": {
"network_id": u"abcd1234",
"port_security_enabled": False,
"name": utils.PhysName("test_stack", "port"),
"admin_state_up": True,
}
}
).AndReturn({"port": {"status": "BUILD", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"}})
neutronclient.Client.show_port("fc68ea2c-b60b-4b4f-bd82-94ec81110766").AndReturn(
{"port": {"status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"}}
)
self.m.ReplayAll()
t = template_format.parse(neutron_port_security_template)
stack = utils.parse_stack(t)
port = stack["port"]
scheduler.TaskRunner(port.create)()
self.m.VerifyAll()
def args2body(self, parsed_args):
_network_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'network', parsed_args.network_id)
body = {'port': {'admin_state_up': parsed_args.admin_state,
'network_id': _network_id, }, }
if parsed_args.mac_address:
body['port'].update({'mac_address': parsed_args.mac_address})
if parsed_args.device_id:
body['port'].update({'device_id': parsed_args.device_id})
if parsed_args.tenant_id:
body['port'].update({'tenant_id': parsed_args.tenant_id})
if parsed_args.name:
body['port'].update({'name': parsed_args.name})
ips = []
if parsed_args.fixed_ip:
for ip_spec in parsed_args.fixed_ip:
ip_dict = utils.str2dict(ip_spec)
if 'subnet_id' in ip_dict:
subnet_name_id = ip_dict['subnet_id']
_subnet_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'subnet', subnet_name_id)
ip_dict['subnet_id'] = _subnet_id
ips.append(ip_dict)
if ips:
body['port'].update({'fixed_ips': ips})
self.args2body_secgroup(parsed_args, body['port'])
self.args2body_extradhcpopt(parsed_args, body['port'])
return body
def validate(self):
"""Validate the provided params."""
super(RBACPolicy, self).validate()
action = self.properties[self.ACTION]
obj_type = self.properties[self.OBJECT_TYPE]
obj_id_or_name = self.properties[self.OBJECT_ID]
# Validate obj_type and action per SUPPORTED_TYPES_ACTIONS.
if obj_type not in self.SUPPORTED_TYPES_ACTIONS:
msg = (_("Invalid object_type: %(obj_type)s. "
"Valid object_type :%(value)s") %
{'obj_type': obj_type,
'value': self.SUPPORTED_TYPES_ACTIONS.keys()})
raise exception.StackValidationFailed(message=msg)
if action not in self.SUPPORTED_TYPES_ACTIONS[obj_type]:
msg = (_("Invalid action %(action)s for object type "
"%(obj_type)s. Valid actions :%(value)s") %
{'action': action, 'obj_type': obj_type,
'value': self.SUPPORTED_TYPES_ACTIONS[obj_type]})
raise exception.StackValidationFailed(message=msg)
# Make sure the value of object_id is correct.
neutronV20.find_resourceid_by_name_or_id(self.client(),
obj_type,
obj_id_or_name)
def test_create_failed(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'subnet',
'sub123',
cmd_resource=None,
).MultipleTimes().AndReturn('sub123')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'router',
'rou123',
cmd_resource=None,
).MultipleTimes().AndReturn('rou123')
self.stub_RouterConstraint_validate()
neutronclient.Client.create_vpnservice(self.VPN_SERVICE_CONF).AndRaise(
exceptions.NeutronClientException())
self.m.ReplayAll()
snippet = template_format.parse(vpnservice_template)
self.stack = utils.parse_stack(snippet)
resource_defns = self.stack.t.resource_definitions(self.stack)
rsrc = vpnservice.VPNService('vpnservice',
resource_defns['VPNService'],
self.stack)
error = self.assertRaises(exception.ResourceFailure,
scheduler.TaskRunner(rsrc.create))
self.assertEqual(
'NeutronClientException: resources.vpnservice: '
'An unknown exception occurred.',
six.text_type(error))
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
self.m.VerifyAll()
def test_ip_address_is_cidr(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), "network", "abcd1234", cmd_resource=None
).MultipleTimes().AndReturn("abcd1234")
neutronclient.Client.create_port(
{
"port": {
"network_id": u"abcd1234",
"allowed_address_pairs": [{"ip_address": u"10.0.3.0/24", "mac_address": u"00-B0-D0-86-BB-F7"}],
"name": utils.PhysName("test_stack", "port"),
"admin_state_up": True,
}
}
).AndReturn({"port": {"status": "BUILD", "id": "2e00180a-ff9d-42c4-b701-a0606b243447"}})
neutronclient.Client.show_port("2e00180a-ff9d-42c4-b701-a0606b243447").AndReturn(
{"port": {"status": "ACTIVE", "id": "2e00180a-ff9d-42c4-b701-a0606b243447"}}
)
self.m.ReplayAll()
t = template_format.parse(neutron_port_with_address_pair_template)
t["resources"]["port"]["properties"]["allowed_address_pairs"][0]["ip_address"] = "10.0.3.0/24"
stack = utils.parse_stack(t)
port = stack["port"]
scheduler.TaskRunner(port.create)()
self.m.VerifyAll()
def test_subnet_deprecated(self):
t = self._test_subnet(resolve_neutron=False)
stack = utils.parse_stack(t)
rsrc = self.create_subnet(t, stack, 'sub_net')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'None'
).AndReturn('None')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'router',
'None'
).AndReturn('None')
self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
rsrc.validate()
ref_id = rsrc.FnGetRefId()
self.assertEqual('91e47a57-7508-46fe-afc9-fc454e8580e1', ref_id)
self.assertIsNone(rsrc.FnGetAtt('network_id'))
self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766',
rsrc.FnGetAtt('network_id'))
self.assertEqual('8.8.8.8', rsrc.FnGetAtt('dns_nameservers')[0])
# assert the dependency (implicit or explicit) between the ports
# and the subnet
self.assertIn(stack['port'], stack.dependencies[stack['sub_net']])
self.assertIn(stack['port2'], stack.dependencies[stack['sub_net']])
self.assertIsNone(scheduler.TaskRunner(rsrc.delete)())
rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again')
self.assertIsNone(scheduler.TaskRunner(rsrc.delete)())
self.m.VerifyAll()
def create_vpnservice(self, resolve_neutron=True, resolve_router=True):
self.stub_SubnetConstraint_validate()
self.stub_RouterConstraint_validate()
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'subnet',
'sub123',
cmd_resource=None,
).AndReturn('sub123')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'router',
'rou123',
cmd_resource=None,
).AndReturn('rou123')
if resolve_neutron:
snippet = template_format.parse(vpnservice_template)
else:
snippet = template_format.parse(vpnservice_template_deprecated)
if resolve_router:
props = snippet['resources']['VPNService']['properties']
props['router'] = 'rou123'
del props['router_id']
neutronclient.Client.create_vpnservice(
self.VPN_SERVICE_CONF).AndReturn({'vpnservice': {'id': 'vpn123'}})
self.stack = utils.parse_stack(snippet)
resource_defns = self.stack.t.resource_definitions(self.stack)
return vpnservice.VPNService('vpnservice',
resource_defns['VPNService'],
self.stack)
def test_missing_subnet_id(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'net1234'
).MultipleTimes().AndReturn('net1234')
neutronclient.Client.create_port({'port': {
'network_id': u'net1234',
'fixed_ips': [
{'ip_address': u'10.0.3.21'}
],
'name': utils.PhysName('test_stack', 'port'),
'admin_state_up': True,
'device_owner': u'network:dhcp'}}
).AndReturn({'port': {
"status": "BUILD",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}})
neutronclient.Client.show_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766'
).AndReturn({'port': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}})
self.m.ReplayAll()
t = template_format.parse(neutron_port_template)
t['resources']['port']['properties']['fixed_ips'][0].pop('subnet')
stack = utils.parse_stack(t)
port = stack['port']
scheduler.TaskRunner(port.create)()
self.m.VerifyAll()
def args2body(self, parsed_args):
_security_group_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), "security_group", parsed_args.security_group_id
)
body = {
"security_group_rule": {
"security_group_id": _security_group_id,
"direction": parsed_args.direction,
"ethertype": parsed_args.ethertype,
}
}
if parsed_args.protocol:
body["security_group_rule"].update({"protocol": parsed_args.protocol})
if parsed_args.port_range_min:
body["security_group_rule"].update({"port_range_min": parsed_args.port_range_min})
if parsed_args.port_range_max:
body["security_group_rule"].update({"port_range_max": parsed_args.port_range_max})
if parsed_args.remote_ip_prefix:
body["security_group_rule"].update({"remote_ip_prefix": parsed_args.remote_ip_prefix})
if parsed_args.remote_group_id:
_remote_group_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), "security_group", parsed_args.remote_group_id
)
body["security_group_rule"].update({"remote_group_id": _remote_group_id})
if parsed_args.tenant_id:
body["security_group_rule"].update({"tenant_id": parsed_args.tenant_id})
return body
def test_allowed_address_pair(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'abcd1234'
).MultipleTimes().AndReturn('abcd1234')
neutronclient.Client.create_port({'port': {
'network_id': u'abcd1234',
'allowed_address_pairs': [{
'ip_address': u'10.0.3.21',
'mac_address': u'00-B0-D0-86-BB-F7'
}],
'name': utils.PhysName('test_stack', 'port'),
'admin_state_up': True}}
).AndReturn({'port': {
"status": "BUILD",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}})
neutronclient.Client.show_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766'
).AndReturn({'port': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}})
self.m.ReplayAll()
t = template_format.parse(neutron_port_with_address_pair_template)
stack = utils.parse_stack(t)
port = stack['port']
scheduler.TaskRunner(port.create)()
self.m.VerifyAll()
def test_port_security_enabled(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'abcd1234'
).MultipleTimes().AndReturn('abcd1234')
neutronclient.Client.create_port({'port': {
'network_id': u'abcd1234',
'port_security_enabled': False,
'name': utils.PhysName('test_stack', 'port'),
'admin_state_up': True}}
).AndReturn({'port': {
"status": "BUILD",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}})
neutronclient.Client.show_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766'
).AndReturn({'port': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766",
}})
self.m.ReplayAll()
t = template_format.parse(neutron_port_security_template)
stack = utils.parse_stack(t)
port = stack['port']
scheduler.TaskRunner(port.create)()
self.m.VerifyAll()
def test_floatingip_create_specify_subnet(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'abcd1234',
cmd_resource=None,
).MultipleTimes().AndReturn('abcd1234')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'subnet',
'sub1234',
cmd_resource=None,
).MultipleTimes().AndReturn('sub1234')
self.stub_NetworkConstraint_validate()
neutronclient.Client.create_floatingip({
'floatingip': {'floating_network_id': u'abcd1234',
'subnet_id': u'sub1234'}
}).AndReturn({'floatingip': {
'status': 'ACTIVE',
'id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766',
'floating_ip_address': '172.24.4.98'
}})
self.m.ReplayAll()
t = template_format.parse(neutron_floating_template)
props = t['resources']['floating_ip']['properties']
props['floating_subnet'] = 'sub1234'
stack = utils.parse_stack(t)
fip = stack['floating_ip']
scheduler.TaskRunner(fip.create)()
self.assertEqual((fip.CREATE, fip.COMPLETE), fip.state)
self.m.VerifyAll()
def args2body(self, parsed_args):
_security_group_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'security_group', parsed_args.security_group_id)
body = {'security_group_rule': {
'security_group_id': _security_group_id,
'direction': parsed_args.direction,
'ethertype': parsed_args.ethertype}}
if parsed_args.protocol:
body['security_group_rule'].update(
{'protocol': parsed_args.protocol})
if parsed_args.port_range_min:
body['security_group_rule'].update(
{'port_range_min': parsed_args.port_range_min})
if parsed_args.port_range_max:
body['security_group_rule'].update(
{'port_range_max': parsed_args.port_range_max})
if parsed_args.remote_ip_prefix:
body['security_group_rule'].update(
{'remote_ip_prefix': parsed_args.remote_ip_prefix})
if parsed_args.remote_group_id:
_remote_group_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'security_group',
parsed_args.remote_group_id)
body['security_group_rule'].update(
{'remote_group_id': _remote_group_id})
if parsed_args.tenant_id:
body['security_group_rule'].update(
{'tenant_id': parsed_args.tenant_id})
return body
def test_create_with_session_persistence(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'subnet',
'sub123'
).AndReturn('sub123')
neutronclient.Client.create_pool({
'pool': {
'subnet_id': 'sub123', 'protocol': u'HTTP',
'name': utils.PhysName('test_stack', 'pool'),
'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}}
).AndReturn({'pool': {'id': '5678'}})
neutronclient.Client.create_vip({
'vip': {
'protocol': u'HTTP', 'name': 'pool.vip',
'admin_state_up': True, 'subnet_id': u'sub123',
'pool_id': '5678', 'protocol_port': 80,
'session_persistence': {
'type': 'APP_COOKIE',
'cookie_name': 'cookie'}}}
).AndReturn({'vip': {'id': 'xyz'}})
neutronclient.Client.show_pool('5678').AndReturn(
{'pool': {'status': 'ACTIVE'}})
neutronclient.Client.show_vip('xyz').AndReturn(
{'vip': {'status': 'ACTIVE'}})
snippet = template_format.parse(pool_with_session_persistence_template)
stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack)
rsrc = loadbalancer.Pool(
'pool', resource_defns['pool'], stack)
self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.m.VerifyAll()
def test_FnGetRefId_convergence_cache_data(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'abcd1234',
cmd_resource=None,
).MultipleTimes().AndReturn('abcd1234')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'subnet',
'sub1234',
cmd_resource=None,
).MultipleTimes().AndReturn('sub1234')
self.m.ReplayAll()
t = template_format.parse(neutron_floating_template)
template = tmpl.Template(t)
stack = parser.Stack(utils.dummy_context(), 'test', template,
cache_data={
'floating_ip': node_data.NodeData.from_dict({
'uuid': mock.ANY,
'id': mock.ANY,
'action': 'CREATE',
'status': 'COMPLETE',
'reference_id': 'abc'})})
rsrc = stack.defn['floating_ip']
self.assertEqual('abc', rsrc.FnGetRefId())
def test_create_router_gateway_enable_snat(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'public',
cmd_resource=None,
).AndReturn('fc68ea2c-b60b-4b4f-bd82-94ec81110766')
neutronclient.Client.create_router({
"router": {
"name": "Test Router",
"external_gateway_info": {
'network_id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766',
},
"admin_state_up": True,
}
}).AndReturn({
"router": {
"status": "BUILD",
"external_gateway_info": None,
"name": "Test Router",
"admin_state_up": True,
"tenant_id": "3e21026f2dc94372b105808c0e721661",
"id": "3e46229d-8fce-4733-819a-b5fe630550f8",
}
})
neutronclient.Client.show_router(
'3e46229d-8fce-4733-819a-b5fe630550f8').MultipleTimes().AndReturn({
"router": {
"status": "ACTIVE",
"external_gateway_info": {
"network_id":
"fc68ea2c-b60b-4b4f-bd82-94ec81110766",
"enable_snat": True
},
"name": "Test Router",
"admin_state_up": True,
"tenant_id": "3e21026f2dc94372b105808c0e721661",
"routes": [],
"id": "3e46229d-8fce-4733-819a-b5fe630550f8"
}
})
self.m.ReplayAll()
t = template_format.parse(neutron_external_gateway_template)
t["resources"]["router"]["properties"]["external_gateway_info"].pop(
"enable_snat")
t["resources"]["router"]["properties"]["external_gateway_info"].pop(
"external_fixed_ips")
stack = utils.parse_stack(t)
rsrc = self.create_router(t, stack, 'router')
rsrc.validate()
ref_id = rsrc.FnGetRefId()
self.assertEqual('3e46229d-8fce-4733-819a-b5fe630550f8', ref_id)
gateway_info = rsrc.FnGetAtt('external_gateway_info')
self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766',
gateway_info.get('network_id'))
self.m.VerifyAll()
def test_create_failed(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'subnet',
'sub123'
).AndReturn('sub123')
neutronclient.Client.create_pool({
'pool': {
'subnet_id': 'sub123', 'protocol': u'HTTP',
'name': utils.PhysName('test_stack', 'pool'),
'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}}
).AndRaise(exceptions.NeutronClientException())
self.m.ReplayAll()
snippet = template_format.parse(pool_template)
stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack)
rsrc = loadbalancer.Pool(
'pool', resource_defns['pool'], stack)
error = self.assertRaises(exception.ResourceFailure,
scheduler.TaskRunner(rsrc.create))
self.assertEqual(
'NeutronClientException: An unknown exception occurred.',
six.text_type(error))
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
self.m.VerifyAll()
def test_subnet(self):
update_props = {'subnet': {
'dns_nameservers': ['8.8.8.8', '192.168.1.254'],
'name': 'mysubnet',
'enable_dhcp': True,
'host_routes': [{'destination': '192.168.1.0/24',
'nexthop': '194.168.1.2'}],
'gateway_ip': '10.0.3.105',
'allocation_pools': [
{'start': '10.0.3.20', 'end': '10.0.3.100'},
{'start': '10.0.3.110', 'end': '10.0.3.200'}]}}
t = self._test_subnet(u_props=update_props)
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'None',
cmd_resource=None,
).AndReturn('None')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'router',
'None',
cmd_resource=None,
).AndReturn('None')
neutronclient.Client.update_subnet(
'91e47a57-7508-46fe-afc9-fc454e8580e1', update_props)
stack = utils.parse_stack(t)
rsrc = self.create_subnet(t, stack, 'sub_net')
self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
rsrc.validate()
ref_id = rsrc.FnGetRefId()
self.assertEqual('91e47a57-7508-46fe-afc9-fc454e8580e1', ref_id)
self.assertIsNone(rsrc.FnGetAtt('network_id'))
self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766',
rsrc.FnGetAtt('network_id'))
self.assertEqual('8.8.8.8', rsrc.FnGetAtt('dns_nameservers')[0])
# assert the dependency (implicit or explicit) between the ports
# and the subnet
self.assertIn(stack['port'], stack.dependencies[stack['sub_net']])
self.assertIn(stack['port2'], stack.dependencies[stack['sub_net']])
update_snippet = rsrc_defn.ResourceDefinition(rsrc.name, rsrc.type(),
update_props['subnet'])
rsrc.handle_update(update_snippet, {}, update_props['subnet'])
# with name None
del update_props['subnet']['name']
rsrc.handle_update(update_snippet, {}, update_props['subnet'])
# with no prop_diff
rsrc.handle_update(update_snippet, {}, {})
self.assertIsNone(scheduler.TaskRunner(rsrc.delete)())
rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again')
self.assertIsNone(scheduler.TaskRunner(rsrc.delete)())
self.m.VerifyAll()
def test_update_router_gateway_as_property(self):
self._create_router_with_gateway()
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'other_public',
cmd_resource=None,
).AndReturn('91e47a57-7508-46fe-afc9-fc454e8580e1')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'subnet',
'sub1234',
cmd_resource=None,
).AndReturn('sub1234')
neutronclient.Client.update_router(
'3e46229d-8fce-4733-819a-b5fe630550f8',
{'router': {
"external_gateway_info": {
'network_id': '91e47a57-7508-46fe-afc9-fc454e8580e1',
'enable_snat': False
},
}}
).AndReturn(None)
neutronclient.Client.show_router(
'3e46229d-8fce-4733-819a-b5fe630550f8').MultipleTimes().AndReturn({
"router": {
"status": "ACTIVE",
"external_gateway_info": {
"network_id": "91e47a57-7508-46fe-afc9-fc454e8580e1",
"enable_snat": False
},
"name": "Test Router",
"admin_state_up": True,
"tenant_id": "3e21026f2dc94372b105808c0e721661",
"routes": [],
"id": "3e46229d-8fce-4733-819a-b5fe630550f8"
}
})
self.m.ReplayAll()
t = template_format.parse(neutron_external_gateway_template)
stack = utils.parse_stack(t)
rsrc = self.create_router(t, stack, 'router')
props = t['resources']['router']['properties'].copy()
props['external_gateway_info'] = {
"network": "other_public",
"enable_snat": False
}
update_template = rsrc.t.freeze(properties=props)
scheduler.TaskRunner(rsrc.update, update_template)()
self.assertEqual((rsrc.UPDATE, rsrc.COMPLETE), rsrc.state)
gateway_info = rsrc.FnGetAtt('external_gateway_info')
self.assertEqual('91e47a57-7508-46fe-afc9-fc454e8580e1',
gateway_info.get('network_id'))
self.assertFalse(gateway_info.get('enable_snat'))
self.m.VerifyAll()
def args2body(self, parsed_args):
_network_id = neutronV20.find_resourceid_by_name_or_id(self.get_client(), "network", parsed_args.network_id)
body = {"port": {"admin_state_up": parsed_args.admin_state, "network_id": _network_id}}
if parsed_args.mac_address:
body["port"].update({"mac_address": parsed_args.mac_address})
if parsed_args.device_id:
body["port"].update({"device_id": parsed_args.device_id})
if parsed_args.tenant_id:
body["port"].update({"tenant_id": parsed_args.tenant_id})
if parsed_args.name:
body["port"].update({"name": parsed_args.name})
ips = []
if parsed_args.fixed_ip:
for ip_spec in parsed_args.fixed_ip:
ip_dict = utils.str2dict(ip_spec)
if "subnet_id" in ip_dict:
subnet_name_id = ip_dict["subnet_id"]
_subnet_id = neutronV20.find_resourceid_by_name_or_id(self.get_client(), "subnet", subnet_name_id)
ip_dict["subnet_id"] = _subnet_id
ips.append(ip_dict)
if ips:
body["port"].update({"fixed_ips": ips})
self.args2body_secgroup(parsed_args, body["port"])
self.args2body_extradhcpopt(parsed_args, body["port"])
return body
def _test_network_gateway_create(self, resolve_neutron=True):
rsrc = self.prepare_create_network_gateway(resolve_neutron)
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'6af055d3-26f6-48dd-a597-7611d7e58d35'
).MultipleTimes().AndReturn(
'6af055d3-26f6-48dd-a597-7611d7e58d35')
neutronclient.Client.disconnect_network_gateway(
'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', {
'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'segmentation_id': 10,
'segmentation_type': u'vlan'
}
).AndReturn(None)
neutronclient.Client.disconnect_network_gateway(
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', {
'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'segmentation_id': 10,
'segmentation_type': u'vlan'
}
).AndReturn(qe.NeutronClientException(status_code=404))
neutronclient.Client.delete_network_gateway(
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37'
).AndReturn(None)
neutronclient.Client.show_network_gateway(
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37'
).AndReturn(sng)
neutronclient.Client.show_network_gateway(
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37'
).AndRaise(qe.NeutronClientException(status_code=404))
neutronclient.Client.delete_network_gateway(
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37'
).AndRaise(qe.NeutronClientException(status_code=404))
self.m.ReplayAll()
rsrc.validate()
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
ref_id = rsrc.FnGetRefId()
self.assertEqual(u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', ref_id)
self.assertRaises(
exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Foo')
self.assertIsNone(scheduler.TaskRunner(rsrc.delete)())
self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state)
rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again')
scheduler.TaskRunner(rsrc.delete)()
self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state)
self.m.VerifyAll()
def find(self, id_or_name, ref_only=False):
service = None
ref = None
if isinstance(self, Key):
service = self._agent.client.compute.keypairs
if isinstance(self, Image):
service = self._agent.client.compute.images
elif isinstance(self, Server):
service = self._agent.client.compute.servers
elif isinstance(self, Flavor):
service = self._agent.client.compute.flavors
elif isinstance(self, Volume):
service = self._agent.client.volume.volumes
elif isinstance(self, SecurityGroup):
service = self._agent.client.compute.security_groups
elif isinstance(self, Network):
service = self._agent.client.compute.networks
elif isinstance(self, SubNet):
sid = neutronV20.find_resourceid_by_name_or_id(
self._agent.clientneutron, "subnet", id_or_name)
ref = self._agent.clientneutron.show_subnet(sid)
elif isinstance(self, Router):
rid = neutronV20.find_resourceid_by_name_or_id(
self._agent.clientneutron, "router", id_or_name)
ref = self._agent.clientneutron.show_router(rid)
if service:
ref = utils.find_resource(service, id_or_name)
if ref_only:
return ref
self._ref = ref
return self
def args2body(self, parsed_args):
_network_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'network', parsed_args.network_id)
body = {'subnet': {'network_id': _network_id,
'ip_version': parsed_args.ip_version, }, }
if parsed_args.cidr:
# With subnetpool, cidr is now optional for creating subnet.
cidr = parsed_args.cidr
body['subnet'].update({'cidr': cidr})
unusable_cidr = '/32' if parsed_args.ip_version == 4 else '/128'
if cidr.endswith(unusable_cidr):
self.log.warning(_("An IPv%(ip)d subnet with a %(cidr)s CIDR "
"will have only one usable IP address so "
"the device attached to it will not have "
"any IP connectivity.")
% {"ip": parsed_args.ip_version,
"cidr": unusable_cidr})
if parsed_args.prefixlen:
body['subnet'].update({'prefixlen': parsed_args.prefixlen})
if parsed_args.subnetpool:
if parsed_args.subnetpool == 'None':
_subnetpool_id = None
else:
_subnetpool_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'subnetpool', parsed_args.subnetpool)
body['subnet'].update({'subnetpool_id': _subnetpool_id})
updatable_args2body(parsed_args, body)
if parsed_args.tenant_id:
body['subnet'].update({'tenant_id': parsed_args.tenant_id})
return body
def run(self, parsed_args):
self.log.debug('run(%s)' % parsed_args)
neutron_client = self.get_client()
neutron_client.format = parsed_args.request_format
_router_id = neutronV20.find_resourceid_by_name_or_id(
neutron_client, self.resource, parsed_args.router)
_ext_net_id = neutronV20.find_resourceid_by_name_or_id(
neutron_client, 'network', parsed_args.external_network)
router_dict = {'network_id': _ext_net_id}
if parsed_args.disable_snat:
router_dict['enable_snat'] = False
if parsed_args.fixed_ip:
ips = []
for ip_spec in parsed_args.fixed_ip:
ip_dict = utils.str2dict(ip_spec)
subnet_name_id = ip_dict.get('subnet_id')
if subnet_name_id:
subnet_id = neutronV20.find_resourceid_by_name_or_id(
neutron_client, 'subnet', subnet_name_id)
ip_dict['subnet_id'] = subnet_id
ips.append(ip_dict)
router_dict['external_fixed_ips'] = ips
neutron_client.add_gateway_router(_router_id, router_dict)
print(_('Set gateway for router %s') % parsed_args.router,
file=self.app.stdout)
def _mock_create_with_security_groups(self, port_prop):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'net1234',
cmd_resource=None,
).MultipleTimes().AndReturn('net1234')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'subnet',
'sub1234',
cmd_resource=None,
).MultipleTimes().AndReturn('sub1234')
neutronclient.Client.create_port({'port': port_prop}).AndReturn(
{'port': {
"status": "BUILD",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"}})
neutronclient.Client.show_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766'
).AndReturn({'port': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}})
self.m.ReplayAll()
def test_gateway_router(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'fc68ea2c-b60b-4b4f-bd82-94ec81110766',
cmd_resource=None,
).MultipleTimes().AndReturn('fc68ea2c-b60b-4b4f-bd82-94ec81110766')
neutronclient.Client.add_gateway_router(
'3e46229d-8fce-4733-819a-b5fe630550f8',
{'network_id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766'}
).AndReturn(None)
neutronclient.Client.remove_gateway_router(
'3e46229d-8fce-4733-819a-b5fe630550f8'
).AndReturn(None)
neutronclient.Client.remove_gateway_router(
'3e46229d-8fce-4733-819a-b5fe630550f8'
).AndRaise(qe.NeutronClientException(status_code=404))
self.stub_RouterConstraint_validate()
self.m.ReplayAll()
t = template_format.parse(neutron_template)
stack = utils.parse_stack(t)
rsrc = self.create_gateway_router(
t, stack, 'gateway', properties={
'router_id': '3e46229d-8fce-4733-819a-b5fe630550f8',
'network': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766'
})
scheduler.TaskRunner(rsrc.delete)()
rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again')
scheduler.TaskRunner(rsrc.delete)()
self.m.VerifyAll()
def test_vnic_create_update(self):
port_prop = {
'network_id': u'net1234',
'fixed_ips': [{
'subnet_id': u'sub1234',
'ip_address': u'10.0.3.21'
}],
'name': utils.PhysName('test_stack', 'port'),
'admin_state_up': True,
'device_owner': 'network:dhcp',
'binding:vnic_type': 'direct'
}
new_port_prop = port_prop.copy()
new_port_prop['binding:vnic_type'] = 'normal'
new_port_prop['name'] = "new_name"
new_port_prop['security_groups'] = [
'8a2f582a-e1cd-480f-b85d-b02631c10656'
]
new_port_prop.pop('network_id')
prop_update = new_port_prop.copy()
new_port_prop['replacement_policy'] = 'AUTO'
new_port_prop['network'] = u'net1234'
neutronV20.find_resourceid_by_name_or_id(mox.IsA(
neutronclient.Client), 'network', 'net1234').AndReturn('net1234')
neutronV20.find_resourceid_by_name_or_id(mox.IsA(
neutronclient.Client), 'subnet', 'sub1234').AndReturn('sub1234')
neutronclient.Client.create_port({
'port': port_prop
}).AndReturn({
'port': {
"status": "BUILD",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
neutronclient.Client.show_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn({
'port': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
self.stub_SubnetConstraint_validate()
self.stub_NetworkConstraint_validate()
neutronclient.Client.update_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {
'port': prop_update
}).AndReturn(None)
neutronclient.Client.show_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn({
'port': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
prop_update2 = prop_update.copy()
prop_update2['binding:vnic_type'] = 'direct'
neutronclient.Client.update_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {
'port': prop_update2
}).AndReturn(None)
neutronclient.Client.show_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn({
'port': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
self.m.ReplayAll()
t = template_format.parse(neutron_port_template)
t['resources']['port']['properties']['binding:vnic_type'] = 'direct'
stack = utils.parse_stack(t)
port = stack['port']
scheduler.TaskRunner(port.create)()
self.assertEqual('direct', port.properties['binding:vnic_type'])
# update to normal
update_snippet = rsrc_defn.ResourceDefinition(port.name, port.type(),
new_port_prop)
scheduler.TaskRunner(port.update, update_snippet)()
self.assertEqual((port.UPDATE, port.COMPLETE), port.state)
self.assertEqual('normal', port.properties['binding:vnic_type'])
# update back to direct
new_port_prop['binding:vnic_type'] = 'direct'
update_snippet = rsrc_defn.ResourceDefinition(port.name, port.type(),
new_port_prop)
scheduler.TaskRunner(port.update, update_snippet)()
self.assertEqual((port.UPDATE, port.COMPLETE), port.state)
self.assertEqual('direct', port.properties['binding:vnic_type'])
self.m.VerifyAll()
def validate_with_client(self, client, value):
neutron_client = client.client('neutron')
neutronV20.find_resourceid_by_name_or_id(
neutron_client, 'subnet', value)
def test_update_router_gateway_as_property(self):
self._create_router_with_gateway()
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'other_public',
cmd_resource=None,
).AndReturn('91e47a57-7508-46fe-afc9-fc454e8580e1')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'fc68ea2c-b60b-4b4f-bd82-94ec81110766',
cmd_resource=None,
).AndReturn('fc68ea2c-b60b-4b4f-bd82-94ec81110766')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'subnet',
'sub1234',
cmd_resource=None,
).AndReturn('sub1234')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'91e47a57-7508-46fe-afc9-fc454e8580e1',
cmd_resource=None,
).AndReturn('91e47a57-7508-46fe-afc9-fc454e8580e1')
neutronclient.Client.update_router(
'3e46229d-8fce-4733-819a-b5fe630550f8', {
'router': {
"external_gateway_info": {
'network_id': '91e47a57-7508-46fe-afc9-fc454e8580e1',
'enable_snat': False
},
}
}).AndReturn(None)
neutronclient.Client.show_router(
'3e46229d-8fce-4733-819a-b5fe630550f8').AndReturn({
"router": {
"status": "ACTIVE",
"external_gateway_info": {
"network_id": "91e47a57-7508-46fe-afc9-fc454e8580e1",
"enable_snat": False
},
"name": "Test Router",
"admin_state_up": True,
"tenant_id": "3e21026f2dc94372b105808c0e721661",
"routes": [],
"id": "3e46229d-8fce-4733-819a-b5fe630550f8"
}
})
self.m.ReplayAll()
t = template_format.parse(neutron_external_gateway_template)
stack = utils.parse_stack(t)
rsrc = self.create_router(t, stack, 'router')
props = t['resources']['router']['properties'].copy()
props['external_gateway_info'] = {
"network": "other_public",
"enable_snat": False
}
update_template = rsrc.t.freeze(properties=props)
scheduler.TaskRunner(rsrc.update, update_template)()
self.assertEqual((rsrc.UPDATE, rsrc.COMPLETE), rsrc.state)
gateway_info = rsrc.FnGetAtt('external_gateway_info')
self.assertEqual('91e47a57-7508-46fe-afc9-fc454e8580e1',
gateway_info.get('network_id'))
self.assertFalse(gateway_info.get('enable_snat'))
self.m.VerifyAll()
def test_router_interface_validate(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'port',
'9577cafd-8e98-4059-a2e6-8a771b4d318e',
cmd_resource=None,
).MultipleTimes().AndReturn('9577cafd-8e98-4059-a2e6-8a771b4d318e')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'router',
'ae478782-53c0-4434-ab16-49900c88016c',
cmd_resource=None,
).MultipleTimes().AndReturn('ae478782-53c0-4434-ab16-49900c88016c')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'subnet',
'9577cafd-8e98-4059-a2e6-8a771b4d318e',
cmd_resource=None,
).MultipleTimes().AndReturn('9577cafd-8e98-4059-a2e6-8a771b4d318e')
self.m.ReplayAll()
t = template_format.parse(neutron_template)
json = t['resources']['router_interface']
json['properties'] = {
'router_id': 'ae478782-53c0-4434-ab16-49900c88016c',
'subnet_id': '9577cafd-8e98-4059-a2e6-8a771b4d318e',
'port_id': '9577cafd-8e98-4059-a2e6-8a771b4d318e'
}
stack = utils.parse_stack(t)
resource_defns = stack.t.resource_definitions(stack)
res = router.RouterInterface('router_interface',
resource_defns['router_interface'], stack)
self.assertRaises(exception.ResourcePropertyConflict, res.validate)
json['properties'] = {
'router_id': 'ae478782-53c0-4434-ab16-49900c88016c',
'port_id': '9577cafd-8e98-4059-a2e6-8a771b4d318e'
}
stack = utils.parse_stack(t)
resource_defns = stack.t.resource_definitions(stack)
res = router.RouterInterface('router_interface',
resource_defns['router_interface'], stack)
self.assertIsNone(res.validate())
json['properties'] = {
'router_id': 'ae478782-53c0-4434-ab16-49900c88016c',
'subnet_id': '9577cafd-8e98-4059-a2e6-8a771b4d318e'
}
stack = utils.parse_stack(t)
resource_defns = stack.t.resource_definitions(stack)
res = router.RouterInterface('router_interface',
resource_defns['router_interface'], stack)
self.assertIsNone(res.validate())
json['properties'] = {
'router_id': 'ae478782-53c0-4434-ab16-49900c88016c'
}
stack = utils.parse_stack(t)
resource_defns = stack.t.resource_definitions(stack)
res = router.RouterInterface('router_interface',
resource_defns['router_interface'], stack)
ex = self.assertRaises(exception.PropertyUnspecifiedError,
res.validate)
self.assertEqual(
"At least one of the following properties "
"must be specified: subnet, port.", six.text_type(ex))
self.m.VerifyAll()
def get_qos_policy_id(client, policy_id_or_name):
_policy_id = neutronv20.find_resourceid_by_name_or_id(
client, 'policy', policy_id_or_name, cmd_resource='qos_policy')
return _policy_id
def _get_pool_id(client, pool_id_or_name):
return neutronV20.find_resourceid_by_name_or_id(client,
'pool',
pool_id_or_name,
cmd_resource='lbaas_pool')
def _get_loadbalancer_id(client, lb_id_or_name):
return neutronV20.find_resourceid_by_name_or_id(
client,
'loadbalancer',
lb_id_or_name,
cmd_resource='lbaas_loadbalancer')
def test_create_and_update_port(self):
props = {
'network_id': u'net1234',
'name': utils.PhysName('test_stack', 'port'),
'admin_state_up': True,
'device_owner': u'network:dhcp'
}
new_props = props.copy()
new_props['name'] = "new_name"
new_props['security_groups'] = ['8a2f582a-e1cd-480f-b85d-b02631c10656']
new_props_update = new_props.copy()
new_props_update.pop('network_id')
new_props1 = new_props.copy()
new_props1.pop('security_groups')
new_props_update1 = new_props_update.copy()
new_props_update1['security_groups'] = [
'0389f747-7785-4757-b7bb-2ab07e4b09c3'
]
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), 'network',
'net1234').MultipleTimes().AndReturn('net1234')
neutronclient.Client.create_port({
'port': props
}).AndReturn({
'port': {
"status": "BUILD",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
neutronclient.Client.show_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn({
'port': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766",
"fixed_ips": {
"subnet_id": "d0e971a6-a6b4-4f4c-8c88-b75e9c120b7e",
"ip_address": "10.0.0.2"
}
}
})
neutronclient.Client.update_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {
'port': new_props_update
}).AndReturn(None)
fake_groups_list = {
'security_groups': [{
'tenant_id': 'dc4b074874244f7693dd65583733a758',
'id': '0389f747-7785-4757-b7bb-2ab07e4b09c3',
'name': 'default',
'security_group_rules': [],
'description': 'no protocol'
}]
}
self.m.StubOutWithMock(neutronclient.Client, 'list_security_groups')
neutronclient.Client.list_security_groups().AndReturn(fake_groups_list)
neutronclient.Client.update_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {
'port': new_props_update1
}).AndReturn(None)
self.m.ReplayAll()
# create port
t = template_format.parse(neutron_port_template)
t['resources']['port']['properties'].pop('fixed_ips')
stack = utils.parse_stack(t)
port = stack['port']
scheduler.TaskRunner(port.create)()
# update port
update_snippet = rsrc_defn.ResourceDefinition(port.name, port.type(),
new_props)
self.assertIsNone(port.handle_update(update_snippet, {}, {}))
# update again to test port without security group
update_snippet = rsrc_defn.ResourceDefinition(port.name, port.type(),
new_props1)
self.assertIsNone(port.handle_update(update_snippet, {}, {}))
self.m.VerifyAll()
def get_port_pair_id(client, id_or_name):
return neutronv20.find_resourceid_by_name_or_id(client, PORT_PAIR_RESOURCE,
id_or_name)
def test_get_port_attributes(self):
subnet_dict = {
'name': 'test-subnet',
'enable_dhcp': True,
'network_id': 'net1234',
'dns_nameservers': [],
'tenant_id': '58a61fc3992944ce971404a2ece6ff98',
'ipv6_ra_mode': None,
'cidr': '10.0.0.0/24',
'allocation_pools': [{
'start': '10.0.0.2',
'end': u'10.0.0.254'
}],
'gateway_ip': '10.0.0.1',
'ipv6_address_mode': None,
'ip_version': 4,
'host_routes': [],
'id': '6dd609ad-d52a-4587-b1a0-b335f76062a5'
}
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), 'network',
'net1234').MultipleTimes().AndReturn('net1234')
neutronclient.Client.create_port({
'port': {
'network_id': u'net1234',
'name': utils.PhysName('test_stack', 'port'),
'admin_state_up': True,
'device_owner': u'network:dhcp'
}
}).AndReturn({
'port': {
'status': 'BUILD',
'id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766'
}
})
neutronclient.Client.show_subnet(
'd0e971a6-a6b4-4f4c-8c88-b75e9c120b7e').AndReturn(
{'subnet': subnet_dict})
neutronclient.Client.show_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').MultipleTimes().AndReturn({
'port': {
'status':
'DOWN',
'name':
utils.PhysName('test_stack', 'port'),
'allowed_address_pairs': [],
'admin_state_up':
True,
'network_id':
'net1234',
'device_id':
'dc68eg2c-b60g-4b3f-bd82-67ec87650532',
'mac_address':
'fa:16:3e:75:67:60',
'tenant_id':
'58a61fc3992944ce971404a2ece6ff98',
'security_groups':
['5b15d80c-6b70-4a1c-89c9-253538c5ade6'],
'fixed_ips': [{
'subnet_id': 'd0e971a6-a6b4-4f4c-8c88-b75e9c120b7e',
'ip_address': '10.0.0.2'
}]
}
})
self.m.ReplayAll()
t = template_format.parse(neutron_port_template)
t['resources']['port']['properties'].pop('fixed_ips')
stack = utils.parse_stack(t)
port = stack['port']
scheduler.TaskRunner(port.create)()
self.assertEqual('DOWN', port.FnGetAtt('status'))
self.assertEqual([], port.FnGetAtt('allowed_address_pairs'))
self.assertEqual(True, port.FnGetAtt('admin_state_up'))
self.assertEqual('net1234', port.FnGetAtt('network_id'))
self.assertEqual('fa:16:3e:75:67:60', port.FnGetAtt('mac_address'))
self.assertEqual(utils.PhysName('test_stack', 'port'),
port.FnGetAtt('name'))
self.assertEqual('dc68eg2c-b60g-4b3f-bd82-67ec87650532',
port.FnGetAtt('device_id'))
self.assertEqual('58a61fc3992944ce971404a2ece6ff98',
port.FnGetAtt('tenant_id'))
self.assertEqual(['5b15d80c-6b70-4a1c-89c9-253538c5ade6'],
port.FnGetAtt('security_groups'))
self.assertEqual([{
'subnet_id': 'd0e971a6-a6b4-4f4c-8c88-b75e9c120b7e',
'ip_address': '10.0.0.2'
}], port.FnGetAtt('fixed_ips'))
self.assertEqual([subnet_dict], port.FnGetAtt('subnets'))
self.assertRaises(exception.InvalidTemplateAttribute, port.FnGetAtt,
'Foo')
self.m.VerifyAll()
def test_floatip_association_port(self):
t = template_format.parse(neutron_floating_template)
stack = utils.parse_stack(t)
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'abcd1234',
cmd_resource=None,
).MultipleTimes().AndReturn('abcd1234')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'subnet',
'sub1234',
cmd_resource=None,
).MultipleTimes().AndReturn('sub1234')
neutronclient.Client.create_floatingip({
'floatingip': {
'floating_network_id': u'abcd1234'
}
}).AndReturn({
'floatingip': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
neutronclient.Client.create_port({
'port': {
'network_id':
u'abcd1234',
'fixed_ips': [{
'subnet_id': u'sub1234',
'ip_address': u'10.0.0.10'
}],
'name':
utils.PhysName(stack.name, 'port_floating'),
'admin_state_up':
True
}
}).AndReturn({
'port': {
"status": "BUILD",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
neutronclient.Client.show_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn({
'port': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
# create as
neutronclient.Client.update_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {
'floatingip': {
'port_id': u'fc68ea2c-b60b-4b4f-bd82-94ec81110766'
}
}).AndReturn({
'floatingip': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
# update as with port_id
neutronclient.Client.update_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {
'floatingip': {
'port_id': u'2146dfbf-ba77-4083-8e86-d052f671ece5',
'fixed_ip_address': None
}
}).AndReturn({
'floatingip': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
# update as with floatingip_id
neutronclient.Client.update_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {
'floatingip': {
'port_id': None
}
}).AndReturn(None)
neutronclient.Client.update_floatingip(
'2146dfbf-ba77-4083-8e86-d052f671ece5', {
'floatingip': {
'port_id': u'2146dfbf-ba77-4083-8e86-d052f671ece5',
'fixed_ip_address': None
}
}).AndReturn({
'floatingip': {
"status": "ACTIVE",
"id": "2146dfbf-ba77-4083-8e86-d052f671ece5"
}
})
# update as with both
neutronclient.Client.update_floatingip(
'2146dfbf-ba77-4083-8e86-d052f671ece5', {
'floatingip': {
'port_id': None
}
}).AndReturn(None)
neutronclient.Client.update_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {
'floatingip': {
'port_id': u'ade6fcac-7d47-416e-a3d7-ad12efe445c1',
'fixed_ip_address': None
}
}).AndReturn({
'floatingip': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
# delete as
neutronclient.Client.update_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {
'floatingip': {
'port_id': None
}
}).AndReturn(None)
neutronclient.Client.delete_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn(None)
neutronclient.Client.show_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndRaise(
qe.PortNotFoundClient(status_code=404))
neutronclient.Client.delete_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn(None)
neutronclient.Client.show_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndRaise(
qe.NeutronClientException(status_code=404))
neutronclient.Client.delete_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndRaise(
qe.PortNotFoundClient(status_code=404))
neutronclient.Client.delete_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndRaise(
qe.NeutronClientException(status_code=404))
self.stub_PortConstraint_validate()
self.m.ReplayAll()
fip = stack['floating_ip']
scheduler.TaskRunner(fip.create)()
self.assertEqual((fip.CREATE, fip.COMPLETE), fip.state)
p = stack['port_floating']
scheduler.TaskRunner(p.create)()
self.assertEqual((p.CREATE, p.COMPLETE), p.state)
fipa = stack['floating_ip_assoc']
scheduler.TaskRunner(fipa.create)()
self.assertEqual((fipa.CREATE, fipa.COMPLETE), fipa.state)
self.assertIsNotNone(fipa.id)
self.assertEqual(fipa.id, fipa.resource_id)
fipa.validate()
# test update FloatingIpAssociation with port_id
props = copy.deepcopy(fipa.properties.data)
update_port_id = '2146dfbf-ba77-4083-8e86-d052f671ece5'
props['port_id'] = update_port_id
update_snippet = rsrc_defn.ResourceDefinition(
fipa.name, fipa.type(), stack.t.parse(stack, props))
scheduler.TaskRunner(fipa.update, update_snippet)()
self.assertEqual((fipa.UPDATE, fipa.COMPLETE), fipa.state)
# test update FloatingIpAssociation with floatingip_id
props = copy.deepcopy(fipa.properties.data)
update_flip_id = '2146dfbf-ba77-4083-8e86-d052f671ece5'
props['floatingip_id'] = update_flip_id
update_snippet = rsrc_defn.ResourceDefinition(fipa.name, fipa.type(),
props)
scheduler.TaskRunner(fipa.update, update_snippet)()
self.assertEqual((fipa.UPDATE, fipa.COMPLETE), fipa.state)
# test update FloatingIpAssociation with port_id and floatingip_id
props = copy.deepcopy(fipa.properties.data)
update_flip_id = 'fc68ea2c-b60b-4b4f-bd82-94ec81110766'
update_port_id = 'ade6fcac-7d47-416e-a3d7-ad12efe445c1'
props['floatingip_id'] = update_flip_id
props['port_id'] = update_port_id
update_snippet = rsrc_defn.ResourceDefinition(fipa.name, fipa.type(),
props)
scheduler.TaskRunner(fipa.update, update_snippet)()
self.assertEqual((fipa.UPDATE, fipa.COMPLETE), fipa.state)
scheduler.TaskRunner(fipa.delete)()
scheduler.TaskRunner(p.delete)()
scheduler.TaskRunner(fip.delete)()
fip.state_set(fip.CREATE, fip.COMPLETE, 'to delete again')
p.state_set(p.CREATE, p.COMPLETE, 'to delete again')
self.assertIsNone(scheduler.TaskRunner(p.delete)())
scheduler.TaskRunner(fip.delete)()
self.m.VerifyAll()
def remove_from_instance(self, context, instance, security_group_name):
"""Remove the security group associated with the instance."""
neutron = neutronv2.get_client(context)
try:
security_group_id = neutronv20.find_resourceid_by_name_or_id(
neutron, 'security_group', security_group_name)
except n_exc.NeutronClientException as e:
exc_info = sys.exc_info()
if e.status_code == 404:
msg = (_("Security group %(name)s is not found for "
"project %(project)s") % {
'name': security_group_name,
'project': context.project_id
})
self.raise_not_found(msg)
else:
LOG.exception(_("Neutron Error:"))
raise exc_info[0], exc_info[1], exc_info[2]
params = {'device_id': instance['uuid']}
try:
ports = neutron.list_ports(**params).get('ports')
except n_exc.NeutronClientException:
with excutils.save_and_reraise_exception():
LOG.exception(_("Neutron Error:"))
if not ports:
msg = (_("instance_id %s could not be found as device id on"
" any ports") % instance['uuid'])
self.raise_not_found(msg)
found_security_group = False
for port in ports:
try:
port.get('security_groups', []).remove(security_group_id)
except ValueError:
# When removing a security group from an instance the security
# group should be on both ports since it was added this way if
# done through the nova api. In case it is not a 404 is only
# raised if the security group is not found on any of the
# ports on the instance.
continue
updated_port = {'security_groups': port['security_groups']}
try:
LOG.info(
_("Adding security group %(security_group_id)s to "
"port %(port_id)s"), {
'security_group_id': security_group_id,
'port_id': port['id']
})
neutron.update_port(port['id'], {'port': updated_port})
found_security_group = True
except Exception:
with excutils.save_and_reraise_exception():
LOG.exception(_("Neutron Error:"))
if not found_security_group:
msg = (_("Security group %(security_group_name)s not associated "
"with the instance %(instance)s") % {
'security_group_name': security_group_name,
'instance': instance['uuid']
})
self.raise_not_found(msg)
def _resolv_sgid(self, secgroup):
return neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'security_group', secgroup)
def test_floatip_port(self):
t = template_format.parse(neutron_floating_no_assoc_template)
t['resources']['port_floating']['properties']['network'] = "xyz1234"
t['resources']['port_floating']['properties']['fixed_ips'][0][
'subnet'] = "sub1234"
t['resources']['router_interface']['properties']['subnet'] = "sub1234"
stack = utils.parse_stack(t)
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'xyz1234',
cmd_resource=None,
).MultipleTimes().AndReturn('xyz1234')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'subnet',
'sub1234',
cmd_resource=None,
).MultipleTimes().AndReturn('sub1234')
neutronclient.Client.create_port({
'port': {
'network_id':
u'xyz1234',
'fixed_ips': [{
'subnet_id': u'sub1234',
'ip_address': u'10.0.0.10'
}],
'name':
utils.PhysName(stack.name, 'port_floating'),
'admin_state_up':
True
}
}).AndReturn({
'port': {
"status": "BUILD",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
neutronclient.Client.show_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn({
'port': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'abcd1234',
cmd_resource=None,
).MultipleTimes().AndReturn('abcd1234')
neutronclient.Client.create_floatingip({
'floatingip': {
'floating_network_id': u'abcd1234',
'port_id': u'fc68ea2c-b60b-4b4f-bd82-94ec81110766'
}
}).AndReturn({
'floatingip': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
# update with new port_id
neutronclient.Client.update_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {
'floatingip': {
'port_id': u'2146dfbf-ba77-4083-8e86-d052f671ece5',
'fixed_ip_address': None
}
}).AndReturn({
'floatingip': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
# update with None port_id
neutronclient.Client.update_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766', {
'floatingip': {
'port_id': None,
'fixed_ip_address': None
}
}).AndReturn({
'floatingip': {
"status": "ACTIVE",
"id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766"
}
})
neutronclient.Client.delete_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn(None)
neutronclient.Client.show_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndRaise(
qe.NeutronClientException(status_code=404))
neutronclient.Client.delete_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn(None)
neutronclient.Client.show_port(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndRaise(
qe.PortNotFoundClient(status_code=404))
self.stub_PortConstraint_validate()
self.m.ReplayAll()
# check dependencies for fip resource
required_by = set(
stack.dependencies.required_by(stack['router_interface']))
self.assertIn(stack['floating_ip'], required_by)
p = stack['port_floating']
scheduler.TaskRunner(p.create)()
self.assertEqual((p.CREATE, p.COMPLETE), p.state)
fip = stack['floating_ip']
scheduler.TaskRunner(fip.create)()
self.assertEqual((fip.CREATE, fip.COMPLETE), fip.state)
# test update FloatingIp with port_id
props = copy.deepcopy(fip.properties.data)
update_port_id = '2146dfbf-ba77-4083-8e86-d052f671ece5'
props['port_id'] = update_port_id
update_snippet = rsrc_defn.ResourceDefinition(
fip.name, fip.type(), stack.t.parse(stack, props))
scheduler.TaskRunner(fip.update, update_snippet)()
self.assertEqual((fip.UPDATE, fip.COMPLETE), fip.state)
# test update FloatingIp with None port_id
props = copy.deepcopy(fip.properties.data)
del (props['port_id'])
update_snippet = rsrc_defn.ResourceDefinition(
fip.name, fip.type(), stack.t.parse(stack, props))
scheduler.TaskRunner(fip.update, update_snippet)()
self.assertEqual((fip.UPDATE, fip.COMPLETE), fip.state)
scheduler.TaskRunner(fip.delete)()
scheduler.TaskRunner(p.delete)()
self.m.VerifyAll()
def test_network_gateway_update(self):
rsrc = self.prepare_create_network_gateway()
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), 'network',
'6af055d3-26f6-48dd-a597-7611d7e58d35').AndReturn(
'6af055d3-26f6-48dd-a597-7611d7e58d35')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), 'network',
'6af055d3-26f6-48dd-a597-7611d7e58d35').AndReturn(
'6af055d3-26f6-48dd-a597-7611d7e58d35')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), 'network',
'6af055d3-26f6-48dd-a597-7611d7e58d35').AndReturn(
'6af055d3-26f6-48dd-a597-7611d7e58d35')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), 'network',
'6af055d3-26f6-48dd-a597-7611d7e58d35').AndReturn(
'6af055d3-26f6-48dd-a597-7611d7e58d35')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), 'network',
'6af055d3-26f6-48dd-a597-7611d7e58d35').AndReturn(
'6af055d3-26f6-48dd-a597-7611d7e58d35')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), 'network',
'6af055d3-26f6-48dd-a597-7611d7e58d35').AndReturn(
'6af055d3-26f6-48dd-a597-7611d7e58d35')
neutronclient.Client.update_network_gateway(
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', {
'network_gateway': {
'name': u'NetworkGatewayUpdate'
}
}).AndReturn(None)
neutronclient.Client.disconnect_network_gateway(
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', {
'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'segmentation_id': 10,
'segmentation_type': u'vlan'
}).AndReturn(None)
neutronclient.Client.connect_network_gateway(
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', {
'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'segmentation_id': 0,
'segmentation_type': u'flat'
}).AndReturn({
'connection_info': {
'network_gateway_id':
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37',
'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'port_id': u'aa800972-f6be-4c65-8453-9ab31834bf80'
}
})
neutronclient.Client.disconnect_network_gateway(
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', {
'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'segmentation_id': 10,
'segmentation_type': u'vlan'
}).AndRaise(qe.NeutronClientException(status_code=404))
neutronclient.Client.connect_network_gateway(
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', {
'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'segmentation_id': 0,
'segmentation_type': u'flat'
}).AndReturn({
'connection_info': {
'network_gateway_id':
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37',
'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'port_id': u'aa800972-f6be-4c65-8453-9ab31834bf80'
}
})
neutronclient.Client.disconnect_network_gateway(
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', {
'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'segmentation_id': 10,
'segmentation_type': u'vlan'
}).AndReturn(None)
neutronclient.Client.delete_network_gateway(
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37').AndReturn(None)
neutronclient.Client.create_network_gateway({
'network_gateway': {
'name':
u'NetworkGateway',
'devices': [{
'id': u'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb',
'interface_name': u'breth2'
}]
}
}).AndReturn({
'network_gateway': {
'id':
'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37',
'name':
'NetworkGateway',
'default':
False,
'tenant_id':
'96ba52dc-c5c5-44c6-9a9d-d3ba1a03f77f',
'devices': [{
'id': 'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb',
'interface_name': 'breth2'
}]
}
})
neutronclient.Client.connect_network_gateway(
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', {
'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'segmentation_id': 10,
'segmentation_type': u'vlan'
}).AndReturn({
'connection_info': {
'network_gateway_id':
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37',
'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'port_id': u'aa800972-f6be-4c65-8453-9ab31834bf80'
}
})
self.m.ReplayAll()
rsrc.validate()
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
# update name
snippet_for_update = rsrc_defn.ResourceDefinition(
rsrc.name, rsrc.type(), {
'name':
u'NetworkGatewayUpdate',
'devices': [{
'id': u'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb',
'interface_name': u'breth1'
}],
'connections': [{
'network': '6af055d3-26f6-48dd-a597-7611d7e58d35',
'segmentation_type': 'vlan',
'segmentation_id': 10
}]
})
prop_diff = {'name': u'NetworkGatewayUpdate'}
self.assertIsNone(
rsrc.handle_update(snippet_for_update, mox.IgnoreArg(), prop_diff))
# update connections
snippet_for_update = rsrc_defn.ResourceDefinition(
rsrc.name, rsrc.type(), {
'name':
u'NetworkGateway',
'devices': [{
'id': u'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb',
'interface_name': u'breth1'
}],
'connections': [{
'network': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'segmentation_type': u'flat',
'segmentation_id': 0
}]
})
prop_diff = {
'connections': [{
'network': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'segmentation_type': u'flat',
'segmentation_id': 0
}]
}
self.assertIsNone(
rsrc.handle_update(snippet_for_update, mox.IgnoreArg(), prop_diff))
# update connections once more
self.assertIsNone(
rsrc.handle_update(snippet_for_update, mox.IgnoreArg(), prop_diff))
# update devices
snippet_for_update = rsrc_defn.ResourceDefinition(
rsrc.name, rsrc.type(), {
'name':
u'NetworkGateway',
'devices': [{
'id': u'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb',
'interface_name': u'breth2'
}],
'connections': [{
'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'segmentation_type': u'vlan',
'segmentation_id': 10
}]
})
prop_diff = {
'devices': [{
'id': u'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb',
'interface_name': u'breth2'
}]
}
self.assertIsNone(
rsrc.handle_update(snippet_for_update, mox.IgnoreArg(), prop_diff))
self.m.VerifyAll()
def _test_floating_ip(self, tmpl, r_iface=True):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'abcd1234',
cmd_resource=None,
).MultipleTimes().AndReturn('abcd1234')
neutronclient.Client.create_floatingip({
'floatingip': {
'floating_network_id': u'abcd1234'
}
}).AndReturn({
'floatingip': {
'id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766',
'floating_network_id': u'abcd1234'
}
})
neutronclient.Client.show_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndRaise(
qe.NeutronClientException(status_code=404))
neutronclient.Client.show_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn({
'floatingip': {
'id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766',
'floating_network_id': u'abcd1234'
}
})
neutronclient.Client.show_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn({
'floatingip': {
'id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766',
'floating_network_id': u'abcd1234'
}
})
timeutils.retry_backoff_delay(1, jitter_max=2.0).AndReturn(0.01)
neutronclient.Client.delete_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn(None)
neutronclient.Client.show_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn({
'floatingip': {
'id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766',
'floating_network_id': u'abcd1234'
}
})
neutronclient.Client.delete_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn(None)
neutronclient.Client.show_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndRaise(
qe.NeutronClientException(status_code=404))
neutronclient.Client.delete_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndRaise(
qe.NeutronClientException(status_code=404))
self.stub_NetworkConstraint_validate()
stack = utils.parse_stack(tmpl)
# assert the implicit dependency between the floating_ip
# and the gateway
self.m.ReplayAll()
if r_iface:
required_by = set(
stack.dependencies.required_by(stack['router_interface']))
self.assertIn(stack['floating_ip_assoc'], required_by)
else:
deps = stack.dependencies[stack['gateway']]
self.assertIn(stack['floating_ip'], deps)
fip = stack['floating_ip']
scheduler.TaskRunner(fip.create)()
self.assertEqual((fip.CREATE, fip.COMPLETE), fip.state)
fip.validate()
fip_id = fip.FnGetRefId()
self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766', fip_id)
self.assertIsNone(fip.FnGetAtt('show'))
self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766',
fip.FnGetAtt('show')['id'])
self.assertRaises(exception.InvalidTemplateAttribute, fip.FnGetAtt,
'Foo')
self.assertEqual(u'abcd1234', fip.FnGetAtt('floating_network_id'))
scheduler.TaskRunner(fip.delete)()
fip.state_set(fip.CREATE, fip.COMPLETE, 'to delete again')
scheduler.TaskRunner(fip.delete)()
self.m.VerifyAll()
def test_subnet_disable_dhcp(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'fc68ea2c-b60b-4b4f-bd82-94ec81110766',
cmd_resource=None,
).AndReturn('fc68ea2c-b60b-4b4f-bd82-94ec81110766')
neutronclient.Client.create_subnet({
'subnet': {
'name':
utils.PhysName('test_stack', 'test_subnet'),
'network_id':
u'fc68ea2c-b60b-4b4f-bd82-94ec81110766',
'dns_nameservers': [u'8.8.8.8'],
'allocation_pools': [{
'start': u'10.0.3.20',
'end': u'10.0.3.150'
}],
'host_routes': [{
'destination': u'10.0.4.0/24',
'nexthop': u'10.0.3.20'
}],
'ip_version':
4,
'enable_dhcp':
False,
'cidr':
u'10.0.3.0/24',
'tenant_id':
'c1210485b2424d48804aad5d39c61b8f'
}
}).AndReturn({
"subnet": {
"allocation_pools": [{
"start": "10.0.3.20",
"end": "10.0.3.150"
}],
"host_routes": [{
"destination": "10.0.4.0/24",
"nexthop": "10.0.3.20"
}],
"cidr":
"10.0.3.0/24",
"dns_nameservers": ["8.8.8.8"],
"enable_dhcp":
False,
"gateway_ip":
"10.0.3.1",
"id":
"91e47a57-7508-46fe-afc9-fc454e8580e1",
"ip_version":
4,
"name":
"name",
"network_id":
"fc68ea2c-b60b-4b4f-bd82-94ec81110766",
"tenant_id":
"c1210485b2424d48804aad5d39c61b8f"
}
})
neutronclient.Client.show_subnet(
'91e47a57-7508-46fe-afc9-fc454e8580e1').AndReturn({
"subnet": {
"name":
"name",
"network_id":
"fc68ea2c-b60b-4b4f-bd82-94ec81110766",
"tenant_id":
"c1210485b2424d48804aad5d39c61b8f",
"allocation_pools": [{
"start": "10.0.3.20",
"end": "10.0.3.150"
}],
"host_routes": [{
"destination": "10.0.4.0/24",
"nexthop": "10.0.3.20"
}],
"gateway_ip":
"10.0.3.1",
"ip_version":
4,
"cidr":
"10.0.3.0/24",
"dns_nameservers": ["8.8.8.8"],
"id":
"91e47a57-7508-46fe-afc9-fc454e8580e1",
"enable_dhcp":
False,
}
})
neutronclient.Client.delete_subnet(
'91e47a57-7508-46fe-afc9-fc454e8580e1').AndReturn(None)
neutronclient.Client.show_subnet(
'91e47a57-7508-46fe-afc9-fc454e8580e1').AndRaise(
qe.NeutronClientException(status_code=404))
self.m.ReplayAll()
t = template_format.parse(neutron_template)
t['resources']['sub_net']['properties']['enable_dhcp'] = 'False'
stack = utils.parse_stack(t)
self.patchobject(stack['net'],
'FnGetRefId',
return_value='fc68ea2c-b60b-4b4f-bd82-94ec81110766')
rsrc = self.create_subnet(t, stack, 'sub_net')
self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
rsrc.validate()
ref_id = rsrc.FnGetRefId()
self.assertEqual('91e47a57-7508-46fe-afc9-fc454e8580e1', ref_id)
self.assertIs(False, rsrc.FnGetAtt('enable_dhcp'))
scheduler.TaskRunner(rsrc.delete)()
self.m.VerifyAll()
def _find_resource_id(self, tenant_id, resource, name_or_id, cmd_resource):
# tenant id in the signature is used for the memoization key,
# that would differentiate similar resource names across tenants.
return neutronV20.find_resourceid_by_name_or_id(
self.client(), resource, name_or_id, cmd_resource=cmd_resource)
def _find_neutron_resource(neutron_client, props, key, key_type):
return neutronV20.find_resourceid_by_name_or_id(
neutron_client, key_type, props.get(key))
def test_ipv6_subnet(self):
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'fc68ea2c-b60b-4b4f-bd82-94ec81110766',
cmd_resource=None,
).AndReturn('fc68ea2c-b60b-4b4f-bd82-94ec81110766')
neutronclient.Client.create_subnet({
'subnet': {
'name': utils.PhysName('test_stack', 'test_subnet'),
'network_id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766',
'dns_nameservers': [u'2001:4860:4860::8844'],
'ip_version': 6,
'enable_dhcp': True,
'cidr': u'fdfa:6a50:d22b::/64',
'tenant_id': 'c1210485b2424d48804aad5d39c61b8f',
'ipv6_address_mode': 'slaac',
'ipv6_ra_mode': 'slaac'
}
}).AndReturn({
"subnet": {
"allocation_pools": [{
"start":
"fdfa:6a50:d22b::2",
"end":
"fdfa:6a50:d22b:0:ffff:ffff:ffff:fffe"
}],
"cidr":
"fd00:1::/64",
"enable_dhcp":
True,
"gateway_ip":
"fdfa:6a50:d22b::1",
"id":
"91e47a57-7508-46fe-afc9-fc454e8580e1",
"ip_version":
6,
"name":
"name",
"network_id":
"fc68ea2c-b60b-4b4f-bd82-94ec81110766",
"tenant_id":
"c1210485b2424d48804aad5d39c61b8f",
'ipv6_address_mode':
'slaac',
'ipv6_ra_mode':
'slaac'
}
})
self.m.ReplayAll()
t = template_format.parse(neutron_template)
props = t['resources']['sub_net']['properties']
props.pop('allocation_pools')
props.pop('host_routes')
props['ip_version'] = 6
props['ipv6_address_mode'] = 'slaac'
props['ipv6_ra_mode'] = 'slaac'
props['cidr'] = 'fdfa:6a50:d22b::/64'
props['dns_nameservers'] = ['2001:4860:4860::8844']
stack = utils.parse_stack(t)
self.patchobject(stack['net'],
'FnGetRefId',
return_value='fc68ea2c-b60b-4b4f-bd82-94ec81110766')
rsrc = self.create_subnet(t, stack, 'sub_net')
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
rsrc.validate()
self.m.VerifyAll()
def find_resourceid_by_name_or_id(self,
resource,
name_or_id,
cmd_resource=None):
return neutronV20.find_resourceid_by_name_or_id(
self.client(), resource, name_or_id, cmd_resource=cmd_resource)
def test_subnet(self):
update_props = {
'subnet': {
'dns_nameservers': ['8.8.8.8', '192.168.1.254'],
'name':
'mysubnet',
'enable_dhcp':
True,
'host_routes': [{
'destination': '192.168.1.0/24',
'nexthop': '194.168.1.2'
}],
'gateway_ip':
'10.0.3.105',
'allocation_pools': [{
'start': '10.0.3.20',
'end': '10.0.3.100'
}, {
'start': '10.0.3.110',
'end': '10.0.3.200'
}]
}
}
t = self._test_subnet(u_props=update_props)
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'fc68ea2c-b60b-4b4f-bd82-94ec81110766',
cmd_resource=None,
).AndReturn('fc68ea2c-b60b-4b4f-bd82-94ec81110766')
neutronclient.Client.update_subnet(
'91e47a57-7508-46fe-afc9-fc454e8580e1', update_props)
stack = utils.parse_stack(t)
self.patchobject(stack['net'],
'FnGetRefId',
return_value='fc68ea2c-b60b-4b4f-bd82-94ec81110766')
rsrc = self.create_subnet(t, stack, 'sub_net')
self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
rsrc.validate()
ref_id = rsrc.FnGetRefId()
self.assertEqual('91e47a57-7508-46fe-afc9-fc454e8580e1', ref_id)
self.assertIsNone(rsrc.FnGetAtt('network_id'))
self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766',
rsrc.FnGetAtt('network_id'))
self.assertEqual('8.8.8.8', rsrc.FnGetAtt('dns_nameservers')[0])
# assert the dependency (implicit or explicit) between the ports
# and the subnet
self.assertIn(stack['port'], stack.dependencies[stack['sub_net']])
self.assertIn(stack['port2'], stack.dependencies[stack['sub_net']])
update_snippet = rsrc_defn.ResourceDefinition(rsrc.name, rsrc.type(),
update_props['subnet'])
rsrc.handle_update(update_snippet, {}, update_props['subnet'])
# with name None
del update_props['subnet']['name']
rsrc.handle_update(update_snippet, {}, update_props['subnet'])
# with no prop_diff
rsrc.handle_update(update_snippet, {}, {})
self.assertIsNone(scheduler.TaskRunner(rsrc.delete)())
rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again')
self.assertIsNone(scheduler.TaskRunner(rsrc.delete)())
self.m.VerifyAll()
def test_properties_are_prepared_for_session_persistence(self):
neutronV20.find_resourceid_by_name_or_id(mox.IsA(neutronclient.Client),
'subnet',
'sub123').AndReturn('sub123')
neutronclient.Client.create_pool({
'pool': {
'subnet_id': 'sub123',
'protocol': u'HTTP',
'name': utils.PhysName('test_stack', 'pool'),
'lb_method': 'ROUND_ROBIN',
'admin_state_up': True
}
}).AndReturn({'pool': {
'id': '5678'
}})
neutronclient.Client.create_vip({
'vip': {
'protocol': u'HTTP',
'name': 'pool.vip',
'admin_state_up': True,
'subnet_id': u'sub123',
'pool_id': '5678',
'protocol_port': 80,
'session_persistence': {
'type': 'HTTP_COOKIE'
}
}
}).AndReturn({'vip': {
'id': 'xyz'
}})
neutronclient.Client.show_pool('5678').AndReturn(
{'pool': {
'status': 'ACTIVE'
}})
neutronclient.Client.show_vip('xyz').AndReturn(
{'vip': {
'status': 'ACTIVE'
}})
snippet = template_format.parse(pool_with_session_persistence_template)
pool = snippet['Resources']['pool']
persistence = pool['Properties']['vip']['session_persistence']
# change persistence type to HTTP_COOKIE that not require cookie_name
persistence['type'] = 'HTTP_COOKIE'
del persistence['cookie_name']
stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack)
resource = loadbalancer.Pool('pool', resource_defns['pool'], stack)
# assert that properties contain cookie_name property with None value
persistence = resource.properties['vip']['session_persistence']
self.assertIn('cookie_name', persistence)
self.assertIsNone(persistence['cookie_name'])
self.m.ReplayAll()
scheduler.TaskRunner(resource.create)()
self.assertEqual((resource.CREATE, resource.COMPLETE), resource.state)
self.m.VerifyAll()
def _get_listener_id(client, listener_id_or_name):
return neutronV20.find_resourceid_by_name_or_id(client,
'listener',
listener_id_or_name,
cmd_resource='listener')
def get_rbac_object_id(client, obj_type, obj_id_or_name):
if obj_type == 'network':
obj_id = neutronV20.find_resourceid_by_name_or_id(
client, 'network', obj_id_or_name)
return obj_id
def test_update_monitors(self):
neutronV20.find_resourceid_by_name_or_id(mox.IsA(neutronclient.Client),
'subnet',
'sub123').AndReturn('sub123')
neutronclient.Client.create_pool({
'pool': {
'subnet_id': 'sub123',
'protocol': u'HTTP',
'name': utils.PhysName('test_stack', 'pool'),
'lb_method': 'ROUND_ROBIN',
'admin_state_up': True
}
}).AndReturn({'pool': {
'id': '5678'
}})
neutronclient.Client.associate_health_monitor(
'5678', {'health_monitor': {
'id': 'mon123'
}})
neutronclient.Client.associate_health_monitor(
'5678', {'health_monitor': {
'id': 'mon456'
}})
neutronclient.Client.create_vip({
'vip': {
'protocol': u'HTTP',
'name': 'pool.vip',
'admin_state_up': True,
'subnet_id': u'sub123',
'pool_id': '5678',
'protocol_port': 80
}
}).AndReturn({'vip': {
'id': 'xyz'
}})
neutronclient.Client.show_pool('5678').AndReturn(
{'pool': {
'status': 'ACTIVE'
}})
neutronclient.Client.show_vip('xyz').AndReturn(
{'vip': {
'status': 'ACTIVE'
}})
neutronclient.Client.disassociate_health_monitor('5678', 'mon456')
neutronclient.Client.associate_health_monitor(
'5678', {'health_monitor': {
'id': 'mon789'
}})
snippet = template_format.parse(pool_template)
stack = utils.parse_stack(snippet)
snippet['Resources']['pool']['Properties']['monitors'] = [
'mon123', 'mon456'
]
resource_defns = stack.t.resource_definitions(stack)
rsrc = loadbalancer.Pool('pool', resource_defns['pool'], stack)
self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)()
update_template = copy.deepcopy(rsrc.t)
update_template['Properties']['monitors'] = ['mon123', 'mon789']
scheduler.TaskRunner(rsrc.update, update_template)()
self.m.VerifyAll()
def _get_bgpvpn_id(client, name_or_id):
return neutronv20.find_resourceid_by_name_or_id(client, BGPVPN.resource,
name_or_id)
def create_pool(self, resolve_neutron=True, with_vip_subnet=False):
neutronclient.Client.create_pool({
'pool': {
'subnet_id': 'sub123',
'protocol': u'HTTP',
'name': utils.PhysName('test_stack', 'pool'),
'lb_method': 'ROUND_ROBIN',
'admin_state_up': True
}
}).AndReturn({'pool': {
'id': '5678'
}})
neutronclient.Client.show_pool('5678').AndReturn(
{'pool': {
'status': 'ACTIVE'
}})
neutronclient.Client.show_vip('xyz').AndReturn(
{'vip': {
'status': 'ACTIVE'
}})
stvipvsn = {
'vip': {
'protocol': u'HTTP',
'name': 'pool.vip',
'admin_state_up': True,
'subnet_id': u'sub9999',
'pool_id': '5678',
'protocol_port': 80
}
}
stvippsn = copy.deepcopy(stvipvsn)
stvippsn['vip']['subnet_id'] = 'sub123'
if resolve_neutron and with_vip_subnet:
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), 'subnet',
'sub123').AndReturn('sub123')
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), 'subnet',
'sub9999').AndReturn('sub9999')
snippet = template_format.parse(pool_template_with_vip_subnet)
neutronclient.Client.create_vip(stvipvsn).AndReturn(
{'vip': {
'id': 'xyz'
}})
elif resolve_neutron and not with_vip_subnet:
neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), 'subnet',
'sub123').AndReturn('sub123')
snippet = template_format.parse(pool_template)
neutronclient.Client.create_vip(stvippsn).AndReturn(
{'vip': {
'id': 'xyz'
}})
else:
snippet = template_format.parse(pool_template_deprecated)
neutronclient.Client.create_vip(stvippsn).AndReturn(
{'vip': {
'id': 'xyz'
}})
stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack)
return loadbalancer.Pool('pool', resource_defns['pool'], stack)
def get_bgp_speaker_id(client, id_or_name):
return neutronv20.find_resourceid_by_name_or_id(client, 'bgp_speaker',
id_or_name)
def retrieve_ids(self, client, args):
gateway_id = neutronV20.find_resourceid_by_name_or_id(
client, self.resource, args.net_gateway_id)
network_id = neutronV20.find_resourceid_by_name_or_id(
client, 'network', args.network_id)
return (gateway_id, network_id)
