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())
def test_(self):
for node_name in self.nodes:
node = self.nodes[node_name]
pp(obj_to_d(node))
