def list_floating_ip(cls, cloudname): """ Method to list floating ips :param cloudname: :return: floating ip list """ try: floating_ips = cls.get_floating_ip_list(cloudname) for floating_ip in 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 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 dict_printer(floating_ips, order=order, header=header) except Exception as ex: Console.error(ex.message, ex) return
def details(self, kind, cloud, id, format="table"): from cloudmesh_client.db.CloudmeshDatabase import CloudmeshDatabase try: cm = CloudmeshDatabase() if kind not in self.kind: raise ValueError('{} not defined'.format(kind)) elements = None for idkey in ["name", "uuid", "id"]: s = {idkey: id} try: elements = cm.find(kind, cloud=cloud, **s) except: pass if len(elements) > 0: break if len(elements) == 0: return None if format == "table": element = elements.values()[0] return attribute_printer(element) else: return dict_printer(elements, output=format) except Exception as ex: Console.error(ex.message, ex)
def get_rules(cls, uuid): """ This method gets the security group rule from the cloudmesh database :param uuid: :return: """ try: args = { "groupid": uuid } rule = cls.cm_db.find("secgrouprule", **args) # check if rules exist if rule is None: return "No rules for security group [{}] in the database. Try cm secgroup refresh." # return table return (dict_printer(rule, order=["user", "category", "name", "fromPort", "toPort", "protocol", "cidr"], output="table")) except Exception as ex: Console.error(ex.message, ex) 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.iteritems(): if value is None: query[key] = "None" del query['output'] try: group = cls.cm.find_by_name("group", **query) if group is not None \ and "output" in kwargs: d = {"0": group} group = dict_printer(d) return group except Exception as ex: Console.error(ex.message, ex)
def list(self, format='dict', sort_keys=True, order=None): if order is None: order = self.order return dict_printer(self.data, order=order, output=format, sort_keys=sort_keys)
def list_quotas(cls, cloud, format): Quota.set_os_environment(cloud) result = Shell.execute("nova", "quota-show") d = Quota.convert_to_dict(result) return dict_printer(d, order=['Quota', 'Limit'], output=format)
def get_info(cls, cloud="kilo", name=None, output="table"): """ Method to get info about a group :param cloud: :param name: :param output: :return: """ try: cloud = cloud or Default.get("cloud") args = { "name": name, "cloud": cloud } # group = cls.get(name=name, cloud=cloud) group = cls.cm.find("group", output="object", **args).first() if group is not None: d = cls.to_dict(group) # Transform the dict to show multiple rows per vm newdict = Group.transform_dict(d) else: return None return dict_printer(newdict, order=cls.order, output=output) except Exception as ex: Console.error(ex.message, ex)
def list(cls, **kwargs): """ This method lists all VMs of the cloud :param cloud: the cloud name """ try: if "name_or_id" in kwargs and kwargs["name_or_id"] is not None: if cls.isUuid(kwargs["name_or_id"]): elements = cls.cm.find("vm", cloud=kwargs["cloud"], uuid=kwargs["name_or_id"]) else: elements = cls.cm.find("vm", cloud=kwargs["cloud"], label=kwargs["name_or_id"]) else: elements = cls.cm.find("vm", cloud=kwargs["cloud"]) # print(elements) # order = ['id', 'uuid', 'name', 'cloud'] (order, header) = CloudProvider(kwargs["cloud"]).get_attributes("vm") # order = None if "name_or_id" in kwargs and kwargs["name_or_id"] is not None: return attribute_printer(elements.values()[0], output=kwargs["output_format"]) else: return dict_printer(elements, order=order, output=kwargs["output_format"]) except Exception as ex: Console.error(ex.message, ex)
def list(cls, **kwargs): """ This method lists all VMs of the cloud """ try: if "name_or_id" in kwargs and kwargs["name_or_id"] is not None: if cls.isUuid(kwargs["name_or_id"]): elements = cls.cm.find("vm", category=kwargs["cloud"], uuid=kwargs["name_or_id"]) else: elements = cls.cm.find("vm", category=kwargs["cloud"], label=kwargs["name_or_id"]) else: elements = cls.cm.find("vm", category=kwargs["cloud"]) # print(elements) # order = ['id', 'uuid', 'name', 'cloud'] (order, header) = CloudProvider(kwargs["cloud"]).get_attributes("vm") # order = None if "name_or_id" in kwargs and kwargs["name_or_id"] is not None: return attribute_printer(list(elements.values())[0], output=kwargs["output_format"]) else: return dict_printer(elements, order=order, output=kwargs["output_format"]) except Exception as ex: Console.error(ex.message, ex)
def list_floating_ip(cls, cloudname): """ 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 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 dict_printer(floating_ips, order=order, header=header) except Exception as ex: Console.error(ex.message, ex) 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( dict_printer(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(dict_printer(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_rules(cls, uuid): """ This method gets the security group rule from the cloudmesh database :param uuid: :return: """ try: args = {"groupid": uuid} rule = cls.cm_db.find("secgrouprule", **args) # check if rules exist if rule is None: return "No rules for security group [{}] in the database. Try cm secgroup refresh." # return table return (dict_printer(rule, order=[ "user", "category", "name", "fromPort", "toPort", "protocol", "cidr" ], output="table")) except Exception as ex: Console.error(ex.message, ex) return None
def get_rules(cls, uuid): # problem: # I don't see rules were ever updated/retrieved from the cloud # """ This method gets the security group rule from the cloudmesh database :param uuid: :return: """ try: """ rule = cls.cm_db.query(model.SECGROUPRULE).filter( model.SECGROUPRULE.groupid == uuid ).all() """ args = { "groupid": uuid } rule = cls.cm_db.find("secgrouprule", **args) # d = cls.toDict(rule) return (dict_printer(rule, order=["user", "cloud", "name", "fromPort", "toPort", "protocol", "cidr"], output="table")) except Exception as ex: Console.error(ex.message, ex)
def list(cls, project, cloud="general"): """ This method queries the database to fetch list of secgroups filtered by cloud, tenant. :param project: :param cloud: :return: """ # noinspection PyUnreachableCode try: """ elements = cls.cm_db.query(model.SECGROUP).filter( model.SECGROUP.cloud == cloud, model.SECGROUP.project == project ).all() d = cls.toDict(elements) """ nova_client = CloudProvider.set(cloud) os_result = nova_client.security_groups.list() d = SecGroup.convert_list_to_dict(os_result) return dict_printer(d, order=["Id", "Name", "Description"], output="table") except Exception as ex: Console.error(ex.message, ex)
def details(self, kind, cloud, id, format="table"): from cloudmesh_client.db.CloudmeshDatabase import CloudmeshDatabase try: cm = CloudmeshDatabase() if kind not in self.kind: raise ValueError('{} not defined'.format(kind)) elements = None for idkey in ["name", "uuid", "id"]: s = {idkey: id} try: elements = cm.find(kind, category=cloud, **s) except: pass if len(elements) > 0: break if len(elements) == 0: return None if format == "table": element = list(elements.values())[0] return attribute_printer(element) else: return dict_printer(elements, output=format) except Exception as ex: Console.error(ex.message, ex)
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 dict_printer(d, order=[ "start", "end", "servers", "cpu hours", "ram mb-hours", "disk gb-hours" ], output=format) except Exception as e: return e
def table(self): d = dict(self.__keys__) return (dict_printer(d, order=["comment", "uri", "fingerprint"], output="table", sort_keys=True))
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 dict_printer(d, order=["start", "end", "servers", "cpu hours", "ram mb-hours", "disk gb-hours"], output=format) except Exception, e: return e
def test_001_yaml(self): """dict_printer of a yaml object""" HEADING() output = dict_printer(self.d, order=None, header=None, output="yaml", sort_keys=True) print(output) assert ":" in output
def test_003_table(self): """dict_printer of a table object""" HEADING() output = dict_printer(self.d, order=None, header=None, output="table", sort_keys=True) print(output) assert "id" in str(output)
def test_002_json(self): """dict_printer of a json object""" HEADING() output = dict_printer(self.d, order=None, header=None, output="json", sort_keys=True) print(output) assert "{" in output
def test_005_csv(self): """dict_printer of a csv object""" HEADING() output = dict_printer(self.d, order=None, header=None, output="csv", sort_keys=True) print(output) assert "id" in str(output)
def test_004_dict(self): """dict_printer of a dict object""" HEADING() output = dict( dict_printer(self.d, order=None, header=None, output="dict", sort_keys=True)) pprint(output) assert "id" in str(output)
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 dict_printer(d, order=["id", "name", "status"], output="table", sort_keys=True) else: return d
def _print_dict_ip(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 dict_printer(d, order=["network", "version", "addr"], output="table", sort_keys=True) else: return d
def _print_dict(d, header=None, format='table'): if format == "json": return json.dumps(d, indent=4) elif format == "yaml": return yaml.dump(d, default_flow_style=False) elif format == "table": return dict_printer( d, order=["name", "comment", "uri", "fingerprint", "source"], output="table", sort_keys=True) else: return d
def list_limits(cls, cloud, format, tenant=" "): # set the environment variables Quota.set_os_environment(cloud) # execute the command args = ["limits", "--tenant", tenant] result = Shell.execute("nova", args) # print results in a format if "ERROR" in result: return result else: d = Limits.convert_to_dict(result) return dict_printer(d, order=["Name", "Used", "Max"], output=format)
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( dict_printer(versions, output=arguments["--format"], order=["name", "version"])) if arguments["--check"] in ["True"]: check_python()
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(dict_printer(versions, output=arguments["--format"], order=["name", "version"])) if arguments["--check"] in ["True"]: check_python()
def _print_dict(d, header=None, format='table'): if format == "json": return json.dumps(d, indent=4) elif format == "yaml": return yaml.dump(d, default_flow_style=False) elif format == "table": return dict_printer(d, order=["name", "comment", "uri", "fingerprint", "source"], output="table", sort_keys=True) else: return d
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.iteritems(): print("export {}={}".format(attribute, value)) elif output == "table": print(attribute_printer(credentials)) else: print(dict_printer(credentials, output=output)) # TODO: bug csv does not work return ""
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 (dict_printer(d, order=['cluster', 'jobid', 'partition', 'name', 'user', 'st', 'time', 'nodes', 'nodelist', 'updated'], output=format)) except Exception as e: Error.traceback(e) return e
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(attribute_printer(credentials)) else: print(dict_printer(credentials, output=output)) # TODO: bug csv does not work return ""
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 dict_printer(floating_ip_pools, order=order, header=header) except Exception as ex: Console.error(ex.message, ex) pass
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 (dict_printer(elements, order=order, header=header, output=output)) else: return None except Exception as ex: Console.error(ex.message, ex)
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 dict_printer(floating_ip_pools, order=order, header=header) except Exception as ex: Console.error(ex.message, ex) 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 dict_printer(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, format="table", cloud="kilo"): """ Method to get list of groups in the cloudmesh database :param format: :param cloud: :return: """ try: args = {} d = cls.cm.find("GROUP", **args) # d = cls.cm.all(model.GROUP) # Transform the dict to show multiple rows per vm newdict = Group.transform_dict(d) return (dict_printer(newdict, order=cls.order, output=format)) except Exception as ex: Console.error(ex.message, ex)
def list(cls, cloud="general", format="table"): """ This method queries the database to fetch list of secgroups filtered by cloud. :param cloud: :return: """ try: elements = cls.cm_db.find("secgroup", category=cloud) #pprint(elements) (order, header) = CloudProvider(cloud).get_attributes("secgroup") return dict_printer(elements, order=order, header=header, output=format) except Exception as ex: Console.error(ex.message, ex)
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) # # # TODO why not use a dict? # filter = {} if cloud is not None: filter["cloud"] = 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 (dict_printer(elements, order=order, header=header, output=output)) else: return None except Exception as ex: Console.error(ex.message, ex)
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= # cm = CloudmeshDatabase() try: elements = cls.cm.find("image", category=cloud) (order, header) = CloudProvider(cloud).get_attributes("image") return dict_printer(elements, order=order, header=header, output=format) except Exception as ex: Console.error(ex.message, ex)
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 dict_printer(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 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() 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) } } print(dict_printer(versions, output=arguments["--format"], order=["name", "version"])) if arguments["--check"] in ["True"]: check_python()
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 (dict_printer(d, order=['cluster', 'partition', 'avail', 'timelimit', 'nodes', 'state', 'nodelist', 'updated'], output=format))
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\"') # ignor 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 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 (dict_printer(d, order=['cluster', 'partition', 'avail', 'timelimit', 'nodes', 'state', 'nodelist', 'updated'], output=format))
def list(cls, cloud, live=False, format="table"): """ This method lists all flavors of the cloud :param cloud: the cloud name """ # cm = CloudmeshDatabase() try: if live: cls.refresh(cloud) elements = cls.cm.find("flavor", category=cloud) # pprint(elements) (order, header) = CloudProvider(cloud).get_attributes("flavor") return dict_printer(elements, order=order, header=header, output=format) except Exception as ex: Console.error(ex.message, ex)
def list(cls, cloud, live=False, format="table"): """ This method lists all flavors of the cloud :param cloud: the cloud name """ # cm = CloudmeshDatabase() try: if live: cls.refresh(cloud) elements = cls.cm.find("flavor", cloud=cloud) # pprint(elements) (order, header) = CloudProvider(cloud).get_attributes("flavor") return dict_printer(elements, order=order, header=header, output=format) except Exception as ex: Console.error(ex.message, ex)
def do_key(self, args, arguments): """ :: Usage: key -h | --help key list [--source=db] [--format=FORMAT] key list --source=cloudmesh [--format=FORMAT] key list --source=ssh [--dir=DIR] [--format=FORMAT] key load [--format=FORMAT] key list --source=git [--format=FORMAT] [--username=USERNAME] key add --git [--name=KEYNAME] FILENAME key add --ssh [--name=KEYNAME] key add [--name=KEYNAME] FILENAME key get NAME key default [KEYNAME | --select] key delete (KEYNAME | --select | --all) [--force] key upload [KEYNAME] [--cloud=CLOUD] key map [--cloud=CLOUD] Manages the keys Arguments: SOURCE db, ssh, all KEYNAME The name of a key. For key upload it defaults to the default key name. FORMAT The format of the output (table, json, yaml) FILENAME The filename with full path in which the key is located NAME_ON_CLOUD Typically the name of the keypair on the cloud. Options: --dir=DIR the directory with keys [default: ~/.ssh] --format=FORMAT the format of the output [default: table] --source=SOURCE the source for the keys [default: db] --username=USERNAME the source for the keys [default: none] --name=KEYNAME The name of a key --all delete all keys --force delete the key form the cloud --name_on_cloud=NAME_ON_CLOUD Typically the name of the keypair on the cloud. Description: key list --source=git [--username=USERNAME] lists all keys in git for the specified user. If the name is not specified it is read from cloudmesh.yaml key list --source=ssh [--dir=DIR] [--format=FORMAT] lists all keys in the directory. If the directory is not specified the default will be ~/.ssh key list --source=cloudmesh [--dir=DIR] [--format=FORMAT] lists all keys in cloudmesh.yaml file in the specified directory. dir is by default ~/.cloudmesh key list [--format=FORMAT] list the keys in teh giiven format: json, yaml, table. table is default key list Prints list of keys. NAME of the key can be specified key add [--name=keyname] FILENAME adds the key specifid by the filename to the key database key get NAME Retrieves the key indicated by the NAME parameter from database and prints its fingerprint. key default [NAME] Used to set a key from the key-list as the default key if NAME is given. Otherwise print the current default key key delete NAME deletes a key. In yaml mode it can delete only key that are not saved in the database key rename NAME NEW renames the key from NAME to NEW. """ # pprint(arguments) def _print_dict(d, header=None, format='table'): if format == "json": return json.dumps(d, indent=4) elif format == "yaml": return yaml.dump(d, default_flow_style=False) elif format == "table": return dict_printer( d, order=["name", "comment", "uri", "fingerprint", "source"], output="table", sort_keys=True) else: return d # return dict_printer(d,order=['cm_id, name, fingerprint']) directory = Config.path_expand(arguments["--dir"]) if arguments['list']: _format = arguments['--format'] _source = arguments['--source'] _dir = arguments['--dir'] if arguments['--source'] == 'ssh': try: sshm = SSHKeyManager() sshm.get_from_dir(directory) d = dict(sshm.__keys__) print(_print_dict(d, format=_format)) msg = "info. OK." Console.ok(msg) except Exception as e: Error.traceback(e) Console.error("Problem listing keys from ssh") elif arguments['--source'] in ['cm', 'cloudmesh']: try: sshm = SSHKeyManager() m = sshm.get_from_yaml(load_order=directory) d = dict(m.__keys__) print(_print_dict(d, format=_format)) msg = "info. OK." Console.ok(msg) except Exception as e: Error.traceback(e) Console.error("Problem listing keys from `{:}`".format( arguments['--source'])) elif arguments['--source'] in ['git']: username = arguments["--username"] # print(username) if username == 'none': conf = ConfigDict("cloudmesh.yaml") username = conf["cloudmesh.github.username"] sshm = SSHKeyManager() try: sshm.get_from_git(username) d = dict(sshm.__keys__) print(_print_dict(d, format=_format)) msg = "info. OK." Console.ok(msg) except Exception as e: Error.traceback(e) Console.error("Problem listing git keys from database") return "" elif arguments['--source'] == 'db': try: sshdb = SSHKeyDBManager() d = sshdb.table_dict() if d != {}: print(_print_dict(d, format=arguments['--format'])) msg = "info. OK." Console.ok(msg) else: Console.error("No keys in the database") except Exception as e: Error.traceback(e) Console.error("Problem listing keys from database") elif arguments['load']: _format = arguments['--format'] _dir = arguments['--dir'] try: sshm = SSHKeyManager() m = sshm.get_from_yaml(load_order=directory) d = dict(m.__keys__) sshdb = SSHKeyDBManager() for keyname in m.__keys__: filename = m[keyname]["path"] try: sshdb.add(filename, keyname, source="yaml", uri="file://" + filename) except Exception as e: Console.error("problem adding key {}:{}".format( keyname, filename)) print(_print_dict(d, format=_format)) msg = "info. OK." Console.ok(msg) except Exception as e: Console.error("Problem adding keys from yaml file") elif arguments['get']: try: name = arguments['NAME'] sshdb = SSHKeyDBManager() d = sshdb.table_dict() for i in d: if d[i]["name"] == name: key = d[i] print("{:}: {:}".format(key['name'], key['fingerprint'])) msg = "info. OK." Console.ok(msg) return "" else: pass Console.error("The key is not in the database") except Exception as e: Error.traceback(e) Console.error("The key is not in the database") # key add --git KEYNAME # key add --ssh KEYNAME # key add [--path=PATH] KEYNAME elif arguments['add'] and arguments["--git"]: print('git add') sshdb = SSHKeyDBManager() keyname = arguments['--name'] gitkeyname = arguments['NAME'] filename = arguments['FILENAME'] # Are we adding to the database as well? # sshdb.add(filename, keyname, source="ssh", uri="file://"+filename) username = arguments["--username"] if username == 'none': conf = ConfigDict("cloudmesh.yaml") username = conf["cloudmesh.github.username"] print(username) sshm = SSHKeyManager() try: sshm.get_from_git(username) d = dict(sshm.__keys__) print(d) except Exception as e: Error.traceback(e) Console.error("Problem adding keys to git for user: "******"" try: # FIXME: correct code to add to git d[gitkeyname]['keyname'] = keyname d[gitkeyname]['user'] = None d[gitkeyname]['source'] = 'git' # sshdb.add_from_dict(d[gitkeyname]) except Exception as e: Console.error("The key already exists") elif arguments['add'] and arguments["--ssh"]: # print('ssh add') sshdb = SSHKeyDBManager() keyname = arguments['--name'] filename = Config.path_expand("~/.ssh/id_rsa.pub") try: sshdb.add(filename, keyname, source="ssh", uri="file://" + filename) print("Key {:} successfully added to the database".format( keyname or "")) msg = "info. OK." Console.ok(msg) except Exception as e: """ Error.traceback(e) print (keyname) print (filename) """ Console.error( "Problem adding the key `{}` from file `{}`".format( keyname, filename)) elif arguments['add'] and not arguments["--git"]: # print('ssh add') sshdb = SSHKeyDBManager() keyname = arguments['--name'] filename = arguments['FILENAME'] try: sshdb.add(filename, keyname, source="ssh", uri="file://" + filename) print("Key {:} successfully added to the database".format( keyname or "")) msg = "info. OK." Console.ok(msg) except ValueError as e: Console.error("The key `{}` already exists".format(keyname), traceflag=False) """ except Exception as e: Error.traceback(e) print (keyname) print (filename) Console.error("Problem adding the key `{}` from file `{}`".format(keyname, filename)) """ return "" elif arguments['default']: # print("default") if arguments['KEYNAME']: keyname = None try: keyname = arguments['KEYNAME'] sshdb = SSHKeyDBManager() sshdb.set_default(keyname) Default.set_key(keyname) print("Key {:} set as default".format(keyname)) msg = "info. OK." Console.ok(msg) except Exception as e: Error.traceback(e) Console.error( "Setting default for key {:} failed.".format(keyname)) elif arguments['--select']: keyname = None try: sshdb = SSHKeyDBManager() select = sshdb.select() if select != 'q': keyname = select.split(':')[0] print("Setting key: {:} as default.".format(keyname)) sshdb.set_default(keyname) msg = "info. OK." Console.ok(msg) except Exception as e: Error.traceback(e) Console.error( "Setting default for selected key {:} failed.".format( keyname)) else: try: sshdb = SSHKeyDBManager() d = sshdb.table_dict() for i in d: if d[i]["is_default"] == "True": key = d[i] print("{:}: {:}".format(key['name'], key['fingerprint'])) msg = "info. OK." Console.ok(msg) return "" else: pass Console.error("The key is not in the database") except Exception as e: Error.traceback(e) Console.error("Problem retrieving default key.") elif arguments['delete']: delete_on_cloud = arguments["--force"] or False # print ("DDD", delete_on_cloud) if arguments['--all']: try: sshm = SSHKeyManager(delete_on_cloud=delete_on_cloud) sshm.delete_all_keys() print("All keys from the database deleted successfully.") msg = "info. OK." Console.ok(msg) except Exception as e: Error.traceback(e) Console.error("Problem deleting keys") elif arguments['--select']: keyname = None sshdb = SSHKeyDBManager() select = sshdb.select() if select != 'q': try: keyname = select.split(':')[0] print("Deleting key: {:}...".format(keyname)) sshm = SSHKeyManager(delete_on_cloud=delete_on_cloud) sshm.delete_key(keyname) msg = "info. OK." Console.ok(msg) except Exception as e: Error.traceback(e) Console.error( "Problem deleting the key `{:}`".format(keyname)) else: keyname = None try: keyname = arguments['KEYNAME'] sshm = SSHKeyManager(delete_on_cloud=delete_on_cloud) sshm.delete_key(keyname) print("Key {:} deleted successfully from database.".format( keyname)) msg = "info. OK." Console.ok(msg) except Exception as e: Error.traceback(e) Console.error( "Problem deleting the key `{:}`".format(keyname)) elif arguments['upload']: try: # # get username # conf = ConfigDict("cloudmesh.yaml") username = conf["cloudmesh"]["profile"]["username"] if username in ['None', 'TBD']: username = None # # get cloudnames # clouds = [] cloud = arguments["--cloud"] or Default.get_cloud() if cloud == "all": config = ConfigDict("cloudmesh.yaml") clouds = config["cloudmesh"]["clouds"] else: clouds.append(cloud) # # get keyname # for cloud in clouds: status = 0 sshdb = SSHKeyDBManager() sshm = SSHKeyManager() keys = sshdb.find_all() for keyid in keys: key = keys[keyid] print("upload key {} -> {}".format(key["name"], cloud)) try: status = sshm.add_key_to_cloud( username, key["name"], cloud, key["name"]) except Exception as e: print(e) if "already exists" in str(e): print("key already exists. Skipping " "upload. ok.") if status == 1: print("Problem uploading key. failed.") msg = "info. OK." Console.ok(msg) except Exception as e: Error.traceback(e) Console.error("Problem adding key to cloud") elif arguments['map']: try: cloud = arguments["--cloud"] or Default.get_cloud() sshm = SSHKeyManager() map_dict = sshm.get_key_cloud_maps(cloud) print( dict_printer(map_dict, order=[ "user", "key_name", "cloud_name", "key_name_on_cloud" ])) except Exception as e: Error.traceback(e) Console.error("Problem adding key to cloud")
def do_cloud(self, args, arguments): """ :: Usage: cloud list [--cloud=CLOUD] [--format=FORMAT] cloud logon CLOUD cloud logout CLOUD cloud activate CLOUD cloud deactivate CLOUD cloud info CLOUD managing the admins test test test test Arguments: KEY the name of the admin VALUE the value to set the key to Options: --cloud=CLOUD the name of the cloud --format=FORMAT the output format [default: table] Description: Cloudmesh contains a cloudmesh.yaml file that contains templates for multiple clouds that you may or may not have access to. Hence it is useful to activate and deactivate clouds you like to use in other commands. To activate a cloud a user can simply use the activate command followed by the name of the cloud to be activated. To find out which clouds are available you can use the list command that will provide you with some basic information. As default it will print a table. Thus the commands:: cloud activate india cloud deactivate aws Will result in +----------------------+--------+-------------------+ | Cloud name | Active | Type | +----------------------+--------+-------------------+ | india | True | Openstack | +----------------------+--------+-------------------+ | aws | False | AWS | +----------------------+--------+-------------------+ To get ore information about the cloud you can use the command cloud info CLOUD It will call internally also the command uses in register See also: register """ # pprint(arguments) cloudname = arguments["--cloud"] or Default.get_cloud() if arguments["logon"]: cloudname = arguments["CLOUD"] provider = CloudProvider(cloudname).provider provider.logon(cloudname) Console.ok("Logged into cloud: " + cloudname) elif arguments["logout"]: cloudname = arguments["CLOUD"] provider = CloudProvider(cloudname).provider provider.logout(cloudname) Console.ok("Logged out of cloud: " + cloudname) elif arguments["activate"]: cloudname = arguments["CLOUD"] provider = CloudProvider(cloudname).provider provider.activate(cloudname) Console.ok("Activated cloud: " + cloudname) elif arguments["deactivate"]: cloudname = arguments["CLOUD"] provider = CloudProvider(cloudname).provider provider.deactivate(cloudname) Console.ok("Deactivated cloud: " + cloudname) elif arguments["list"]: provider = CloudProvider(cloudname).provider clouds = provider.list_clouds() (order, header) = CloudProvider(cloudname).get_attributes("clouds") Console.msg(dict_printer(clouds, order=order, header=header)) pass
def clouds(self, format='json', order=None): filename = "cloudmesh.yaml" config = ConfigDict(filename) yaml_clouds = dict(config["cloudmesh"]["clouds"]) return dict_printer(yaml_clouds, output=format, order=order)
def clouds(self, format="json", order=None): filename = "cloudmesh.yaml" config = ConfigDict(filename) yaml_clouds = dict(config["cloudmesh"]["clouds"]) return dict_printer(yaml_clouds, output=format, order=order)
def simple_list(id=None, format="table"): result = "" if id is None: r = Comet.get(Comet.url("cluster/")) else: r = Comet.get(Comet.url("cluster/" + id + "/")) if r is None: Console.error("Could not find cluster `{}`" .format(id)) return result r = [r] if r is not None: if 'error' in r: Console.error("An error occurred: {error}".format(**r)) raise ValueError("COMET Error") elif 'error' in r[0]: Console.error("An error occurred: {error}".format(**r[0])) raise ValueError("COMET Error") if format == "rest": result = r else: elements = {} for cluster in r: element = {} for attribute in ["project", "name", "description"]: element[attribute] = cluster[attribute] element["nodes"] = len(cluster["computes"]) for attribute in cluster["frontend"]: element["frontend " + attribute] = cluster["frontend"][ attribute] names = [] for compute in cluster["computes"]: names.append(compute["name"]) element["computes"] = hostlist.collect_hostlist(names) elements[cluster["name"]] = element result = dict_printer(elements, order=[ "name", "project", "nodes", "computes", "frontend name", "frontend state", "frontend type", "description", ], header=[ "Name", "Project", "Count", "Nodes", "Frontend (Fe)", "State (Fe)", "Type (Fe)", "Description", ], output=format) return result