def test_init_with_all_data_v6(self, group_name):
        data = {
            group_name: {
                'standalone_network_plugin_gateway': '2001:db8::0001',
                'standalone_network_plugin_mask': '88',
                'standalone_network_plugin_segmentation_id': '3999',
                'standalone_network_plugin_allowed_ip_ranges': (
                    '2001:db8::-2001:db8:0000:0000:0000:007f:ffff:ffff'),
                'standalone_network_plugin_ip_version': 6,
            },
        }
        with test_utils.create_temp_config_with_opts(data):
            instance = plugin.StandaloneNetworkPlugin(
                config_group_name=group_name)

        self.assertEqual(6, instance.ip_version)
        self.assertEqual('2001:db8::0001', instance.gateway)
        self.assertEqual('88', instance.mask)
        self.assertEqual('3999', instance.segmentation_id)
        self.assertEqual(['2001:db8::/89'], instance.allowed_cidrs)
        self.assertEqual(
            ['2001:db8::-2001:db8:0000:0000:0000:007f:ffff:ffff'],
            instance.allowed_ip_ranges)
        self.assertEqual(
            netaddr.IPNetwork('2001:db8::0001/88'), instance.net)
        self.assertEqual(
            ('2001:db8::', '2001:db8::0001', '2001:db8::ff:ffff:ffff'),
            instance.reserved_addresses)
    def test_deallocate_network(self):
        share_server_id = 'fake_share_server_id'
        data = {
            'DEFAULT': {
                'standalone_network_plugin_gateway': '10.0.0.1',
                'standalone_network_plugin_mask': '24',
            },
        }
        fake_allocations = [{'id': 'fake1'}, {'id': 'fake2'}]
        with test_utils.create_temp_config_with_opts(data):
            instance = plugin.StandaloneNetworkPlugin()
        self.mock_object(
            instance.db, 'network_allocations_get_for_share_server',
            mock.Mock(return_value=fake_allocations))
        self.mock_object(instance.db, 'network_allocation_delete')

        instance.deallocate_network(fake_context, share_server_id)

        instance.db.network_allocations_get_for_share_server.\
            assert_called_once_with(fake_context, share_server_id)
        instance.db.network_allocation_delete.\
            assert_has_calls([
                mock.call(fake_context, 'fake1'),
                mock.call(fake_context, 'fake2'),
            ])
    def test_allocate_network_no_available_ipv4_addresses(self):
        data = {
            'DEFAULT': {
                'standalone_network_plugin_gateway': '10.0.0.1',
                'standalone_network_plugin_mask': '30',
            },
        }
        with test_utils.create_temp_config_with_opts(data):
            instance = plugin.StandaloneNetworkPlugin()
        self.mock_object(instance.db, 'share_network_update')
        self.mock_object(instance.db, 'network_allocation_create')
        self.mock_object(
            instance.db, 'network_allocations_get_by_ip_address',
            mock.Mock(return_value=['not empty list']))

        self.assertRaises(
            exception.NetworkBadConfigurationException,
            instance.allocate_network,
            fake_context, fake_share_server, fake_share_network)

        instance.db.share_network_update.assert_called_once_with(
            fake_context, fake_share_network['id'],
            dict(segmentation_id=None, cidr=instance.net.cidr, ip_version=4))
        instance.db.network_allocations_get_by_ip_address.assert_has_calls(
            [mock.call(fake_context, '10.0.0.2')])
 def test_init_valid(self):
     nova_net_id = 'fake_nova_net_id'
     config_data = dict(
         DEFAULT=dict(nova_single_network_plugin_net_id=nova_net_id))
     with test_utils.create_temp_config_with_opts(config_data):
         instance = plugin.NovaSingleNetworkPlugin()
     self.assertEqual(nova_net_id, instance.net_id)
    def test_allocate_network_one_ip_address_ipv4_no_usages_exist(self):
        data = {
            'DEFAULT': {
                'standalone_network_plugin_gateway': '10.0.0.1',
                'standalone_network_plugin_mask': '24',
            },
        }
        with test_utils.create_temp_config_with_opts(data):
            instance = plugin.StandaloneNetworkPlugin()
        self.mock_object(instance.db, 'share_network_update')
        self.mock_object(instance.db, 'network_allocation_create')
        self.mock_object(
            instance.db, 'network_allocations_get_by_ip_address',
            mock.Mock(return_value=[]))

        allocations = instance.allocate_network(
            fake_context, fake_share_server, fake_share_network)

        self.assertEqual(1, len(allocations))
        instance.db.share_network_update.assert_called_once_with(
            fake_context, fake_share_network['id'],
            dict(segmentation_id=None, cidr=instance.net.cidr, ip_version=4))
        instance.db.network_allocations_get_by_ip_address.assert_has_calls(
            [mock.call(fake_context, '10.0.0.2')])
        instance.db.network_allocation_create.assert_called_once_with(
            fake_context,
            dict(share_server_id=fake_share_server['id'],
                 ip_address='10.0.0.2', status=constants.STATUS_ACTIVE))
    def test_init_with_all_data_v4(self, group_name):
        data = {
            group_name: {
                'standalone_network_plugin_gateway': '10.0.0.1',
                'standalone_network_plugin_mask': '255.255.0.0',
                'standalone_network_plugin_segmentation_id': '1001',
                'standalone_network_plugin_allowed_ip_ranges': (
                    '10.0.0.3-10.0.0.7,10.0.0.69-10.0.0.157,10.0.0.213'),
                'standalone_network_plugin_ip_version': 4,
            },
        }
        allowed_cidrs = [
            '10.0.0.3/32', '10.0.0.4/30', '10.0.0.69/32', '10.0.0.70/31',
            '10.0.0.72/29', '10.0.0.80/28', '10.0.0.96/27', '10.0.0.128/28',
            '10.0.0.144/29', '10.0.0.152/30', '10.0.0.156/31', '10.0.0.213/32',
        ]
        with test_utils.create_temp_config_with_opts(data):
            instance = plugin.StandaloneNetworkPlugin(
                config_group_name=group_name)

        self.assertEqual(4, instance.ip_version)
        self.assertEqual('10.0.0.1', instance.gateway)
        self.assertEqual('255.255.0.0', instance.mask)
        self.assertEqual('1001', instance.segmentation_id)
        self.assertEqual(allowed_cidrs, instance.allowed_cidrs)
        self.assertEqual(
            ['10.0.0.3-10.0.0.7', '10.0.0.69-10.0.0.157', '10.0.0.213'],
            instance.allowed_ip_ranges)
        self.assertEqual(
            netaddr.IPNetwork('10.0.0.1/255.255.0.0'), instance.net)
        self.assertEqual(
            ('10.0.0.0', '10.0.0.1', '10.0.255.255'),
            instance.reserved_addresses)
    def test_init_only_with_required_data_v6(self, group_name):
        data = {
            group_name: {
                'standalone_network_plugin_gateway': (
                    '2001:cdba::3257:9652'),
                'standalone_network_plugin_mask': '48',
                'standalone_network_plugin_ip_version': 6,
            },
        }
        with test_utils.create_temp_config_with_opts(data):
            instance = plugin.StandaloneNetworkPlugin(
                config_group_name=group_name)

        self.assertEqual(
            '2001:cdba::3257:9652', instance.gateway)
        self.assertEqual('48', instance.mask)
        self.assertEqual(None, instance.segmentation_id)
        self.assertEqual(None, instance.allowed_ip_ranges)
        self.assertEqual(6, instance.ip_version)
        self.assertEqual(
            netaddr.IPNetwork('2001:cdba::3257:9652/48'),
            instance.net)
        self.assertEqual(
            ['2001:cdba::3257:9652/48'], instance.allowed_cidrs)
        self.assertEqual(
            ('2001:cdba::', '2001:cdba::3257:9652',
             '2001:cdba:0:ffff:ffff:ffff:ffff:ffff'),
            instance.reserved_addresses)
