def setup_connection_meta(self, within): if not self.node.public_ips: raise Exception("No public IP address, so cannot SSH") if self.node.state == 2: # state = 2 is terminated on AWS, need to lookup MAP/enum from lib for general solution. TODO raise Exception("Node is terminated, so cannot SSH") if self.node.extra is not None and "ssh_config" in self.node.extra: # TODO: Get value for `self.env_kwargs['ssh_config_path']` and set that ssh_config_to_fab = { "IdentityFile": "key_filename", "HostName": "host", "Port": "port", "User": "******", } for ssh_name, fab_name in iteritems(ssh_config_to_fab): if ssh_name in self.node.extra["ssh_config"]: setattr(self.env, fab_name, self.node.extra["ssh_config"][ssh_name]) if "ssh" in self.config_provider: if "private_key_path" in self.config_provider["ssh"]: self.env.key_filename = ( self.env.key_filename or self.config_provider["ssh"]["private_key_path"]) if "node_password" in self.config_provider["ssh"]: self.env.password = self.config_provider["ssh"][ "node_password"] assert (self.env.key_filename or self.env.password ), "Set a private key or password to have unattended deploys" if self.env.user is None or self.env.user == "user": self.env.user = (self.node.extra["user"] if "user" in self.node.extra else self.guess_os_username()) if (self.env.password is None or self.env.password == "unspecified") and "password" in self.node.extra: self.env.password = self.node.extra["password"] dir_or_key = (lambda d_or_k: d_or_k.directory or d_or_k.file)( ProcessNode.get_directory_or_key(self.process_dict, within)) if ip_address(self.node.public_ips[0]).is_private: self.dns_name = self.node.public_ips[0] # LOL elif (not self.dns_name and "skydns2" not in self.process_dict["register"][dir_or_key] and "consul" not in self.process_dict["register"][dir_or_key]): # self.dns_name = '{public_ip}.xip.io'.format(public_ip=self.node.public_ips[0]) self.dns_name = self.node.public_ips[0] # raise Exception('No DNS name and no way of acquiring one') self.env.hosts = [self.dns_name] if "no_key_filename" in self.node.extra and self.node.extra[ "no_key_filename"]: del self.env.key_filename self.env.use_ssh_config = False print("<env>") pp(obj_to_d(self.env)) print("</env>")
def process_nodes(cluster_location, config, method, method_args): clustering_results = [] for node_res in list_nodes(cluster_location, marshall=json): process_node_obj = ProcessNode(config, node_res, clustering_results) getattr(process_node_obj, method)(cluster_location, *method_args) clustering_results = process_node_obj.previous_clustering_results pp(clustering_results)
def configure1(*args, **kwargs): config_join = partial( path.join, path.join( path.dirname( resource_filename(modules[__name__].__package__, "__init__.py")), "_config", ), ) run("mkdir -p ~/genconf") with open(config_join("config.yaml")) as f: d = load(f) d["agent_list"] = [] pp(d) run("touch ~/genconf/ipdetect") with open(config_join("ipdetect.bash")) as f: put(f, "~/genconf/ipdetect")
def set_node(self): self.provider_dict = self.strategy.get_provider(self.offset) self.provider_cls = (lambda driver: driver( region=self.provider_dict['provider']['region'], **self.provider_dict['auth'] ))(get_driver(getattr(Provider, self.provider_dict['provider']['name']))) if 'http_proxy' in environ: self.provider_cls.connection.set_http_proxy(proxy_url=environ['http_proxy']) # pp(map(obj_to_d, self.list_sizes())) get_option = partial(self.strategy.get_option, provider_name=self.provider_dict['provider']['name']) '''pp(map(node_to_dict, ifilter(lambda n: '14.04.5 x64' in n.id or '14.04.5 x64' in n.name, self.list_images())))''' self.node_specs = { 'size': get_option('hardware', self.list_sizes()), 'image': get_option('image', self.list_images()), 'location': get_option('location', self.list_locations()) } if 'create_with' in self.provider_dict: self.node_specs.update(self.provider_dict['create_with']) if 'node_password' in self.provider_dict['ssh']: self.node_specs.update({ 'auth': NodeAuthPassword(self.provider_dict['ssh']['node_password']) }) pp({self.provider_dict['provider']['name']: self.node_specs}) if 'security_group' in self.provider_dict: self.node_specs.update({'ex_securitygroup': self.provider_dict['security_group']}) if 'key_name' in self.provider_dict: self.node_specs.update({'ex_keyname': self.provider_dict['key_name']}) self.node_specs.update(dict((ex, val) for ex, val in self.provider_dict.iteritems() if ex.startswith('ex')))
def test_(self): for node_name in self.nodes: node = self.nodes[node_name] pp(obj_to_d(node))
else: raise NotImplementedError("{}".format(cluster["type"])) offregister = offregisterC(self.env, self.node, self.node_name, self.dns_name) add_cluster_ret = offregister.prepare_cluster_obj(cluster, res) offregister.run_tasks(**add_cluster_ret._asdict()) # offregister.run_tasks(cluster_path, cluster_type, res, tag, args, kwargs) save_node_info( self.node_name, node_to_dict(self.node), folder=add_cluster_ret.cluster_path, marshall=json, ) def guess_os_username(self, hint=None): return guess_os_username(node=self.node, hint=hint) def guess_os(self, hint=None): return guess_os(node=self.node, hint=hint) handle_unprocessed = lambda: tuple( ProcessNode(resource_filename("config", "register.sample.json"), node) for node in list_nodes(marshall=json)) if __name__ == "__main__": unprocessed_handler = handle_unprocessed() for handler in unprocessed_handler: pp(handler.set_clusters("/unclustered"))
return 'user' def guess_os(self, hint=None): node_name = self.node.name.lower() if 'ubuntu' in node_name: return 'ubuntu' elif 'core' in node_name: return 'core' return hint or 'ubuntu' def tail(self, within, *method_args): method_args = ''.join(method_args) self.setup_connection_meta(within) directory = self.get_directory(self.process_dict, within) for cluster_type in self.process_dict['register'][directory]: cluster_type = cluster_type[:-len(':master')] if cluster_type.endswith(':master') else cluster_type execute( globals()[ '{os}_tail_{cluster_name}'.format(os=self.guess_os_username(), cluster_name=cluster_type)], method_args ) handle_unprocessed = lambda: tuple(ProcessNode(resource_filename('config', 'register.sample.json'), node) for node in list_nodes(marshall=json)) if __name__ == '__main__': unprocessed_handler = handle_unprocessed() for handler in unprocessed_handler: pp(handler.set_clusters())