def details(self, kind, category, id, format="table"):
from cloudmesh_client.db.CloudmeshDatabase import CloudmeshDatabase
cm = CloudmeshDatabase()
try:
if kind not in self.kind:
raise ValueError('{} not defined'.format(kind))
elements = None
for idkey in ["cm_id", "name", "uuid", "id", "cm_id"]:
s = {idkey: id}
try:
elements = cm.find(kind=kind, category=category, **s)
except:
pass
if elements is not None:
break
if elements is None:
return None
if len(elements) > 0:
element = elements[0]
if format == "table":
return Printer.attribute(element)
else:
return Printer.write(element, output=format)
else:
return None
except Exception as ex:
Console.error(ex.message)
def details(self, kind, category, id, format="table"):
from cloudmesh_client.db.CloudmeshDatabase import CloudmeshDatabase
cm = CloudmeshDatabase()
try:
if kind not in self.kind:
raise ValueError('{} not defined'.format(kind))
elements = None
for idkey in ["cm_id", "name", "uuid", "id", "cm_id"]:
s = {idkey: id}
try:
elements = cm.find(kind=kind, category=category, **s)
except:
pass
if elements is not None:
break
if elements is None:
return None
if len(elements) > 0:
element = elements[0]
if format == "table":
return Printer.attribute(element)
else:
return Printer.write(element,
output=format)
else:
return None
except Exception as ex:
Console.error(ex.message)
def export(host, output):
config = ConfigDict("cloudmesh.yaml")
credentials = dict(
config["cloudmesh"]["clouds"][host]["credentials"])
if not arguments["--password"]:
credentials["OS_PASSWORD"] = "******"
if output is None:
for attribute, value in credentials.items():
print("export {}={}".format(attribute, value))
elif output == "table":
print(Printer.attribute(credentials))
else:
print(Printer.write(credentials, output=output))
def export(host, output):
config = ConfigDict("cloudmesh.yaml")
credentials = dict(
config["cloudmesh"]["clouds"][host]["credentials"])
if not arguments["--password"]:
credentials["OS_PASSWORD"] = "******"
if output is None:
for attribute, value in credentials.items():
print("export {}={}".format(attribute, value))
elif output == "table":
print(Printer.attribute(credentials))
else:
print(Printer.write(credentials, output=output))
def get_info(cls, category="general", name=None, output="table"):
"""
Method to get info about a group
:param cloud:
:param name:
:param output:
:return:
"""
try:
cloud = category or Default.cloud
args = {
"category": category
}
if name is not None:
args["name"] = name
group = cls.cm.find(kind="group", output="dict", **args)
return Printer.write(group,
order=cls.order,
output=output)
except Exception as ex:
Console.error(ex.message)
def list(cls,
order=None,
header=None,
output='table'):
"""
lists the default values in the specified format.
TODO: This method has a bug as it uses format and output,
only one should be used.
:param category: the category of the default value. If general is used
it is a special category that is used for global values.
:param format: json, table, yaml, dict, csv
:param order: The order in which the attributes are returned
:param output: The output format.
:return:
"""
if order is None:
order, header = None, None
# order, header = Attributes(cls.__kind__, provider=cls.__provider__)
try:
result = cls.cm.all(provider=cls.__provider__, kind=cls.__kind__)
return (Printer.write(result,
order=order,
output=output))
except Exception as e:
Console.error("Error creating list", traceflag=False)
Console.error(e.message)
return None
def get(cls, **kwargs):
"""
This method queries the database to fetch group(s)
with given name filtered by cloud.
:param name:
:param cloud:
:return:
"""
query = dict(kwargs)
if 'output' in kwargs:
for key, value in kwargs.items():
if value is None:
query[key] = "None"
del query['output']
try:
print("QQQ"), query
group = cls.cm.find(kind="group", **query)
print("gggg", group)
if group is not None \
and "output" in kwargs:
d = {"0": group}
group = Printer.write(d)
return group
except Exception as ex:
Console.error(ex.message)
def list(self, format='dict', sort_keys=True, order=None):
if order is None:
order = self.order
return Printer.write(self.data,
order=order,
output=format,
sort_keys=sort_keys)
def list_rules(cls, group=None, output='table'):
"""
This method gets the security group rules
from the cloudmesh database
:param uuid:
:return:
"""
try:
if group is None:
rules = cls.cm.find(kind="secgrouprule")
else:
args = {"group": group}
rules = cls.cm.find(kind="secgrouprule", **args)
# check if rules exist
if rules is None:
return "No rules for security group={} in the database. Try cm secgroup refresh.".format(
group)
# return table
return (Printer.write(rules,
order=[
"user", "group", "category", "name",
"fromPort", "toPort", "protocol", "cidr"
],
output=output))
except Exception as ex:
Console.error("Listing Security group rules")
return None
def get(cls, **kwargs):
"""
This method queries the database to fetch group(s)
with given name filtered by cloud.
:param name:
:param cloud:
:return:
"""
query = dict(kwargs)
if 'output' in kwargs:
for key, value in kwargs.items():
if value is None:
query[key] = "None"
del query['output']
try:
print("QQQ"), query
group = cls.cm.find(kind="group", **query)
print("gggg", group)
if group is not None \
and "output" in kwargs:
d = {"0": group}
group = Printer.write(d)
return group
except Exception as ex:
Console.error(ex.message)
def dict_choice(d):
if d is None:
return None
elements = dict(d)
i = 1
for e in d:
elements[e]["id"] = i
i += 1
# pprint(d)
if elements != {}:
# noinspection PyPep8
print(Printer.write(elements,
order=["id",
"name",
"comment",
"uri",
"fingerprint",
"source"],
output="table",
sort_keys=True))
else:
print("ERROR: No keys in the database")
return
n = num_choice(i - 1, tries=10) + 1
element = None
for e in elements:
if str(elements[e]["id"]) is str(n):
element = elements[e]
break
return element
def dict_choice(d):
if d is None:
return None
elements = dict(d)
i = 1
for e in d:
elements[e]["id"] = i
i += 1
# pprint(d)
if elements != {}:
# noinspection PyPep8
print(Printer.write(elements,
order=["id",
"name",
"comment",
"uri",
"fingerprint",
"source"],
output="table",
sort_keys=True))
else:
print("ERROR: No keys in the database")
return
n = num_choice(i - 1, tries=10) + 1
element = None
for e in elements:
if str(elements[e]["id"]) is str(n):
element = elements[e]
break
return element
def list_unused_floating_ip(cls, cloudname, output='table'):
"""
Method to list unused floating ips
These floating ips are not associated with any instance
:param cloudname:
:return: floating ip list
"""
try:
# fetch unused floating ips
floating_ips = cls.get_unused_floating_ip_list(cloudname)
# print the output
return Printer.write(floating_ips,
order=[
"ip",
"pool",
"id",
"cloud"
],
header=[
"floating_ip",
"floating_ip_pool",
"floating_ip_id",
"cloud"
],
output=output)
except Exception as ex:
Console.error(ex.message)
return
def list(cls, cloud=None, names=None, output='table', live=False):
try:
if live:
cls.refresh(cloud)
elements = cls.cm.find(kind="vm", category=cloud)
result = []
if "all" in names:
for element in elements:
result.append(element)
elif names is not None:
for element in elements:
if element["name"] in names:
result.append(element)
(order, header) = CloudProvider(cloud).get_attributes("ip")
return Printer.write(result,
order=order,
header=header,
output=output)
except Exception as ex:
Console.error(ex.message)
def list(cls,
category=None,
order=None,
output='table'):
"""
lists the default values in the specified format.
TODO: This method has a bug as it uses format and output,
only one should be used.
:param category: the category of the default value. If general is used
it is a special category that is used for global values.
:param order: The order in which the attributes are returned
:param output: The output format. json, table, yaml, dict, csv
:return:
"""
# if order is None:
# # (order, header) = CloudProvider(category).get_attributes("default")
try:
if category is None:
d = cls.cm.all("default")
else:
d = cls.cm.find('default', category=category)
return (Printer.dict_printer(d,
order=order,
output=output))
except:
return None
def list(cls, cloud=None, names=None, output='table', live=False):
try:
if live:
cls.refresh(cloud)
elements = cls.cm.find(kind="vm", category=cloud)
result = []
if "all" in names:
for element in elements:
result.append(element)
elif names is not None:
for element in elements:
if element["name"] in names:
result.append(element)
(order, header) = CloudProvider(cloud).get_attributes("ip")
return Printer.write(result,
order=order,
header=header,
output=output)
except Exception as ex:
Console.error(ex.message)
def list(cls, category=None, order=None, header=None, output=None):
"""
lists the default values in the specified format.
TODO: This method has a bug as it uses format and output,
only one should be used.
:param category: the category of the default value. If general is used
it is a special category that is used for global values.
:param format: json, table, yaml, dict, csv
:param order: The order in which the attributes are returned
:param output: The output format.
:return:
"""
if order is None:
order, header = None, None
# order = ['user',
# 'category',
# 'name',
# 'value',
# 'updated_at']
# order, header = Attributes(cls.__kind__, provider=cls.__provider__)
if output is None:
output = Default.output or 'table'
try:
if category is None:
result = cls.cm.all(kind=cls.__kind__)
else:
result = cls.cm.all(provider=category, kind=cls.__kind__)
table = Printer.write(result, output=output)
return table
except Exception as e:
Console.error("Error creating list", traceflag=False)
Console.error(e.message)
return None
def list(cls, name, live=False, format="table"):
"""
This method lists all workflows of the cloud
:param cloud: the cloud name
"""
# Console.TODO("this method is not yet implemented")
# return
try:
elements = cls.cm.find(kind="workflow", category='general')
# pprint(elements)
# (order, header) = CloudProvider(cloud).get_attributes("workflow")
order = None
header = None
# Console.msg(elements)
return Printer.write(elements,
order=order,
header=header,
output=format)
except Exception as ex:
Console.error(ex.message)
def list(self, format='dict', sort_keys=True, order=None):
if order is None:
order = self.order
return Printer.write(self.data,
order=order,
output=format,
sort_keys=sort_keys)
def list(cls, name, live=False, format="table"):
"""
This method lists all workflows of the cloud
:param cloud: the cloud name
"""
# Console.TODO("this method is not yet implemented")
# return
try:
elements = cls.cm.find(kind="workflow", category='general')
# pprint(elements)
# (order, header) = CloudProvider(cloud).get_attributes("workflow")
order = None
header= None
# Console.msg(elements)
return Printer.write(elements,
order=order,
header=header,
output=format)
except Exception as ex:
Console.error(ex.message)
def list(cls, cloud, start=None, end=None, tenant=None, format="table"):
# set the environment variables
set_os_environ(cloud)
try:
# execute the command
args = ["usage"]
if start is not None:
args.extend(["--start", start])
if end is not None:
args.extend(["--end", end])
if tenant is not None:
args.extend(["--tenant", tenant])
result = Shell.execute("nova", args)
result = Nova.remove_subjectAltName_warning(result)
lines = result.splitlines()
dates = lines[0]
# TODO: as stated below, nova returns additional lines,
# on my pc, SecurityWarning is returned, so filtering..
for l in lines[1:]:
if l.__contains__("SecurityWarning"):
lines.remove(l)
table = '\n'.join(lines[1:])
dates = dates.replace("Usage from ",
"").replace("to",
"").replace(" +",
" ")[:-1].split()
#
# TODO: for some reason the nova command has returned not the
# first + char, so we could not ignore the line we may set - as
# additional comment char, but that did not work
#
d = TableParser.convert(table, comment_chars="+#")
# d["0"]["start"] = "start"
# d["0"]["end"] = "end"
d["0"]["start"] = dates[0]
d["0"]["end"] = dates[1]
# del d['0']
return Printer.write(d,
order=[
"start", "end", "servers", "cpu hours",
"ram mb-hours", "disk gb-hours"
],
output=format)
except Exception as e:
return e
def list(cls, category=None, live=False, output="table"):
"this does not work only returns all ceys in the db"
(order, header) = CloudProvider(category).get_attributes("key")
d = cls.cm.find(kind="key", scope="all", output=output)
return Printer.write(d,
order=order,
header=header,
output=output)
def list(cls, cloud, start=None, end=None, tenant=None, format="table"):
# set the environment variables
set_os_environ(cloud)
try:
# execute the command
args = ["usage"]
if start is not None:
args.extend(["--start", start])
if end is not None:
args.extend(["--end", end])
if tenant is not None:
args.extend(["--tenant", tenant])
result = Shell.execute("nova", args)
result = Nova.remove_subjectAltName_warning(result)
lines = result.splitlines()
dates = lines[0]
# TODO: as stated below, nova returns additional lines,
# on my pc, SecurityWarning is returned, so filtering..
for l in lines[1:]:
if l.__contains__("SecurityWarning"):
lines.remove(l)
table = '\n'.join(lines[1:])
dates = dates.replace("Usage from ", "").replace("to", "").replace(" +", " ")[:-1].split()
#
# TODO: for some reason the nova command has returned not the
# first + char, so we could not ignore the line we may set - as
# additional comment char, but that did not work
#
d = TableParser.convert(table, comment_chars="+#")
# d["0"]["start"] = "start"
# d["0"]["end"] = "end"
d["0"]["start"] = dates[0]
d["0"]["end"] = dates[1]
# del d['0']
return Printer.write(d,
order=["start",
"end",
"servers",
"cpu hours",
"ram mb-hours",
"disk gb-hours"],
output=format)
except Exception as e:
return e
def _list_print(l, output, order=None):
if output in ["yaml", "dict", "json"]:
l = _convert(l)
result = Printer.write(l, order=order, output=output)
if output in ["table", "yaml", "json", "csv"]:
print(result)
else:
pprint(result)
def details(cls, cloud, id, live=False, format="table"):
elements = cls.cm.find(kind="workflow", category='general', cm_id=id)
Console.msg(elements)
order = None
header = None
# Console.TODO("this method is not yet implemented")
return Printer.write(elements,
order=order,
header=header,
output=format)
def details(cls, cloud, id, live=False, format="table"):
elements = cls.cm.find(kind="workflow", category='general' ,cm_id =id)
Console.msg(elements)
order = None
header= None
# Console.TODO("this method is not yet implemented")
return Printer.write(elements,
order=order,
header=header,
output=format)
def node_info(clusterid, nodeid=None, format='table'):
if nodeid:
url = Comet.url("cluster/{}/compute/{}/".format(clusterid, nodeid))
else:
url = Comet.url("cluster/{}/frontend/".format(clusterid))
r = Comet.get(url)
return Printer.attribute(
r,
#order=Cluster.NODEINFO_ORDER,
output=format)
def node_info(clusterid, nodeid=None, format='table'):
if nodeid:
url = Comet.url("cluster/{}/compute/{}/"
.format(clusterid, nodeid))
else:
url = Comet.url("cluster/{}/frontend/"
.format(clusterid))
r = Comet.get(url)
return Printer.attribute(r,
#order=Cluster.NODEINFO_ORDER,
output=format)
def boot_from_args(arg):
arg.username = arg.username or Image.guess_username(arg.image)
is_name_provided = arg.name is not None
arg.user = Default.user
for index in range(0, arg.count):
vm_details = dotdict({
"cloud": arg.cloud,
"name": Vm.get_vm_name(arg.name, index),
"image": arg.image,
"flavor": arg.flavor,
"key": arg.key,
"secgroup": arg.secgroup,
"group": arg.group,
"username": arg.username,
"user": arg.user
})
# correct the username
vm_details.username = Image.guess_username_from_category(
vm_details.cloud,
vm_details.image,
username=arg.username)
try:
if arg.dryrun:
print(Printer.attribute(vm_details, output=arg.format))
msg = "dryrun info. OK."
Console.ok(msg)
else:
vm_id = Vm.boot(**vm_details)
if vm_id is None:
msg = "info. failed."
Console.error(msg, traceflag=False)
return ""
# set name and counter in defaults
Default.set_vm(value=vm_details.name)
if is_name_provided is False:
Default.incr_counter("name")
# Add to group
if vm_id is not None:
Group.add(name=vm_details.group,
species="vm",
member=vm_details.name,
category=vm_details.cloud)
msg = "info. OK."
Console.ok(msg)
except Exception as e:
Console.error("Problem booting instance {name}".format(**vm_details), traceflag=False)
def _print_dict(d, header=None, format='table'):
msg = Printer.write(
d,
order=["name", "comment", "uri", "fingerprint", "source"],
output=format,
sort_keys=True)
if msg is None:
Console.error("No keys found.", traceflag=False)
return None
else:
return msg
def boot_from_args(arg):
arg.username = arg.username or Image.guess_username(arg.image)
is_name_provided = arg.name is not None
arg.user = Default.user
for index in range(0, arg.count):
vm_details = dotdict({
"cloud": arg.cloud,
"name": Vm.generate_vm_name(arg.name, index),
"image": arg.image,
"flavor": arg.flavor,
"key": arg.key,
"secgroup": arg.secgroup,
"group": arg.group,
"username": arg.username,
"user": arg.user
})
# correct the username
vm_details.username = Image.guess_username_from_category(
vm_details.cloud, vm_details.image, username=arg.username)
try:
if arg.dryrun:
print(Printer.attribute(vm_details, output=arg.format))
msg = "dryrun info. OK."
Console.ok(msg)
else:
vm_id = Vm.boot(**vm_details)
if vm_id is None:
msg = "info. failed."
Console.error(msg, traceflag=False)
return ""
# set name and counter in defaults
Default.set_vm(value=vm_details.name)
if is_name_provided is False:
Default.incr_counter("name")
# Add to group
if vm_id is not None:
Group.add(name=vm_details.group,
species="vm",
member=vm_details.name,
category=vm_details.cloud)
msg = "info. OK."
Console.ok(msg)
except Exception as e:
Console.error(
"Problem booting instance {name}".format(**vm_details),
traceflag=False)
def _LIST_PRINT(l, output, order=None):
if output in ["yaml", "dict", "json"]:
l = _convert(l)
result = Printer.write(l,
order=order,
output=output)
if output in ["table", "yaml", "json", "csv"]:
print(result)
else:
pprint(result)
def do_version(self, args, arguments):
"""
Usage:
version [--format=FORMAT] [--check=CHECK]
Options:
--format=FORMAT the format to print the versions in [default: table]
--check=CHECK boolean tp conduct an additional check [default: True]
Description:
Prints out the version number
"""
python_version, pip_version = get_python()
try:
git_hash_version = Shell.execute('git',
'log -1 --format=%h',
traceflag=False,
witherror=False)
except:
git_hash_version = 'N/A'
versions = {
"cloudmesh_client": {
"name": "cloudmesh_client",
"version": str(cloudmesh_client.__version__)
},
# "cloudmesh_base": {
# "name": "cloudmesh_base",
# "version": str(cloudmesh_base.__version__)
# },
"python": {
"name": "python",
"version": str(python_version)
},
"pip": {
"name": "pip",
"version": str(pip_version)
},
"git": {
"name": "git hash",
"version": str(git_hash_version)
}
}
print(
Printer.write(versions,
output=arguments["--format"],
order=["name", "version"]))
if arguments["--check"] in ["True"]:
check_python()
def do_info(self, args, arguments):
"""
::
Usage:
info [--cloud=CLOUD] [--format=FORMAT]
Options:
--format=FORMAT the output format [default: table]
--cloud=CLOUD the cloud name
Examples:
cm info
"""
arg = dotdict(arguments)
arg.cloud = arguments["--cloud"] or Default.cloud
arg.FORMAT = arguments["--format"] or "table"
d = {
"cloud": arg.cloud,
"key": Default.key,
"user": Default.user,
"vm": Default.vm,
"group": Default.group,
"secgroup": Default.secgroup,
"counter": Default.get_counter(name="name"),
"image": Default.get_image(category=arg.cloud),
"flavor": Default.get_flavor(category=arg.cloud),
"refresh": str(Default.refresh),
"debug": str(Default.debug),
"interactive": str(Default.interactive),
"purge": str(Default.purge),
}
order = [
"cloud", "key", "user", "vm", "group", "secgroup", "counter",
"image", "flavor", "refresh", "debug", "interactive", "purge"
]
print(
Printer.attribute(d,
order=order,
output=arg.FORMAT,
sort_keys=False))
if d["key"] in ["TBD", ""] or d["user"] in ["TBD", ""]:
msg = "Please replace the TBD values"
msg = msg + "\nSee Also: \n\n" \
+ " cm register profile \n" \
+ " cm default user=YOURUSERNAME\n"
Console.error(msg, traceflag=False)
return ""
def node_info(clusterid, nodeid=None, format='table'):
if nodeid:
url = Comet.url("cluster/{}/compute/{}/"
.format(clusterid, nodeid))
else:
url = Comet.url("cluster/{}/frontend/"
.format(clusterid))
r = Comet.get(url)
ret = "ERROR: Node not available. Please check the cluster/node name!\n"
if r:
ret = Printer.attribute(r,
#order=Cluster.NODEINFO_ORDER,
output=format)
return ret
def list(cls, cloud, tenant, output="table"):
try:
provider = CloudProvider(cloud).provider
result = provider.list_quota(cloud)
(order, header) = CloudProvider(cloud).get_attributes("quota")
return Printer.attribute(result, header=header, output=output)
except Exception as e:
import sys
print(sys.exc_info()[0])
return e
def list(cls, name=None, output='table'):
# ignore names for now
try:
elements = cls.cm.find(kind="launcher", category='general', scope="all", output="dict")
order = None
header = None
return Printer.write(elements,
order=order,
header=header,
output=output)
except Exception as ex:
Console.error(ex.message)
return ""
def _print_dict(d, header=None, format='table'):
msg = Printer.write(d,
order=["name",
"comment",
"uri",
"fingerprint",
"source"],
output=format,
sort_keys=True)
if msg is None:
Console.error("No keys found.", traceflag=False)
return None
else:
return msg
def list(cls,
group=None,
name=None,
category='general',
output='table',
scope='all'):
"""
This method queries the database to fetch list of secgroups
filtered by cloud.
:param cloud:
:return:
"""
query = dotdict({
"kind": "secgrouprule",
"scope": "all"
})
if category is "general":
if group is not None:
query.group = group
if name is not None:
query.name = name
query.category = category
elements = cls.cm.find(**query)
else:
elements = CloudProvider(category).provider.list_secgroup_rules(category)
if elements is None:
return None
else:
# pprint(elements)
#
# BUG this should not depend on cloud, but on "general"
#
# (order, header) = CloudProvider(cloud).get_attributes("secgroup")
order = ['name', 'group', 'fromPort', 'toPort', 'cidr', 'protocol']
header = None
return Printer.write(elements,
order=order,
header=header,
output=output)
def list(cls,
group=None,
name=None,
category='general',
output='table',
scope='all'):
"""
This method queries the database to fetch list of secgroups
filtered by cloud.
:param cloud:
:return:
"""
query = dotdict({
"kind": "secgrouprule",
"scope": "all"
})
if category is "general":
if group is not None:
query.group = group
if name is not None:
query.name = name
query.category = category
elements = cls.cm.find(**query)
else:
elements = CloudProvider(category).provider.list_secgroup_rules(category)
if elements is None:
return None
else:
# pprint(elements)
#
# BUG this should not depend on cloud, but on "general"
#
# (order, header) = CloudProvider(cloud).get_attributes("secgroup")
order = ['name', 'group', 'fromPort', 'toPort', 'cidr', 'protocol']
header = None
return Printer.write(elements,
order=order,
header=header,
output=output)
def list(cls, cloud, output="table", tenant=None):
try:
provider = CloudProvider(cloud).provider
# if tenant is None:
# tenant = provider.tenant
result = provider.list_limits(tenant)["absolute"]
(order, header) = CloudProvider(cloud).get_attributes("limits")
return Printer.attribute(result,
header=header,
output=output)
except Exception as e:
return e
def do_version(self, args, arguments):
"""
Usage:
version [--format=FORMAT] [--check=CHECK]
Options:
--format=FORMAT the format to print the versions in [default: table]
--check=CHECK boolean tp conduct an additional check [default: True]
Description:
Prints out the version number
"""
python_version, pip_version = get_python()
try:
git_hash_version = Shell.execute('git', 'log -1 --format=%h')
except:
git_hash_version = 'N/A'
versions = {
"cloudmesh_client": {
"name": "cloudmesh_client",
"version": str(cloudmesh_client.__version__)
},
# "cloudmesh_base": {
# "name": "cloudmesh_base",
# "version": str(cloudmesh_base.__version__)
# },
"python": {
"name": "python",
"version": str(python_version)
},
"pip": {
"name": "pip",
"version": str(pip_version)
},
"git": {
"name": "git hash",
"version": str(git_hash_version)
}
}
print(Printer.write(versions, output=arguments["--format"],
order=["name", "version"]))
if arguments["--check"] in ["True"]:
check_python()
def list(cls, cloud, tenant, output="table"):
try:
provider = CloudProvider(cloud).provider
result = provider.list_quota(cloud)
(order, header) = CloudProvider(cloud).get_attributes("quota")
return Printer.attribute(result,
header=header,
output=output)
except Exception as e:
import sys
print(sys.exc_info()[0])
return e
def list(cls,
name=None,
order=None,
header=None,
output='table'):
"""
lists the default values in the specified format.
TODO: This method has a bug as it uses format and output,
only one should be used.
:param category: the category of the default value. If general is used
it is a special category that is used for global values.
:param format: json, table, yaml, dict, csv
:param order: The order in which the attributes are returned
:param output: The output format.
:return:
"""
if order is None:
order, header = None, None
# order = ['user',
# 'category',
# 'name',
# 'value',
# 'updated_at']
# order, header = Attributes(cls.__kind__, provider=cls.__provider__)
try:
query = {
"provider": cls.__provider__,
"kind": cls.__kind__,
"category": 'general'
}
result = None
if name is not None:
query["name"] = name
result = cls.cm.find(**query)
if result is None:
table = None
else:
table = Printer.write(result,
output='table')
return table
except Exception as e:
Console.error("Error creating list", traceflag=False)
Console.error(e.message)
return None
def list(cls,
kind,
cloud,
user=None,
tenant=None,
order=None,
header=None,
output="table"):
"""
Method lists the data in the db for
given cloud and of given kind
:param kind:
:param cloud:
:param tenant:
:param user:
:param order:
:param header:
:param output:
:return:
"""
try:
# get the model object
table = cls.cm.get_table(kind)
filter = {}
if cloud is not None:
filter["category"] = cloud
if user is not None:
filter["user"] = user
if tenant is not None:
filter["tenant"] = tenant
elements = cls.cm.find(table, **filter)
if elements is not None or elements is not {}:
# convert the output to a dict
return (Printer.write(elements,
order=order,
header=header,
output=output))
else:
return None
except Exception as ex:
Console.error(ex.message)
def queue(cls, cluster, format='json', job=None):
try:
args = 'squeue '
if job is not None:
if job.isdigit():
args += ' -j {} '.format(str(job)) # search by job id
else:
args += ' -n {} '.format(job) # search by job name
f = '--format=%all'
args += f
result = Shell.ssh(cluster, args)
# TODO: process till header is found...(Need a better way)
l = result.splitlines()
for i, res in enumerate(l):
if 'ACCOUNT|GRES|' in res:
result = "\n".join(str(x) for x in l[i:])
break
parser = TableParser(strip=True)
d = parser.to_dict(result)
# add cluster and updated to each entry
for key in list(d.keys()):
d[key]['cluster'] = cluster
d[key]['updated'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
if format == 'json':
return json.dumps(d, indent=4, separators=(',', ': '))
else:
return (Printer.write(d,
order=['cluster',
'jobid',
'partition',
'name',
'user',
'st',
'time',
'nodes',
'nodelist',
'updated'],
output=format))
except Exception as e:
Error.traceback(e)
return e
def do_info(self, args, arguments):
"""
::
Usage:
info [--cloud=CLOUD] [--format=FORMAT]
Options:
--format=FORMAT the output format [default: table]
--cloud=CLOUD the cloud name
Examples:
cm info
"""
arg = dotdict(arguments)
arg.cloud = arguments["--cloud"] or Default.cloud
arg.FORMAT = arguments["--format"] or "table"
d = {
"cloud": arg.cloud,
"key": Default.key,
"user": Default.user,
"vm": Default.vm,
"group": Default.group,
"secgroup": Default.secgroup,
"counter": Default.get_counter(name="name"),
"image": Default.get_image(category=arg.cloud),
"flavor": Default.get_flavor(category=arg.cloud),
"refresh": str(Default.refresh),
"debug": str(Default.debug),
"interactive": str(Default.interactive),
"purge": str(Default.purge),
}
order = ["cloud", "key", "user", "vm", "group", "secgroup",
"counter", "image", "flavor", "refresh", "debug", "interactive", "purge"]
print(Printer.attribute(d, order=order, output=arg.FORMAT, sort_keys=False))
if d["key"] in ["TBD", ""] or d["user"] in ["TBD", ""]:
msg = "Please replace the TBD values"
msg = msg + "\nSee Also: \n\n" \
+ " cm register profile \n" \
+ " cm default user=YOURUSERNAME\n"
Console.error(msg, traceflag=False)
return ""
def _print_dict(d, header=None, format='table'):
if format == "json":
return json.dumps(d, indent=4)
elif format == "yaml":
return pyaml.dump(d)
elif format == "table":
return Printer.write(d,
order=[
"id", "name", "start_time",
"end_time", "user", "project",
"hosts", "description", "cloud"
],
output="table",
sort_keys=True)
elif format == "csv":
TODO.implement()
else:
return d
def list_floating_ip_pool(cls, cloudname):
"""
Method to list floating ip pool
:param cloudname:
:return:
"""
try:
cloud_provider = CloudProvider(cloudname).provider
floating_ip_pools = cloud_provider.list_floating_ip_pools()
(order, header
) = CloudProvider(cloudname).get_attributes("floating_ip_pool")
return Printer.write(floating_ip_pools, order=order, header=header)
except Exception as ex:
Console.error(ex.message)
pass
def get_fixed_ip(cls, cloudname, fixed_ip_addr, output='table'):
"""
Method retrieves fixed ip info
:param cloudname:
:param fixed_ip_addr:
:return: fixed_ip_info
"""
try:
cloud_provider = CloudProvider(cloudname).provider
result = cloud_provider.get_fixed_ip(fixed_ip_addr=fixed_ip_addr)
return Printer.attribute(result,
header=["name", "value"],
output=output)
except Exception as ex:
Console.error(ex.message)
return
def print_ssh_table(output):
content = read(filename="~/.ssh/config").split("\n")
entries = [
]
def empty():
return {
"host": None,
"hostname": None,
"user": None,
"proxycommand": None,
"serveraliveinterval": None,
"localforward": None,
"forwardx11": None
}
entry = empty()
for line in content:
line = line.strip()
if line.startswith("#"):
pass
elif line.strip() == "":
pass
elif "Host " in line:
hostname = line.strip().split("Host")[1]
entry["host"] = hostname.strip()
if entry is not None:
entries.append(entry)
entry = empty()
else:
attribute, value = line.strip().split(" ", 1)
entry[attribute.lower()] = value.strip()
# pprint(entries)
order = ["host",
"hostname",
"user",
"proxycommand",
"serveraliveinterval",
"localforward",
"forwardx11"]
print(Printer.list(entries, order=order))
def list(cls, cloud, format="table"):
"""
This method lists all images of the cloud
:param cloud: the cloud name
"""
# TODO: make a CloudmeshDatabase without requiring the user=
try:
elements = cls.cm.find(kind="image", category=cloud, scope="all")
(order, header) = CloudProvider(cloud).get_attributes("image")
return Printer.write(elements,
order=order,
header=header,
output=format)
except Exception as ex:
Console.error(ex.message)
def list_floating_ip_pool(cls, cloudname):
"""
Method to list floating ip pool
:param cloudname:
:return:
"""
try:
cloud_provider = CloudProvider(cloudname).provider
floating_ip_pools = cloud_provider.list_floating_ip_pools()
(order, header) = CloudProvider(cloudname).get_attributes("floating_ip_pool")
return Printer.write(floating_ip_pools,
order=order,
header=header)
except Exception as ex:
Console.error(ex.message)
pass
def list(cls, cloud, format="table"):
"""
This method lists all images of the cloud
:param cloud: the cloud name
"""
# TODO: make a CloudmeshDatabase without requiring the user=
try:
elements = cls.cm.find(kind="image", category=cloud, scope="all")
(order, header) = CloudProvider(cloud).get_attributes("image")
return Printer.write(elements,
order=order,
header=header,
output=format)
except Exception as ex:
Console.error(ex.message)
def list(cls, name=None, order=None, header=None, output='table'):
"""
lists the default values in the specified format.
TODO: This method has a bug as it uses format and output,
only one should be used.
:param category: the category of the default value. If general is used
it is a special category that is used for global values.
:param format: json, table, yaml, dict, csv
:param order: The order in which the attributes are returned
:param output: The output format.
:return:
"""
if order is None:
order, header = None, None
# order = ['user',
# 'category',
# 'name',
# 'value',
# 'updated_at']
# order, header = Attributes(cls.__kind__, provider=cls.__provider__)
try:
query = {
"provider": cls.__provider__,
"kind": cls.__kind__,
"category": 'general'
}
result = None
if name is not None:
query["name"] = name
result = cls.cm.find(**query)
if result is None:
table = None
else:
table = Printer.write(result, output='table')
return table
except Exception as e:
Console.error("Error creating list", traceflag=False)
Console.error(e.message)
return None
def test_005(self):
HEADING()
Key.delete()
Key.add_from_path("~/.ssh/id_rsa.pub")
d = Key.all(output="dict")
print(d)
print(Printer.write(d, output="table"))
assert 'id_rsa.pub' in str(d)
d = Key.find(name='rsa')
print('find function: ', d)
Key.delete(name='rsa')
d = Key.all(output="dict")
assert d is None
def list_on_cloud(cls, cloud, live=False, format="table"):
"""
This method lists all flavors of the cloud
:param cloud: the cloud name
"""
try:
keys = CloudProvider(cloud).provider.list_key(cloud)
for key in keys:
keys[key]["category"] = cloud
if keys is None or keys is []:
return None
(order, header) = CloudProvider(cloud).get_attributes("key")
return Printer.write(keys,
order=order,
header=header,
output=format)
except Exception as ex:
Console.error(ex.message)
