def test_type_validation(self):
# Make sure internal type checking implementation properly sets types.
self.provider.config['text_type_check'] = 'test-text'
# pylint:disable=protected-access
config_value = self.provider._get_config_value('text_type_check', None)
self.assertIsInstance(config_value, six.string_types)
# pylint:disable=protected-access
env_value = self.provider._get_config_value(
'some_config_value', get_env('MOTO_AMIS_PATH'))
self.assertIsInstance(env_value, six.string_types)
# pylint:disable=protected-access
none_value = self.provider._get_config_value(
'some_config_value', get_env('MISSING_ENV', None))
self.assertIsNone(none_value)
# pylint:disable=protected-access
bool_value = self.provider._get_config_value(
'some_config_value', get_env('MISSING_ENV', True))
self.assertIsInstance(bool_value, bool)
# pylint:disable=protected-access
int_value = self.provider._get_config_value(
'default_result_limit', None)
self.assertIsInstance(int_value, int)
def __init__(self, config):
super(AzureCloudProvider, self).__init__(config)
# mandatory config values
self.subscription_id = self._get_config_value(
'azure_subscription_id', get_env('AZURE_SUBSCRIPTION_ID'))
self.client_id = self._get_config_value(
'azure_client_id', get_env('AZURE_CLIENT_ID', None))
self.secret = self._get_config_value(
'azure_secret', get_env('AZURE_SECRET', None))
self.tenant = self._get_config_value(
'azure_tenant', get_env('AZURE_TENANT', None))
# optional config values
self.access_token = self._get_config_value(
'azure_access_token', get_env('AZURE_ACCESS_TOKEN', None))
self.region_name = self._get_config_value(
'azure_region_name', get_env('AZURE_REGION_NAME', 'eastus'))
self.resource_group = self._get_config_value(
'azure_resource_group', get_env('AZURE_RESOURCE_GROUP',
'cloudbridge'))
# Storage account name is limited to a max length of 24 alphanum chars
# and unique across all of Azure. Thus, a uuid is used to generate a
# unique name for the Storage Account based on the resource group,
# while also using the subscription ID to ensure that different users
# having the same resource group name do not have the same SA name.
self.storage_account = self._get_config_value(
'azure_storage_account',
get_env(
'AZURE_STORAGE_ACCOUNT',
'storacc' + self.subscription_id[-6:] +
str(uuid.uuid5(uuid.NAMESPACE_OID,
str(self.resource_group)))[-6:]))
self.vm_default_user_name = self._get_config_value(
'azure_vm_default_username', get_env(
'AZURE_VM_DEFAULT_USERNAME', None)) \
or self.__get_deprecated_username('cbuser')
self.public_key_storage_table_name = self._get_config_value(
'azure_public_key_storage_table_name', get_env(
'AZURE_PUBLIC_KEY_STORAGE_TABLE_NAME', 'cbcerts'))
self._azure_client = None
self._security = AzureSecurityService(self)
self._storage = AzureStorageService(self)
self._compute = AzureComputeService(self)
self._networking = AzureNetworkingService(self)
def __get_deprecated_username(self, default):
username = self._get_config_value(
'azure_vm_default_user_name', get_env(
'AZURE_VM_DEFAULT_USER_NAME', None))
if username:
return self.__wrap_deprecated_username(username)
else:
return default
def _connect_cinder(self):
"""Get an OpenStack Cinder (block storage) client object."""
api_version = self._get_config_value(
'os_volume_api_version', get_env('OS_VOLUME_API_VERSION', 2))
return cinder_client.Client(api_version,
auth_url=self.auth_url,
session=self._keystone_session,
region_name=self.region_name)
def _connect_nova_region(self, region_name):
"""Get an OpenStack Nova (compute) client object."""
# Force reauthentication with Keystone
self._cached_keystone_session = None
api_version = self._get_config_value(
'os_compute_api_version', get_env('OS_COMPUTE_API_VERSION', 2))
service_name = self._get_config_value(
'nova_service_name', get_env('NOVA_SERVICE_NAME', None))
if self.config.debug_mode:
nova_shell.OpenStackComputeShell().setup_debugging(True)
nova = nova_client.Client(
api_version,
session=self._keystone_session,
auth_url=self.auth_url,
region_name=region_name,
service_name=service_name,
http_log_debug=True if self.config.debug_mode else False)
return nova
def __init__(self, config):
super(AWSCloudProvider, self).__init__(config)
# Initialize cloud connection fields
# These are passed as-is to Boto
self._region_name = self._get_config_value('aws_region_name',
'us-east-1')
self._zone_name = self._get_config_value('aws_zone_name')
self.session_cfg = {
'aws_access_key_id':
self._get_config_value('aws_access_key',
get_env('AWS_ACCESS_KEY')),
'aws_secret_access_key':
self._get_config_value('aws_secret_key',
get_env('AWS_SECRET_KEY')),
'aws_session_token':
self._get_config_value('aws_session_token', None)
}
self.ec2_cfg = {
'use_ssl': self._get_config_value('ec2_is_secure', True),
'verify': self._get_config_value('ec2_validate_certs', True),
'endpoint_url': self._get_config_value('ec2_endpoint_url')
}
self.s3_cfg = {
'use_ssl': self._get_config_value('s3_is_secure', True),
'verify': self._get_config_value('s3_validate_certs', True),
'endpoint_url': self._get_config_value('s3_endpoint_url')
}
# service connections, lazily initialized
self._session = None
self._ec2_conn = None
self._vpc_conn = None
self._s3_conn = None
# Initialize provider services
self._compute = AWSComputeService(self)
self._networking = AWSNetworkingService(self)
self._security = AWSSecurityService(self)
self._storage = AWSStorageService(self)
def _connect_swift(self, options=None):
"""
Get an OpenStack Swift (object store) client connection.
:param options: A dictionary of options from which values will be
passed to the connection.
:return: A Swift client connection using the auth credentials held by
the OpenStackCloudProvider instance
"""
clean_options = self._clean_options(options,
swift_client.Connection.__init__)
storage_url = self._get_config_value('os_storage_url',
get_env('OS_STORAGE_URL', None))
auth_token = self._get_config_value('os_auth_token',
get_env('OS_AUTH_TOKEN', None))
if storage_url and auth_token:
clean_options['preauthurl'] = storage_url
clean_options['preauthtoken'] = auth_token
else:
clean_options['authurl'] = self.auth_url
clean_options['session'] = self._keystone_session
return swift_client.Connection(**clean_options)
def test_type_validation(self):
"""
Make sure internal type checking implementation properly sets types.
"""
self.provider.config['text_type_check'] = 'test-text'
config_value = self.provider._get_config_value('text_type_check', None)
self.assertIsInstance(config_value, six.string_types)
env_value = self.provider._get_config_value('some_config_value',
get_env('MOTO_AMIS_PATH'))
self.assertIsInstance(env_value, six.string_types)
none_value = self.provider._get_config_value(
'some_config_value', get_env('MISSING_ENV', None))
self.assertIsNone(none_value)
bool_value = self.provider._get_config_value(
'some_config_value', get_env('MISSING_ENV', True))
self.assertIsInstance(bool_value, bool)
int_value = self.provider._get_config_value('default_result_limit',
None)
self.assertIsInstance(int_value, int)
def create_provider_instance(self):
provider_name = get_env("CB_TEST_PROVIDER", "aws")
use_mock_drivers = parse_bool(
os.environ.get("CB_USE_MOCK_PROVIDERS", "True"))
factory = CloudProviderFactory()
provider_class = factory.get_provider_class(provider_name,
get_mock=use_mock_drivers)
config = {
'default_wait_interval':
self.get_provider_wait_interval(provider_class),
'default_result_limit':
5
}
return provider_class(config)
def create_provider_instance(self):
provider_name = cb_helpers.get_env("CB_TEST_PROVIDER", "aws")
zone_cfg_key = get_provider_test_data(provider_name,
'placement_cfg_key')
factory = CloudProviderFactory()
provider_class = factory.get_provider_class(provider_name)
config = {
'default_wait_interval':
self.get_provider_wait_interval(provider_class),
'default_result_limit':
5,
zone_cfg_key:
get_provider_test_data(provider_name, 'placement')
}
return provider_class(config)
def __init__(self, config):
super(OpenStackCloudProvider, self).__init__(config)
# Initialize cloud connection fields
self.username = self._get_config_value(
'os_username', get_env('OS_USERNAME'))
self.password = self._get_config_value(
'os_password', get_env('OS_PASSWORD'))
self.project_name = self._get_config_value(
'os_project_name', get_env('OS_PROJECT_NAME')
or get_env('OS_TENANT_NAME'))
self.auth_url = self._get_config_value(
'os_auth_url', get_env('OS_AUTH_URL'))
self._region_name = self._get_config_value(
'os_region_name', get_env('OS_REGION_NAME'))
self._zone_name = self._get_config_value(
'os_zone_name', get_env('OS_ZONE_NAME'))
self.project_domain_name = self._get_config_value(
'os_project_domain_name',
get_env('OS_PROJECT_DOMAIN_NAME'))
self.user_domain_name = self._get_config_value(
'os_user_domain_name',
get_env('OS_USER_DOMAIN_NAME'))
# Service connections, lazily initialized
self._nova = None
self._keystone = None
self._glance = None
self._cinder = None
self._swift = None
self._neutron = None
self._os_conn = None
# Additional cached variables
self._cached_keystone_session = None
# Initialize provider services
self._compute = OpenStackComputeService(self)
self._networking = OpenStackNetworkingService(self)
self._security = OpenStackSecurityService(self)
self._storage = OpenStackStorageService(self)
class BaseInternetGateway(BaseCloudResource, BaseObjectLifeCycleMixin,
InternetGateway):
CB_DEFAULT_INET_GATEWAY_NAME = cb_helpers.get_env(
'CB_DEFAULT_INET_GATEWAY_NAME', 'cloudbridge-inetgateway')
def __init__(self, provider):
super(BaseInternetGateway, self).__init__(provider)
self.__provider = provider
def __eq__(self, other):
return (isinstance(other, InternetGateway) and
# pylint:disable=protected-access
self._provider == other._provider and self.id == other.id)
def wait_till_ready(self, timeout=None, interval=None):
self.wait_for(
[GatewayState.AVAILABLE],
terminal_states=[GatewayState.ERROR, GatewayState.UNKNOWN],
timeout=timeout,
interval=interval)
if op_func(sys.version_info, (major, minor)):
self.skipTest(
"Skipping test because python version {0} is {1} expected"
" version {2}".format(sys.version_info[:2], op,
(major, minor)))
func(self, *args, **kwargs)
return wrapper
return wrap
TEST_DATA_CONFIG = {
"AWSCloudProvider": {
# Match the ami value with entry in custom_amis.json for use with moto
"image": cb_helpers.get_env('CB_IMAGE_AWS', 'ami-aa2ea6d0'),
"vm_type": cb_helpers.get_env('CB_VM_TYPE_AWS', 't2.nano'),
"placement": cb_helpers.get_env('CB_PLACEMENT_AWS', 'us-east-1a'),
"placement_cfg_key": "aws_zone_name"
},
'OpenStackCloudProvider': {
'image':
cb_helpers.get_env('CB_IMAGE_OS',
'c66bdfa1-62b1-43be-8964-e9ce208ac6a5'),
"vm_type":
cb_helpers.get_env('CB_VM_TYPE_OS', 'm1.tiny'),
"placement":
cb_helpers.get_env('CB_PLACEMENT_OS', 'nova'),
"placement_cfg_key":
"os_zone_name"
},
if provider:
for service in services:
if not provider.has_service(service):
self.skipTest("Skipping test because '%s' service is"
" not implemented" % (service, ))
func(self, *args, **kwargs)
return wrapper
return wrap
TEST_DATA_CONFIG = {
"AWSCloudProvider": {
# Match the ami value with entry in custom_amis.json for use with moto
"image": get_env('CB_IMAGE_AWS', 'ami-aa2ea6d0'),
"vm_type": get_env('CB_VM_TYPE_AWS', 't2.nano'),
"placement": get_env('CB_PLACEMENT_AWS', 'us-east-1a'),
},
"OpenStackCloudProvider": {
"image":
os.environ.get('CB_IMAGE_OS', 'c66bdfa1-62b1-43be-8964-e9ce208ac6a5'),
"vm_type":
os.environ.get('CB_VM_TYPE_OS', 'm1.tiny'),
"placement":
os.environ.get('CB_PLACEMENT_OS', 'nova'),
},
"AzureCloudProvider": {
"placement":
get_env('CB_PLACEMENT_AZURE', 'eastus'),
"image":
