def get_running_environment(self, env_name, env_template_name, all_credentials): nodes = self.list(all_credentials, lambda x: node_predicates.running_in_env(env_name, env_template_name)(x)) region_nodes_map = {} for node in nodes: if not node.region().name in region_nodes_map.keys(): region_nodes_map.update({node.region().name:[node]}) else: region_nodes_map[node.region().name].append(node) locations = self.get_locations(region_nodes_map) return phoenix.environment_description.EnvironmentDescription(env_name, locations)
def get_running_environment(self, env_name, env_template_name, all_credentials): nodes = self.list(all_credentials, lambda x: node_predicates.running_in_env(env_name, env_template_name)(x)) locations = [] if not nodes is None and len(nodes) != 0: locations.append(Location(self.host_name, nodes)) return phoenix.environment_description.EnvironmentDescription(env_name, locations)
def delta_defs_with_running_nodes(self, node_definitions): # Given a list of node definitions, determines if a running node matches. If so, # that node is removed from the returned node definitons. # Returns a tuple of nodes still to provision, a mapping from service to running nodes for those # nodes that match, and list of nodes in the environment that are no longer needed pre_existing_nodes = defaultdict(lambda: set()) node_defs_to_provision = [] nodes_in_environment = self.node_provider.list(self.all_credentials, lambda x: node_predicates.running_in_env(self.name, self.env_def_name)(x)) for node_def in node_definitions: matching_running_node = next((n for n in nodes_in_environment if n.matches_definition(node_def)), None) if matching_running_node: for service in node_def.services: pre_existing_nodes[service].add(matching_running_node) # We don't want to match the same node again! nodes_in_environment.remove(matching_running_node) else: node_defs_to_provision.append(node_def) # At this point, if there are any nodes still in 'nodes_in_environment' then they haven't matched, and need # therefore to be terminated nodes_to_terminate = [] nodes_to_terminate.extend(nodes_in_environment) return node_defs_to_provision, pre_existing_nodes, nodes_to_terminate
def list_nodes(self): return self.node_provider.list(self.all_credentials, lambda x: node_predicates.running_in_env(self.name, self.env_def_name)(x))
def test_full_end_to_end_integration_test(self): with settings(credentials_dir="credentials"): environment_definition = launch(env_template="lxc_hello_world", env_name="auto", config_dir="samples") node_provider = environment_definition.node_provider nodes = node_provider.list(environment_definition.all_credentials, lambda x: node_predicates.running_in_env('auto','lxc_hello_world')(x)) hello_world_node = [x for x in nodes if 'hello_world' in x.get_services()].pop() status, output = commands.getstatusoutput("curl -s %s/healthcheck" % hello_world_node.address().get_service_address('hello_world')[1]) self.assertEqual(status, 0) self.assertEqual(output, "* Apache: OK\n* deadlocks: OK")
def test_can_create_elb_for_a_service(self): with settings(credentials_dir="credentials"): self.remove_existing_hello_world_elb('elb_integration', 'hello_world') dynamic_env_name = "test_can_create_a_load_balancer_for_a_service"+str(int(round(time.time() * 1000))) env_template_name = "elb_integration" self.env_to_shut_down.update({env_template_name: dynamic_env_name}) environment_definition = launch(env_template=env_template_name, env_name=dynamic_env_name, config_dir="samples", property_file="build_credentials/phoenix.ini") node_provider = environment_definition.node_provider nodes = node_provider.list(environment_definition.all_credentials, lambda x: node_predicates.running_in_env(dynamic_env_name, env_template_name)(x)) node_provider = environment_definition.node_provider node = [x for x in nodes if 'hello_world' in x.get_services()].pop() conn = self.get_connection_for_region(node.region().name, node_provider.public_api_key, node_provider.private_api_key) hook_elb_name = environment_definition.service_lifecycle_hooks['hello_world'][0].elb_name load_balancer = conn.get_all_load_balancers(load_balancer_names=[hook_elb_name])[0] # self.assertEqual(load_balancer.dns_name, node.address().get_dns_name()) TODO: make sure the node address dns matches with the elb dns status, output = commands.getstatusoutput("curl -s %s:8081/healthcheck" % load_balancer.dns_name) self.assertEqual(status, 0) self.assertEqual(output, "* Apache: OK\n* deadlocks: OK")
def test_should_have_a_functioning_hello_world(self): with settings(credentials_dir="credentials"): dynamic_env_name = "test_should_have_a_functioning_hello_world_"+str(int(round(time.time() * 1000))) env_template_name = "integration" self.env_to_shut_down.update({env_template_name: dynamic_env_name}) environment_definition = launch(env_template=env_template_name, env_name=dynamic_env_name, config_dir="samples", property_file="build_credentials/phoenix.ini") node_provider = environment_definition.node_provider nodes = node_provider.list(environment_definition.all_credentials, lambda x: node_predicates.running_in_env(dynamic_env_name, env_template_name)(x)) hello_world_node = [x for x in nodes if 'hello_world' in x.get_services()].pop() status, output = commands.getstatusoutput("curl -s %s:8081/healthcheck" % hello_world_node.address().dns_name) self.assertEqual(status, 0) self.assertEqual(output, "* Apache: OK\n* deadlocks: OK")
def get_running_node(self, environment_definition, env_def_name, environment_name, node_provider): nodes = node_provider.list(environment_definition.all_credentials, lambda x: node_predicates.running_in_env(environment_name, env_def_name)(x)) self.assertEquals(len(nodes), 1) return nodes[0]