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