Exemple #8
0
    def test_no_auth_obj(self):
        mock_client_loader = self.mock_object(
            neutron_api.client_auth, 'AuthClientLoader')
        fake_context = 'fake_context'
        data = {
            'neutron': {
                'endpoint_type': 'foo_endpoint_type',
                'region_name': 'foo_region_name',
            }
        }

        self.client = None
        with test_utils.create_temp_config_with_opts(data):
            self.client = neutron_api.API()
            self.client.get_client(fake_context)

        mock_client_loader.assert_called_once_with(
            client_class=neutron_api.clientv20.Client,
            exception_module=neutron_api.neutron_client_exc,
            cfg_group=neutron_api.NEUTRON_GROUP
        )
        mock_client_loader.return_value.get_client.assert_called_once_with(
            self.client,
            fake_context,
            endpoint_type=data['neutron']['endpoint_type'],
            region_name=data['neutron']['region_name'],
        )
Exemple #9
0
    def test_no_auth_obj(self):
        mock_client_loader = self.mock_object(
            nova.client_auth, 'AuthClientLoader')
        fake_context = 'fake_context'
        data = {
            'nova': {
                'api_microversion': 'foo_api_microversion',
                'endpoint_type': 'foo_endpoint_type',
                'region_name': 'foo_region_name',
            }
        }

        with test_utils.create_temp_config_with_opts(data):
            nova.novaclient(fake_context)

        mock_client_loader.assert_called_once_with(
            client_class=nova.nova_client.Client,
            exception_module=nova.nova_exception,
            cfg_group=nova.NOVA_GROUP
        )
        mock_client_loader.return_value.get_client.assert_called_once_with(
            fake_context,
            version=data['nova']['api_microversion'],
            endpoint_type=data['nova']['endpoint_type'],
            region_name=data['nova']['region_name'],
        )
    def _setup_manage_network_allocations(self, label=None):
        data = {
            'DEFAULT': {
                'standalone_network_plugin_gateway': '192.168.0.1',
                'standalone_network_plugin_mask': '24',
            },
        }
        with test_utils.create_temp_config_with_opts(data):
            instance = plugin.StandaloneNetworkPlugin(label=label)

        return instance
    def test_allocate_network_two_ip_addresses_ipv4_two_usages_exist(self):
        ctxt = type('FakeCtxt', (object,), {'fake': ['10.0.0.2', '10.0.0.4']})

        def fake_get_allocations_by_ip_address(context, ip_address):
            if ip_address not in context.fake:
                context.fake.append(ip_address)
                return []
            else:
                return context.fake

        data = {
            'DEFAULT': {
                'standalone_network_plugin_gateway': '10.0.0.1',
                'standalone_network_plugin_mask': '24',
            },
        }
        with test_utils.create_temp_config_with_opts(data):
            instance = plugin.StandaloneNetworkPlugin()
        self.mock_object(instance.db, 'share_network_update')
        self.mock_object(instance.db, 'network_allocation_create')
        self.mock_object(
            instance.db, 'network_allocations_get_by_ip_address',
            mock.Mock(side_effect=fake_get_allocations_by_ip_address))

        allocations = instance.allocate_network(
            ctxt, fake_share_server, fake_share_network, count=2)

        self.assertEqual(2, len(allocations))
        na_data = {
            'network_type': None,
            'segmentation_id': None,
            'cidr': six.text_type(instance.net.cidr),
            'gateway': six.text_type(instance.gateway),
            'ip_version': 4,
            'mtu': 1500,
        }
        instance.db.share_network_update.assert_called_once_with(
            ctxt, fake_share_network['id'], dict(**na_data))
        instance.db.network_allocations_get_by_ip_address.assert_has_calls(
            [mock.call(ctxt, '10.0.0.2'), mock.call(ctxt, '10.0.0.3'),
             mock.call(ctxt, '10.0.0.4'), mock.call(ctxt, '10.0.0.5')])
        instance.db.network_allocation_create.assert_has_calls([
            mock.call(
                ctxt,
                dict(share_server_id=fake_share_server['id'],
                     ip_address='10.0.0.3', status=constants.STATUS_ACTIVE,
                     label='user', **na_data)),
            mock.call(
                ctxt,
                dict(share_server_id=fake_share_server['id'],
                     ip_address='10.0.0.5', status=constants.STATUS_ACTIVE,
                     label='user', **na_data)),
        ])
 def test_invalid_init_required_data_improper(self, data):
     group_name = 'custom_group_name'
     if 'gateway' in data:
         data['standalone_network_plugin_gateway'] = data.pop('gateway')
     if 'mask' in data:
         data['standalone_network_plugin_mask'] = data.pop('mask')
     data = {group_name: data}
     with test_utils.create_temp_config_with_opts(data):
         self.assertRaises(
             exception.NetworkBadConfigurationException,
             plugin.StandaloneNetworkPlugin,
             config_group_name=group_name)
