def do_login(auth_url=GLOBAL_AUTH_URL, user_domain_name=GLOBAL_USER_DOMAIN_NAME, **username): try: if check_env() and check_session(): old_env_data = get_env_values() if is_current_env(auth_url, user_domain_name, username=old_env_data['username']): print("You are already logged.") print(" use 'neo login -D' to see your current account") else: print("Doing fresh login. You switched user account") do_fresh_login(auth_url=auth_url, user_domain_name=user_domain_name) elif check_env() and not check_session(): print("Retrieving old login data ...") regenerate_sess() utils.log_info("Login Success") else: print("Doing fresh login. You don't have old login data") do_fresh_login() except Exception as e: utils.log_err(e) utils.log_err("Login Failed") return False
def do_login(): try: if check_env(): load_env_file() else: username = get_username() password = get_password() get_project_id(username, password) load_env_file() auth = v3.Password( auth_url=os.environ.get("OS_AUTH_URL"), username=os.environ.get("OS_USERNAME"), password=os.environ.get("OS_PASSWORD"), user_domain_name=os.environ.get("OS_USER_DOMAIN_NAME"), project_id=os.environ.get("OS_PROJECT_ID"), reauthenticate=True, include_catalog=True) sess = session.Session(auth=auth) set_session(sess) with open("{}/.neo.env".format(home)) as envfile: if not 'OS_TOKEN' in envfile.read(): token = sess.get_token() add_token(token) load_env_file() utils.log_info("Login Success") return True except Exception as e: utils.log_err(e) utils.log_err("Login Failed") return False
def initialize(manifest_fie): init = list() utils.log_info("Initialization....") key = utils.do_deploy_dir(manifest_fie) for stack in utils.initdir(key): for project in key["stack"][stack]: template = key["data"][stack][project]["template"] try: parameters = key["data"][stack][project]["parameters"] except: parameters = None url = False try: url = utils.repodata()[stack][template]["url"] except: utils.log_err("template {} is not exist!".format(template)) exit() dest = "{}/{}/{}".format(key["deploy_dir"], stack, project) utils.log_info("Build {} {} template".format(project, stack)) if not utils.template_url(url, dest): utils.log_err("Check your internet connection!") exit() utils.log_info("Done...") """ Stack init dict """ stack_init = {} stack_init["dir"] = dest stack_init["project"] = project stack_init["stack"] = stack stack_init["env_file"] = False if parameters: utils.log_info("Create {} {} environment file".format( project, stack)) utils.yaml_create("{}/env.yml".format(dest), { "parameters": parameters }) utils.log_info("Done...") stack_init["env_file"] = "{}/env.yml".format(dest) init.append(stack_init) """ Reformat squences deploy """ if utils.check_key(key["data"], "deploy"): if len(key["data"]["deploy"]) > 0: set_sequence = list() for deploy in key["data"]["deploy"]: set_deploy = deploy.split(".") set_stack = set_deploy[0] set_project = set_deploy[1] set_sequence.append([ new_init for new_init in init if (new_init["stack"] == set_stack) and ( new_init["project"] == set_project) ][0]) init = set_sequence utils.yaml_create("{}/deploy.yml".format(key["deploy_dir"]), init) return init
def do_create(initialize, session=None): try: heat = get_heat_client(session) for deploy in initialize: deploy_init_file = "{}/init.yml".format(deploy["dir"]) deploy_file = utils.yaml_parser(deploy_init_file)["create"] """ template """ deploy_template = "{}/{}".format(deploy["dir"], deploy_file) deploy_name = deploy["project"] files, template = template_utils.process_template_path( deploy_template) """Create Stack""" utils.log_info("Create {} stack....".format(deploy["project"])) if not deploy["env_file"]: heat.stacks.create(stack_name=deploy_name, template=template, files=files) else: deploy_env_file = open(deploy["env_file"]) heat.stacks.create( stack_name=deploy_name, template=template, environment=deploy_env_file.read(), files=files, ) if len(initialize) > 0: time.sleep(8) except Exception as e: utils.log_err(e) else: pass finally: pass
def do_fresh_login(username=None, auth_url=None): if username != None: username = username password = get_password() auth_url = auth_url else: username = get_username() password = get_password() if auth_url != None: auth_url = auth_url else: auth_url = get_region() try: project_id = get_project_id(username, password, auth_url, GLOBAL_USER_DOMAIN_NAME) dump_session( generate_session( auth_url=auth_url, username=username, password=password, project_id=project_id, user_domain_name=GLOBAL_USER_DOMAIN_NAME, )) # generate fresh neo.env # passing username and password to pass toml config create_env_file(username, password, auth_url) utils.log_info("Login Success") except Exception as e: utils.log_err(e) utils.log_err("Login Failed")
def execute(self): if self.args["vm"]: instance_id = self.args["<VM_ID>"] limit = self.args['--limit'] if not instance_id: default_file = orch.check_manifest_file() if default_file: keys = utils.get_key(default_file) instances = keys['stack']['instances'] if len(instances) > 0: vms = vm_lib.get_list() for vm in vms: if vm.name == instances[0]: instance_id = vm.id break else: utils.log_err('VM not found') else: utils.log_err("Can't find neo.yml manifest file!") else: vm_data = vm_lib.get_list() for vm in vm_data: if (instance_id == vm.name) or (instance_id == vm.id): instance_id = vm.id try: utils.log_info( vm_lib.get_console_logs(instance_id, length=limit)) except Exception as err: utils.log_err(err.message) exit()
def do_logout(): temp = utils.tmp_dir() if check_session(): home = os.path.expanduser("~") os.remove(os.path.join(temp, "session.pkl")) utils.del_tmp_dir(temp) os.remove(get_toml_config()) utils.log_info("Logout Success")
def do_create(initialize, session=None): try: heat = get_heat_client(session) for deploy in initialize: deploy_init_file = "{}/init.yml".format(deploy["dir"]) deploy_file = utils.yaml_parser(deploy_init_file)["create"] """ template """ deploy_template = "{}/{}".format(deploy["dir"], deploy_file) deploy_name = deploy["project"] files, template = template_utils.process_template_path( deploy_template) """Create Stack""" utils.log_info("Create {} stack....".format(deploy["project"])) if not deploy["env_file"]: heat.stacks.create( stack_name=deploy_name, template=template, files=files) else: deploy_env_file = open(deploy["env_file"]) heat.stacks.create( stack_name=deploy_name, template=template, environment=deploy_env_file.read(), files=files) if (len(initialize) > 0): time.sleep(8) # if deploy["stack"] == "clusters": # utils.log_info("Generate {} private key...".format( # deploy["project"])) # wait_key = True # private_key_file = None # while wait_key: # out = get_pkey_from_stack( # deploy["project"]) # if out: # private_key_file = "{}/private_key.pem".format( # deploy["dir"]) # with open(private_key_file, "w") as pkey: # pkey.write(out) # os.chmod(private_key_file, 0o600) # utils.log_info("Done...") # wait_key = False # else: # time.sleep(5) except Exception as e: utils.log_err(e) else: pass finally: pass
def do_fresh_login(auth_url=GLOBAL_AUTH_URL, user_domain_name=GLOBAL_USER_DOMAIN_NAME): try: username = get_username() password = get_password() # use default value for fresh login project_id = get_project_id(username, password, auth_url, user_domain_name) # generate fresh session generate_session(auth_url=auth_url, username=username, password=password, project_id=project_id, user_domain_name=user_domain_name) # generate fresh neo.env create_env_file(username, password, project_id, auth_url, user_domain_name) utils.log_info("Login Success") except Exception as e: utils.log_err(e) utils.log_err("Login Failed")
def login_check(username=None, region=None): try: print("Connecting to region " + region + " at " + GLOBAL_REGION[region]) auth_url = GLOBAL_REGION[region] old_env_data = get_active_env() if check_env() and check_session(): if is_current_env( auth_url, GLOBAL_USER_DOMAIN_NAME, username=old_env_data["username"] ): print("You have logged in") print("You are already logged.") print(" use 'neo login -D' to see your current account") else: print("You have switch user or region, doing relogin") do_fresh_login(username, auth_url) elif check_env() and not check_session(): print("Retrieving old login data ...") regenerate_sess() utils.log_info("Login Success") else: do_fresh_login(username, auth_url) except KeyError as e: utils.log_err("Region " + str(e) + " is not found")
def do_login(): try: username = get_username() password = get_password() project_id = get_project_id(username, password) sess = generate_session( auth_url=auth_url, username=username, password=password, user_domain_name=user_domain_name, project_id=project_id, reauthenticate=True, include_catalog=True) set_session(sess) utils.log_info("Login Success") return True except Exception as e: utils.log_err(e) utils.log_err("Login Failed") return False
def execute(self): """ Remote client over SSH """ if self.args["ssh"]: cridential = self.args["<USER@HOSTS>"].split("@") if len(cridential) != 2: print(self.__doc__) exit(0) user = cridential[0] hostname = cridential[1] utils.ssh_shell(hostname, user) exit(0) """ Remote VM over SSH """ if self.args["vm"]: vm_id = self.args["<VM_ID>"] """ cek vm metadata from stack """ utils.log_info("Check your key pairs") vm_detail = vm_lib.detail(vm_id).to_dict() key_pair_temp = tempfile.NamedTemporaryFile(delete=True) try: key_name = vm_detail["key_name"] out = orch.get_private_key(key_name) if out: with open(key_pair_temp.name, 'w') as pkey: pkey.write(out) os.chmod(key_pair_temp.name, 0o600) utils.log_info("Done...") else: utils.log_err("Can't find key pairs on your Virtual Machine!") exit() except Exception as e: utils.log_err("Can't find key pairs on your Virtual Machine!") exit() # Address addr = list() addr_objs = utils.get_index(vm_detail["addresses"]) if len(addr_objs) > 0: for addr_obj in addr_objs: for addr_ip in vm_detail["addresses"][addr_obj]: if addr_ip["OS-EXT-IPS:type"] == "floating": addr_meta = addr_ip["addr"] addr.append(addr_meta) if not (len(addr) > 0): utils.log_err("Can't find floating IP Address!") exit() utils.log_info("Check username") user = orch.get_metadata(vm_detail["name"], "user") if not user: user = "" while user == "": user = input( "Username : "******"Login with {}".format(user)) utils.ssh_shell(addr[0], user, key_file=key_pair_temp.name) exit(0) """ Remote by manifest file neo.yaml """ set_file = self.args["--file"] default_file = orch.check_manifest_file() deploy_file = ".deploy/deploy.yml" if set_file: if os.path.exists(set_file): default_file = set_file else: utils.log_err("{} file is not exists!".format(set_file)) exit() if not default_file: utils.log_err("Can't find neo.yml manifest file!") exit() if os.path.exists(deploy_file): deploy_init = utils.yaml_parser(deploy_file) deploy_init = [d_init for d_init in deploy_init if d_init["stack"] in ["instances","clusters","databases"]] else: deploy_init = orch.initialize(default_file) deploy_init = [d_init for d_init in deploy_init if d_init["stack"] in ["instances","clusters","databases"]] meta = None if len(deploy_init) == 1: meta = deploy_init[0] if len(deploy_init) > 1: meta_project = [pra_meta["project"] for pra_meta in deploy_init] meta_field = [{"type": "TitleSelectOne", "name": "Select Project", "key": "project", "values": meta_project}] meta_field = utils.prompt_generator("Select project...",meta_field) meta = [pra_meta for pra_meta in deploy_init if pra_meta in [meta_field["project"]]][0] if meta: project_name = meta["project"] project_dir = meta["dir"] private_key_file = "{}/private_key.pem".format(project_dir) project_hostname = None project_user = None if not os.path.exists(private_key_file): utils.log_info("Generate {} private key...".format( project_name)) wait_key = True while wait_key: out = orch.get_pkey_from_stack(project_name) if out: with open(private_key_file, "w") as pkey: pkey.write(out) os.chmod(private_key_file, 0o600) utils.log_info("Done...") wait_key = False else: pkeys = orch.get_private_key(project_name) if pkeys: with open(private_key_file, "w") as pkey: pkey.write(pkeys) os.chmod(private_key_file, 0o600) utils.log_info("Done...") wait_key = False else: time.sleep(5) if os.path.exists(private_key_file): if not project_hostname: project_hostname = orch.get_metadata(project_name, "controller") project_user = orch.get_metadata(project_name, "user") do_ssh = True print("Try to connect...", end="") while do_ssh: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) result = sock.connect_ex((project_hostname, 22)) if result == 0: print("\nSuccess...") time.sleep(3) do_ssh = False else: print(".", end="") time.sleep(3) do_ssh = True if self.args["--command"]: try: utils.ssh_out_stream(project_hostname, project_user, self.args["--command"], key_file=private_key_file) except KeyboardInterrupt: exit() elif self.args["--tunneling"]: try: tunnel_args = " ".join(["-L {}".format(t_arg) for t_arg in self.args["--tunneling"].split(",")]) commands = "ssh -i {} {} {}@{}".format(private_key_file, tunnel_args, project_user, project_hostname).split(" ") subprocess.call(commands) except KeyboardInterrupt: exit() else: try: utils.ssh_shell(project_hostname, project_user, key_file=private_key_file) except KeyboardInterrupt: exit()
def do_logout(): if check_env(): with open("{}/.neo.env".format(home)) as envfile: os.remove("{}/.neo.env".format(home)) utils.log_info("Logout Success")
def execute(self): """ Remote client over SSH """ if self.args["ssh"]: cridential = self.args["<USER@HOSTS>"].split("@") if len(cridential) != 2: print(self.__doc__) exit(0) user = cridential[0] hostname = cridential[1] utils.ssh_shell(hostname, user) exit(0) """ Remote VM over SSH """ if self.args["vm"]: vm_id = self.args["<VM_ID>"] """ cek vm metadata from stack """ utils.log_info("Check your key pairs") vm_detail = vm_lib.detail(vm_id).to_dict() key_pair_temp = tempfile.NamedTemporaryFile(delete=True) try: key_name = vm_detail["key_name"] out = orch.get_private_key(key_name) if out: with open(key_pair_temp.name, 'w') as pkey: pkey.write(out) os.chmod(key_pair_temp.name, 0o600) utils.log_info("Done...") else: utils.log_err( "Can't find key pairs on your Virtual Machine!") exit() except Exception as e: utils.log_err("Can't find key pairs on your Virtual Machine!") exit() # Address addr = list() addr_objs = utils.get_index(vm_detail["addresses"]) if len(addr_objs) > 0: for addr_obj in addr_objs: for addr_ip in vm_detail["addresses"][addr_obj]: if addr_ip["OS-EXT-IPS:type"] == "floating": addr_meta = addr_ip["addr"] addr.append(addr_meta) if not (len(addr) > 0): utils.log_err("Can't find floating IP Address!") exit() utils.log_info("Check username") user = orch.get_metadata(vm_detail["name"], "user") if not user: user = "" while user == "": user = input("Username : "******"Login with {}".format(user)) utils.ssh_shell(addr[0], user, key_file=key_pair_temp.name) exit(0) """ Remote by manifest file neo.yaml """ set_file = self.args["--file"] default_file = orch.check_manifest_file() deploy_file = ".deploy/deploy.yml" if set_file: if os.path.exists(set_file): default_file = set_file else: utils.log_err("{} file is not exists!".format(set_file)) exit() if not default_file: utils.log_err("Can't find neo.yml manifest file!") exit() if os.path.exists(deploy_file): deploy_init = utils.yaml_parser(deploy_file) deploy_init = [ d_init for d_init in deploy_init if d_init["stack"] in ["instances", "clusters", "databases"] ] else: deploy_init = orch.initialize(default_file) deploy_init = [ d_init for d_init in deploy_init if d_init["stack"] in ["instances", "clusters", "databases"] ] meta = None if len(deploy_init) == 1: meta = deploy_init[0] if len(deploy_init) > 1: meta_project = [pra_meta["project"] for pra_meta in deploy_init] meta_field = [{ "type": "TitleSelectOne", "name": "Select Project", "key": "project", "values": meta_project }] meta_field = utils.prompt_generator("Select project...", meta_field) meta = [ pra_meta for pra_meta in deploy_init if pra_meta in [meta_field["project"]] ][0] if meta: project_name = meta["project"] project_dir = meta["dir"] private_key_file = "{}/private_key.pem".format(project_dir) project_hostname = None project_user = None if not os.path.exists(private_key_file): utils.log_info( "Generate {} private key...".format(project_name)) wait_key = True while wait_key: out = orch.get_pkey_from_stack(project_name) if out: with open(private_key_file, "w") as pkey: pkey.write(out) os.chmod(private_key_file, 0o600) utils.log_info("Done...") wait_key = False else: pkeys = orch.get_private_key(project_name) if pkeys: with open(private_key_file, "w") as pkey: pkey.write(pkeys) os.chmod(private_key_file, 0o600) utils.log_info("Done...") wait_key = False else: time.sleep(5) if os.path.exists(private_key_file): if not project_hostname: project_hostname = orch.get_metadata( project_name, "controller") project_user = orch.get_metadata(project_name, "user") do_ssh = True print("Try to connect...", end="") while do_ssh: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) result = sock.connect_ex((project_hostname, 22)) if result == 0: print("\nSuccess...") time.sleep(3) do_ssh = False else: print(".", end="") time.sleep(3) do_ssh = True if self.args["--command"]: try: utils.ssh_out_stream(project_hostname, project_user, self.args["--command"], key_file=private_key_file) except KeyboardInterrupt: exit() if self.args["--tunneling"]: try: tunnel_args = " ".join([ "-L {}".format(t_arg) for t_arg in self.args["--tunneling"].split(",") ]) commands = "ssh -i {} {} {}@{}".format( private_key_file, tunnel_args, project_user, project_hostname).split(" ") subprocess.call(commands) except KeyboardInterrupt: exit() utils.ssh_shell(project_hostname, project_user, key_file=private_key_file)
def do_logout(): if check_session(): os.remove('/tmp/session.pkl') utils.log_info("Logout Success")
def execute(self): set_file = self.args["--file"] default_file = orch.check_manifest_file() if self.args["vm"]: instance_id = self.args["<VM_ID>"] try: q_vm = utils.question( "Are you sure to delete this virtual machines ? ") if q_vm: vm_lib.do_delete(instance_id) utils.log_info("VM has been deleted") except Exception as e: utils.log_err(e) else: pass finally: pass exit() if self.args["network"]: network_id = self.args["<NETWORK_ID>"] try: q_net = utils.question("Are you sure to delete this network ?") if q_net: network_lib.do_delete(network_id) utils.log_info("network has been deleted") except Exception as e: utils.log_err(e) else: pass finally: pass exit() if self.args["stack"]: stack_name = self.args["<STACK_NAME>"] try: q_stack = utils.question( 'Are you sure to delete "{}" stack ? '.format(stack_name)) if q_stack: proj = orch.do_delete(stack_name) if proj: utils.log_info( "Stack {} has been deleted".format(stack_name)) else: utils.log_err( "Stack {} is not exists".format(stack_name)) except Exception as e: utils.log_err(e) else: pass finally: pass exit() if set_file: if os.path.exists(set_file): default_file = "{}".format(set_file) else: utils.log_err("{} file is not exists!".format(set_file)) print(self.__doc__) exit() if not default_file: utils.log_err("Can't find neo.yml manifest file!") print(self.__doc__) exit() projects = utils.get_project(default_file) project_answer = ",".join(projects) q_project = utils.question( "Are you sure to delete {} ? ".format(project_answer)) if q_project: for project in projects: proj = orch.do_delete(project) if proj: utils.log_info("Stack {} has been deleted".format(project)) else: utils.log_err("Stack {} is not exists".format(project))
def execute(self): set_file = self.args["--file"] default_file = orch.check_manifest_file() if self.args["vm"]: instance_id = self.args["<VM_ID>"] try: answer = "" while answer not in ["y", "n"]: answer = input( "Are you sure to delete this virtual machines [y/n]? " ).lower() if answer == "y": vm_lib.do_delete(instance_id) utils.log_info("VM has been deleted") except Exception as e: utils.log_err(e) else: pass finally: pass exit() if self.args["network"]: network_id = self.args["<NETWORK_ID>"] try: answer = "" while answer not in ["y", "n"]: answer = input( "Are you sure to delete this network [Y/N]? ") if answer == "y": network_lib.do_delete(network_id) utils.log_info("network has been deleted") except Exception as e: utils.log_err(e) else: pass finally: pass exit() if self.args["stack"]: stack_name = self.args["<STACK_NAME>"] try: answer = "" while answer not in ["y", "n"]: answer = input( "Are you sure to delete \"{}\" stack [Y/N]? ".format(stack_name)) if answer == "y": proj = orch.do_delete(stack_name) if proj: utils.log_info("Stack {} has been deleted".format(stack_name)) else: utils.log_err("Stack {} is not exists".format(stack_name)) except Exception as e: utils.log_err(e) else: pass finally: pass exit() if set_file: if os.path.exists(set_file): default_file = "{}".format(set_file) else: utils.log_err("{} file is not exists!".format(set_file)) print(self.__doc__) exit() if not default_file: utils.log_err("Can't find neo.yml manifest file!") print(self.__doc__) exit() projects = utils.get_project(default_file) project_answer = ",".join(projects) answer = "" while answer not in ["y", "n"]: answer = input("Are you sure to delete {} [y/n]? ".format( project_answer).lower()) if answer == "y": for project in projects: proj = orch.do_delete(project) if proj: utils.log_info("Stack {} has been deleted".format(project)) else: utils.log_err("Stack {} is not exists".format(project))