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")