Exemple #13
0
    def test_init_invalid(self, net, subnet):
        config_data = dict()
        # Simulate absence of set values
        if net:
            config_data['neutron_net_id'] = net
        if subnet:
            config_data['neutron_subnet_id'] = subnet
        config_data = dict(DEFAULT=config_data)

        with test_utils.create_temp_config_with_opts(config_data):
            self.assertRaises(
                exception.NetworkBadConfigurationException,
                plugin.NeutronSingleNetworkPlugin)
Exemple #14
0
 def _get_neutron_single_network_plugin_instance(self):
     fake_subnet_id = 'fake_subnet_id'
     config_data = {
         'DEFAULT': {
             'neutron_net_id': 'fake_net_id',
             'neutron_subnet_id': fake_subnet_id,
         }
     }
     fake_net = {'subnets': [fake_subnet_id]}
     self.mock_object(
         neutron_api.API, 'get_network', mock.Mock(return_value=fake_net))
     with test_utils.create_temp_config_with_opts(config_data):
         instance = plugin.NeutronSingleNetworkPlugin()
         return instance
 def test_invalid_init_mismatch_of_versions(self, gateway, vers):
     group_name = 'DEFAULT'
     data = {
         group_name: {
             'standalone_network_plugin_gateway': gateway,
             'standalone_network_plugin_ip_version': vers,
             'standalone_network_plugin_mask': '25',
         },
     }
     with test_utils.create_temp_config_with_opts(data):
         self.assertRaises(
             exception.NetworkBadConfigurationException,
             plugin.StandaloneNetworkPlugin,
             config_group_name=group_name)
 def test_invalid_init_incorrect_allowed_ip_ranges_v4(self, ip_range):
     group_name = 'DEFAULT'
     data = {
         group_name: {
             'standalone_network_plugin_gateway': '10.0.0.1',
             'standalone_network_plugin_mask': '255.255.255.0',
             'standalone_network_plugin_allowed_ip_ranges': ip_range,
         },
     }
     with test_utils.create_temp_config_with_opts(data):
         self.assertRaises(
             exception.NetworkBadConfigurationException,
             plugin.StandaloneNetworkPlugin,
             config_group_name=group_name)
    def test_init_with_valid_network_types_v4(self, network_type):
        data = {
            'DEFAULT': {
                'standalone_network_plugin_gateway': '10.0.0.1',
                'standalone_network_plugin_mask': '255.255.0.0',
                'standalone_network_plugin_network_type': network_type,
                'standalone_network_plugin_segmentation_id': 1001,
                'standalone_network_plugin_ip_version': 4,
            },
        }
        with test_utils.create_temp_config_with_opts(data):
            instance = plugin.StandaloneNetworkPlugin(
                config_group_name='DEFAULT')

            self.assertEqual(instance.network_type, network_type)
 def test_init_with_fake_network_types_v4(self, fake_network_type):
     data = {
         'DEFAULT': {
             'standalone_network_plugin_gateway': '10.0.0.1',
             'standalone_network_plugin_mask': '255.255.0.0',
             'standalone_network_plugin_network_type': fake_network_type,
             'standalone_network_plugin_segmentation_id': 1001,
             'standalone_network_plugin_ip_version': 4,
         },
     }
     with test_utils.create_temp_config_with_opts(data):
         self.assertRaises(
             cfg.ConfigFileValueError,
             plugin.StandaloneNetworkPlugin,
             config_group_name='DEFAULT',
         )
