def matches_definition(self, node_definition): logger.info("Matching %s against definition %s" % (self, node_definition)) return self.boto_instance.image_id == node_definition.ami_id and \ self.boto_instance.instance_type == node_definition.size and \ self._tag('credentials_name') == node_definition.credentials_name and \ self.boto_instance.region.name == node_definition.region and \ self.get_services().keys() == node_definition.services
def service_terminated(self, service_name, node): conn = self.get_connection_for_region(node.region().name) try: load_balancer = conn.get_all_load_balancers(load_balancer_names=[self.elb_name])[0] logger.info('Existing load balancer found with name %s' %self.elb_name) load_balancer.degregister_instances([node.id()]) except: pass
def launch(env_template=None, env_name=None, config_dir=DEFAULT_ENVIRONMENT, noop=False, property_file=None): """Launches a new environment, or applies changes made to an existing environment""" with env_conf_from_dir(config_dir, env_name, property_file, noop=noop) as env_defs: if noop: logger.info("Running in NOOP mode - no changes will be made to your system") environment_definition = env_defs[env_template] environment_definition.launch() if noop: print environment_definition.node_provider.noop_actions_string() else: print describe_running_environment(config_dir, environment_definition, env_name, env_template, TextTableEnvironmentDescriber()) return environment_definition
def create_security_group_if_it_does_not_exists(self, service_name): """ Creates a security group for the given service name if that service group does not already exist returns the fully qualified name of the security group """ security_group_name = self._get_sec_group_name(service_name) sec_groups = self.connection.get_all_security_groups() if not len([x for x in sec_groups if x.name == security_group_name]): logger.info("Creating new Security Group %s" % security_group_name) self.connection.create_security_group(security_group_name, "dynamically created security group") else: logger.info("Security Group %s already exists" % security_group_name) return security_group_name
def wait_for_ready(self, callback, start_up_timeout=90): logger.info("Waiting for node %s to be ready" % self.id()) start = time.time() node_is_up = False while time.time() - start <= start_up_timeout : self.boto_instance.update() if self.state() == 'running' and self.boto_instance.ip_address is not None: node_is_up = self.connection_provider.connected_to_node(self.boto_instance.ip_address, 22) if node_is_up : logger.info("*********Node %s is ready!********" % self.id()) break else: logger.debug("Waiting for 5 seconds for node %s" % self.id()) sleep(5) if not node_is_up : raise Exception("Node %s is not running" % self.id()) # For some reason, with the Ubuntu instances we use, if we try and install packages too quickly after the machine # boots, we don't get the transient dependencies - highly annoying. sleep(10) callback()
def launch(self): node_defs_to_provision, services_to_already_launched_nodes, running_nodes_to_terminate = self.delta_defs_with_running_nodes( self.node_definitions) # AWS Problems: # 1. Shutting down instances in a different environment # 2. Not matching existing instances # TODO - Should log gracefully during lifecycle events.... logger.info("Shutting down instances %s" % [n.id() for n in running_nodes_to_terminate]) logger.info("Launching new instances %s" % node_defs_to_provision) services_to_newly_launched_nodes = self._provision_nodes(node_defs_to_provision, blocking=True) map(lambda n: self.node_provider.shutdown(n.id()), running_nodes_to_terminate) services_to_all_running_nodes = self.merge_service_to_nodes_dicts(services_to_already_launched_nodes, services_to_newly_launched_nodes) self.tag_nodes_with_services(services_to_all_running_nodes) env_settings = self.build_environment_settings(services_to_all_running_nodes) logger.debug("settings: %s" % env_settings) self.configure_services(services_to_all_running_nodes, env_settings)
def wait_for_ready(self, callback, start_up_timeout=45): logger.info("Waiting for node %s to be ready" % self.id()) start = time.time() succeeded = False while time.time() - start <= start_up_timeout: try: succeeded = self.ssh_command_helper.run_command_silently("ping -c1 %s" % self.node_id).succeeded except: pass if succeeded : logger.info("*********Node %s is ready!*********" % self.id()) break else: logger.info("Node %s not yet ready, checking again in 3 seconds" % self.id()) time.sleep(3) if not succeeded : raise Exception("Node %s is not running" % self.node_id) callback()
def service_installed(self, service_name, node, connectivities): conn = self.get_connection_for_region(node.region().name) try: load_balancer = conn.get_all_load_balancers(load_balancer_names=[self.elb_name])[0] logger.info('Existing load balancer found with name %s' %self.elb_name) except: load_balancer = None if load_balancer is None: logger.info('Creating a new load balancer: '+ self.elb_name) elb_ports = self.get_elb_mappings(connectivities) load_balancer = conn.create_load_balancer(self.elb_name, str(node.placement()), elb_ports) health_check_address = self.app_healthcheck_target hc = HealthCheck( interval=20, healthy_threshold=3, unhealthy_threshold=5, target=health_check_address ) load_balancer.configure_health_check(hc) logger.info('Registering node id %s for availability zone %s' %(node.id(), node.placement())) load_balancer.enable_zones([node.placement()]) load_balancer.register_instances([node.id()])
def run_command(self, command, warn_only=False): with settings(warn_only = warn_only): logger.info("Running on node %s" % str(self)) return self.ssh_command_helper.run_command("sudo ssh -i /root/.ssh/id_rsa -oStrictHostKeyChecking=no root@%s '%s'" % (self.node_id, command))
def tearDown(self): for env_template, env_name in self.env_to_shut_down.items() : logger.info("Terminating environment: template %s, name %s" % (env_template, env_name)) logger.info(commands.getoutput("cd phoenix && ./pho terminate_environment --env_template %s --env_name %s --property_file %s" % (env_template, env_name, "../build_credentials/phoenix.ini"))) self.env_to_shut_down.clear()