class _ComputeAuthComposite(MemoizedAuthServiceComposite): _compute_endpoint_config = ComputeEndpointConfig _auth_endpoint_config = UserAuthConfig() _auth_user_config = UserConfig() def __init__(self): self.compute_endpoint_config = self._compute_endpoint_config() self.marshalling_config = MarshallingConfig() super(_ComputeAuthComposite, self).__init__( service_name=self.compute_endpoint_config.compute_endpoint_name, region=self.compute_endpoint_config.region, endpoint_config=self._auth_endpoint_config, user_config=self._auth_user_config) self.servers_url = self.public_url if self.compute_endpoint_config.compute_endpoint_url: self.servers_url = '{0}/{1}'.format( self.compute_endpoint_config.compute_endpoint_url, self.tenant_id) self.client_args = { 'url': self.servers_url, 'auth_token': self.token_id, 'serialize_format': self.marshalling_config.serializer, 'deserialize_format': self.marshalling_config.deserializer }
def setUpClass(cls): super(ObjectStorageFixture, cls).setUpClass() endpoint_config = UserAuthConfig() user_config = UserConfig() objectstorage_config = ObjectStorageConfig() objectstorage_api_config = ObjectStorageAPIConfig() auth_provider = AuthProvider() access_data = auth_provider.get_access_data(endpoint_config, user_config) service = access_data.get_service( objectstorage_config.identity_service_name) endpoint = service.get_endpoint(objectstorage_config.region) storage_url = endpoint.public_url auth_token = access_data.token.id_ cls.base_container_name = objectstorage_api_config.base_container_name cls.base_object_name = objectstorage_api_config.base_object_name cls.client = ObjectStorageAPIClient(storage_url, auth_token) cls.behaviors = ObjectStorageAPI_Behaviors(client=cls.client)
def get_auth_data(): """ Authenticate and return a dictionary containing the storage url and auth token. """ result = { 'storage_url': None, 'auth_token': None} endpoint_config = UserAuthConfig() user_config = UserConfig() objectstorage_config = ObjectStorageConfig() auth_provider = AuthProvider() access_data = auth_provider.get_access_data( endpoint_config, user_config) if endpoint_config.strategy.lower() == 'saio_tempauth': result['storage_url'] = access_data.storage_url result['auth_token'] = access_data.auth_token else: service = access_data.get_service( objectstorage_config.identity_service_name) endpoint = service.get_endpoint(objectstorage_config.region) result['storage_url'] = endpoint.public_url result['auth_token'] = access_data.token.id_ return result
def get_access_data(self, endpoint_config=None, user_config=None): endpoint_config = endpoint_config or UserAuthConfig() user_config = user_config or UserConfig() if endpoint_config.strategy.lower() == 'keystone': token_client = OSTokenAPI_Client( endpoint_config.auth_endpoint, 'json', 'json') token_behaviors = OSTokenAPI_Behaviors(token_client) return token_behaviors.get_access_data(user_config.username, user_config.password, user_config.tenant_name) elif endpoint_config.strategy.lower() == 'rax_auth': token_client = RaxTokenAPI_Client( endpoint_config.auth_endpoint, 'json', 'json') token_behaviors = RaxTokenAPI_Behaviors(token_client) return token_behaviors.get_access_data(user_config.username, user_config.api_key, user_config.tenant_id) elif endpoint_config.strategy.lower() == 'saio_tempauth': auth_client = SaioAuthAPI_Client(endpoint_config.auth_endpoint) auth_behaviors = SaioAuthAPI_Behaviors(auth_client) return auth_behaviors.get_access_data( user_config.username, user_config.password) else: raise NotImplementedError
def __init__( self, service_name, region, endpoint_config=None, user_config=None): self.endpoint_config = endpoint_config or UserAuthConfig() self.user_config = user_config or UserConfig() self.service_name = service_name self.region = region
def setUpClass(cls): super(ComputeFixture, cls).setUpClass() cls.flavors_config = FlavorsConfig() cls.images_config = ImagesConfig() cls.servers_config = ServersConfig() cls.compute_endpoint = ComputeEndpointConfig() cls.marshalling = MarshallingConfig() cls.config_drive_config = ConfigDriveConfig() cls.flavor_ref = cls.flavors_config.primary_flavor cls.flavor_ref_alt = cls.flavors_config.secondary_flavor cls.image_ref = cls.images_config.primary_image cls.image_ref_alt = cls.images_config.secondary_image cls.disk_path = cls.servers_config.instance_disk_path cls.endpoint_config = UserAuthConfig() cls.user_config = UserConfig() access_data = AuthProvider.get_access_data(cls.endpoint_config, cls.user_config) # If authentication fails, halt if access_data is None: cls.assertClassSetupFailure('Authentication failed.') compute_service = access_data.get_service( cls.compute_endpoint.compute_endpoint_name) url = compute_service.get_endpoint( cls.compute_endpoint.region).public_url # If a url override was provided, use that value instead if cls.compute_endpoint.compute_endpoint_url: url = '{0}/{1}'.format(cls.compute_endpoint.compute_endpoint_url, cls.user_config.tenant_id) client_args = {'url': url, 'auth_token': access_data.token.id_, 'serialize_format': cls.marshalling.serializer, 'deserialize_format': cls.marshalling.deserializer} cls.flavors_client = FlavorsClient(**client_args) cls.servers_client = ServersClient(**client_args) cls.images_client = ImagesClient(**client_args) cls.keypairs_client = KeypairsClient(**client_args) cls.security_groups_client = SecurityGroupsClient(**client_args) cls.security_group_rule_client = SecurityGroupRulesClient( **client_args) cls.rescue_client = RescueClient(**client_args) cls.vnc_client = VncConsoleClient(**client_args) cls.console_output_client = ConsoleOutputClient(**client_args) cls.server_behaviors = ServerBehaviors(cls.servers_client, cls.servers_config, cls.images_config, cls.flavors_config) cls.image_behaviors = ImageBehaviors(cls.images_client, cls.servers_client, cls.images_config) cls.config_drive_behaviors = ConfigDriveBehaviors(cls.servers_client, cls.servers_config, cls.server_behaviors) cls.flavors_client.add_exception_handler(ExceptionHandler()) cls.resources = ResourcePool()
def __init__(self, images_client, images_config): super(ImagesV1Behaviors, self).__init__() self.config = images_config self.client = images_client access_data = AuthProvider().get_access_data() self.tenants_client = TenantsAPI_Client(UserAuthConfig().auth_endpoint, access_data.token.id_, 'json', 'json')
def __init__(self, service_name, region, endpoint_config=None, user_config=None): self.endpoint_config = endpoint_config or UserAuthConfig() self.user_config = user_config or UserConfig() self.access_data = self.cache_access_data(endpoint_config, user_config) self.token_id = self.access_data.token.id_ self.tenant_id = self.access_data.token.tenant.id_ self.service_name = service_name self.region = region
def setUpClass(cls): super(ImagesFixture, cls).setUpClass() cls.images_config = ImagesConfig() cls.marshalling = MarshallingConfig() cls.endpoint_config = UserAuthConfig() cls.user_config = UserConfig() cls.alt_user_config = AltUserConfig() cls.third_user_config = ThirdUserConfig() cls.resources = ResourcePool() cls.serialize_format = cls.marshalling.serializer cls.deserialize_format = cls.marshalling.deserializer cls.user_list = cls.generate_user_list(cls.images_config.account_list) cls.access_data = cls.user_list['user'][cls.ACCESS_DATA] cls.images_client = cls.user_list['user'][cls.CLIENT] cls.images_behavior = cls.user_list['user'][cls.BEHAVIOR] cls.tenant_id = cls.access_data.token.tenant.id_ cls.addClassCleanup(cls.images_behavior.resources.release) if cls.user_list.get('alt_user'): cls.alt_access_data = cls.user_list['alt_user'][cls.ACCESS_DATA] cls.alt_images_client = cls.user_list['alt_user'][cls.CLIENT] cls.alt_images_behavior = cls.user_list['alt_user'][cls.BEHAVIOR] cls.alt_tenant_id = cls.alt_access_data.token.tenant.id_ cls.addClassCleanup(cls.alt_images_behavior.resources.release) if cls.user_list.get('third_user'): cls.third_access_data = ( cls.user_list['third_user'][cls.ACCESS_DATA]) cls.third_images_client = cls.user_list['third_user'][cls.CLIENT] cls.third_images_behavior = ( cls.user_list['third_user'][cls.BEHAVIOR]) cls.third_tenant_id = cls.third_access_data.token.tenant.id_ cls.addClassCleanup(cls.third_images_behavior.resources.release) cls.error_msg = Messages.ERROR_MSG cls.id_regex = re.compile(ImageProperties.ID_REGEX) cls.import_from = cls.images_config.import_from cls.import_from_bootable = cls.images_config.import_from_bootable cls.import_from_format = cls.images_config.import_from_format cls.export_to = cls.images_config.export_to cls.max_created_at_delta = cls.images_config.max_created_at_delta cls.max_expires_at_delta = cls.images_config.max_expires_at_delta cls.max_updated_at_delta = cls.images_config.max_updated_at_delta cls.test_file = cls.read_data_file(cls.images_config.test_file) cls.addClassCleanup(cls.resources.release) cls.exception_handler = ExceptionHandler() cls.images_client.add_exception_handler(cls.exception_handler)
def setUpClass(cls): super(ImagesV1Fixture, cls).setUpClass() access_data = AuthProvider().get_access_data() images_endpoint = '{base_url}/v1'.format(base_url=cls.config.base_url) cls.remote_image = cls.config.remote_image cls.http_image = cls.config.http_image cls.tenants_client = TenantsAPI_Client(UserAuthConfig().auth_endpoint, access_data.token.id_, 'json', 'json') cls.api_client = ImagesV1Client(images_endpoint, access_data.token.id_, 'json', 'json') cls.behaviors = ImagesV1Behaviors(cls.api_client, cls.config) cls.tenant_ids = TenantsBehaviors( cls.tenants_client).get_all_tenant_ids()
def __init__(self, username=None, password=None): self.storage_url = None self.auth_token = None self._access_data = AuthComposite.authenticate(username, password) self.endpoint_config = UserAuthConfig() self.objectstorage_config = ObjectStorageConfig() if self.endpoint_config.strategy.lower() == 'saio_tempauth': self.storage_url = self._access_data.storage_url self.auth_token = self._access_data.auth_token else: service = self._access_data.get_service( self.objectstorage_config.identity_service_name) endpoint = service.get_endpoint(self.objectstorage_config.region) self.storage_url = endpoint.public_url self.auth_token = self._access_data.token.id_
def authenticate(cls, username=None, password=None): """ Should only be called from an instance of AuthComposite """ if username and password: from cloudcafe.identity.v2_0.tokens_api.client import \ TokenAPI_Client client = TokenAPI_Client(UserAuthConfig().auth_endpoint, serialize_format="json", deserialize_format="json") access_data = client.authenticate(username=username, password=password).entity else: access_data = AuthProvider.get_access_data() if access_data is None: raise AssertionError('Authentication failed in setup') return access_data
def setUpClass(cls): super(ComputeFixture, cls).setUpClass() cls.flavors_config = FlavorsConfig() cls.images_config = ImagesConfig() cls.servers_config = ServersConfig() cls.compute_endpoint = ComputeEndpointConfig() cls.flavor_ref = cls.flavors_config.primary_flavor cls.flavor_ref_alt = cls.flavors_config.secondary_flavor cls.image_ref = cls.images_config.primary_image cls.image_ref_alt = cls.images_config.secondary_image cls.disk_path = cls.servers_config.instance_disk_path cls.endpoint_config = UserAuthConfig() user_config = UserConfig() access_data = AuthProvider.get_access_data(cls.endpoint_config, user_config) compute_service = access_data.get_service( cls.compute_endpoint.compute_endpoint_name) url = compute_service.get_endpoint( cls.compute_endpoint.region).public_url cls.flavors_client = FlavorsClient(url, access_data.token.id_, 'json', 'json') cls.servers_client = ServersClient(url, access_data.token.id_, 'json', 'json') cls.images_client = ImagesClient(url, access_data.token.id_, 'json', 'json') cls.keypairs_client = KeypairsClient(url, access_data.token.id_, 'json', 'json') cls.sec_groups_client = SecurityGroupsClient(url, access_data.token.id_, 'json', 'json') cls.rescue_client = RescueClient(url, access_data.token.id_, 'json', 'json') cls.server_behaviors = ServerBehaviors(cls.servers_client, cls.servers_config, cls.images_config, cls.flavors_config) cls.image_behaviors = ImageBehaviors(cls.images_client, cls.servers_client, cls.images_config) cls.flavors_client.add_exception_handler(ExceptionHandler()) cls.resources = ResourcePool()
def get_access_data(endpoint_config=None, user_config=None): endpoint_config = endpoint_config or UserAuthConfig() user_config = user_config or UserConfig() if endpoint_config.strategy.lower() == 'keystone': return IdentityServiceBehaviors.get_access_data( user_config.username, user_config.password, user_config.tenant_name, endpoint_config.auth_endpoint) elif endpoint_config.strategy.lower() == 'rax_auth': token_client = RaxTokenAPI_Client(endpoint_config.auth_endpoint, 'json', 'json') token_behaviors = RaxTokenAPI_Behaviors(token_client) return token_behaviors.get_access_data(user_config.username, user_config.api_key, user_config.tenant_id) elif endpoint_config.strategy.lower() == 'rax_auth_mfa': passcode = user_config.passcode if passcode is None: # TODO: This is a place holder for adding the functionality to # use an external service (e.g. - SMS) to provide the passcode pass token_client = RaxToken_MFA_API_Client( url=endpoint_config.auth_endpoint, serialize_format='json', deserialize_format='json') token_behaviors = RaxToken_MFA_API_Behaviors(token_client) return token_behaviors.get_access_data( username=user_config.username, password=user_config.password, tenant_id=user_config.tenant_id, passcode=passcode) elif endpoint_config.strategy.lower() == 'saio_tempauth': auth_client = SaioAuthAPI_Client(endpoint_config.auth_endpoint) auth_behaviors = SaioAuthAPI_Behaviors(auth_client) return auth_behaviors.get_access_data(user_config.username, user_config.password) else: raise NotImplementedError
def setUpClass(cls): super(BareMetalFixture, cls).setUpClass() cls.marshalling = MarshallingConfig() cls.bare_metal_endpoint = BareMetalEndpointConfig() cls.endpoint_config = UserAuthConfig() cls.user_config = UserConfig() cls.access_data = AuthProvider.get_access_data(cls.endpoint_config, cls.user_config) # If authentication fails, halt if cls.access_data is None: cls.assertClassSetupFailure('Authentication failed.') bare_metal_service = cls.access_data.get_service( cls.bare_metal_endpoint.bare_metal_endpoint_name) url = bare_metal_service.get_endpoint( cls.bare_metal_endpoint.region).public_url # If a url override was provided, use that value instead if cls.bare_metal_endpoint.bare_metal_endpoint_url: url = cls.bare_metal_endpoint.bare_metal_endpoint_url client_args = { 'url': url, 'auth_token': cls.access_data.token.id_, 'serialize_format': cls.marshalling.serializer, 'deserialize_format': cls.marshalling.deserializer } cls.chassis_client = ChassisClient(**client_args) cls.drivers_client = DriversClient(**client_args) cls.nodes_client = NodesClient(**client_args) cls.ports_client = PortsClient(**client_args) cls.resources = ResourcePool() cls.addClassCleanup(cls.resources.release)
def setUpClass(cls): super(ImagesIntegrationFixture, cls).setUpClass() cls.object_storage_client = cls.client cls.object_storage_behaviors = cls.behaviors # Work around to create compute/obj storage additional user composites auth_endpoint_config = UserAuthConfig() compute_endpoint = ComputeEndpointConfig() images_config = ImagesConfig() flavors_config = FlavorsConfig() marshalling_config = MarshallingConfig() object_storage_config = ObjectStorageConfig() object_storage_api_config = ObjectStorageAPIConfig() servers_config = ServersConfig() user_config_alt_one = AltOneUserConfig() access_data_alt_one = AuthProvider.get_access_data( auth_endpoint_config, user_config_alt_one) # Create compute clients and behaviors for alt_one user compute_service_alt_one = access_data_alt_one.get_service( compute_endpoint.compute_endpoint_name) compute_url_check_alt_one = compute_service_alt_one.get_endpoint( compute_endpoint.region) # If compute endpoint validation fails, fail immediately if compute_url_check_alt_one is None: cls.assertClassSetupFailure('Compute endpoint validation failed') compute_url_alt_one = compute_service_alt_one.get_endpoint( compute_endpoint.region).public_url cls.compute_alt_one_images_client = ComputeImagesClient( compute_url_alt_one, access_data_alt_one.token.id_, marshalling_config.serializer, marshalling_config.deserializer) cls.compute_alt_one_servers_client = ServersClient( compute_url_alt_one, access_data_alt_one.token.id_, marshalling_config.serializer, marshalling_config.deserializer) cls.compute_alt_one_images_behaviors = ComputeImageBehaviors( images_client=cls.compute_alt_one_images_client, servers_client=cls.compute_alt_one_servers_client, config=images_config) cls.compute_alt_one_servers_behaviors = ServerBehaviors( servers_client=cls.compute_alt_one_servers_client, images_client=cls.compute_alt_one_images_client, servers_config=servers_config, images_config=images_config, flavors_config=flavors_config) # Create object storage client and behaviors for alt_one user object_storage_service_alt_one = access_data_alt_one.get_service( object_storage_config.identity_service_name) object_storage_url_check_alt_one = ( object_storage_service_alt_one.get_endpoint( object_storage_config.region)) # If endpoint validation fails, fail immediately if object_storage_url_check_alt_one is None: cls.assertClassSetupFailure('Endpoint validation failed') storage_url_alt_one = object_storage_service_alt_one.get_endpoint( object_storage_config.region).public_url cls.object_storage_alt_one_client = ObjectStorageAPIClient( storage_url_alt_one, access_data_alt_one.token.id_) cls.object_storage_alt_one_behaviors = ObjectStorageAPI_Behaviors( cls.object_storage_alt_one_client, object_storage_api_config) # Needed in order to allow assertions on exceptions cls.compute.flavors.client.delete_exception_handler( cls.compute_exception_handler)
def setUpClass(cls): """ Initialize autoscale configs, behaviors and client """ super(AutoscaleFixture, cls).setUpClass() cls.resources = ResourcePool() cls.autoscale_config = AutoscaleConfig() cls.endpoint_config = UserAuthConfig() user_config = UserConfig() access_data = AuthProvider.get_access_data(cls.endpoint_config, user_config) server_service = access_data.get_service( cls.autoscale_config.server_endpoint_name) load_balancer_service = access_data.get_service( cls.autoscale_config.load_balancer_endpoint_name) server_url = server_service.get_endpoint( cls.autoscale_config.region).public_url lbaas_url = load_balancer_service.get_endpoint( cls.autoscale_config.region).public_url cls.tenant_id = cls.autoscale_config.tenant_id env = os.environ['OSTNG_CONFIG_FILE'] if ('preprod' in env.lower()) or ('dev' in env.lower()): cls.url = str(cls.autoscale_config.server_endpoint) + '/' + str( cls.tenant_id) else: autoscale_service = access_data.get_service( cls.autoscale_config.autoscale_endpoint_name) cls.url = autoscale_service.get_endpoint( cls.autoscale_config.region).public_url cls.autoscale_client = AutoscalingAPIClient(cls.url, access_data.token.id_, 'json', 'json') cls.server_client = ServersClient(server_url, access_data.token.id_, 'json', 'json') cls.lbaas_client = LbaasAPIClient(lbaas_url, access_data.token.id_, 'json', 'json') cls.autoscale_behaviors = AutoscaleBehaviors(cls.autoscale_config, cls.autoscale_client) cls.gc_name = cls.autoscale_config.gc_name cls.gc_cooldown = int(cls.autoscale_config.gc_cooldown) cls.gc_min_entities = int(cls.autoscale_config.gc_min_entities) cls.gc_min_entities_alt = int(cls.autoscale_config.gc_min_entities_alt) cls.gc_max_entities = int(cls.autoscale_config.gc_max_entities) cls.lc_name = cls.autoscale_config.lc_name cls.lc_flavor_ref = cls.autoscale_config.lc_flavor_ref cls.lc_image_ref = cls.autoscale_config.lc_image_ref cls.lc_image_ref_alt = cls.autoscale_config.lc_image_ref_alt cls.sp_name = rand_name(cls.autoscale_config.sp_name) cls.sp_cooldown = int(cls.autoscale_config.sp_cooldown) cls.sp_change = int(cls.autoscale_config.sp_change) cls.sp_change_percent = int(cls.autoscale_config.sp_change_percent) cls.sp_desired_capacity = int(cls.autoscale_config.sp_desired_capacity) cls.sp_policy_type = cls.autoscale_config.sp_policy_type cls.upd_sp_change = int(cls.autoscale_config.upd_sp_change) cls.lc_load_balancers = cls.autoscale_config.lc_load_balancers cls.sp_list = cls.autoscale_config.sp_list cls.wb_name = rand_name(cls.autoscale_config.wb_name) cls.load_balancer_1 = int(cls.autoscale_config.load_balancer_1) cls.load_balancer_2 = int(cls.autoscale_config.load_balancer_2) cls.load_balancer_3 = int(cls.autoscale_config.load_balancer_3) cls.lb_other_region = int(cls.autoscale_config.lb_other_region) cls.interval_time = int(cls.autoscale_config.interval_time) cls.timeout = int(cls.autoscale_config.timeout) cls.scheduler_interval = OtterConstants.SCHEDULER_INTERVAL cls.scheduler_batch = OtterConstants.SCHEDULER_BATCH cls.max_maxentities = OtterConstants.MAX_MAXENTITIES cls.max_cooldown = OtterConstants.MAX_COOLDOWN cls.max_groups = OtterConstants.MAX_GROUPS cls.max_policies = OtterConstants.MAX_POLICIES cls.max_webhooks = OtterConstants.MAX_WEBHOOKS cls.limit_value_all = OtterConstants.LIMIT_VALUE_ALL cls.limit_unit_all = OtterConstants.LIMIT_UNIT_ALL cls.limit_value_webhook = OtterConstants.LIMIT_VALUE_WEBHOOK cls.limit_unit_webhook = OtterConstants.LIMIT_UNIT_WEBHOOK cls.non_autoscale_username = cls.autoscale_config.non_autoscale_username cls.non_autoscale_password = cls.autoscale_config.non_autoscale_password cls.non_autoscale_tenant = cls.autoscale_config.non_autoscale_tenant
def setUpClass(cls): super(ImagesFixture, cls).setUpClass() cls.images_config = ImagesConfig() cls.marshalling = MarshallingConfig() cls.endpoint_config = UserAuthConfig() cls.user_config = UserConfig() cls.alt_user_config = AltUserConfig() cls.third_user_config = ThirdUserConfig() cls.resources = ResourcePool() cls.serialize_format = cls.marshalling.serializer cls.deserialize_format = cls.marshalling.deserializer cls.access_data = AuthProvider.get_access_data(cls.endpoint_config, cls.user_config) # If authentication fails, fail immediately if cls.access_data is None: cls.assertClassSetupFailure('Authentication failed') cls.alt_access_data = AuthProvider.get_access_data( cls.endpoint_config, cls.alt_user_config) # If authentication fails, fail immediately if cls.alt_access_data is None: cls.assertClassSetupFailure('Authentication failed') cls.third_access_data = AuthProvider.get_access_data( cls.endpoint_config, cls.third_user_config) # If authentication fails, fail immediately if cls.third_access_data is None: cls.assertClassSetupFailure('Authentication failed') images_service = cls.access_data.get_service( cls.images_config.endpoint_name) images_url_check = images_service.get_endpoint( cls.images_config.region) # If endpoint validation fails, fail immediately if images_url_check is None: cls.assertClassSetupFailure('Endpoint validation failed') cls.url = (images_service.get_endpoint( cls.images_config.region).public_url) # If a url override was provided, use it instead if cls.images_config.override_url: cls.url = cls.images_config.override_url cls.images_client = cls.generate_images_client(cls.access_data) cls.alt_images_client = cls.generate_images_client(cls.alt_access_data) cls.third_images_client = cls.generate_images_client( cls.third_access_data) cls.images_behavior = ImagesBehaviors(images_client=cls.images_client, images_config=cls.images_config) cls.alt_images_behavior = ImagesBehaviors( images_client=cls.alt_images_client, images_config=cls.images_config) cls.third_images_behavior = ImagesBehaviors( images_client=cls.third_images_client, images_config=cls.images_config) cls.alt_tenant_id = cls.alt_access_data.token.tenant.id_ cls.error_msg = Messages.ERROR_MSG cls.export_to = cls.images_config.export_to cls.id_regex = re.compile(ImageProperties.ID_REGEX) cls.import_from = cls.images_config.import_from cls.import_from_bootable = cls.images_config.import_from_bootable cls.import_from_format = cls.images_config.import_from_format cls.max_created_at_delta = cls.images_config.max_created_at_delta cls.max_expires_at_delta = cls.images_config.max_expires_at_delta cls.max_updated_at_delta = cls.images_config.max_updated_at_delta cls.tenant_id = cls.access_data.token.tenant.id_ cls.third_tenant_id = cls.third_access_data.token.tenant.id_ cls.test_file = cls.read_data_file(cls.images_config.test_file) cls.image_schema_json = cls.read_data_file( cls.images_config.image_schema_json) cls.images_schema_json = cls.read_data_file( cls.images_config.images_schema_json) cls.image_member_schema_json = cls.read_data_file( cls.images_config.image_member_schema_json) cls.image_members_schema_json = cls.read_data_file( cls.images_config.image_members_schema_json) cls.task_schema_json = cls.read_data_file( cls.images_config.task_schema_json) cls.tasks_schema_json = cls.read_data_file( cls.images_config.tasks_schema_json) cls.addClassCleanup(cls.resources.release) cls.addClassCleanup(cls.images_behavior.resources.release) cls.addClassCleanup(cls.alt_images_behavior.resources.release) cls.addClassCleanup(cls.third_images_behavior.resources.release)
def setUpClass(cls): super(ComputeFixture, cls).setUpClass() cls.flavors_config = FlavorsConfig() cls.images_config = ImagesConfig() cls.servers_config = ServersConfig() cls.compute_endpoint = ComputeEndpointConfig() cls.marshalling = MarshallingConfig() cls.config_drive_config = ConfigDriveConfig() cls.cloud_init_config = CloudInitConfig() cls.flavor_ref = cls.flavors_config.primary_flavor cls.flavor_ref_alt = cls.flavors_config.secondary_flavor cls.image_ref = cls.images_config.primary_image cls.image_ref_alt = cls.images_config.secondary_image cls.disk_path = cls.servers_config.instance_disk_path cls.split_ephemeral_disk_enabled = \ cls.servers_config.split_ephemeral_disk_enabled cls.ephemeral_disk_max_size = \ cls.servers_config.ephemeral_disk_max_size cls.disk_format_type = cls.servers_config.disk_format_type cls.expected_networks = cls.servers_config.expected_networks cls.file_injection_enabled = \ cls.servers_config.personality_file_injection_enabled cls.endpoint_config = UserAuthConfig() cls.user_config = UserConfig() cls.access_data = AuthProvider.get_access_data(cls.endpoint_config, cls.user_config) # If authentication fails, halt if cls.access_data is None: cls.assertClassSetupFailure('Authentication failed.') compute_service = cls.access_data.get_service( cls.compute_endpoint.compute_endpoint_name) url = compute_service.get_endpoint( cls.compute_endpoint.region).public_url # If a url override was provided, use that value instead if cls.compute_endpoint.compute_endpoint_url: url = '{0}/{1}'.format(cls.compute_endpoint.compute_endpoint_url, cls.user_config.tenant_id) client_args = {'url': url, 'auth_token': cls.access_data.token.id_, 'serialize_format': cls.marshalling.serializer, 'deserialize_format': cls.marshalling.deserializer} cls.flavors_client = FlavorsClient(**client_args) cls.servers_client = ServersClient(**client_args) cls.boot_from_volume_client = VolumesBootClient(**client_args) cls.images_client = ImagesClient(**client_args) cls.keypairs_client = KeypairsClient(**client_args) cls.security_groups_client = SecurityGroupsClient(**client_args) cls.security_group_rule_client = SecurityGroupRulesClient( **client_args) cls.volume_attachments_client = VolumeAttachmentsAPIClient( url=url, auth_token=cls.access_data.token.id_, serialize_format=cls.marshalling.serializer, deserialize_format=cls.marshalling.deserializer) cls.rescue_client = RescueClient(**client_args) cls.vnc_client = VncConsoleClient(**client_args) cls.console_output_client = ConsoleOutputClient(**client_args) cls.limits_client = LimitsClient(**client_args) cls.server_behaviors = ServerBehaviors( servers_client=cls.servers_client, images_client=cls.images_client, servers_config=cls.servers_config, images_config=cls.images_config, flavors_config=cls.flavors_config) cls.volume_server_behaviors = VolumeServerBehaviors( servers_client=cls.servers_client, images_client=cls.images_client, servers_config=cls.servers_config, images_config=cls.images_config, flavors_config=cls.flavors_config, server_behaviors=cls.server_behaviors, boot_from_volume_client=cls.boot_from_volume_client) cls.image_behaviors = ImageBehaviors(cls.images_client, cls.servers_client, cls.images_config) cls.config_drive_behaviors = ConfigDriveBehaviors(cls.servers_client, cls.servers_config, cls.server_behaviors) cls.flavors_client.add_exception_handler(ExceptionHandler()) cls.resources = ResourcePool() cls.addClassCleanup(cls.resources.release)
"Will not run RCv3 tests.") if not all([x is not None for x in (_autoscale_client, _server_client, _lbaas_client)]): raise Exception( "Unable to instantiate all necessary clients.") return (_autoscale_client, _server_client, _images_client, _lbaas_client, _rcv3_client) # Global testing state - unfortunate, but only needs to be done once and also # makes it easier to skip tests based on configs and clients. autoscale_config = AutoscaleConfig() endpoint_config = UserAuthConfig() # Get optional RCV3 values. These might not be present in the config # file. try: _rcv3_load_balancer_pool = json.loads( autoscale_config.rcv3_load_balancer_pool) except Exception: _rcv3_load_balancer_pool = None _rcv3_cloud_network = autoscale_config.rcv3_cloud_network (autoscale_client, server_client, images_client, lbaas_client, rcv3_client) = _set_up_clients()