def setUpClass(cls): super(ComputeAdminFixture, cls).setUpClass() # Setup admin client auth_config = ComputeAdminAuthConfig() user_config = ComputeAdminUserConfig() access_data = AuthProvider.get_access_data(auth_config, user_config) admin_endpoint_config = ComputeAdminEndpointConfig() compute_service = access_data.get_service( admin_endpoint_config.compute_endpoint_name) url = compute_service.get_endpoint( admin_endpoint_config.region).public_url cls.admin_flavors_client = FlavorsClient(url, access_data.token.id_, 'json', 'json') cls.admin_servers_client = ServersClient(url, access_data.token.id_, 'json', 'json') cls.admin_server_behaviors = ServerBehaviors(cls.admin_servers_client, cls.servers_config, cls.images_config, cls.flavors_config) cls.admin_images_client = ImagesClient(url, access_data.token.id_, 'json', 'json') cls.admin_images_behaviors = ImageBehaviors(cls.admin_images_client, cls.admin_servers_client, cls.images_config) cls.admin_hosts_client = HostsClient(url, access_data.token.id_, 'json', 'json') cls.admin_quotas_client = QuotasClient(url, access_data.token.id_, 'json', 'json') cls.admin_servers_client.add_exception_handler(ExceptionHandler())
def setUpClass(cls): super(AuthorizationTests, cls).setUpClass() cls.metadata = {'meta_key_1': 'meta_value_1', 'meta_key_2': 'meta_value_2'} cls.server = cls.server_behaviors.create_active_server( metadata=cls.metadata).entity cls.resources.add(cls.server.id, cls.servers_client.delete_server) image_name = rand_name('testimage') cls.image_meta = {'key1': 'value1', 'key2': 'value2'} image_resp = cls.servers_client.create_image(cls.server.id, image_name, cls.image_meta) assert image_resp.status_code == 202 cls.image_id = cls.parse_image_id(image_resp) cls.image_behaviors.wait_for_image_status( cls.image_id, NovaImageStatusTypes.ACTIVE) cls.resources.add(cls.image_id, cls.images_client.delete_image) secondary_user = ComputeAuthorizationConfig() access_data = AuthProvider.get_access_data(cls.endpoint_config, secondary_user) 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.flavors_client.add_exception_handler(ExceptionHandler())
def setUpClass(cls): super(ComputeAdminFixture, cls).setUpClass() # Setup admin client auth_config = ComputeAdminAuthConfig() user_config = ComputeAdminUserConfig() access_data = AuthProvider.get_access_data(auth_config, user_config) admin_endpoint_config = ComputeAdminEndpointConfig() compute_service = access_data.get_service( admin_endpoint_config.compute_endpoint_name) url = compute_service.get_endpoint( admin_endpoint_config.region).public_url client_args = {'url': url, 'auth_token': access_data.token.id_, 'serialize_format': cls.marshalling.serializer, 'deserialize_format': cls.marshalling.deserializer} cls.admin_flavors_client = FlavorsClient(**client_args) cls.admin_servers_client = ServersClient(**client_args) cls.admin_images_client = ImagesClient(**client_args) cls.admin_hosts_client = HostsClient(**client_args) cls.admin_quotas_client = QuotasClient(**client_args) cls.admin_hypervisors_client = HypervisorsClient(**client_args) cls.admin_server_behaviors = ServerBehaviors(cls.admin_servers_client, cls.servers_config, cls.images_config, cls.flavors_config) cls.admin_images_behaviors = ImageBehaviors(cls.admin_images_client, cls.admin_servers_client, cls.images_config) cls.admin_servers_client.add_exception_handler(ExceptionHandler())
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 setUpClass(cls): super(TestFixedIPsMultiple, cls).setUpClass() network_name = 'network_{0}'.format(cls.NAMES_PREFIX) cls.network = cls.create_server_network(name=network_name, ipv4=True) cls.delete_networks.append(cls.network.id) keypair_name = 'key_{0}'.format(cls.NAMES_PREFIX) cls.keypair = cls.create_keypair(name=keypair_name) cls.delete_keypairs.append(cls.keypair.name) svr_name = 'svr_{0}'.format(cls.NAMES_PREFIX) network_ids = [ cls.public_network_id, cls.service_network_id, cls.network.id ] cls.server = cls.create_test_server(name=svr_name, key_name=cls.keypair.name, network_ids=network_ids, active_server=False) cls.server_persona = ServerPersona(server=cls.server, pnet=True, snet=True, inet=True, pnet_fix_ipv4_count=1, snet_fix_ipv4_count=1, inet_fix_ipv4_count=1, network=cls.network, keypair=cls.keypair, ssh_username='******') server_ids = [cls.server_persona.server.id] cls.delete_servers.extend(server_ids) cls.pub_net_id = cls.public_network_id cls.pri_net_id = cls.service_network_id cls.iso_net_id = cls.network.id cls.initial_pub_ip = cls.server_persona.pnet_fix_ipv4 cls.initial_pri_ip = cls.server_persona.snet_fix_ipv4 cls.initial_iso_ip = cls.server_persona.inet_fix_ipv4 # Initial IPv4 counts, update as needed if using a specific server cls.ini_ips_count = 1 # Multiple fixed IPs to add cls.FIXED_IPS_TO_ADD = cls.net.config.multiple_fixed_ips_to_add admin_user = ComputeAdminUserConfig() compute_admin_endpoint = ComputeAdminEndpointConfig() auth_endpoint_config = ComputeAdminAuthConfig() access_data = AuthProvider.get_access_data(auth_endpoint_config, admin_user) compute_service = access_data.get_service( compute_admin_endpoint.compute_endpoint_name) url = compute_service.get_endpoint( compute_admin_endpoint.region).public_url cls.servers_client = ServersClient(url, access_data.token.id_, 'json', 'json') cls.add_msg = ('Unable to add a {0} network fixed IP to server {1} ' 'Response: {2}') cls.rem_msg = ('Unable to remove a {0} network fixed IP of server {1} ' 'Response: {2}')
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 setUpClass(cls): """ Perform actions that setup the necessary resources for testing. The following resources are created during this setup: - Creates an active server with metadata. - Creates an image with metadata and waits for active status. """ super(AuthorizationTests, cls).setUpClass() cls.metadata = { 'meta_key_1': 'meta_value_1', 'meta_key_2': 'meta_value_2' } cls.server = cls.server_behaviors.create_active_server( metadata=cls.metadata).entity cls.resources.add(cls.server.id, cls.servers_client.delete_server) image_name = rand_name('testimage') cls.image_meta = {'user_key1': 'value1', 'user_key2': 'value2'} image_resp = cls.servers_client.create_image(cls.server.id, image_name, cls.image_meta) assert image_resp.status_code == 202 cls.image_id = cls.parse_image_id(image_resp) cls.image_behaviors.wait_for_image_status(cls.image_id, NovaImageStatusTypes.ACTIVE) cls.resources.add(cls.image_id, cls.images_client.delete_image) secondary_user = ComputeAuthorizationConfig() compute_endpoint = ComputeEndpointConfig() auth_endpoint_config = UserAuthConfig() access_data = AuthProvider.get_access_data(auth_endpoint_config, secondary_user) compute_service = access_data.get_service( compute_endpoint.compute_endpoint_name) url = compute_service.get_endpoint(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.flavors_client.add_exception_handler(ExceptionHandler())
def __init__(self): self.compute_auth_composite = _ComputeAuthComposite() self.config = ServersConfig() self.client = ServersClient(**self.compute_auth_composite.client_args) self.behaviors = None
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)
class TestFixedIPsConnectivity(NetworkingComputeFixture, ScenarioMixin): """ Testing connectivity between servers by adding fixed ips to existing servers. """ NAMES_PREFIX = 'fixed_ips_connectivity' PRIVATE_KEY_PATH = '/root/pkey' MAX_RETRIES = 5 admin_user = ComputeAdminUserConfig() compute_admin_endpoint = ComputeAdminEndpointConfig() auth_endpoint_config = ComputeAdminAuthConfig() access_data = AuthProvider.get_access_data(auth_endpoint_config, admin_user) compute_service = access_data.get_service( compute_admin_endpoint.compute_endpoint_name) url = compute_service.get_endpoint( compute_admin_endpoint.region).public_url servers_client = ServersClient(url, access_data.token.id_, 'json', 'json') SSH_COMMAND = ('ssh -o UserKnownHostsFile=/dev/null ' '-o StrictHostKeyChecking=no -o ConnectTimeout=60 ' '-i {private_key_path} {user}@{ip_address}') ssh_msg = ('Failed remote ssh connection from ' 'server {0} to server {1}') @classmethod def setUpClass(cls): super(TestFixedIPsConnectivity, cls).setUpClass() network_name = 'network_{0}'.format(cls.NAMES_PREFIX) cls.network = cls.create_server_network(name=network_name, ipv4=True) cls.delete_networks.append(cls.network.id) keypair_name = 'key_{0}'.format(cls.NAMES_PREFIX) cls.keypair = cls.create_keypair(name=keypair_name) cls.delete_keypairs.append(cls.keypair.name) svr_name_1 = 'svr_1_{0}'.format(cls.NAMES_PREFIX) svr_name_2 = 'svr_2_{0}'.format(cls.NAMES_PREFIX) network_ids = [ cls.public_network_id, cls.service_network_id, cls.network.id ] cls.server1 = cls.create_test_server(name=svr_name_1, key_name=cls.keypair.name, network_ids=network_ids, active_server=False) cls.server2 = cls.create_test_server(name=svr_name_2, key_name=cls.keypair.name, network_ids=network_ids, active_server=False) cls.servers = [cls.server1, cls.server2] cls.FIXED_IPS_TO_ADD = cls.net.config.fixed_ips_to_add cls.PNET_FIX_IPv4_COUNT = cls.FIXED_IPS_TO_ADD + 1 cls.SNET_FIX_IPv4_COUNT = cls.FIXED_IPS_TO_ADD + 1 cls.INET_FIX_IPv4_COUNT = cls.FIXED_IPS_TO_ADD + 1 cls.TOTAL_INITIAL_IPS_SERVER = 3 cls.TOTAL_NETWORKS_ATTACHED_TO_SERVER = 3 cls.TOTAL_IPS_SERVER = cls.TOTAL_INITIAL_IPS_SERVER + \ (cls.FIXED_IPS_TO_ADD * cls.TOTAL_NETWORKS_ATTACHED_TO_SERVER) # Add fixed IPs to servers for server in cls.servers: cls.add_fixed_ips_network(server, cls.public_network_id, number_fixed_ips=cls.FIXED_IPS_TO_ADD) cls.add_fixed_ips_network(server, cls.service_network_id, number_fixed_ips=cls.FIXED_IPS_TO_ADD) cls.add_fixed_ips_network(server, cls.network.id, number_fixed_ips=cls.FIXED_IPS_TO_ADD) cls.server_persona1 = ServerPersona( server=cls.server1, pnet=True, snet=True, inet=True, pnet_fix_ipv4_count=cls.PNET_FIX_IPv4_COUNT, snet_fix_ipv4_count=cls.SNET_FIX_IPv4_COUNT, inet_fix_ipv4_count=cls.INET_FIX_IPv4_COUNT, network=cls.network, keypair=cls.keypair, ssh_username='******') cls.server_persona2 = ServerPersona( server=cls.server2, pnet=True, snet=True, inet=True, pnet_fix_ipv4_count=cls.PNET_FIX_IPv4_COUNT, snet_fix_ipv4_count=cls.SNET_FIX_IPv4_COUNT, inet_fix_ipv4_count=cls.INET_FIX_IPv4_COUNT, network=cls.network, keypair=cls.keypair, ssh_username='******') server_ids = [ cls.server_persona1.server.id, cls.server_persona2.server.id ] cls.delete_servers.extend(server_ids) cls._transfer_private_key_to_vm( cls.server_persona1.remote_client.ssh_client, cls.keypair.private_key, cls.PRIVATE_KEY_PATH) cls._transfer_private_key_to_vm( cls.server_persona2.remote_client.ssh_client, cls.keypair.private_key, cls.PRIVATE_KEY_PATH) @tags('admin', 'positive') def test_server_ifconfig(self): """Testing ifconfig on servers""" servers = [self.server_persona1, self.server_persona2] for server in servers: ips = [] ips.extend(server.pnet_fix_ipv4) ips.extend(server.snet_fix_ipv4) ips.extend(server.inet_fix_ipv4) rm_client = server.remote_client ifconfig_ips = [] stdout = None retry_count = 0 while stdout is None or len(ifconfig_ips) != self.TOTAL_IPS_SERVER: del ifconfig_ips[:] if retry_count < self.MAX_RETRIES: ifconfig_output = rm_client.ssh_client.\ execute_shell_command("hostname -I") stdout = ifconfig_output.stdout pattern = re.compile(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}') matches = pattern.finditer(stdout) for match in matches: ifconfig_ips.append(match.group()) if len(ifconfig_ips) == self.TOTAL_IPS_SERVER or \ retry_count == self.MAX_RETRIES: break retry_count += 1 server_ip_not_found = False for ip in ips: if ip not in ifconfig_ips: server_ip_not_found = True break self.assertFalse(server_ip_not_found, msg="server {} ip {} not found in output of " "ifconfig {}".format(server, ip, ifconfig_ips)) @tags('admin', 'positive') def test_public_ping(self): """Testing ping on servers with public network""" msg_err = 'Public ping to IP address {0} - FAILED' msg_ok = 'Public ping to IP address {0} - OK' pub_ipv4_addr = [] pub_ipv4_addr.extend(self.server_persona1.pnet_fix_ipv4) pub_ipv4_addr.extend(self.server_persona2.pnet_fix_ipv4) all_pub_ips_ping_result = [] failure_flag = False for ip_addr in pub_ipv4_addr: ip_addr_reachable = PingClient.ping(ip_addr, 4) if ip_addr_reachable: all_pub_ips_ping_result.append(msg_ok.format(ip_addr)) else: all_pub_ips_ping_result.append(msg_err.format(ip_addr)) failure_flag = True msg = 'Got connectivity failures. Ping Results: {0}' # Fail the test if any ping failure is found self.assertFalse(failure_flag, msg.format(all_pub_ips_ping_result)) @tags('admin', 'positive') def test_remote_public_ping(self): """Testing public network remote ping on servers""" self._test_remote_ping(port_type='pnet') @tags('admin', 'positive') def test_remote_private_ping(self): """Testing private network remote ping on servers""" self._test_remote_ping(port_type='snet') @tags('admin', 'positive') def test_remote_isolated_ping(self): """Testing isolated network remote ping on servers""" self._test_remote_ping(port_type='inet') def _test_remote_ping(self, port_type): """Testing remote ping on servers""" conn = Connectivity(self.server_persona2, self.server_persona1) icmp_basic = dict(port_type=port_type, protocol='icmp', ip_version=4) rp = conn.verify_personas_conn(**icmp_basic) result = rp[0] ping_result = result['connection'] self.assertTrue(ping_result, rp) @tags('admin', 'positive') def test_remote_public_ssh(self): """Testing Public remote ssh on servers""" self._test_remote_ssh(self.server_persona1.pnet_fix_ipv4[0]) @tags('admin', 'positive') def test_remote_private_ssh(self): """Testing ServiceNet remote ssh on servers""" self._test_remote_ssh(self.server_persona1.snet_fix_ipv4[0]) @tags('admin', 'positive') def test_remote_isolated_ssh(self): """Testing isolated network A remote ssh on servers""" self._test_remote_ssh(self.server_persona1.inet_fix_ipv4[0]) def _test_remote_ssh(self, target_ip_addr): """Testing remote ssh on servers""" rc2 = self.server_persona2.remote_client ssh_cmd = self.SSH_COMMAND.format( private_key_path=self.PRIVATE_KEY_PATH, user=self.server_persona1.ssh_username, ip_address=target_ip_addr) stdout = None ssh_connection_established = False retry_count = 0 while stdout is None or not stdout.endswith('# '): if retry_count < self.MAX_RETRIES: output = rc2.ssh_client.execute_shell_command(ssh_cmd) stdout = output.stdout retry_count += 1 if retry_count == self.MAX_RETRIES: break if stdout.endswith('# '): ssh_connection_established = True self.assertTrue( ssh_connection_established, self.ssh_msg.format(self.server_persona2.pnet_fix_ipv4[0], target_ip_addr)) @classmethod def add_fixed_ips_network(cls, server, network, number_fixed_ips): # Add fixed IP's to server for _ in range(number_fixed_ips): cls.servers_client.add_fixed_ip(server.id, network)
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(ComputeIntegrationFixture, cls).setUpClass() cls.flavors_config = FlavorsConfig() cls.servers_config = ServersConfig() cls.compute_endpoint = ComputeEndpointConfig() # Instantiate servers client compute_service = cls.access_data.get_service( cls.compute_endpoint.compute_endpoint_name) alt_compute_service = cls.alt_access_data.get_service( cls.compute_endpoint.compute_endpoint_name) compute_url_check = compute_service.get_endpoint( cls.compute_endpoint.region) alt_compute_url_check = alt_compute_service.get_endpoint( cls.compute_endpoint.region) # If compute endpoint validation fails, fail immediately if compute_url_check is None: cls.assertClassSetupFailure('Compute endpoint validation failed') # If compute endpoint validation fails, fail immediately if alt_compute_url_check is None: cls.assertClassSetupFailure('Compute endpoint validation failed') cls.compute_url = compute_service.get_endpoint( cls.compute_endpoint.region).public_url cls.alt_compute_url = alt_compute_service.get_endpoint( cls.compute_endpoint.region).public_url client_args = { 'url': cls.compute_url, 'auth_token': cls.access_data.token.id_, 'serialize_format': cls.serialize_format, 'deserialize_format': cls.deserialize_format } cls.servers_client = ServersClient(**client_args) alt_client_args = { 'url': cls.alt_compute_url, 'auth_token': cls.alt_access_data.token.id_, 'serialize_format': cls.serialize_format, 'deserialize_format': cls.deserialize_format } cls.alt_servers_client = ServersClient(**alt_client_args) # Instantiate compute images client and behavior cls.compute_images_client = ComputeImagesClient(**client_args) cls.alt_compute_images_client = ComputeImagesClient(**alt_client_args) cls.compute_image_behaviors = ComputeImageBehaviors( images_client=cls.compute_images_client, servers_client=cls.servers_client, config=cls.images_config) cls.alt_compute_image_behaviors = ComputeImageBehaviors( images_client=cls.alt_compute_images_client, servers_client=cls.alt_servers_client, config=cls.images_config) # Instantiate servers behavior cls.server_behaviors = ServerBehaviors( servers_client=cls.servers_client, images_client=cls.compute_images_client, servers_config=cls.servers_config, images_config=cls.images_config, flavors_config=cls.flavors_config) cls.alt_server_behaviors = ServerBehaviors( servers_client=cls.alt_servers_client, images_client=cls.alt_compute_images_client, servers_config=cls.servers_config, images_config=cls.images_config, flavors_config=cls.flavors_config)
def compute_cleanup(): # Load necessary configurations compute_endpoint = ComputeEndpointConfig() marshalling = MarshallingConfig() endpoint_config = UserAuthConfig() user_config = UserConfig() access_data = AuthProvider.get_access_data( endpoint_config, user_config) # If authentication fails, halt if access_data is None: raise Exception('Authentication failed.') compute_service = access_data.get_service( compute_endpoint.compute_endpoint_name) url = compute_service.get_endpoint( compute_endpoint.region).public_url # If a url override was provided, use that value instead if compute_endpoint.compute_endpoint_url: url = '{0}/{1}'.format(compute_endpoint.compute_endpoint_url, user_config.tenant_id) client_args = {'url': url, 'auth_token': access_data.token.id_, 'serialize_format': marshalling.serializer, 'deserialize_format': marshalling.deserializer} flavors_client = FlavorsClient(**client_args) servers_client = ServersClient(**client_args) images_client = ImagesClient(**client_args) keypairs_client = KeypairsClient(**client_args) flavors_client.add_exception_handler(ExceptionHandler()) keys = keypairs_client.list_keypairs().entity print 'Preparing to delete {count} keys...'.format(count=len(keys)) for key in keys: try: keypairs_client.delete_keypair(key.name) except Exception: print 'Failed to delete key {id}: {exception}'.format( id=key.id, exception=traceback.format_exc()) servers = servers_client.list_servers_with_detail().entity print 'Preparing to delete {count} servers...'.format(count=len(servers)) for server in servers: try: servers_client.delete_server(server.id) except Exception: print 'Failed to delete server {id}: {exception}'.format( id=server.id, exception=traceback.format_exc()) images = images_client.list_images(image_type='snapshot').entity print 'Preparing to delete {count} image snapshots...'.format(count=len(images)) for image in images: try: images_client.delete_image(image.id) except Exception: print 'Failed to delete image {id}: {exception}'.format( id=image.id, exception=traceback.format_exc()) if raxcafe_installed: nova_networks_client = NovaNetworksClient(**client_args) raw_networks = nova_networks_client.list_networks().entity # remove the public and snet networks as well as any additional # networks to be preserved networks = [nw for nw in raw_networks if nw.id_ not in preserved_networks] print 'Preparing to delete {count} networks...'.format(count=len(networks)) for network in networks: try: nova_networks_client.delete_network(network.id_) except Exception: print 'Failed to delete network {id}: {exception}'.format( id=network.id_, exception=traceback.format_exc())
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)