Exemple #19
0
    def test_init_subnet_does_not_belong_to_net(self, fake_net):
        fake_net_id = 'fake_net_id'
        config_data = {
            'DEFAULT': {
                'neutron_net_id': fake_net_id,
                'neutron_subnet_id': 'fake_subnet_id',
            }
        }
        self.mock_object(
            neutron_api.API, 'get_network', mock.Mock(return_value=fake_net))

        with test_utils.create_temp_config_with_opts(config_data):
            self.assertRaises(
                exception.NetworkBadConfigurationException,
                plugin.NeutronSingleNetworkPlugin)
            neutron_api.API.get_network.assert_called_once_with(fake_net_id)
    def test_allocate_network_zero_addresses_ipv4(self):
        data = {
            'DEFAULT': {
                'standalone_network_plugin_gateway': '10.0.0.1',
                'standalone_network_plugin_mask': '24',
            },
        }
        with test_utils.create_temp_config_with_opts(data):
            instance = plugin.StandaloneNetworkPlugin()
        self.mock_object(instance.db, 'share_network_update')

        allocations = instance.allocate_network(
            fake_context, fake_share_server, fake_share_network, count=0)

        self.assertEqual([], allocations)
        instance.db.share_network_update.assert_called_once_with(
            fake_context, fake_share_network['id'],
            dict(segmentation_id=None, cidr=instance.net.cidr, ip_version=4))
    def test_invalid_init_mismatch_of_versions(self, gateway, vers):
        group_name = 'DEFAULT'
        data = {
            group_name: {
                'standalone_network_plugin_gateway': gateway,
                'standalone_network_plugin_mask': '25',
            },
        }
        if vers == 4:
            data[group_name]['network_plugin_ipv4_enabled'] = True
        if vers == 6:
            data[group_name]['network_plugin_ipv4_enabled'] = False
            data[group_name]['network_plugin_ipv6_enabled'] = True

        with test_utils.create_temp_config_with_opts(data):
            self.assertRaises(
                exception.NetworkBadConfigurationException,
                plugin.StandaloneNetworkPlugin,
                config_group_name=group_name)
