def show_port(port, session=None): neutron = get_neutron_client(session) try: obj_port = neutron.show_port(port) except Exception as e: utils.log_err(e) return obj_port
def dump_session(sess): temp = utils.tmp_dir() try: with open("{}/session.pkl".format(temp), "wb") as f: dill.dump(sess, f) except: utils.log_err("Dump session failed")
def get_floatingips(session=None): neutron = get_neutron_client(session) try: floatingips = neutron.list_floatingips() except Exception as e: utils.log_err(e) return floatingips["floatingips"]
def execute(self): if self.args["--describe"]: envs = login_lib.get_env_values() env_data = [[ envs['username'], envs['auth_url'], envs['project_id'], envs['user_domain_name'] ]] if len(env_data) == 0: utils.log_err("No Data...") print(self.__doc__) exit() print( tabulate(env_data, headers=[ "Username", "Auth URL", "Project ID", "Domain Name" ], tablefmt="grid")) exit() if (self.args["--domain"] and self.args["--keystone-url"]): try: username = self.args['--username'] auth_url = self.args['--keystone-url'] user_domain_name = self.args['--domain'] login_lib.do_login(auth_url=auth_url, user_domain_name=user_domain_name, username=username) except Exception as e: utils.log_err(e) if (not self.args["--domain"] and not self.args["--keystone-url"]): login_lib.do_login()
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 list_sec_group(session=None): neutron = get_neutron_client(session) try: sec_group = neutron.list_security_groups() except Exception as e: utils.log_err(e) return sec_group["security_groups"]
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 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 show_floatingips(floatingips, session=None): neutron = get_neutron_client(session) try: obj_floatingips = neutron.show_floatingip(floatingips) except Exception as e: utils.log_err(e) return obj_floatingips
def get_list(session=None): neutron = get_neutron_client(session) try: networks = neutron.list_networks() except Exception as e: utils.log_err(e) return networks["networks"]
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 show_subnet_pool(subnetpool, session=None): neutron = get_neutron_client(session) try: obj_subnetpools = neutron.show_subnetpool(subnetpool) except Exception as e: utils.log_err(e) return obj_subnetpools
def detach_interface(vm_id, port_id, session=None): compute = get_nova_client(session) try: detach_ip = compute.servers.interface_detach(vm_id, port_id) except Exception as e: utils.log_err(e) return detach_ip
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 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 get_list(session=None): compute = get_nova_client(session) try: instances = [instance for instance in compute.servers.list()] except Exception as e: utils.log_err(e) return instances
def list_router(session=None): obj_router_list = list() neutron = get_neutron_client(session) try: obj_router_list = neutron.list_routers() except Exception as e: utils.log_err(e) return obj_router_list
def action_logs_show(vm_id, action_id, session=None): compute = get_nova_client(session) detail_action = list() try: detail_action = compute.instance_action.get(vm_id, action_id) except Exception as e: utils.log_err(e) return detail_action
def action_logs(vm_id, session=None): compute = get_nova_client(session) log_action = list() try: log_action = compute.instance_action.list(vm_id) except Exception as e: utils.log_err(e) return log_action
def show_router(routers, session=None): neutron = get_neutron_client(session) try: obj_router = neutron.show_router(routers) except Exception as e: utils.log_err(e) return obj_router
def get_heat_client(session=None): try: if not session: session = login_lib.load_dumped_session() heat = heat_client.Client('1', session=session) return heat except Exception as e: utils.log_err(e)
def get_heat_client(session=None): try: if not session: session = login_lib.get_session() heat = heat_client.Client('1', session=session) return heat except Exception as e: utils.log_err(e)
def show_subnet(subnet, session=None): obj_subnet = list() neutron = get_neutron_client(session) try: obj_subnet = neutron.show_subnet(subnet) except Exception as e: utils.log_err(e) return obj_subnet
def do_delete(vol_id, session=None): storage = get_cinder_client(session) try: storage.volumes.delete(vol_id) except Exception as e: utils.log_err("Volumes Not Delete : " + str(e)) return 0 else: return 1
def list_subnet_pool(session=None): obj_subnetpool_list = list() neutron = get_neutron_client(session) try: obj_subnetpool_list = neutron.list_subnetpools() except Exception as e: utils.log_err(e) return obj_subnetpool_list
def attach_interface(vm_id, port_id, net_id, fixed_ip, session=None): compute = get_nova_client(session) try: attach_ip = compute.servers.interface_attach(vm_id, port_id, net_id, fixed_ip, tag=None) except Exception as e: utils.log_err(e) return attach_ip
def rules_sec_groups(sec_group, session=None): obj_sec_rule = list() neutron = get_neutron_client(session) try: sec_group = neutron.list_security_groups()["security_groups"] except Exception as e: utils.log_err(e) else: for i in sec_group: data = {"name": i["name"], "description": i["description"]} obj_sec_rule.append(data) return obj_sec_rule
def get_env_values(): if check_env(): load_env_file() neo_env = {} neo_env['username'] = os.environ.get('OS_USERNAME') neo_env['password'] = os.environ.get('OS_PASSWORD') neo_env['auth_url'] = os.environ.get('OS_AUTH_URL') neo_env['project_id'] = os.environ.get('OS_PROJECT_ID') neo_env['user_domain_name'] = os.environ.get('OS_USER_DOMAIN_NAME') return neo_env else: utils.log_err("Can't find neo.env")
def get_region(): show_region_list() region = input("region (Default: wjv-1): ") region = region.lower() try: if region == "": region = "wjv-1" # print(GLOBAL_REGION[region]) return GLOBAL_REGION[region] except KeyError: utils.log_err("Region not found, please check your region input") exit()
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_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 create_env_file(username, password, project_id, auth_url, user_domain_name): try: env_file = open("{}/.neo.env".format(GLOBAL_HOME), "w+") env_file.write("OS_USERNAME=%s\n" % username) env_file.write("OS_PASSWORD=%s\n" % password) env_file.write("OS_AUTH_URL=%s\n" % auth_url) env_file.write("OS_PROJECT_ID=%s\n" % project_id) env_file.write("OS_USER_DOMAIN_NAME=%s\n" % user_domain_name) env_file.close() return True except Exception as e: utils.log_err(e) return False
def do_login(username=None, region=None): if region == None and username == None: if check_env() and check_session(): print("You have logged in") print(" use 'neo login -D' to see your current account") else: do_fresh_login() elif region == None or username == None: if username == None: utils.log_err("You need to specify a username") elif region == None: login_check(username, DEFAULT_REGION) else: region = region.lower() login_check(username, region)
def execute(self): headers = ["ID", "Name", "Status", "Created", "Updated"] set_file = self.args["--file"] default_file = orch.check_manifest_file() 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() deploy_init = orch.initialize(default_file) try: orch.do_update(deploy_init) except: utils.log_err("Update Stack failed...") exit() projects = utils.get_project(default_file) project_list = list() for project in projects: proj = orch.get_stack(project) if proj: project_list.append(proj) if len(project_list) > 0: print(tabulate(project_list, headers=headers, tablefmt="grid"))
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 execute(self): if self.args["--template"]: if self.args["--template"] in ('clusters', 'instances', 'networks'): tmpl = self.args["--template"] if self.args["--interactive"]: ncurses.init(stack=tmpl) else: prompt.init(stack=tmpl) exit() if self.args["kubernetes"]: if self.args["--interactive"]: print(ncurses.init(stack="clusters", project="kubernetes")) else: print(prompt.init(stack="clusters", project="kubernetes")) if self.args["vm"]: if self.args["--interactive"]: print(ncurses.init(stack="instances", project="vm")) else: print(prompt.init(stack="instances", project="vm")) headers = ["ID", "Name", "Status", "Created", "Updated"] set_file = self.args["--file"] default_file = orch.check_manifest_file() 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!") q_stack = utils.question( "Do you want to generate neo.yml manifest? ") if q_stack: if self.args["--interactive"]: print(ncurses.init()) else: print(prompt.init()) q_deploy = utils.question("Continue to deploy? ") if q_deploy: default_file = "neo.yml" else: exit() else: exit() else: q_deploy = utils.question("Continue to deploy? ") if q_deploy: default_file = "neo.yml" else: exit() deploy_init = orch.initialize(default_file) try: orch.do_create(deploy_init) except Exception as e: utils.log_err(e) utils.log_err("Deploying Stack failed...") exit() projects = utils.get_project(default_file) project_list = list() for project in projects: proj = orch.get_stack(project) if proj: project_list.append(proj) if len(project_list) > 0: print(tabulate(project_list, headers=headers, tablefmt="grid"))
def execute(self): headers = ["ID", "Name", "Status", "Created", "Updated"] if self.args["stack"]: print(tabulate(orch.get_list(), headers=headers, tablefmt="grid")) exit() set_file = self.args["--file"] default_file = orch.check_manifest_file() if self.args["vm"]: data_instance = list() for instance in vm_lib.get_list(): pre_instance = [instance.id, instance.name] pre_instance.append(image.detail(instance.image["id"]).name) flavors = vm_lib.detail_flavor(instance.flavor["id"]) flavors_name = flavors.name flavors_vcpu = flavors.vcpus flavors_ram = bitmath.MiB(flavors.ram).to_GiB().best_prefix() pre_instance.append(flavors_name) pre_instance.append(flavors_ram) pre_instance.append(flavors_vcpu) # Address addr = list() addr_objs = utils.get_index(instance.addresses) if len(addr_objs) > 0: for addr_obj in addr_objs: addr.append("network : {}".format(addr_obj)) for addr_ip in instance.addresses[addr_obj]: addr_meta = "{} IP : {}".format( addr_ip["OS-EXT-IPS:type"], addr_ip["addr"]) addr.append(addr_meta) if len(addr) > 0: pre_instance.append("\n".join(addr)) else: pre_instance.append("") pre_instance.append(instance.status) data_instance.append(pre_instance) if len(data_instance) == 0: utils.log_err("No Data...") print(self.__doc__) exit() print( tabulate( data_instance, headers=[ "ID", "Name", "Image", "Flavor", "RAM (GiB)", "vCPU", "Addresses", "Status" ], tablefmt="grid")) exit() if self.args["network"]: data_network = [[ network['id'], network['name'], network['status'] ] for network in network_lib.get_list()] if len(data_network) == 0: utils.log_err("No Data...") print(self.__doc__) exit() print( tabulate( data_network, headers=["ID", "Name", "Status"], tablefmt="grid")) exit() if self.args["--outputs"]: stack_name = self.args["--outputs"].split(".") if len(stack_name) is 1: for meta in orch.get_meta_stack(stack_name[0]): print(meta["output_key"], " :") print(meta["output_value"]) print("") if len(stack_name) is 2: print(orch.get_metadata(stack_name[0], stack_name[1])) 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("Oops!! Can't find neo.yml manifest file!") print(self.__doc__) exit() projects = utils.get_project(default_file) project_list = list() for project in projects: proj = orch.get_stack(project) if proj: project_list.append(proj) if len(project_list) > 0: print(tabulate(project_list, headers=headers, tablefmt="grid")) else: utils.log_err("No Data...") print(self.__doc__)
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))
def set_session(sess): try: with open('/tmp/session.pkl', 'wb') as f: dill.dump(sess, f) except Exception as e: utils.log_err("set session failed")