def test_allocate_vip_when_port_creation_fails(self): fake_lb_vip = data_models.Vip(subnet_id=t_constants.MOCK_SUBNET_ID) fake_lb = data_models.LoadBalancer(id='1', vip=fake_lb_vip) create_port = self.driver.neutron_client.create_port create_port.side_effect = Exception self.assertRaises(network_base.AllocateVIPException, self.driver.allocate_vip, fake_lb)
def test_update_vip_when_listener_deleted(self): listeners = [data_models.Listener(protocol_port=80, protocol=constants.PROTOCOL_TCP), data_models.Listener( protocol_port=443, protocol=constants.PROTOCOL_TCP, provisioning_status=constants.PENDING_DELETE), data_models.Listener( protocol_port=50, protocol=constants.PROTOCOL_UDP, provisioning_status=constants.PENDING_DELETE)] vip = data_models.Vip(ip_address='10.0.0.2') lb = data_models.LoadBalancer(id='1', listeners=listeners, vip=vip) list_sec_grps = self.driver.neutron_client.list_security_groups list_sec_grps.return_value = {'security_groups': [{'id': 'secgrp-1'}]} fake_rules = { 'security_group_rules': [ {'id': 'rule-80', 'port_range_max': 80, 'protocol': 'tcp'}, {'id': 'rule-22', 'port_range_max': 443, 'protocol': 'tcp'}, {'id': 'rule-udp-50', 'port_range_max': 50, 'protocol': 'tcp'} ] } list_rules = self.driver.neutron_client.list_security_group_rules list_rules.return_value = fake_rules delete_rule = self.driver.neutron_client.delete_security_group_rule create_rule = self.driver.neutron_client.create_security_group_rule self.driver.update_vip(lb) delete_rule.assert_has_calls( [mock.call('rule-22'), mock.call('rule-udp-50')]) self.assertTrue(create_rule.called)
def test_create_load_balancer_full_graph_single( self, mock_get_create_load_balancer_flow, mock_api_get_session, mock_dyn_log_listener, mock_taskflow_load, mock_pool_repo_get, mock_member_repo_get, mock_l7rule_repo_get, mock_l7policy_repo_get, mock_listener_repo_get, mock_lb_repo_get, mock_health_mon_repo_get, mock_amp_repo_get): self.conf.config(group="controller_worker", loadbalancer_topology=constants.TOPOLOGY_SINGLE) listeners = [ data_models.Listener(id='listener1'), data_models.Listener(id='listener2') ] lb = data_models.LoadBalancer(id=LB_ID, listeners=listeners) mock_lb_repo_get.return_value = lb mock_eng = mock.Mock() mock_taskflow_load.return_value = mock_eng store = { constants.LOADBALANCER_ID: LB_ID, 'update_dict': { 'topology': constants.TOPOLOGY_SINGLE } } cw = controller_worker.ControllerWorker() cw.create_load_balancer(LB_ID) # mock_create_single_topology.assert_called_once() # mock_create_active_standby_topology.assert_not_called() mock_get_create_load_balancer_flow.assert_called_with( topology=constants.TOPOLOGY_SINGLE, listeners=lb.listeners) mock_taskflow_load.assert_called_with( mock_get_create_load_balancer_flow.return_value, store=store) mock_eng.run.assert_any_call()
def create_vip_port(self, loadbalancer_id, project_id, vip_dictionary): vip_obj = driver_utils.provider_vip_dict_to_vip_obj(vip_dictionary) lb_obj = data_models.LoadBalancer(id=loadbalancer_id, project_id=project_id, vip=vip_obj) network_driver = utils.get_network_driver() vip_network = network_driver.get_network( vip_dictionary[lib_consts.VIP_NETWORK_ID]) if not vip_network.port_security_enabled: message = "Port security must be enabled on the VIP network." raise exceptions.DriverError(user_fault_string=message, operator_fault_string=message) try: vip = network_driver.allocate_vip(lb_obj) except network_base.AllocateVIPException as e: message = str(e) if getattr(e, 'orig_msg', None) is not None: message = e.orig_msg raise exceptions.DriverError(user_fault_string=message, operator_fault_string=message) LOG.info('Amphora provider created VIP port %s for load balancer %s.', vip.port_id, loadbalancer_id) return driver_utils.vip_dict_to_provider_dict(vip.to_dict())
def test_allocate_vip_when_no_port_provided(self): port_create_dict = copy.deepcopy(t_constants.MOCK_NEUTRON_PORT) port_create_dict['port']['device_owner'] = ( allowed_address_pairs.OCTAVIA_OWNER) port_create_dict['port']['device_id'] = 'lb-1' create_port = self.driver.neutron_client.create_port create_port.return_value = port_create_dict show_subnet = self.driver.neutron_client.show_subnet show_subnet.return_value = {'subnet': { 'id': t_constants.MOCK_SUBNET_ID, 'network_id': t_constants.MOCK_NETWORK_ID }} fake_lb_vip = data_models.Vip(subnet_id=t_constants.MOCK_SUBNET_ID, network_id=t_constants.MOCK_NETWORK_ID) fake_lb = data_models.LoadBalancer(id='1', vip=fake_lb_vip, project_id='test-project') vip = self.driver.allocate_vip(fake_lb) exp_create_port_call = { 'port': { 'name': 'octavia-lb-1', 'network_id': t_constants.MOCK_NETWORK_ID, 'device_id': 'lb-1', 'device_owner': allowed_address_pairs.OCTAVIA_OWNER, 'admin_state_up': False, 'project_id': 'test-project', 'fixed_ips': [{'subnet_id': t_constants.MOCK_SUBNET_ID}] } } create_port.assert_called_once_with(exp_create_port_call) self.assertIsInstance(vip, data_models.Vip) self.assertEqual(t_constants.MOCK_IP_ADDRESS, vip.ip_address) self.assertEqual(t_constants.MOCK_SUBNET_ID, vip.subnet_id) self.assertEqual(t_constants.MOCK_PORT_ID, vip.port_id) self.assertEqual(fake_lb.id, vip.load_balancer_id)
def test_listeners_update(self, mock_driver, mock_generate_uuid, mock_log, mock_get_session, mock_listener_repo_get, mock_listener_repo_update, mock_amphora_repo_update): listeners_update_obj = amphora_driver_tasks.ListenersUpdate() listeners = [ data_models.Listener(id='listener1'), data_models.Listener(id='listener2') ] vip = data_models.Vip(ip_address='10.0.0.1') lb = data_models.LoadBalancer(id='lb1', listeners=listeners, vip=vip) listeners_update_obj.execute(lb) mock_driver.update.assert_called_once_with(lb) self.assertEqual(1, mock_driver.update.call_count) # Test the revert amp = listeners_update_obj.revert(lb) expected_db_calls = [ mock.call(_session_mock, id=listeners[0].id, provisioning_status=constants.ERROR), mock.call(_session_mock, id=listeners[1].id, provisioning_status=constants.ERROR) ] repo.ListenerRepository.update.has_calls(expected_db_calls) self.assertEqual(2, repo.ListenerRepository.update.call_count) self.assertIsNone(amp)
def test_update_vip_when_listener_deleted(self): listeners = [ data_models.Listener(protocol_port=80), data_models.Listener(protocol_port=443, provisioning_status=constants.PENDING_DELETE) ] lb = data_models.LoadBalancer(id='1', listeners=listeners) list_sec_grps = self.driver.neutron_client.list_security_groups list_sec_grps.return_value = {'security_groups': [{'id': 'secgrp-1'}]} fake_rules = { 'security_group_rules': [{ 'id': 'rule-80', 'port_range_max': 80, 'protocol': 'tcp' }, { 'id': 'rule-22', 'port_range_max': 443, 'protocol': 'tcp' }] } list_rules = self.driver.neutron_client.list_security_group_rules list_rules.return_value = fake_rules delete_rule = self.driver.neutron_client.delete_security_group_rule create_rule = self.driver.neutron_client.create_security_group_rule self.driver.update_vip(lb) delete_rule.assert_called_once_with('rule-22') self.assertTrue(create_rule.called)
def test_allocate_vip_when_port_already_provided(self): fake_lb_vip = data_models.Vip() fake_lb = data_models.LoadBalancer(id='1', vip=fake_lb_vip) self.assertRaises(network_base.AllocateVIPException, self.driver.allocate_vip, fake_lb) show_port = self.driver.neutron_client.show_port show_port.return_value = n_constants.MOCK_NEUTRON_PORT fake_lb_vip = data_models.Vip(port_id=n_constants.MOCK_PORT_ID, subnet_id=n_constants.MOCK_SUBNET_ID) fake_lb = data_models.LoadBalancer(id='1', vip=fake_lb_vip) vip = self.driver.allocate_vip(fake_lb) self.assertIsInstance(vip, data_models.Vip) self.assertEqual(n_constants.MOCK_IP_ADDRESS, vip.ip_address) self.assertEqual(n_constants.MOCK_SUBNET_ID, vip.subnet_id) self.assertEqual(n_constants.MOCK_PORT_ID, vip.port_id) self.assertEqual(fake_lb.id, vip.load_balancer_id)
def test_update_vip(self): listeners = [data_models.Listener(protocol_port=80), data_models.Listener(protocol_port=443)] lb = data_models.LoadBalancer(id='1', listeners=listeners) list_sec_grps = self.driver.neutron_client.list_security_groups list_sec_grps.return_value = {'security_groups': [{'id': 'secgrp-1'}]} fake_rules = { 'security_group_rules': [ {'id': 'rule-80', 'port_range_max': 80}, {'id': 'rule-22', 'port_range_max': 22} ] } list_rules = self.driver.neutron_client.list_security_group_rules list_rules.return_value = fake_rules delete_rule = self.driver.neutron_client.delete_security_group_rule create_rule = self.driver.neutron_client.create_security_group_rule self.driver.update_vip(lb) delete_rule.assert_called_once_with('rule-22') expected_create_rule = { 'security_group_rule': { 'security_group_id': 'secgrp-1', 'direction': 'ingress', 'protocol': 'TCP', 'port_range_min': 443, 'port_range_max': 443 } } create_rule.assert_called_once_with(expected_create_rule)
def setUp(self): super(TestNoopAmphoraLoadBalancerDriver, self).setUp() self.driver = driver.NoopAmphoraLoadBalancerDriver() self.listener = data_models.Listener() self.listener.id = uuidutils.generate_uuid() self.listener.protocol_port = 80 self.vip = data_models.Vip() self.vip.ip_address = "10.0.0.1" self.amphora = data_models.Amphora() self.amphora.id = self.FAKE_UUID_1 self.load_balancer = data_models.LoadBalancer( id=FAKE_UUID_1, amphorae=[self.amphora], vip=self.vip, listeners=[self.listener]) self.listener.load_balancer = self.load_balancer self.network = network_models.Network(id=self.FAKE_UUID_1) self.port = network_models.Port(id=uuidutils.generate_uuid()) self.amphorae_net_configs = { self.amphora.id: network_models.AmphoraNetworkConfig( amphora=self.amphora, vip_subnet=network_models.Subnet(id=self.FAKE_UUID_1)) } self.pem_file = 'test_pem_file' self.agent_config = 'test agent config' self.timeout_dict = { constants.REQ_CONN_TIMEOUT: 1, constants.REQ_READ_TIMEOUT: 2, constants.CONN_MAX_RETRIES: 3, constants.CONN_RETRY_INTERVAL: 4 }
def test_get_amphorae_network_configs(self, mock_get_net_driver): mock_driver = mock.MagicMock() mock_get_net_driver.return_value = mock_driver lb = o_data_models.LoadBalancer() net_task = network_tasks.GetAmphoraeNetworkConfigs() net_task.execute(lb) mock_driver.get_network_configs.assert_called_once_with(lb)
def test_update_vip_when_security_group_missing(self): listeners = [] vip = data_models.Vip(ip_address='10.0.0.2') lb = data_models.LoadBalancer(id='1', listeners=listeners, vip=vip) list_sec_grps = self.driver.neutron_client.list_security_groups list_sec_grps.return_value = {'security_groups': []} self.assertRaises(exceptions.MissingVIPSecurityGroup, self.driver.update_vip, lb)
def test_update_vip_for_delete(self, mock_get_net_driver): mock_driver = mock.MagicMock() mock_get_net_driver.return_value = mock_driver vip = o_data_models.Vip() lb = o_data_models.LoadBalancer(vip=vip) net_task = network_tasks.UpdateVIPForDelete() net_task.execute(lb) mock_driver.update_vip.assert_called_once_with(lb, for_delete=True)
def test_deallocate_vip(self, mock_get_net_driver): mock_driver = mock.MagicMock() mock_get_net_driver.return_value = mock_driver net = network_tasks.DeallocateVIP() vip = o_data_models.Vip() lb = o_data_models.LoadBalancer(vip=vip) net.execute(lb) mock_driver.deallocate_vip.assert_called_once_with(lb.vip)
def test_update_vip_for_delete_when_security_group_missing(self, update_rules): listeners = [] vip = data_models.Vip(ip_address='10.0.0.2') lb = data_models.LoadBalancer(id='1', listeners=listeners, vip=vip) list_sec_grps = self.driver.neutron_client.list_security_groups list_sec_grps.return_value = {'security_groups': []} self.driver.update_vip(lb, for_delete=True) update_rules.assert_not_called()
def test_update_loadbalancer(self): p = producer.LoadBalancerProducer() lb = data_models.LoadBalancer(id=10) lb_updates = load_balancer.LoadBalancerPUT(enabled=False) p.update(lb, lb_updates) kw = {'load_balancer_id': lb.id, 'load_balancer_updates': lb_updates.to_dict(render_unsets=False)} self.mck_client.cast.assert_called_once_with( {}, 'update_load_balancer', **kw)
def test_post_vip_plug(self, exec_command): amps = [data_models.Amphora(id=MOCK_AMP_ID, compute_id=MOCK_COMPUTE_ID, lb_network_ip=MOCK_IP_ADDRESS)] vip = data_models.Vip(ip_address=MOCK_IP_ADDRESS) lb = data_models.LoadBalancer(amphorae=amps, vip=vip) vip_subnet = network_models.Subnet(id=MOCK_SUBNET_ID, gateway_ip=MOCK_IP_ADDRESS, cidr=MOCK_CIDR) vip_port = network_models.Port(id=MOCK_PORT_ID, device_id=MOCK_COMPUTE_ID) amphorae_net_config = {amps[0].id: network_models.AmphoraNetworkConfig( amphora=amps[0], vip_subnet=vip_subnet, vip_port=vip_port, vrrp_port=self.port )} iface = 'eth1' exec_command.return_value = ('{0}: '.format(iface), '') self.driver.post_vip_plug(lb, amphorae_net_config) grep_call = mock.call( ssh_driver.CMD_GREP_LINK_BY_MAC.format(mac_address='123')) dhclient_call = mock.call(ssh_driver.CMD_DHCLIENT.format(iface), run_as_root=True) add_ip_call = mock.call(ssh_driver.CMD_ADD_IP_ADDR.format( MOCK_IP_ADDRESS, iface), run_as_root=True) show_ip_call = mock.call(ssh_driver.CMD_SHOW_IP_ADDR.format(iface)) create_vip_table_call = mock.call( ssh_driver.CMD_CREATE_VIP_ROUTE_TABLE.format( ssh_driver.VIP_ROUTE_TABLE), run_as_root=True ) add_route_call = mock.call( ssh_driver.CMD_ADD_ROUTE_TO_TABLE.format( MOCK_CIDR, iface, ssh_driver.VIP_ROUTE_TABLE), run_as_root=True ) add_default_route_call = mock.call( ssh_driver.CMD_ADD_DEFAULT_ROUTE_TO_TABLE.format( MOCK_IP_ADDRESS, iface, ssh_driver.VIP_ROUTE_TABLE), run_as_root=True ) add_rule_from_call = mock.call( ssh_driver.CMD_ADD_RULE_FROM_NET_TO_TABLE.format( MOCK_CIDR, ssh_driver.VIP_ROUTE_TABLE), run_as_root=True ) add_rule_to_call = mock.call( ssh_driver.CMD_ADD_RULE_TO_NET_TO_TABLE.format( MOCK_CIDR, ssh_driver.VIP_ROUTE_TABLE), run_as_root=True ) exec_command.assert_has_calls([grep_call, dhclient_call, add_ip_call, show_ip_call, create_vip_table_call, add_route_call, add_default_route_call, add_rule_from_call, add_rule_to_call]) self.assertEqual(9, exec_command.call_count)
def test_update_vip_for_delete(self, mock_get_session, mock_get_lb, mock_get_net_driver): mock_driver = mock.MagicMock() mock_get_net_driver.return_value = mock_driver vip = o_data_models.Vip() lb = o_data_models.LoadBalancer(vip=vip) mock_get_lb.return_value = lb listener = {constants.LOADBALANCER_ID: lb.id} net_task = network_tasks.UpdateVIPForDelete() net_task.execute(listener) mock_driver.update_vip.assert_called_once_with(lb, for_delete=True)
def test_update_vip_during_update_loadbalancer(self, mock_vip): vip_object = o_data_models.Vip() lb_object = o_data_models.LoadBalancer(vip=vip_object) update_attr = model_tasks.UpdateAttributes() update_attr.execute(lb_object, { 'vip': { 'fool1': 'bar1' }, 'description': 'bar2' }) mock_vip.assert_called_once_with({'fool1': 'bar1'})
def setUp(self): super(TestAmphoraFlows, self).setUp() self.conf = self.useFixture(oslo_fixture.Config(cfg.CONF)) self.conf.config(group="controller_worker", amphora_driver='amphora_haproxy_rest_driver') self.conf.config(group="nova", enable_anti_affinity=False) self.AmpFlow = amphora_flows.AmphoraFlows() self.amp1 = data_models.Amphora(id=1) self.amp2 = data_models.Amphora(id=2) self.amp3 = data_models.Amphora(id=3, status=constants.DELETED) self.lb = data_models.LoadBalancer( id=4, amphorae=[self.amp1, self.amp2, self.amp3])
def test_delete_lb_rack_vthunder_vlan_flow(self, mock_net_driver): self.conf.register_opts(config_options.A10_GLOBAL_OPTS, group=a10constants.A10_GLOBAL_CONF_SECTION) self.conf.register_opts(config_options.A10_HARDWARE_THUNDER_OPTS, group=a10constants.A10_HARDWARE_THUNDER_CONF_SECTION) self.conf.config(group=a10constants.A10_GLOBAL_CONF_SECTION, network_type='vlan') self.conf.config(group=a10constants.A10_HARDWARE_THUNDER_CONF_SECTION, devices=[RACK_DEVICE]) lb = o_data_models.LoadBalancer(id=a10constants.MOCK_LOAD_BALANCER_ID, project_id='project-rack-vthunder') (del_flow, store) = self.flows.get_delete_load_balancer_flow(lb, False, False) self.assertIsInstance(del_flow, flow.Flow)
def test_LoadBalancer_update(self): new_id = uuidutils.generate_uuid() new_project_id = uuidutils.generate_uuid() new_server_group_id = uuidutils.generate_uuid() new_created_at = self.CREATED_AT + datetime.timedelta(minutes=5) new_updated_at = self.UPDATED_AT + datetime.timedelta(minutes=10) new_name = 'new-test-lb' new_description = 'new-test-lb-description' new_provisioning_status = 'new-great' new_operating_status = 'new-even-better' new_enabled = False new_vrrp_group = 2 new_topology = 'new-infinite' reference_LB_obj = data_models.LoadBalancer( id=new_id, project_id=new_project_id, name=new_name, description=new_description, provisioning_status=new_provisioning_status, operating_status=new_operating_status, enabled=new_enabled, vip=None, vrrp_group=new_vrrp_group, topology=new_topology, listeners=[], amphorae=[], pools=[], server_group_id=new_server_group_id, created_at=new_created_at, updated_at=new_updated_at) update_dict = { 'id': new_id, 'project_id': new_project_id, 'name': new_name, 'description': new_description, 'provisioning_status': new_provisioning_status, 'operating_status': new_operating_status, 'enabled': new_enabled, 'vrrp_group': new_vrrp_group, 'topology': new_topology, 'server_group_id': new_server_group_id, 'created_at': new_created_at, 'updated_at': new_updated_at } test_LB_obj = copy.deepcopy(self.LB_obj) test_LB_obj.update(update_dict) self.assertEqual(reference_LB_obj, test_LB_obj)
def test_update_vip(self): listeners = [data_models.Listener(protocol_port=80, peer_port=1024), data_models.Listener(protocol_port=443, peer_port=1025)] vip = data_models.Vip(ip_address='10.0.0.2') lb = data_models.LoadBalancer(id='1', listeners=listeners, vip=vip) list_sec_grps = self.driver.neutron_client.list_security_groups list_sec_grps.return_value = {'security_groups': [{'id': 'secgrp-1'}]} fake_rules = { 'security_group_rules': [ {'id': 'rule-80', 'port_range_max': 80, 'protocol': 'tcp'}, {'id': 'rule-22', 'port_range_max': 22, 'protocol': 'tcp'} ] } list_rules = self.driver.neutron_client.list_security_group_rules list_rules.return_value = fake_rules delete_rule = self.driver.neutron_client.delete_security_group_rule create_rule = self.driver.neutron_client.create_security_group_rule self.driver.update_vip(lb) delete_rule.assert_called_once_with('rule-22') expected_create_rule_1 = { 'security_group_rule': { 'security_group_id': 'secgrp-1', 'direction': 'ingress', 'protocol': 'TCP', 'port_range_min': 1024, 'port_range_max': 1024, 'ethertype': 'IPv4' } } expected_create_rule_2 = { 'security_group_rule': { 'security_group_id': 'secgrp-1', 'direction': 'ingress', 'protocol': 'TCP', 'port_range_min': 1025, 'port_range_max': 1025, 'ethertype': 'IPv4' } } expected_create_rule_3 = { 'security_group_rule': { 'security_group_id': 'secgrp-1', 'direction': 'ingress', 'protocol': 'TCP', 'port_range_min': 443, 'port_range_max': 443, 'ethertype': 'IPv4' } } create_rule.assert_has_calls([mock.call(expected_create_rule_1), mock.call(expected_create_rule_2), mock.call(expected_create_rule_3)])
def test_post_vip_plug_no_down_links(self, exec_command): amps = [data_models.Amphora(id=MOCK_AMP_ID, compute_id=MOCK_COMPUTE_ID, lb_network_ip=MOCK_IP_ADDRESS)] vip = data_models.Vip(ip_address=MOCK_IP_ADDRESS) lb = data_models.LoadBalancer(amphorae=amps, vip=vip) amphorae_net_config = {amps[0].id: network_models.AmphoraNetworkConfig( amphora=amps[0], vrrp_port=self.port )} exec_command.return_value = ('', '') self.driver.post_vip_plug(lb, amphorae_net_config) exec_command.assert_called_once_with( ssh_driver.CMD_GREP_LINK_BY_MAC.format(mac_address='123'))
def create_vip_port(self, loadbalancer_id, project_id, vip_dictionary): vip_obj = driver_utils.provider_vip_dict_to_vip_obj(vip_dictionary) lb_obj = data_models.LoadBalancer(id=loadbalancer_id, project_id=project_id, vip=vip_obj) network_driver = utils.get_network_driver() try: vip = network_driver.allocate_vip(lb_obj) except network_base.AllocateVIPException as e: raise exceptions.DriverError(user_fault_string=e.orig_msg, operator_fault_string=e.orig_msg) LOG.info('Amphora provider created VIP port %s for load balancer %s.', vip.port_id, loadbalancer_id) return driver_utils.vip_dict_to_provider_dict(vip.to_dict())
def test_db_loadbalancer_to_provider_loadbalancer(self): vip = data_models.Vip(ip_address=self.sample_data.ip_address, network_id=self.sample_data.network_id, port_id=self.sample_data.port_id, subnet_id=self.sample_data.subnet_id) test_db_lb = data_models.LoadBalancer(id=1, vip=vip) provider_lb = utils.db_loadbalancer_to_provider_loadbalancer( test_db_lb) ref_provider_lb = driver_dm.LoadBalancer( loadbalancer_id=1, vip_address=self.sample_data.ip_address, vip_network_id=self.sample_data.network_id, vip_port_id=self.sample_data.port_id, vip_subnet_id=self.sample_data.subnet_id) self.assertEqual(ref_provider_lb.to_dict(render_unsets=True), provider_lb.to_dict(render_unsets=True))
def test_update_vip_when_no_listeners(self): listeners = [] vip = data_models.Vip(ip_address='10.0.0.2') lb = data_models.LoadBalancer(id='1', listeners=listeners, vip=vip) list_sec_grps = self.driver.neutron_client.list_security_groups list_sec_grps.return_value = {'security_groups': [{'id': 'secgrp-1'}]} fake_rules = { 'security_group_rules': [ {'id': 'all-egress', 'protocol': None, 'direction': 'egress'}, {'id': 'ssh-rule', 'protocol': 'tcp', 'port_range_max': 22} ] } list_rules = self.driver.neutron_client.list_security_group_rules list_rules.return_value = fake_rules delete_rule = self.driver.neutron_client.delete_security_group_rule self.driver.update_vip(lb) delete_rule.assert_called_once_with('ssh-rule')
def generate_load_balancer(vip=None, amphorae=None): amphorae = amphorae or [] global LB_SEED LB_SEED += 1 lb = data_models.LoadBalancer(id='lb{0}-id'.format(LB_SEED), tenant_id='2', name='lb{0}'.format(LB_SEED), description='lb{0}'.format(LB_SEED), vip=vip, amphorae=amphorae) for amp in lb.amphorae: amp.load_balancer = lb amp.load_balancer_id = lb.id if vip: vip.load_balancer = lb vip.load_balancer_id = lb.id return lb
def generate_load_balancer(vip=None, amphorae=None): amphorae = amphorae or [] global LB_SEED LB_SEED += 1 lb = data_models.LoadBalancer(id='lb{0}-id'.format(LB_SEED), project_id='2', name='lb{0}'.format(LB_SEED), description='lb{0}'.format(LB_SEED), vip=vip, amphorae=amphorae) for amp in lb.amphorae: amp.load_balancer = lb amp.load_balancer_id = lb.id amp.status = constants.AMPHORA_ALLOCATED if vip: vip.load_balancer = lb vip.load_balancer_id = lb.id return lb
def test_db_loadbalancer_to_provider_loadbalancer(self, mock_get_session, mock_get_flavor): mock_get_flavor.return_value = {'shaved_ice': 'cherry'} vip = data_models.Vip(ip_address=self.sample_data.ip_address, network_id=self.sample_data.network_id, port_id=self.sample_data.port_id, subnet_id=self.sample_data.subnet_id) test_db_lb = data_models.LoadBalancer(id=1, flavor_id='2', vip=vip) provider_lb = utils.db_loadbalancer_to_provider_loadbalancer( test_db_lb) ref_provider_lb = driver_dm.LoadBalancer( loadbalancer_id=1, flavor={'shaved_ice': 'cherry'}, vip_address=self.sample_data.ip_address, vip_network_id=self.sample_data.network_id, vip_port_id=self.sample_data.port_id, vip_subnet_id=self.sample_data.subnet_id) self.assertEqual(ref_provider_lb.to_dict(render_unsets=True), provider_lb.to_dict(render_unsets=True))