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(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(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 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 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 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 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 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 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 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 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 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 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 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(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, 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, 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, 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 _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_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 _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, 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 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 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 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,
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 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 _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(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, 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, 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)
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)
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(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 = 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 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 info(cls, cluster, format='json', all=False):
if all:
result = Shell.ssh(cluster, 'sinfo --format=\"%all\"')
else:
result = Shell.ssh(
cluster,
'sinfo --format=\"%P|%a|%l|%D|%t|%N\"')
# ignore leading lines till header is found
l = result.splitlines()
for i, res in enumerate(l):
if 'PARTITION|AVAIL|' in res:
result = "\n".join(l[i:])
break
parser = TableParser(strip=False)
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',
'partition',
'avail',
'timelimit',
'nodes',
'state',
'nodelist',
'updated'],
output=format))
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 list_floating_ip(cls, cloudname, output='table'):
"""
Method to list floating ips
:param cloudname:
:return: floating ip list
"""
try:
floating_ips = cls.get_floating_ip_list(cloudname)
for floating_ip in list(floating_ips.values()):
# Get instance_id associated with instance
instance_id = floating_ip["instance_id"]
if instance_id is not None:
try:
instance_name = cls.find_instance_name(
cloudname=cloudname, instance_id=instance_id)
# Assign it to the dict
floating_ip["instance_name"] = instance_name
floating_ip["cloud"] = cloudname
except Exception as ex:
Console.error(ex.message)
continue
else:
# If no instance associated, keep None
floating_ip["instance_name"] = None
(order,
header) = CloudProvider(cloudname).get_attributes("floating_ip")
return Printer.write(floating_ips,
order=order,
header=header,
output=output)
except Exception as ex:
Console.error(ex.message)
return
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, live=False, format="table"):
"""
This method lists all hpcs of the cloud
:param cloud: the cloud name
"""
try:
if live:
cls.refresh(cloud)
elements = cls.cm.find(kind="hpc", category=cloud)
# pprint(elements)
(order, header) = CloudProvider(cloud).get_attributes("hpc")
return Printer.write(elements,
order=order,
header=header,
output=format)
except Exception as ex:
Console.error(ex.message)
def list_floating_ip(cls, cloudname, output='table'):
"""
Method to list floating ips
:param cloudname:
:return: floating ip list
"""
try:
floating_ips = cls.get_floating_ip_list(cloudname)
for floating_ip in list(floating_ips.values()):
# Get instance_id associated with instance
instance_id = floating_ip["instance_id"]
if instance_id is not None:
try:
instance_name = cls.find_instance_name(cloudname=cloudname,
instance_id=instance_id)
# Assign it to the dict
floating_ip["instance_name"] = instance_name
floating_ip["cloud"] = cloudname
except Exception as ex:
Console.error(ex.message)
continue
else:
# If no instance associated, keep None
floating_ip["instance_name"] = None
(order, header) = CloudProvider(cloudname).get_attributes("floating_ip")
return Printer.write(floating_ips,
order=order,
header=header,
output=output)
except Exception as ex:
Console.error(ex.message)
return
def list(cls, **kwargs):
"""
This method lists all VMs of the cloud
"""
arg = dotdict(kwargs)
if "name" in arg:
arg.name = arg.name
arg.output = arg.output or 'table'
# pprint (kwargs)
# prevent circular dependency
def vm_groups(vm):
"""
:param vm: name of the vm
:return: a list of groups the vm is in
"""
try:
query = {
'kind': "group",
'provider': 'general',
"species": "vm",
"member": vm,
"scope": 'all',
"output": 'dict'
}
d = cls.cm.find(**query)
groups_vm = set()
if d is not None and len(d) > 0:
for vm in d:
groups_vm.add(vm['name'])
return list(groups_vm)
except Exception as ex:
Console.error(ex.message)
return []
try:
if "name" in arg and arg.name is not None:
if cls.isUuid(arg.name):
elements = cls.cm.find(kind="vm",
category=arg.category,
uuid=arg.name)
else:
elements = cls.cm.find(kind="vm",
category=arg.category,
label=arg.name)
else:
elements = cls.cm.find(kind="vm", category=arg.category)
if elements is None or len(elements) == 0:
return None
for elem in elements:
element = elem
name = element["name"]
groups = vm_groups(name)
element["group"] = ','.join(groups)
# print(elements)
# order = ['id', 'uuid', 'name', 'cloud']
(order, header) = CloudProvider(arg.category).get_attributes("vm")
# order = None
if "name" in arg and arg.name is not None:
return Printer.attribute(elements[0], output=arg.output)
else:
return Printer.write(elements, order=order, output=arg.output)
except Exception as ex:
Console.error(ex.message)
def do_vm(self, args, arguments):
"""
::
Usage:
vm default [--cloud=CLOUD][--format=FORMAT]
vm refresh [all][--cloud=CLOUD]
vm boot [--name=NAME]
[--cloud=CLOUD]
[--username=USERNAME]
[--image=IMAGE]
[--flavor=FLAVOR]
[--group=GROUP]
[--public]
[--secgroup=SECGROUP]
[--key=KEY]
[--dryrun]
vm boot [--n=COUNT]
[--cloud=CLOUD]
[--username=USERNAME]
[--image=IMAGE]
[--flavor=FLAVOR]
[--group=GROUP]
[--public]
[--secgroup=SECGROUP]
[--key=KEY]
[--dryrun]
vm ping [NAME] [N]
vm console [NAME]
[--group=GROUP]
[--cloud=CLOUD]
[--force]
vm start [NAMES]
[--group=GROUP]
[--cloud=CLOUD]
[--force]
vm stop [NAMES]
[--group=GROUP]
[--cloud=CLOUD]
[--force]
vm terminate [NAMES]
[--group=GROUP]
[--cloud=CLOUD]
[--force]
vm delete [NAMES]
[--group=GROUP]
[--cloud=CLOUD]
[--keep]
[--dryrun]
vm ip assign [NAMES]
[--cloud=CLOUD]
vm ip show [NAMES]
[--group=GROUP]
[--cloud=CLOUD]
[--format=FORMAT]
[--refresh]
vm ip inventory [NAMES]
[--header=HEADER]
[--file=FILE]
vm ssh [NAME] [--username=USER]
[--quiet]
[--ip=IP]
[--cloud=CLOUD]
[--key=KEY]
[--command=COMMAND]
vm rename [OLDNAMES] [NEWNAMES] [--force] [--dryrun]
vm list [NAMES]
[--cloud=CLOUDS|--active]
[--group=GROUP]
[--format=FORMAT]
[--refresh]
vm status [NAMES]
vm wait [--cloud=CLOUD] [--interval=SECONDS]
vm info [--cloud=CLOUD]
[--format=FORMAT]
vm check NAME
vm username USERNAME [NAMES] [--cloud=CLOUD]
Arguments:
COMMAND positional arguments, the commands you want to
execute on the server(e.g. ls -a) separated by ';',
you will get a return of executing result instead of login to
the server, note that type in -- is suggested before
you input the commands
NAME server name. By default it is set to the name of last vm from database.
NAMES server name. By default it is set to the name of last vm from database.
KEYPAIR_NAME Name of the openstack keypair to be used to create VM. Note this is
not a path to key.
NEWNAMES New names of the VM while renaming.
OLDNAMES Old names of the VM while renaming.
Options:
--username=USERNAME the username to login into the vm. If not specified it will be guessed
from the image name and the cloud
--ip=IP give the public ip of the server
--cloud=CLOUD give a cloud to work on, if not given, selected
or default cloud will be used
--count=COUNT give the number of servers to start
--detail for table print format, a brief version
is used as default, use this flag to print
detailed table
--flavor=FLAVOR give the name or id of the flavor
--group=GROUP give the group name of server
--secgroup=SECGROUP security group name for the server
--image=IMAGE give the name or id of the image
--key=KEY specify a key to use, input a string which
is the full path to the private key file
--keypair_name=KEYPAIR_NAME Name of the openstack keypair to be used to create VM.
Note this is not a path to key.
--user=USER give the user name of the server that you want
to use to login
--name=NAME give the name of the virtual machine
--force rename/ delete vms without user's confirmation
--command=COMMAND
specify the commands to be executed
Description:
commands used to boot, start or delete servers of a cloud
vm default [options...]
Displays default parameters that are set for vm boot either on the
default cloud or the specified cloud.
vm boot [options...]
Boots servers on a cloud, user may specify flavor, image .etc, otherwise default values
will be used, see how to set default values of a cloud: cloud help
vm start [options...]
Starts a suspended or stopped vm instance.
vm stop [options...]
Stops a vm instance .
vm delete [options...]
Delete servers of a cloud, user may delete a server by its name or id, delete servers
of a group or servers of a cloud, give prefix and/or range to find servers by their names.
Or user may specify more options to narrow the search
vm floating_ip_assign [options...]
assign a public ip to a VM of a cloud
vm ip show [options...]
show the ips of VMs
vm ssh [options...]
login to a server or execute commands on it
vm list [options...]
same as command "list vm", please refer to it
vm status [options...]
Retrieves status of last VM booted on cloud and displays it.
Tip:
give the VM name, but in a hostlist style, which is very
convenient when you need a range of VMs e.g. sample[1-3]
=> ['sample1', 'sample2', 'sample3']
sample[1-3,18] => ['sample1', 'sample2', 'sample3', 'sample18']
Quoting commands:
cm vm login gvonlasz-004 --command=\"uname -a\"
"""
"""
# terminate
# issues a termination to the cloud, keeps vm in database
# delete
# issues a terminate if not already done
# (remember you do not have to go to cloud if state is already terminated)
# deletes the vm from database
#
# bulk rename
rename abc[0-1] def[3-4] renames the abc0,abc1 -> def3,def4
if arguments["rename"]:
oldnames = Parameter.expand(arguments["OLDNAME"])
newnames = Parameter.expand(arguments["NEWNAME"])
# check if new names ar not already taken
# to be implemented
if len(oldnames) == len(newnames):
for i in range(0, len(oldnames)):
oldname = oldnames[i]
newname = newnames[i]
if newname is None or newname == '':
print("New node name cannot be empty")
else:
print(Cluster.rename_node(clusterid, oldname, newname))
"""
cm = CloudmeshDatabase()
def _print_dict(d, header=None, output='table'):
return Printer.write(d, order=["id", "name", "status"], output=output, sort_keys=True)
def _print_dict_ip(d, header=None, output='table'):
return Printer.write(d, order=["network", "version", "addr"], output=output, sort_keys=True)
def get_vm_name(name=None, offset=0, fill=3):
if name is None:
count = Default.get_counter(name='name') + offset
prefix = Default.user
if prefix is None or count is None:
Console.error("Prefix and Count could not be retrieved correctly.", traceflag=False)
return
name = prefix + "-" + str(count).zfill(fill)
return name
def _refresh_cloud(cloud):
try:
msg = "Refresh VMs for cloud {:}.".format(cloud)
if Vm.refresh(cloud=cloud):
Console.ok("{:} OK.".format(msg))
else:
Console.error("{:} failed".format(msg), traceflag=False)
except Exception as e:
Console.error("Problem running VM refresh", traceflag=False)
def _get_vm_names():
vm_list = cm.find(kind="vm")
vms = [vm["name"] for vm in vm_list]
names = pattern = arguments["NAMES"]
if pattern is not None:
if "*" in pattern:
names = search(vms, pattern)
else:
names = Parameter.expand(names)
if names == ['last'] or names is None:
names == [Default.vm]
return vm_list, names
cloud = arguments["--cloud"] or Default.cloud
config = ConfigDict("cloudmesh.yaml")
active_clouds = config["cloudmesh"]["active"]
def _refresh(cloud):
all = arguments["all"] or None
if all is None:
_refresh_cloud(cloud)
else:
for cloud in active_clouds:
_refresh_cloud(cloud)
arg = dotdict(arguments)
arg.cloud = arguments["--cloud"] or Default.cloud
arg.image = arguments["--image"] or Default.get(name="image", category=arg.cloud)
arg.flavor = arguments["--flavor"] or Default.get(name="flavor", category=arg.cloud)
arg.group = arguments["--group"] or Default.group
arg.secgroup = arguments["--secgroup"] or Default.secgroup
arg.key = arguments["--key"] or Default.key
arg.dryrun = arguments["--dryrun"]
arg.name = arguments["--name"]
arg.format = arguments["--format"] or 'table'
arg.refresh = Default.refresh or arguments["--refresh"]
arg.count = int(arguments["--n"] or 1)
arg.dryrun = arguments["--dryrun"]
arg.verbose = not arguments["--quiet"]
#
# in many cases use NAMES
# if arg.NAMES is not None:
# arg.names = Parameter.expand(arg.NAMES) # gvonlasz[001-002] gives ["gvonlasz-001", "gvonlasz-002"]
# else:
# arg.names = None
#
if arguments["boot"]:
arg.username = arguments["--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": 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)
elif arguments["username"]:
arg.username = arguments["--username"] or Image.guess_username(arg.image)
cloud = arg.cloud
username = arg.USERNAME
if arg.NAMES is None:
names = [Default.vm]
else:
names = Parameter.expand(arg.NAMES)
if len(names) == 0:
return
for name in names:
arg.name = name
Console.ok("Set username for {cloud}:{name} to {USERNAME}".format(**arg))
Vm.set_login_user(name=name, cloud=cloud, username=username)
elif arguments["default"]:
try:
count = Default.get_counter()
prefix = Username()
if prefix is None or count is None:
Console.error("Prefix and Count could not be retrieved correctly.", traceflag=False)
return
vm_name = prefix + "-" + str(count).zfill(3)
arg = {
"name": vm_name,
"cloud": arguments["--cloud"] or Default.cloud
}
for attribute in ["image", "flavor"]:
arg[attribute] = Default.get(name=attribute, category=cloud)
for attribute in ["key", "group", "secgroup"]:
arg[attribute] = Default.get(name=attribute, category='general')
output = arguments["--format"] or "table"
print(Printer.attribute(arg, output=output))
msg = "info. OK."
Console.ok(msg)
ValueError("default command not implemented properly. Upon "
"first install the defaults should be read from yaml.")
except Exception as e:
# Error.traceback(e)
Console.error("Problem listing defaults", traceflag=False)
elif arguments["ping"]:
try:
if arguments["NAME"] is None and arguments["N"] is None:
name = arguments["NAME"] or Default.vm
n = arguments["N"] or 1
elif arguments["NAME"].isdigit():
n = arguments["NAME"]
name = Default.vm
else:
name = arguments["NAME"] or Default.vm
n = arguments["N"] or 1
print("Ping:", name, str(n))
vm = dotdict(Vm.list(name=name, category=cloud, output="dict")["dict"])
ip = vm.floating_ip
result = Shell.ping(host=ip, count=n)
print(result)
except Exception as e:
Console.error(e.message, traceflag=False)
elif arguments["console"]:
try:
name = arguments["NAME"] or Default.vm
vm = dotdict(Vm.list(name=name, category=cloud, output="dict")["dict"])
cloud_provider = CloudProvider(cloud).provider
vm_list = cloud_provider.list_console(vm.uuid)
print(vm_list)
msg = "info. OK."
Console.ok(msg)
except Exception as e:
# Error.traceback(e)
Console.error("Problem retrieving status of the VM", traceflag=False)
elif arguments["status"]:
try:
cloud_provider = CloudProvider(cloud).provider
vm_list = cloud_provider.list_vm(cloud)
vms = [vm_list[i]["name"] for i in vm_list ]
print ("V", vms)
pattern = arguments["NAMES"]
if pattern is not None:
if "*" in pattern:
print ("serach")
names = search(vms, pattern)
else:
names = Parameter.expand()
for i in vm_list:
if vm_list[i]["name"] in names:
print("{} {}".format(vm_list[i]["status"], vm_list[i]["name"]))
else:
print("{} {}".format(vm_list[0]["status"], vm_list[0]["name"]))
except Exception as e:
# Error.traceback(e)
Console.error("Problem retrieving status of the VM", traceflag=True)
elif arguments["wait"]:
interval = arguments["--interval"] or 5
try:
cloud_provider = CloudProvider(cloud).provider
for i in range(1,10):
vm_list = cloud_provider.list_vm(cloud)
time.sleep(float(1))
d = {}
for id in vm_list:
vm = vm_list[id]
d[vm["name"]] = vm["status"]
print (d)
print("{} {}".format(vm_list[0]["status"], vm_list[0]["name"]))
if vm_list[0]["status"] in ['ACTIVE']:
return
except Exception as e:
# Error.traceback(e)
Console.error("Problem retrieving status of the VM", traceflag=True)
elif arguments["info"]:
try:
cloud_provider = CloudProvider(cloud).provider
vms = cloud_provider.list_vm(cloud)
vm = vms[0]
output_format = arguments["--format"] or "table"
print(Printer.attribute(vm, output=output_format))
msg = "info. OK."
Console.ok(msg)
except Exception as e:
# Error.traceback(e)
Console.error("Problem retrieving status of the VM", traceflag=False)
elif arguments["check"]:
test = {}
try:
names = Parameter.expand(arguments["NAME"])
id = 0
for name in names:
print("Not implemented: {}".format(name))
# TODO: check the status of the vms
status = "active"
# TODO: check if they have a floating ip
# TODO: get ip
floating_ip = "127.0.0.1"
ip = True
# ping
# TODO: ping the machine with the shell command
ping = True
# check if one can login and run a command
check = False
try:
r = Shell.execute("uname", "-a")
# do a real check
check = True
except:
check = False
test[name] = {
"id": id,
"name": name,
"status": status,
"ip": ip,
"ping": ping,
"login": check
}
id += 1
pprint(test)
print(Printer.write(test,
order=["id",
"name",
"status",
"ip",
"ping",
"login"],
output="table",
sort_keys=True))
msg = "not yet implemented. failed."
Console.error(msg, traceflag=False)
except Exception as e:
# Error.traceback(e)
Console.error("Problem retrieving status of the VM", traceflag=False)
elif arguments["start"]:
try:
servers = Parameter.expand(arguments["NAMES"])
# If names not provided, take the last vm from DB.
if len(servers) == 0:
last_vm = Default.vm
if last_vm is None:
Console.error("No VM records in database. Please run vm refresh.", traceflag=False)
return ""
name = last_vm["name"]
# print(name)
servers = list()
servers.append(name)
group = arguments["--group"]
force = arguments["--force"]
# if default cloud not set, return error
if not cloud:
Console.error("Default cloud not set.", traceflag=False)
return ""
Vm.start(cloud=cloud, servers=servers)
msg = "info. OK."
Console.ok(msg)
except Exception as e:
# Error.traceback(e)
Console.error("Problem starting instances", traceflag=False)
elif arguments["stop"]:
try:
servers = Parameter.expand(arguments["NAMES"])
# If names not provided, take the last vm from DB.
if servers is None or len(servers) == 0:
last_vm = Default.vm
if last_vm is None:
Console.error("No VM records in database. Please run vm refresh.", traceflag=False)
return ""
name = last_vm["name"]
# print(name)
servers = list()
servers.append(name)
group = arguments["--group"]
force = arguments["--force"]
# if default cloud not set, return error
if not cloud:
Console.error("Default cloud not set.", traceflag=False)
return ""
Vm.stop(cloud=cloud, servers=servers)
msg = "info. OK."
Console.ok(msg)
except Exception as e:
# Error.traceback(e)
Console.error("Problem stopping instances", traceflag=False)
elif arguments["refresh"]:
_refresh(cloud)
elif arguments["delete"]:
dryrun = arguments["--dryrun"]
group = arguments["--group"]
force = not arguments["--keep"]
cloud = arguments["--cloud"]
vms, servers = _get_vm_names()
if servers in [None, []]:
Console.error("No vms found.", traceflag=False)
return ""
for server in servers:
if dryrun:
Console.ok("Dryrun: delete {}".format(server))
else:
Vm.delete(servers=[server], force=force)
return ""
elif arguments["ip"] and arguments["assign"]:
if arguments["NAMES"] is None:
names = [Default.vm]
else:
names = Parameter.expand(arguments["NAMES"])
for name in names:
# ip = Network.get_floatingip(....)
vm = dotdict(Vm.list(name=name, category=cloud, output="dict")["dict"])
if vm.floating_ip is None:
Console.ok("Assign IP to {}".format(name))
try:
floating_ip = Network.find_assign_floating_ip(cloudname=cloud,
instance_id=name)
Vm.refresh(cloud=cloud)
if floating_ip is not None:
print(
"Floating IP assigned to {:} is {:}".format(
name, floating_ip))
msg = "info. OK."
Console.ok(msg)
except Exception as e:
Console.error("Problem assigning floating ips.", traceflag=False)
else:
Console.error("VM {} already has a floating ip: {}".format(name, vm.floating_ip), traceflag=False)
elif arguments["ip"] and arguments["inventory"]:
vms, names = _get_vm_names()
if names in [None, []]:
if str(Default.vm) in ['None', None]:
Console.error("The default vm is not set.", traceflag=False)
return ""
else:
names = [Default.vm]
header = arguments["--header"] or "[servers]"
filename = arguments["--file"] or "inventory.txt"
try:
vm_ips = []
for vm in vms:
if vm["name"] in names:
print (vm["name"])
vm_ips.append(vm["floating_ip"])
result = header + "\n"
result += '\n'.join(vm_ips)
Console.ok("Creating inventory file: {}".format(filename))
Console.ok(result)
with open(filename, 'w') as f:
f.write(result)
except Exception as e:
Console.error("Problem getting ip addresses for instance", traceflag=True)
elif arguments["ip"] and arguments["show"]:
if arguments["NAMES"] is None:
if str(Default.vm) in ['None', None]:
Console.error("The default vm is not set.", traceflag=False)
return ""
else:
names = [Default.vm]
else:
names = Parameter.expand(arguments["NAMES"])
group = arguments["--group"]
output_format = arguments["--format"] or "table"
refresh = arguments["--refresh"]
try:
ips = Ip.list(cloud=arg.cloud, output=output_format, names=names)
print(ips)
except Exception as e:
Console.error("Problem getting ip addresses for instance", traceflag=False)
elif arguments["ssh"]:
def _print(msg):
if arg.verbose:
Console.msg(msg)
chameleon = "chameleon" in ConfigDict(filename="cloudmesh.yaml")["cloudmesh"]["clouds"][arg.cloud][
"cm_host"]
if chameleon:
arg.username = "******"
elif arg.cloud == "azure":
arg.username = ConfigDict(filename="cloudmesh.yaml")["cloudmesh"]["clouds"]["azure"]["default"]["username"]
else:
if arg.username is None:
Console.error("Could not guess the username of the vm", traceflag=False)
return
arg.username = arguments["--username"] or Image.guess_username(arg.image)
arg.command = arguments["--command"]
data = dotdict({
'name': arguments["NAME"] or Default.vm,
'username': arg.username,
'cloud': arg.cloud,
'command': arg.command
})
_print("login {cloud}:{username}@{name}".format(**data))
vm = Vm.get(data.name, category=data.cloud)
Vm.set_login_user(name=data.name, cloud=data.cloud, username=data.username)
data.floating_ip = vm.floating_ip
data.key = arguments["--key"] or Default.key
_print(Printer.attribute(data))
'''
if vm.username is None:
user_from_db = Vm.get_login_user(vm.name, vm.cloud)
user_suggest = user_from_db or Default.user
username = input("Username (Default: {}):".format(user_suggest)) or user_suggest
Vm.set_login_user(name=data.name, cloud=cloud, username=data.username)
'''
ip = arguments["--ip"]
commands = arguments["--command"]
ip_addresses = []
cloud_provider = CloudProvider(cloud).provider
ip_addr = cloud_provider.get_ips(vm.name)
ipaddr_dict = Vm.construct_ip_dict(ip_addr, cloud)
for entry in ipaddr_dict:
ip_addresses.append(ipaddr_dict[entry]["addr"])
if len(ip_addresses) > 0:
if ip is not None:
if ip not in ip_addresses:
Console.error("IP Address specified does not match with the host.", traceflag=False)
return ""
else:
_print("Determining IP Address to use with a ping test.")
# This part assumes that the ping is allowed to the machine.
for ipadd in ip_addresses:
_print("Checking {:}...".format(ipadd))
try:
# Evading ping test, as ping is not enabled for VMs on Azure cloud
# socket.gethostbyaddr(ipadd)
# ip will be set if above command is successful.
ip = ipadd
except socket.herror:
_print("Cannot reach {:}.".format(ipadd))
if ip is None:
_print("Unable to connect to the machine")
return ""
else:
_print("IP to be used is: {:}".format(ip))
#
# TODO: is this correctly implemented
#
if not cloud == 'azure':
SecGroup.enable_ssh(cloud=cloud)
if arg.verbose:
Console.info("Connecting to Instance at IP:" + format(ip))
# Constructing the ssh command to connect to the machine.
sshcommand = "ssh"
if arg.key is not None:
sshcommand += " -i {:}".format(arg.key)
sshcommand += " -o StrictHostKeyChecking=no"
sshcommand += " {:}@{:}".format(data.username, ip)
if commands is not None:
sshcommand += " \"{:}\"".format(commands)
# print(sshcommand)
os.system(sshcommand)
else:
Console.error("No Public IPs found for the instance", traceflag=False)
elif arguments["list"]:
# groups = Group.list(output="dict")
arg = dotdict(arguments)
arg.names = arguments["NAMES"]
arg.group = arguments["--group"]
if arg.group is None:
arg.group = []
else:
arg.group = Parameter.expand(arguments["--group"])
arg.refresh = arguments["--refresh"] or Default.refresh
if arg.NAMES is not None:
arg.names = Parameter.expand(arguments["NAMES"])
else:
arg.names = ["all"]
_format = arguments["--format"] or "table"
if arguments["--active"]:
clouds = active_clouds
else:
if arguments["--cloud"]:
clouds = Parameter.expand(arguments["--cloud"])
else:
clouds = [Default.cloud]
try:
d = ConfigDict("cloudmesh.yaml")
for cloud in clouds:
if arg.refresh:
_refresh(cloud)
Console.ok("Listing VMs on Cloud: {:}".format(cloud))
vms = Vm.list(category=cloud, output="raw")
# print ("XXX", type(vms), vms)
if vms is None:
break
result = []
if "all" in arg.names:
if result is None:
result = []
else:
result = vms
elif arg.group is not None and len(arg.group) > 0:
for vm in vms:
if vm["group"] in arg.group:
result.append(vm)
elif arg.names is not None and len(arg.names) > 0:
for vm in vms:
if vm["name"] in arg.names:
result.append(vm)
if len(result) > 0:
# print(result)
(order, header) = CloudProvider(cloud).get_attributes("vm")
print(Printer.write(result,
order=order,
output=_format)
)
else:
Console.error("No data found with requested parameters.", traceflag=False)
except Exception as e:
# Error.traceback(e)
Console.error("Problem listing all instances", traceflag=False)
elif arguments["rename"]:
try:
oldnames = Parameter.expand(arguments["OLDNAMES"])
newnames = Parameter.expand(arguments["NEWNAMES"])
force = arguments["--force"]
if oldnames is None or newnames is None:
Console.error("Wrong VMs specified for rename", traceflag=False)
elif len(oldnames) != len(newnames):
Console.error("The number of VMs to be renamed is wrong",
traceflat=False)
else:
for i in range(0, len(oldnames)):
oldname = oldnames[i]
newname = newnames[i]
if arguments["--dryrun"]:
Console.ok("Rename {} to {}".format(oldname, newname))
else:
Vm.rename(cloud=cloud,
oldname=oldname,
newname=newname,
force=force
)
msg = "info. OK."
Console.ok(msg)
except Exception as e:
# Error.traceback(e)
Console.error("Problem deleting instances", traceflag=False)
return ""
def do_comet(self, args, arguments):
"""
::
Usage:
comet init
comet active [ENDPOINT]
comet ll [CLUSTERID] [--format=FORMAT] [--endpoint=ENDPOINT]
comet cluster [--concise|--status] [CLUSTERID]
[--format=FORMAT]
[--sort=SORTKEY]
[--endpoint=ENDPOINT]
comet computeset [COMPUTESETID]
[--allocation=ALLOCATION]
[--cluster=CLUSTERID]
[--state=COMPUTESESTATE]
[--endpoint=ENDPOINT]
comet start CLUSTERID [--count=NUMNODES] [COMPUTENODEIDS]
[--allocation=ALLOCATION]
[--reservation=RESERVATION]
[--walltime=WALLTIME]
[--endpoint=ENDPOINT]
comet terminate COMPUTESETID [--endpoint=ENDPOINT]
comet power (on|off|reboot|reset|shutdown) CLUSTERID [NODESPARAM]
[--endpoint=ENDPOINT]
comet console [--link] CLUSTERID [COMPUTENODEID]
[--endpoint=ENDPOINT]
comet node info CLUSTERID [COMPUTENODEID] [--format=FORMAT]
[--endpoint=ENDPOINT]
comet node rename CLUSTERID OLDNAMES NEWNAMES
[--endpoint=ENDPOINT]
comet iso list [--endpoint=ENDPOINT]
comet iso upload [--isoname=ISONAME] PATHISOFILE
[--endpoint=ENDPOINT]
comet iso attach ISOIDNAME CLUSTERID [COMPUTENODEIDS]
[--endpoint=ENDPOINT]
comet iso detach CLUSTERID [COMPUTENODEIDS]
[--endpoint=ENDPOINT]
comet reservation (list|create|update|delete)
Options:
--endpoint=ENDPOINT Specify the comet nucleus service
endpoint to work with, e.g., dev
or production
--format=FORMAT Format is either table, json, yaml,
csv, rest
[default: table]
--sort=SORTKEY Sorting key for the table view
--count=NUMNODES Number of nodes to be powered on.
When this option is used, the comet system
will find a NUMNODES number of arbitrary nodes
that are available to boot as a computeset
--allocation=ALLOCATION Allocation to charge when power on
node(s)
--reservation=RESERVATION Submit the request to an existing reservation
--walltime=WALLTIME Walltime requested for the node(s).
Walltime could be an integer value followed
by a unit (m, h, d, w, for minute, hour, day,
and week, respectively). E.g., 3h, 2d
--isoname=ISONAME Name of the iso image after being stored remotely.
If not specified, use the original filename
--state=COMPUTESESTATE List only computeset with the specified state.
The state could be submitted, running, completed
--link Whether to open the console url or just show the link
--concise Concise table view for cluster info
--status Cluster table view displays only those columns showing state of nodes
Arguments:
ENDPOINT Service endpoint based on the yaml config file.
By default it's either dev or production.
CLUSTERID The assigned name of a cluster, e.g. vc1
COMPUTESETID An integer identifier assigned to a computeset
COMPUTENODEID A compute node name, e.g., vm-vc1-0
If not provided, the requested action will be taken
on the frontend node of the specified cluster
COMPUTENODEIDS A set of compute node names in hostlist format,
e.g., vm-vc1-[0-3]
One single node is also acceptable: vm-vc1-0
If not provided, the requested action will be taken
on the frontend node of the specified cluster
NODESPARAM Specifying the node/nodes/computeset to act on.
In case of integer, will be intepreted as a computesetid;
in case of a hostlist format, e.g., vm-vc1-[0-3], a group
of nodes; or a single host is also acceptable,
e.g., vm-vc1-0
ISONAME Name of an iso image at remote server
ISOIDNAME Index or name of an iso image at the remote server.
The index is based on the list from 'comet iso list'.
PATHISOFILE The full path to the iso image file to be uploaded
OLDNAMES The list of current node names to be renamed, in hostlist
format. A single host is also acceptable.
NEWNAMES The list of new names to rename to, in hostlist format.
A single host is also acceptable.
"""
# back up of all the proposed commands/options
"""
comet status
comet tunnel start
comet tunnel stop
comet tunnel status
comet logon
comet logoff
comet ll [CLUSTERID] [--format=FORMAT]
comet docs
comet info [--user=USER]
[--project=PROJECT]
[--format=FORMAT]
comet cluster [CLUSTERID][--name=NAMES]
[--user=USER]
[--project=PROJECT]
[--hosts=HOSTS]
[--start=TIME_START]
[--end=TIME_END]
[--hosts=HOSTS]
[--format=FORMAT]
comet computeset [COMPUTESETID]
comet start ID
comet stop ID
comet power on CLUSTERID [NODESPARAM]
[--allocation=ALLOCATION]
[--walltime=WALLTIME]
comet power (off|reboot|reset|shutdown) CLUSTERID [NODESPARAM]
comet console CLUSTERID [COMPUTENODEID]
comet delete [all]
[--user=USER]
[--project=PROJECT]
[--name=NAMES]
[--hosts=HOSTS]
[--start=TIME_START]
[--end=TIME_END]
[--host=HOST]
comet delete --file=FILE
comet update [--name=NAMES]
[--hosts=HOSTS]
[--start=TIME_START]
[--end=TIME_END]
comet add [--user=USER]
[--project=PROJECT]
[--host=HOST]
[--description=DESCRIPTION]
[--start=TIME_START]
[--end=TIME_END]
NAME
comet add --file=FILENAME
Options:
--user=USER user name
--name=NAMES Names of the vcluster
--start=TIME_START Start time of the vcluster, in
YYYY/MM/DD HH:MM:SS format.
[default: 1901-01-01]
--end=TIME_END End time of the vcluster, in YYYY/MM/DD
HH:MM:SS format. In addition a duratio
can be specified if the + sign is the
first sig The duration will than be
added to the start time.
[default: 2100-12-31]
--project=PROJECT project id
--host=HOST host name
--description=DESCRIPTION description summary of the vcluster
--file=FILE Adding multiple vclusters from one file
--format=FORMAT Format is either table, json, yaml,
csv, rest
[default: table]
--allocation=ALLOCATION Allocation to charge when power on
node(s)
--walltime=WALLTIME Walltime requested for the node(s)
Arguments:
FILENAME the file to open in the cwd if . is
specified. If file in in cwd
you must specify it with ./FILENAME
Opens the given URL in a browser window.
"""
"""
if not arguments["tunnel"] and Comet.tunnelled and not Comet.is_tunnel():
Console.error("Please establish a tunnel first with:")
print
print (" comet tunnel start")
print
return ""
try:
if not arguments["tunnel"]:
logon = Comet.logon()
if logon is False:
Console.error("Could not logon")
return ""
except:
Console.error("Could not logon")
# pprint (arguments)
output_format = arguments["--format"] or "table"
if arguments["status"]:
Comet.state()
elif arguments["tunnel"] and arguments["start"]:
Comet.tunnel(True)
elif arguments["tunnel"] and arguments["stop"]:
Comet.tunnel(False)
elif arguments["tunnel"] and arguments["status"]:
Comet.state()
elif arguments["logon"]:
if self.context.comet_token is None:
if Comet.logon():
Console.ok("logging on")
self.context.comet_token = Comet.token
else:
Console.error("could not logon")
else:
Console.error("already logged on")
elif arguments["logoff"]:
if self.context.comet_token is None:
Console.error("not logged in")
else:
if Comet.logoff():
Console.ok("Logging off")
self.context.comet_token = None
else:
Console.error(
"some issue while logging off. Maybe comet not reachable")
elif arguments["docs"]:
Comet.docs()
elif arguments["info"]:
Console.error("not yet implemented")
elif arguments["add"]:
print ("add the cluster")
elif arguments["start"]:
cluster_id = arguments["ID"]
print("start", cluster_id)
Cluster.start(cluster_id)
elif arguments["stop"]:
cluster_id = arguments["ID"]
print("stop", cluster_id)
Cluster.stop(cluster_id)
elif arguments["ll"]:
"""
if arguments["init"]:
print ("Initializing the comet configuration file...")
config = ConfigDict("cloudmesh.yaml")
# for unit testing only.
cometConf = config["cloudmesh.comet"]
endpoints = []
# print (cometConf.keys())
if "endpoints" in cometConf.keys():
endpoints = cometConf["endpoints"].keys()
if len(endpoints) < 1:
Console.error("No service endpoints available. "
"Please check the config template",
traceflag=False)
return ""
if "username" in cometConf.keys():
default_username = cometConf['username']
# print (default_username)
if 'TBD' == default_username:
set_default_user = \
input("Set a default username (RETURN to skip): ")
if set_default_user:
config.data["cloudmesh"]["comet"]["username"] = \
set_default_user
config.save()
Console.ok("Comet default username set!")
if "active" in cometConf.keys():
active_endpoint = cometConf['active']
set_active_endpoint = \
input("Set the active service endpoint to use. "
"The availalbe endpoints are - %s [%s]: "
% ("/".join(endpoints),
active_endpoint)
)
if set_active_endpoint:
if set_active_endpoint in endpoints:
config.data["cloudmesh"]["comet"]["active"] = \
set_active_endpoint
config.save()
Console.ok("Comet active service endpoint set!")
else:
Console.error("The provided endpoint does not match "
"any available service endpoints. Try %s"
% "/".join(endpoints),
traceflag=False)
if cometConf['active'] in endpoints:
endpoint_url = cometConf["endpoints"] \
[cometConf['active']]["nucleus_base_url"]
api_version = cometConf["endpoints"] \
[cometConf['active']]["api_version"]
set_endpoint_url = \
input("Set the base url for the nucleus %s service [%s]: " \
% (cometConf['active'],
endpoint_url)
)
if set_endpoint_url:
if set_endpoint_url != endpoint_url:
config.data["cloudmesh"]["comet"]["endpoints"] \
[cometConf['active']]["nucleus_base_url"] \
= set_endpoint_url
config.save()
Console.ok("Service base url set!")
set_api_version = \
input("Set the api version for the nucleus %s service [%s]: " \
% (cometConf['active'],
api_version)
)
if set_api_version:
if set_api_version != api_version:
config.data["cloudmesh"]["comet"]["endpoints"] \
[cometConf['active']]["api_version"] \
= set_api_version
config.save()
Console.ok("Service api version set!")
print("Authenticating to the nucleus %s " \
"service and obtaining the apikey..." \
% cometConf['active'])
Comet.get_apikey(cometConf['active'])
return ''
# Comet.get_apikey()
if arguments["active"]:
config = ConfigDict("cloudmesh.yaml")
cometConf = config["cloudmesh.comet"]
endpoint = arguments["ENDPOINT"] or None
# parameter specified, intended to change
if endpoint:
if "endpoints" in cometConf.keys():
endpoints = cometConf["endpoints"].keys()
if endpoint in endpoints:
config.data["cloudmesh"] \
["comet"] \
["active"] = endpoint
config.save()
Console.ok("Comet active service endpoint set"
" to: %s" % endpoint)
else:
Console.error("The provided endpoint does not match "
"any available service endpoints. Try %s."
% "/".join(endpoints),
traceflag = False)
else:
Console.error("No available endpoint to set. "
"Check config file!",
traceflag=False)
else:
if "active" in cometConf.keys():
active_endpoint = cometConf['active']
Console.ok("Current active service endpoint is: %s"
% active_endpoint)
else:
Console.error("Cannot set active endpoint. "
"Check config file!",
traceflag = False)
try:
endpoint = None
config = ConfigDict("cloudmesh.yaml")
cometConf = config["cloudmesh.comet"]
if arguments["--endpoint"]:
endpoint = arguments["--endpoint"]
if "endpoints" in cometConf.keys():
endpoints = cometConf["endpoints"].keys()
if endpoint not in endpoints:
Console.error("The provided endpoint does not match "
"any available service endpoints. Try %s."
% "/".join(endpoints),
traceflag = False)
return ''
logon = Comet.logon(endpoint=endpoint)
if logon is False:
Console.error("Could not logon. Please try first:\n"
"cm comet init",
traceflag = False)
return ""
except:
Console.error("Could not logon",
traceflag = False)
output_format = arguments["--format"] or "table"
if arguments["ll"]:
cluster_id = arguments["CLUSTERID"] or None
print(Cluster.simple_list(cluster_id, format=output_format))
elif arguments["cluster"]:
view = "FULL"
if arguments["--concise"]:
view = "CONCISE"
if arguments["--status"]:
view = "STATE"
cluster_id = arguments["CLUSTERID"]
sortkey = arguments["--sort"]
print(Cluster.list(cluster_id,
format=output_format,
sort=sortkey,
view=view))
elif arguments["computeset"]:
computeset_id = arguments["COMPUTESETID"] or None
cluster = arguments["--cluster"] or None
state = arguments["--state"] or None
allocation = arguments["--allocation"] or None
cluster = arguments["--cluster"] or None
print (Cluster.computeset(computeset_id, cluster, state, allocation))
elif arguments["start"]:
clusterid = arguments["CLUSTERID"]
numnodes = arguments["--count"] or None
computenodeids = arguments["COMPUTENODEIDS"] or None
# check allocation information for the cluster
cluster = Cluster.list(clusterid, format='rest')
try:
allocations = cluster[0]['allocations']
except:
# print (cluster)
Console.error("No allocation available for the specified cluster."\
"Please check with the comet help team",
traceflag=False)
return ""
# checking whether the computesetids is in valid hostlist format
if computenodeids:
try:
hosts_param = hostlist.expand_hostlist(computenodeids)
except hostlist.BadHostlist:
Console.error("Invalid hosts list specified!",
traceflag=False)
return ""
elif numnodes:
try:
param = int(numnodes)
except ValueError:
Console.error("Invalid count value specified!",
traceflag=False)
return ""
if param <= 0:
Console.error("count value has to be greather than zero",
traceflag=False)
return ""
numnodes = param
else:
Console.error("You have to specify either the count of nodes, " \
"or the names of nodes in hostlist format",
traceflag=False)
return ""
walltime = arguments["--walltime"] or None
allocation = arguments["--allocation"] or None
reservation = arguments["--reservation"] or None
# validating walltime and allocation parameters
walltime = Cluster.convert_to_mins(walltime)
if not walltime:
print("No valid walltime specified. " \
"Using system default (2 days)")
if not allocation:
if len(allocations) == 1:
allocation = allocations[0]
else:
allocation = Cluster.display_get_allocation(allocations)
# issuing call to start a computeset with specified parameters
print(Cluster.computeset_start(clusterid,
computenodeids,
numnodes,
allocation,
reservation,
walltime)
)
elif arguments["terminate"]:
computesetid = arguments["COMPUTESETID"]
print(Cluster.computeset_terminate(computesetid))
elif arguments["power"]:
clusterid = arguments["CLUSTERID"] or None
fuzzyparam = arguments["NODESPARAM"] or None
# parsing nodesparam for proper action
if fuzzyparam:
try:
param = int(fuzzyparam)
subject = 'COMPUTESET'
except ValueError:
param = fuzzyparam
try:
hosts_param = hostlist.expand_hostlist(fuzzyparam)
subject = 'HOSTS'
except hostlist.BadHostlist:
Console.error("Invalid hosts list specified!",
traceflag=False)
return ""
else:
subject = 'FE'
param = None
if arguments["on"]:
action = "on"
elif arguments["off"]:
action = "off"
elif arguments["reboot"]:
action = "reboot"
elif arguments["reset"]:
action = "reset"
elif arguments["shutdown"]:
action = "shutdown"
else:
action = None
print (Cluster.power(clusterid,
subject,
param,
action)
)
elif arguments["console"]:
clusterid = arguments["CLUSTERID"]
linkonly = False
if arguments["--link"]:
linkonly = True
nodeid = None
if 'COMPUTENODEID' in arguments:
nodeid = arguments["COMPUTENODEID"]
Comet.console(clusterid, nodeid, linkonly)
elif arguments["iso"]:
if arguments["list"]:
isos = (Comet.list_iso())
idx = 0
for iso in isos:
if iso.startswith("public/"):
iso = iso.split("/")[1]
idx += 1
print ("{}: {}".format(idx, iso))
if arguments["upload"]:
isofile = arguments["PATHISOFILE"]
isofile = os.path.abspath(isofile)
if os.path.isfile(isofile):
if arguments["--isoname"]:
filename = arguments["--isoname"]
else:
filename = os.path.basename(isofile)
else:
print ("File does not exist - {}" \
.format(arguments["PATHISOFILE"]))
return ""
print(Comet.upload_iso(filename, isofile))
elif arguments["attach"]:
isoidname = arguments["ISOIDNAME"]
clusterid = arguments["CLUSTERID"]
computenodeids = arguments["COMPUTENODEIDS"] or None
print(Cluster.attach_iso(isoidname, clusterid, computenodeids))
elif arguments["detach"]:
clusterid = arguments["CLUSTERID"]
computenodeids = arguments["COMPUTENODEIDS"] or None
print(Cluster.detach_iso(clusterid, computenodeids))
elif arguments["node"]:
if arguments["info"]:
clusterid = arguments["CLUSTERID"]
nodeid = arguments["COMPUTENODEID"]
print (Cluster.node_info(clusterid, nodeid=nodeid, format=output_format))
elif arguments["rename"]:
clusterid = arguments["CLUSTERID"]
oldnames = Parameter.expand(arguments["OLDNAMES"])
newnames = Parameter.expand(arguments["NEWNAMES"])
if len(oldnames) != len(newnames):
Console.error("Length of OLDNAMES and NEWNAMES have to be the same",
traceflag=False)
return ""
else:
for newname in newnames:
if newname.strip() == "":
Console.error("Newname cannot be empty string",
traceflag=False)
return ""
cluster_data = Cluster.list(clusterid, format="rest")
if len(cluster_data) > 0:
computes = cluster_data[0]["computes"]
nodenames = [x["name"] for x in computes]
else:
Console.error("Error obtaining the cluster information",
traceflag=False)
return ""
# check if new names ar not already taken
# to be implemented
# print (oldnames)
# print (newnames)
# print (nodenames)
oldset = set(oldnames)
newset = set(newnames)
currentset = set(nodenames)
# at least one OLDNAME does not exist
if not oldset <= currentset:
Console.error("Not all OLDNAMES are valid", traceflag=False)
return ""
else:
# those unchanged nodes
keptset = currentset - oldset
# duplication between name of unchanged nodes and
# the requested NEWNAMES
if keptset & newset != set():
Console.error("Not proceeding as otherwise introducing "\
"duplicated names",
traceflag=False)
else:
for i in range(0,len(oldnames)):
oldname = oldnames[i]
newname = newnames[i]
print ("%s -> %s" % (oldname, newname))
confirm = input("Confirm batch renaming (Y/y to confirm, "\
"any other key to abort):")
if confirm.lower() == 'y':
print ("Conducting batch renaming")
for i in range(0,len(oldnames)):
oldname = oldnames[i]
newname = newnames[i]
print (Cluster.rename_node(clusterid,
oldname,
newname))
else:
print ("Action aborted!")
elif arguments["reservation"]:
if arguments["create"] or \
arguments["update"] or \
arguments["delete"]:
Console.info("Operation not supported. Please contact XSEDE helpdesk for help!")
if arguments["list"]:
if "hpcinfo" in cometConf:
hpcinfourl = cometConf["hpcinfo"]["endpoint"]
else:
Console.error("Admin feature not configured for this client", traceflag = False)
return ""
ret = requests.get("%s/reservations/%s" % (hpcinfourl,
cometConf['active'])
)
jobs = ret.json()
result = Printer.write(jobs)
print (result)
return ""