Exemple #22
0
    def test_init_valid(self):
        fake_net_id = 'fake_net_id'
        fake_subnet_id = 'fake_subnet_id'
        config_data = {
            'DEFAULT': {
                'neutron_net_id': fake_net_id,
                'neutron_subnet_id': fake_subnet_id,
            }
        }
        fake_net = {'subnets': ['fake1', 'fake2', fake_subnet_id]}
        self.mock_object(
            neutron_api.API, 'get_network', mock.Mock(return_value=fake_net))

        with test_utils.create_temp_config_with_opts(config_data):
            instance = plugin.NeutronSingleNetworkPlugin()

            self.assertEqual(fake_net_id, instance.net)
            self.assertEqual(fake_subnet_id, instance.subnet)
            neutron_api.API.get_network.assert_called_once_with(fake_net_id)
Exemple #23
0
    def test_with_auth_obj(self):
        fake_context = 'fake_context'
        data = {
            'nova': {
                'api_microversion': 'foo_api_microversion',
                'endpoint_type': 'foo_endpoint_type',
                'region_name': 'foo_region_name',
            }
        }

        with test_utils.create_temp_config_with_opts(data):
            nova.novaclient(fake_context)

        nova.AUTH_OBJ.get_client.assert_called_once_with(
            fake_context,
            version=data['nova']['api_microversion'],
            endpoint_type=data['nova']['endpoint_type'],
            region_name=data['nova']['region_name'],
        )
Exemple #24
0
    def test_no_auth_obj(self):
        mock_client_loader = self.mock_object(
            nova.client_auth, 'AuthClientLoader')
        fake_context = 'fake_context'
        data = {
            'DEFAULT': {
                'nova_admin_username': '******',
                'nova_admin_password': '******',
                'nova_admin_tenant_name': 'foo_tenant_name',
                'nova_admin_auth_url': 'foo_auth_url',
            },
            'nova': {
                'api_microversion': 'foo_api_microversion',
                'api_insecure': True,
                'ca_certificates_file': 'foo_ca_certificates_file',
                'endpoint_type': 'foo_endpoint_type',
                'region_name': 'foo_region_name',
            }
        }

        with test_utils.create_temp_config_with_opts(data):
            nova.novaclient(fake_context)

        mock_client_loader.assert_called_once_with(
            client_class=nova.nova_client.Client,
            exception_module=nova.nova_exception,
            cfg_group=nova.NOVA_GROUP,
            deprecated_opts_for_v2={
                'username': data['DEFAULT']['nova_admin_username'],
                'password': data['DEFAULT']['nova_admin_password'],
                'tenant_name': data['DEFAULT']['nova_admin_tenant_name'],
                'auth_url': data['DEFAULT']['nova_admin_auth_url'],
            },
        )
        mock_client_loader.return_value.get_client.assert_called_once_with(
            fake_context,
            version=data['nova']['api_microversion'],
            insecure=data['nova']['api_insecure'],
            cacert=data['nova']['ca_certificates_file'],
            endpoint_type=data['nova']['endpoint_type'],
            region_name=data['nova']['region_name'],
        )
