def create_floatingip_port_forwarding(self, context, floatingip_id,
port_forwarding):
port_forwarding = port_forwarding.get(apidef.RESOURCE_NAME)
port_forwarding['floatingip_id'] = floatingip_id
self._check_port_has_binding_floating_ip(context, port_forwarding)
with db_api.CONTEXT_WRITER.using(context):
fip_obj = self._get_fip_obj(context, floatingip_id)
if fip_obj.fixed_port_id:
raise lib_l3_exc.FloatingIPPortAlreadyAssociated(
port_id=port_forwarding['internal_port_id'],
fip_id=fip_obj.id,
floating_ip_address=fip_obj.floating_ip_address,
fixed_ip=str(port_forwarding['internal_ip_address']),
net_id=fip_obj.floating_network_id)
router_id = self._find_a_router_for_fip_port_forwarding(
context, port_forwarding, fip_obj)
pf_obj = pf.PortForwarding(context, **port_forwarding)
# If this func does not raise an exception, means the
# router_id matched.
# case1: fip_obj.router_id = None
# case2: fip_obj.router_id is the same with we selected.
self._check_router_match(context, fip_obj, router_id,
port_forwarding)
if not fip_obj.router_id:
values = {'router_id': router_id, 'fixed_port_id': None}
l3_obj.FloatingIP.update_objects(context,
values,
id=floatingip_id)
try:
pf_obj.create()
except obj_exc.NeutronDbObjectDuplicateEntry:
(__, conflict_params) = self._find_existing_port_forwarding(
context, floatingip_id, port_forwarding)
message = _("A duplicate port forwarding entry with same "
"attributes already exists, conflicting "
"values are %s") % conflict_params
raise lib_exc.BadRequest(resource=apidef.RESOURCE_NAME,
msg=message)
if self._rpc_notifications_required:
self.push_api.push(context, [pf_obj], rpc_events.CREATED)
registry.notify(pf_consts.PORT_FORWARDING,
events.AFTER_CREATE,
self,
payload=[
callbacks.PortForwardingPayload(
context, current_pf=pf_obj)
])
return pf_obj
def setUp(self):
super(PortForwardingExtensionBaseTestCase, self).setUp()
self.fip_pf_ext = pf.PortForwardingAgentExtension()
self.context = context.get_admin_context()
self.connection = mock.Mock()
self.floatingip2 = router.FloatingIP(context=None, id=_uuid(),
floating_ip_address='172.24.6.12',
floating_network_id=_uuid(),
router_id=_uuid(),
status='ACTIVE')
self.portforwarding1 = pf_obj.PortForwarding(
context=None, id=_uuid(), floatingip_id=self.floatingip2.id,
external_port=1111, protocol='tcp', internal_port_id=_uuid(),
internal_ip_address='1.1.1.1', internal_port=11111,
floating_ip_address=self.floatingip2.floating_ip_address,
router_id=self.floatingip2.router_id)
self.agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
self.ex_gw_port = {'id': _uuid()}
self.fip = {'id': _uuid(),
'floating_ip_address': TEST_FIP,
'fixed_ip_address': '192.168.0.1',
'floating_network_id': _uuid(),
'port_id': _uuid(),
'host': HOSTNAME}
self.router = {'id': self.floatingip2.router_id,
'gw_port': self.ex_gw_port,
'ha': False,
'distributed': False,
lib_const.FLOATINGIP_KEY: [self.fip]}
self.router_info = l3router.RouterInfo(
self.agent, self.floatingip2.router_id, self.router,
**self.ri_kwargs)
self.centralized_port_forwarding_fip_set = set(
[str(self.floatingip2.floating_ip_address) + '/32'])
self.pf_managed_fips = [self.floatingip2.id]
self.router_info.ex_gw_port = self.ex_gw_port
self.router_info.fip_managed_by_port_forwardings = self.pf_managed_fips
self.agent.router_info[self.router['id']] = self.router_info
self.get_router_info = mock.patch(
'neutron.agent.l3.l3_agent_extension_api.'
'L3AgentExtensionAPI.get_router_info').start()
self.get_router_info.return_value = self.router_info
self.agent_api = l3_ext_api.L3AgentExtensionAPI(None)
self.fip_pf_ext.consume_api(self.agent_api)
self.port_forwardings = [self.portforwarding1]
def test_update_port_forwarding(self):
self._set_pf()
new_pf1 = pf_obj.PortForwarding(
context=None, id=self.portforwarding2.id,
floatingip_id=self.floatingip1,
external_port=11122, protocol='tcp',
internal_port_id=self.portforwarding2.internal_port_id,
internal_ip_address='1.1.1.22', internal_port=11122,
floating_ip_address='111.111.111.111',
router_id=self.router1)
self.mapping.update_port_forwardings([new_pf1])
self.assertEqual(
new_pf1,
self.mapping.managed_port_forwardings[self.portforwarding2.id])
def setUp(self):
super(RouterFipPortForwardingMappingTestCase, self).setUp()
self.mapping = pf.RouterFipPortForwardingMapping()
self.router1 = _uuid()
self.router2 = _uuid()
self.floatingip1 = _uuid()
self.floatingip2 = _uuid()
self.floatingip3 = _uuid()
self.portforwarding1 = pf_obj.PortForwarding(
context=None, id=_uuid(), floatingip_id=self.floatingip1,
external_port=1111, protocol='tcp', internal_port_id=_uuid(),
internal_ip_address='1.1.1.1', internal_port=11111,
floating_ip_address='111.111.111.111',
router_id=self.router1)
self.portforwarding2 = pf_obj.PortForwarding(
context=None, id=_uuid(), floatingip_id=self.floatingip1,
external_port=1112, protocol='tcp', internal_port_id=_uuid(),
internal_ip_address='1.1.1.2', internal_port=11112,
floating_ip_address='111.111.111.111',
router_id=self.router1)
self.portforwarding3 = pf_obj.PortForwarding(
context=None, id=_uuid(), floatingip_id=self.floatingip2,
external_port=1113, protocol='tcp', internal_port_id=_uuid(),
internal_ip_address='1.1.1.3', internal_port=11113,
floating_ip_address='111.222.111.222',
router_id=self.router1)
self.portforwarding4 = pf_obj.PortForwarding(
context=None, id=_uuid(), floatingip_id=self.floatingip3,
external_port=2222, protocol='tcp', internal_port_id=_uuid(),
internal_ip_address='2.2.2.2', internal_port=22222,
floating_ip_address='222.222.222.222',
router_id=self.router2)
self.portforwardings_dict = {
self.portforwarding1.id: self.portforwarding1,
self.portforwarding2.id: self.portforwarding2,
self.portforwarding3.id: self.portforwarding3,
self.portforwarding4.id: self.portforwarding4}
def _fake_pf_obj(self, is_object=False, **kwargs):
pf_obj_defaults_dict = {
'id': 'id',
'floatingip_id': 'fip_id',
'protocol': 'udp',
'floating_ip_address': 'fip_addr',
'external_port': 'ext_port',
'internal_ip_address': 'internal_addr',
'internal_port': 'internal_port',
'router_id': 'rtr_id'
}
pf_obj_dict = {**pf_obj_defaults_dict, **kwargs}
if is_object:
return port_forwarding_obj.PortForwarding(**pf_obj_dict)
return mock.Mock(**pf_obj_dict)
def create_floatingip_port_forwarding(self, context, floatingip_id,
port_forwarding):
port_forwarding = port_forwarding.get(apidef.RESOURCE_NAME)
port_forwarding['floatingip_id'] = floatingip_id
with db_api.context_manager.writer.using(context):
fip_obj = self._get_fip_obj(context, floatingip_id)
if fip_obj.fixed_port_id:
raise lib_l3_exc.FloatingIPPortAlreadyAssociated(
port_id=port_forwarding['internal_port_id'],
fip_id=fip_obj.id,
floating_ip_address=fip_obj.floating_ip_address,
fixed_ip=str(port_forwarding['internal_ip_address']),
net_id=fip_obj.floating_network_id)
router_id = self._find_a_router_for_fip_port_forwarding(
context, port_forwarding, fip_obj)
pf_obj = pf.PortForwarding(context, **port_forwarding)
# If this func does not raise an exception, means the
# router_id matched.
# case1: fip_obj.router_id = None
# case2: fip_obj.router_id is the same with we selected.
self._check_router_match(context, fip_obj, router_id,
port_forwarding)
if not fip_obj.router_id:
values = {'router_id': router_id, 'fixed_port_id': None}
router.FloatingIP.update_objects(context,
values,
id=floatingip_id)
try:
pf_obj.create()
except obj_exc.NeutronDbObjectDuplicateEntry:
(__, conflict_params) = self._find_existing_port_forwarding(
context, floatingip_id, port_forwarding)
message = _("A duplicate port forwarding entry with same "
"attributes already exists, conflicting "
"values are %s") % conflict_params
raise lib_exc.BadRequest(resource=apidef.RESOURCE_NAME,
msg=message)
self.push_api.push(context, [pf_obj], rpc_events.CREATED)
return pf_obj
def test_add_update_router_port_forwarding_change(self, mock_remove_chain,
mock_ip_device,
mock_add_chain,
mock_add_rule):
self.fip_pf_ext.add_router(self.context, self.router)
update_portforwarding = pf_obj.PortForwarding(
context=None,
id=self.portforwarding1.id,
floatingip_id=self.portforwarding1.floatingip_id,
external_port=2222,
protocol='tcp',
internal_port_id=_uuid(),
internal_ip_address='2.2.2.2',
internal_port=22222,
floating_ip_address=self.portforwarding1.floating_ip_address,
router_id=self.portforwarding1.router_id)
self.port_forwardings = [update_portforwarding]
mock_delete = mock.Mock()
mock_ip_device.return_value = mock_delete
self.fip_pf_ext.update_router(self.context, self.router)
current_chain = (
'pf-' +
self.portforwarding1.id)[:lib_const.MAX_IPTABLES_CHAIN_LEN_WRAP]
mock_remove_chain.assert_called_once_with(current_chain)
mock_delete.delete_socket_conntrack_state.assert_called_once_with(
str(self.portforwarding1.floating_ip_address),
self.portforwarding1.external_port,
protocol=self.portforwarding1.protocol)
(chain_name, chain_rule,
rule_tag) = self._get_chainrule_tag_from_pf_obj(update_portforwarding)
mock_add_chain.assert_has_calls(
[mock.call('fip-pf'), mock.call(chain_name)])
mock_add_rule.assert_has_calls([
mock.call(DEFAULT_RULE[0], DEFAULT_RULE[1]),
mock.call(DEFAULT_CHAIN, ('-j %s-' % BINARY_NAME) + chain_name,
tag=rule_tag),
mock.call(chain_name, chain_rule[1], tag=rule_tag)
])
def test_add_update_router(self, mock_add_fip, mock_add_chain,
mock_add_rule, mock_send_fip_status):
# simulate the router add and already there is a port forwarding
# resource association.
mock_add_fip.return_value = lib_const.FLOATINGIP_STATUS_ACTIVE
self.fip_pf_ext.add_router(self.context, self.router)
self._assert_called_iptables_process(mock_add_chain,
mock_add_rule,
mock_add_fip,
mock_send_fip_status,
target_obj=self.portforwarding1)
# Then we create another port forwarding with the same fip
mock_add_fip.reset_mock()
mock_send_fip_status.reset_mock()
mock_add_chain.reset_mock()
mock_add_rule.reset_mock()
test_portforwarding = pf_obj.PortForwarding(
context=None,
id=_uuid(),
floatingip_id=self.floatingip2.id,
external_port=2222,
protocol='tcp',
internal_port_id=_uuid(),
internal_ip_address='2.2.2.2',
internal_port=22222,
floating_ip_address=self.floatingip2.floating_ip_address,
router_id=self.floatingip2.router_id)
self.pf_managed_fips.append(self.floatingip2.id)
self.port_forwardings.append(test_portforwarding)
self.fip_pf_ext.update_router(self.context, self.router)
self._assert_called_iptables_process(mock_add_chain,
mock_add_rule,
mock_add_fip,
mock_send_fip_status,
target_obj=test_portforwarding)
def setUp(self):
super(L3AgentFipPortForwardingExtensionTestFramework, self).setUp()
self.conf.set_override('extensions', ['port_forwarding'], 'agent')
self.agent = neutron_l3_agent.L3NATAgentWithStateReport(
'agent1', self.conf)
self.fip_pf_ext = pf.PortForwardingAgentExtension()
self.fip_id1 = _uuid()
self.fip_id2 = _uuid()
self.fip_id3 = _uuid()
self.portforwarding1 = pf_obj.PortForwarding(
context=None,
id=_uuid(),
floatingip_id=self.fip_id1,
external_port=1111,
protocol='tcp',
internal_port_id=_uuid(),
internal_ip_address='1.1.1.1',
internal_port=11111,
floating_ip_address='111.111.111.111',
router_id=_uuid())
self.portforwarding2 = pf_obj.PortForwarding(
context=None,
id=_uuid(),
floatingip_id=self.fip_id1,
external_port=1112,
protocol='tcp',
internal_port_id=_uuid(),
internal_ip_address='1.1.1.2',
internal_port=11112,
floating_ip_address='111.111.111.111',
router_id=_uuid())
self.portforwarding3 = pf_obj.PortForwarding(
context=None,
id=_uuid(),
floatingip_id=self.fip_id2,
external_port=1113,
protocol='tcp',
internal_port_id=_uuid(),
internal_ip_address='1.1.1.3',
internal_port=11113,
floating_ip_address='111.222.111.222',
router_id=_uuid())
self.portforwarding4 = pf_obj.PortForwarding(
context=None,
id=_uuid(),
floatingip_id=self.fip_id3,
external_port=2222,
protocol='tcp',
internal_port_id=_uuid(),
internal_ip_address='2.2.2.2',
internal_port=22222,
floating_ip_address='222.222.222.222',
router_id=_uuid())
self.port_forwardings = [
self.portforwarding1, self.portforwarding2, self.portforwarding3,
self.portforwarding4
]
self._set_bulk_pull_mock()
self.managed_fips = [self.fip_id1, self.fip_id2, self.fip_id3]
self.fip_list_for_pf = [
'111.111.111.111/32', '111.222.111.222/32', '222.222.222.222/32'
]
def _get_pf_objs(self, context, fip_id):
pf_dicts = self._pf_plugin.get_floatingip_port_forwardings(
context, fip_id)
return [port_forwarding_obj.PortForwarding(context=context, **pf_dict)
for pf_dict in pf_dicts]
