def verify(self, network, service, setup_info): """ Given the network name and the service name of the service under test, verify that it's behaving as expected. """ def check_vault_setup(): public_ips = [ i.public_ip for s in service.subnetworks for i in s.instances ] assert public_ips, "No services are running..." for public_ip in public_ips: shares = 1 threshold = 1 client = hvac.Client(url='http://%s:8200' % public_ip) result = client.initialize(shares, threshold) root_token = result['root_token'] keys = result['keys'] client.unseal_multi(keys) logged_in_client = hvac.Client(url='http://%s:8200' % public_ip, token=root_token) logged_in_client.write('secret/foo', baz='bar', lease='1h') my_secret = logged_in_client.read('secret/foo') logged_in_client.delete('secret/foo') assert "baz" in my_secret[ "data"], "Baz not in my_secret: %s" % my_secret assert my_secret["data"][ "baz"] == "bar", "Baz not 'bar': %s" % my_secret call_with_retries(check_vault_setup, RETRY_COUNT, RETRY_DELAY)
def verify(self, network, service, setup_info): """ Given the network name and the service name of the service under test, verify that it's behaving as expected. """ def check_responsive(): public_ips = [ i.public_ip for s in service.subnetworks for i in s.instances ] assert public_ips for public_ip in public_ips: response = requests.get("http://%s" % public_ip) expected_content = "Hello World" assert response.content, "No content in response" assert expected_content in str( response.content), ("Unexpected content in response: %s" % response.content) call_with_retries(check_responsive, RETRY_COUNT, RETRY_DELAY)
def verify(self, network, service, setup_info): """ Given the network name and the service name of the service under test, verify that it's behaving as expected. """ def check_consul_setup(): public_ips = [ i.public_ip for s in service.subnetworks for i in s.instances ] assert public_ips, "No services are running..." for public_ip in public_ips: consul_client = consul.Consul(public_ip) assert consul_client.kv.put( 'testkey', 'testvalue'), "Failed to put test key!" testvalue = consul_client.kv.get('testkey') assert testvalue[1]["Key"] == "testkey" consul_client.kv.delete('testkey') call_with_retries(check_consul_setup, RETRY_COUNT, RETRY_DELAY)
def verify(self, network, service, setup_info): """ Given the network name and the service name of the service under test, verify that it's behaving as expected. """ def check_prometheus(): instances = self.client.service.get_instances(service) assert instances, "No instances found!" for instance in instances: endpoint = 'http://%s:9090/api/v1/query' % instance.public_ip params = {"query": "prometheus_build_info"} response = requests.get(endpoint, params=params) api_response = response.json() assert api_response["status"] == "success" monitoring_self = False for result in api_response["data"]["result"]: if result["metric"]["instance"] == "localhost:9090": monitoring_self = True assert monitoring_self, "Found no metrics for Prometheus" call_with_retries(check_prometheus, RETRY_COUNT, RETRY_DELAY)
def verify(self, network, service, setup_info): """ Given the network name and the service name of the service under test, verify that it's behaving as expected. """ def check_consul_setup(): instances = self.client.service.get_instances(service) assert instances, "No instances found!" postgres_ip = instances[0].public_ip conn = psycopg2.connect("host=%s dbname=test user=test" % postgres_ip) cur = conn.cursor() cur.execute( "CREATE TABLE test (id serial PRIMARY KEY, num integer, data varchar);" ) cur.execute("INSERT INTO test (num, data) VALUES (%s, %s)", (100, "abcdef")) cur.execute("SELECT * FROM test;") value = cur.fetchone() assert value == (1, 100, 'abcdef'), "Saved value does not match!" call_with_retries(check_consul_setup, RETRY_COUNT, RETRY_DELAY)
def run_ssh_test(profile=None, provider=None, credentials=None): """ Test that the instance management works against the given provider. """ # Get the client for this test client = cloudless.Client(profile, provider, credentials) # Get a somewhat unique network name network_name = generate_unique_name("unittest") # Get a somewhat unique service name service_name = generate_unique_name("unittest") # Get a keypair to use key_pair = generate_ssh_keypair() # Provision all the resources test_network = client.network.create(network_name, blueprint=NETWORK_BLUEPRINT) if client.provider in ["aws", "mock-aws"]: test_service = client.service.create( test_network, service_name, AWS_SERVICE_BLUEPRINT, template_vars={ "cloudless_image_build_ssh_key": key_pair.public_key, "cloudless_image_build_ssh_username": "******" }, count=1) else: assert client.provider == "gce" test_service = client.service.create( test_network, service_name, GCE_SERVICE_BLUEPRINT, template_vars={ "cloudless_image_build_ssh_key": key_pair.public_key, "cloudless_image_build_ssh_username": "******" }, count=1) def validate_service(network, service, count): discovered_service = client.service.get(network, service.name) assert discovered_service.network == network assert discovered_service.name == service.name assert discovered_service == service assert isinstance(discovered_service, Service) assert isinstance(service, Service) instances = [] for subnetwork in discovered_service.subnetworks: instances.extend(subnetwork.instances) assert len(instances) == count assert instances == client.service.get_instances(service) # Check that our service is provisioned properly validate_service(test_network, test_service, 1) # Add a path for SSH internet = CidrBlock("0.0.0.0/0") client.paths.add(internet, test_service, 22) if client.provider != "mock-aws": # Test that we can connect with the given key def attempt_connection(): ssh = paramiko.SSHClient() ssh_key = paramiko.RSAKey(file_obj=StringIO(key_pair.private_key)) public_ip = [ i.public_ip for i in client.service.get_instances(test_service) ][0] ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect(hostname=public_ip, username="******", pkey=ssh_key) return ssh call_with_retries(attempt_connection, int(10), float(1.0)) ssh = attempt_connection() _, ssh_stdout, ssh_stderr = ssh.exec_command("whoami") assert ssh_stdout.read().decode().strip() == "cloudless" assert ssh_stderr.read().decode().strip() == "" # Make sure they are gone when I destroy them client.service.destroy(test_service) # Clean up the VPC client.network.destroy(test_network)