Exemple #25
0
    def test_no_auth_obj(self):
        mock_client_loader = self.mock_object(
            cinder.client_auth, 'AuthClientLoader')
        fake_context = 'fake_context'
        data = {
            'DEFAULT': {
                'cinder_admin_username': '******',
                'cinder_admin_password': '******',
                'cinder_admin_tenant_name': 'foo_tenant_name',
                'cinder_admin_auth_url': 'foo_auth_url',
            },
            'cinder': {
                'api_insecure': True,
                'ca_certificates_file': 'foo_ca_certificates_file',
                'http_retries': 3,
                'endpoint_type': 'foo_endpoint_type',
                'region_name': 'foo_region_name',
            }
        }

        with test_utils.create_temp_config_with_opts(data):
            cinder.cinderclient(fake_context)

        mock_client_loader.assert_called_once_with(
            client_class=cinder.cinder_client.Client,
            exception_module=cinder.cinder_exception,
            cfg_group=cinder.CINDER_GROUP,
            deprecated_opts_for_v2={
                'username': data['DEFAULT']['cinder_admin_username'],
                'password': data['DEFAULT']['cinder_admin_password'],
                'tenant_name': data['DEFAULT']['cinder_admin_tenant_name'],
                'auth_url': data['DEFAULT']['cinder_admin_auth_url'],
            },
        )
        mock_client_loader.return_value.get_client.assert_called_once_with(
            fake_context,
            insecure=data['cinder']['api_insecure'],
            cacert=data['cinder']['ca_certificates_file'],
            retries=data['cinder']['http_retries'],
            endpoint_type=data['cinder']['endpoint_type'],
            region_name=data['cinder']['region_name'],
        )
Exemple #26
0
    def test_allocate_network_host_id_prconfigured(self):
        has_provider_nw_ext = mock.patch.object(
            self.plugin, '_has_provider_network_extension').start()
        has_provider_nw_ext.return_value = True
        save_nw_data = mock.patch.object(self.plugin,
                                         '_save_neutron_network_data').start()
        save_subnet_data = mock.patch.object(
            self.plugin,
            '_save_neutron_subnet_data').start()

        config_data = {
            'DEFAULT': {
                'neutron_host_id': 'fake_host_id',
            }
        }
        with test_utils.create_temp_config_with_opts(config_data):
            with mock.patch.object(self.plugin.neutron_api, 'create_port',
                                   mock.Mock(return_value=fake_neutron_port)):
                self.plugin.allocate_network(
                    self.fake_context,
                    fake_share_server,
                    fake_share_network,
                    allocation_info={'count': 1})

                has_provider_nw_ext.assert_any_call()
                save_nw_data.assert_called_once_with(self.fake_context,
                                                     fake_share_network)
                save_subnet_data.assert_called_once_with(self.fake_context,
                                                         fake_share_network)
                self.plugin.neutron_api.create_port.assert_called_once_with(
                    fake_share_network['project_id'],
                    network_id=fake_share_network['neutron_net_id'],
                    subnet_id=fake_share_network['neutron_subnet_id'],
                    device_owner='manila:share', host_id='fake_host_id')
                db_api.network_allocation_create.assert_called_once_with(
                    self.fake_context,
                    fake_network_allocation)

                has_provider_nw_ext.stop()
                save_nw_data.stop()
                save_subnet_data.stop()
    def test_init_only_with_required_data_v4(self, group_name):
        data = {
            group_name: {
                'standalone_network_plugin_gateway': '10.0.0.1',
                'standalone_network_plugin_mask': '24',
            },
        }
        with test_utils.create_temp_config_with_opts(data):
            instance = plugin.StandaloneNetworkPlugin(
                config_group_name=group_name)

        self.assertEqual('10.0.0.1', instance.gateway)
        self.assertEqual('24', instance.mask)
        self.assertEqual(None, instance.segmentation_id)
        self.assertEqual(None, instance.allowed_ip_ranges)
        self.assertEqual(4, instance.ip_version)
        self.assertEqual(netaddr.IPNetwork('10.0.0.1/24'), instance.net)
        self.assertEqual(['10.0.0.1/24'], instance.allowed_cidrs)
        self.assertEqual(
            ('10.0.0.0', '10.0.0.1', '10.0.0.255'),
            instance.reserved_addresses)
    def test_no_auth_obj(self):
        mock_client_loader = self.mock_object(
            neutron_api.client_auth, 'AuthClientLoader')
        fake_context = 'fake_context'
        data = {
            'DEFAULT': {
                'neutron_admin_username': '******',
                'neutron_admin_password': '******',
                'neutron_admin_tenant_name': 'foo_tenant_name',
                'neutron_admin_auth_url': 'foo_auth_url',
            },
            'neutron': {
                'endpoint_type': 'foo_endpoint_type',
                'region_name': 'foo_region_name',
            }
        }

        self.client = None
        with test_utils.create_temp_config_with_opts(data):
            self.client = neutron_api.API()
            self.client.get_client(fake_context)

        mock_client_loader.assert_called_once_with(
            client_class=neutron_api.clientv20.Client,
            exception_module=neutron_api.neutron_client_exc,
            cfg_group=neutron_api.NEUTRON_GROUP,
            deprecated_opts_for_v2={
                'username': data['DEFAULT']['neutron_admin_username'],
                'password': data['DEFAULT']['neutron_admin_password'],
                'tenant_name': data['DEFAULT']['neutron_admin_tenant_name'],
                'auth_url': data['DEFAULT']['neutron_admin_auth_url'],
            },
        )
        mock_client_loader.return_value.get_client.assert_called_once_with(
            self.client,
            fake_context,
            endpoint_type=data['neutron']['endpoint_type'],
            region_name=data['neutron']['region_name'],
        )
Exemple #29
0
    def test_with_auth_obj(self):
        fake_context = 'fake_context'
        data = {
            'neutron': {
                'endpoint_type': 'foo_endpoint_type',
                'region_name': 'foo_region_name',
            }
        }

        self.client = None
        with test_utils.create_temp_config_with_opts(data):
            self.client = neutron_api.API()
            self.client.auth_obj = type(
                'FakeAuthObj', (object, ), {'get_client': mock.Mock()})
            self.client.get_client(fake_context)

        self.client.auth_obj.get_client.assert_called_once_with(
            self.client,
            fake_context,
            endpoint_type=data['neutron']['endpoint_type'],
            region_name=data['neutron']['region_name'],
        )
    def test_allocate_network_zero_addresses_ipv6(self):
        data = {
            'DEFAULT': {
                'standalone_network_plugin_gateway': '2001:db8::0001',
                'standalone_network_plugin_mask': '64',
                'standalone_network_plugin_ip_version': 6,
            },
        }
        with test_utils.create_temp_config_with_opts(data):
            instance = plugin.StandaloneNetworkPlugin()
        self.mock_object(instance.db, 'share_network_update')

        allocations = instance.allocate_network(
            fake_context, fake_share_server, fake_share_network, count=0)

        self.assertEqual([], allocations)
        instance.db.share_network_update.assert_called_once_with(
            fake_context, fake_share_network['id'],
            dict(network_type=None, segmentation_id=None,
                 cidr=six.text_type(instance.net.cidr),
                 gateway=six.text_type(instance.gateway),
                 ip_version=6,
                 mtu=1500))
Exemple #31
0
    def test_with_auth_obj(self):
        fake_context = 'fake_context'
        data = {
            'neutron': {
                'url': 'http://localhost:9696',
                'endpoint_type': 'foo_endpoint_type',
                'region_name': 'foo_region_name',
            }
        }

        self.client = None
        with test_utils.create_temp_config_with_opts(data):
            self.client = neutron_api.API()
            self.client.auth_obj = type(
                'FakeAuthObj', (object, ), {'get_client': mock.Mock()})
            self.client.get_client(fake_context)

        self.client.auth_obj.get_client.assert_called_once_with(
            self.client,
            fake_context,
            endpoint_type=data['neutron']['endpoint_type'],
            region_name=data['neutron']['region_name'],
            endpoint_override=data['neutron']['url'],
        )
Exemple #32
0
    def test_allocate_network_zero_addresses_ipv6(self):
        data = {
            'DEFAULT': {
                'standalone_network_plugin_gateway': '2001:db8::0001',
                'standalone_network_plugin_mask': '64',
                'standalone_network_plugin_ip_version': 6,
            },
        }
        with test_utils.create_temp_config_with_opts(data):
            instance = plugin.StandaloneNetworkPlugin()
        self.mock_object(instance.db, 'share_network_update')

        allocations = instance.allocate_network(fake_context,
                                                fake_share_server,
                                                fake_share_network,
                                                count=0)

        self.assertEqual([], allocations)
        instance.db.share_network_update.assert_called_once_with(
            fake_context, fake_share_network['id'],
            dict(network_type=None,
                 segmentation_id=None,
                 cidr=six.text_type(instance.net.cidr),
                 ip_version=6))
Exemple #33
0
    def test_no_auth_obj(self):
        mock_client_loader = self.mock_object(cinder.client_auth,
                                              'AuthClientLoader')
        fake_context = 'fake_context'
        data = {
            'cinder': {
                'http_retries': 3,
                'endpoint_type': 'foo_endpoint_type',
                'region_name': 'foo_region_name',
            }
        }

        with test_utils.create_temp_config_with_opts(data):
            cinder.cinderclient(fake_context)

        mock_client_loader.assert_called_once_with(
            client_class=cinder.cinder_client.Client,
            cfg_group=cinder.CINDER_GROUP)
        mock_client_loader.return_value.get_client.assert_called_once_with(
            fake_context,
            retries=data['cinder']['http_retries'],
            endpoint_type=data['cinder']['endpoint_type'],
            region_name=data['cinder']['region_name'],
        )
Exemple #34
0
 def test_verify_share_driver_mode_option_type(self):
     data = {'DEFAULT': {'driver_handles_share_servers': 'True'}}
     with test_utils.create_temp_config_with_opts(data):
         share_driver = driver.ShareDriver([True, False])
         self.assertTrue(share_driver.driver_handles_share_servers)
 def _get_instance(self, label=None):
     nova_net_id = 'fake_nova_net_id'
     config_data = dict(DEFAULT=dict(
         nova_single_network_plugin_net_id=nova_net_id))
     with test_utils.create_temp_config_with_opts(config_data):
         return plugin.NovaSingleNetworkPlugin(label=label)
Exemple #36
0
 def test_verify_share_protocols_invalid_cases(self, proto):
     data = dict(DEFAULT=dict(enabled_share_protocols=proto))
     with test_utils.create_temp_config_with_opts(data):
         self.assertRaises(exception.ManilaException,
                           config.verify_share_protocols)
Exemple #37
0
 def test_verify_share_protocols_valid_cases(self, proto):
     data = dict(DEFAULT=dict(enabled_share_protocols=proto))
     with test_utils.create_temp_config_with_opts(data):
         config.verify_share_protocols()
Exemple #38
0
    def test_allocate_network_two_ip_addresses_ipv4_two_usages_exist(self):
        ctxt = type('FakeCtxt', (object, ), {'fake': ['10.0.0.2', '10.0.0.4']})

        def fake_get_allocations_by_ip_address(context, ip_address):
            if ip_address not in context.fake:
                context.fake.append(ip_address)
                return []
            else:
                return context.fake

        data = {
            'DEFAULT': {
                'standalone_network_plugin_gateway': '10.0.0.1',
                'standalone_network_plugin_mask': '24',
            },
        }
        with test_utils.create_temp_config_with_opts(data):
            instance = plugin.StandaloneNetworkPlugin()
        self.mock_object(instance.db, 'share_network_update')
        self.mock_object(instance.db, 'network_allocation_create')
        self.mock_object(
            instance.db, 'network_allocations_get_by_ip_address',
            mock.Mock(side_effect=fake_get_allocations_by_ip_address))

        allocations = instance.allocate_network(ctxt,
                                                fake_share_server,
                                                fake_share_network,
                                                count=2)

        self.assertEqual(2, len(allocations))
        na_data = {
            'network_type': None,
            'segmentation_id': None,
            'cidr': six.text_type(instance.net.cidr),
            'gateway': six.text_type(instance.gateway),
            'ip_version': 4,
        }
        instance.db.share_network_update.assert_called_once_with(
            ctxt, fake_share_network['id'], dict(**na_data))
        instance.db.network_allocations_get_by_ip_address.assert_has_calls([
            mock.call(ctxt, '10.0.0.2'),
            mock.call(ctxt, '10.0.0.3'),
            mock.call(ctxt, '10.0.0.4'),
            mock.call(ctxt, '10.0.0.5')
        ])
        instance.db.network_allocation_create.assert_has_calls([
            mock.call(
                ctxt,
                dict(share_server_id=fake_share_server['id'],
                     ip_address='10.0.0.3',
                     status=constants.STATUS_ACTIVE,
                     label='user',
                     **na_data)),
            mock.call(
                ctxt,
                dict(share_server_id=fake_share_server['id'],
                     ip_address='10.0.0.5',
                     status=constants.STATUS_ACTIVE,
                     label='user',
                     **na_data)),
        ])
 def test_init_invalid(self, data):
     config_data = dict(DEFAULT=data)
     with test_utils.create_temp_config_with_opts(config_data):
         self.assertRaises(exception.NetworkBadConfigurationException,
                           plugin.NovaSingleNetworkPlugin)