def pprint_floating_ip(ip, display_mails=False, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "Floating IP %s" % ip.id ucache = UserCache(ASTAKOS_AUTH_URL, ASTAKOS_TOKEN) userid = ip.userid vtype_info = OrderedDict([ ("id", ip.id), ("address", ip.address), ("network", ip.network_id), ("port", ip.nic_id), ("server", ip.nic.machine_id), ("userid", userid), ("username", ucache.get_name(userid) if (display_mails and userid is not None) else None), ("project", ip.project), ("shared_to_project", ip.shared_to_project), ("deleted", ip.deleted), ("created", ip.created), ("updated", ip.updated), ]) pprint_table(stdout, vtype_info.items(), separator=" | ", title=title)
def set_container_quota(args): try: utils = ManageAccounts() try: quota = int(args.quota) except: raise ValueError('Invalid quota') accounts = [args.account] if args.account \ else utils.existing_accounts() failed = [] def update_container_policy(account): trans = utils.backend.wrapper.conn.begin() try: utils.backend.update_container_policy(account, account, args.container, {'quota': quota}) if args.dry: print "Skipping database commit." trans.rollback() else: trans.commit() except Exception as e: failed.append((account, e)) map(update_container_policy, accounts) if failed and args.report: sys.stdout.write('Failed for the following accounts:\n') pprint_table(sys.stdout, failed, headers=[]) except Exception as e: sys.stderr.write('%s\n' % e) finally: utils.cleanup()
def set_container_quota(args): try: utils = ManageAccounts() try: quota = int(args.quota) except: raise ValueError('Invalid quota') accounts = [args.account] if args.account \ else utils.existing_accounts() failed = [] def update_container_policy(account): trans = utils.backend.wrapper.conn.begin() try: utils.backend.update_container_policy( account, account, args.container, {'quota': quota} ) if args.dry: print "Skipping database commit." trans.rollback() else: trans.commit() except Exception, e: failed.append((account, e)) map(update_container_policy, accounts) if failed and args.report: sys.stdout.write( 'Failed for the following accounts:\n' ) pprint_table(sys.stdout, failed, headers=[])
def pprint_volume_in_ganeti(volume, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "State of volume %s in Ganeti" % volume.id vm = volume.machine if vm is None: stdout.write("volume is not attached to any instance.\n") return client = vm.get_client() try: vm_info = client.GetInstance(vm.backend_vm_id) except GanetiApiError as e: if e.code == 404: stdout.write("Volume seems attached to server %s, but" " server does not exist in backend.\n" % vm) return raise e disks = disks_from_instance(vm_info) try: gnt_disk = filter( lambda disk: disk.get("name") == volume.backend_volume_uuid, disks)[0] gnt_disk["instance"] = vm_info["name"] except IndexError: stdout.write("Volume %s is not attached to instance %s\n" % (volume.id, vm.id)) return pprint_table(stdout, gnt_disk.items(), None, separator=" | ", title=title) vm.put_client(client)
def pretty_print_stats(stats, stdout, cluster_details=True): newline = lambda: stdout.write("\n") _datetime = stats.get("datetime") stdout.write("datetime: %s\n" % _datetime) newline() servers = stats.get("servers") if servers is not None: pprint_servers(servers, stdout) newline() networks = stats.get("networks") if networks is not None: pprint_networks(networks, stdout) newline() ip_pools = stats.get("ip_pools") if ip_pools is not None: pprint_ip_pools(ip_pools, stdout) newline() images = stats.get("images") if images is not None: pprint_table(stdout, sorted(images.items()), separator=" | ", title="Statistics for Images") newline() clusters = stats.get("clusters") if clusters is not None: pprint_clusters(clusters, stdout, detail=cluster_details)
def pprint_volume(volume, display_mails=False, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "State of volume %s in DB" % volume.id ucache = UserCache(ASTAKOS_AUTH_URL, ASTAKOS_TOKEN) userid = volume.userid volume_type = volume.volume_type volume_dict = OrderedDict([ ("id", volume.id), ("size", volume.size), ("disk_template", volume_type.template), ("disk_provider", volume_type.provider), ("server_id", volume.machine_id), ("userid", volume.userid), ("project", volume.project), ("username", ucache.get_name(userid) if display_mails else None), ("index", volume.index), ("name", volume.name), ("state", volume.status), ("delete_on_termination", volume.delete_on_termination), ("deleted", volume.deleted), ("backendjobid", volume.backendjobid), ]) pprint_table(stdout, volume_dict.items(), None, separator=" | ", title=title)
def pprint_ippool(subnet, stdout=None, title=None): """Pretty print IP Pools of a subnet. Only IPv4 subnets have IP Pools""" if int(subnet.ipversion) != 4: return 0 if stdout is None: stdout = sys.stdout stdout.write("IP Pools of subnet %s:\n\n" % subnet.id) for pool in subnet.get_ip_pools(): size = pool.pool_size available = pool.available.count() info = OrderedDict([("First_IP", pool.return_start()), ("Last_IP", pool.return_end()), ("Size", size), ("Available", available)]) pprint_table(stdout, info.items(), None, separator=" | ", title=None) reserved = [ pool.index_to_value(index) for index, ip in enumerate(pool.reserved[:size]) if ip is False ] if reserved != []: stdout.write("\nExternally Reserved IPs:\n\n") stdout.write(", ".join(reserved) + "\n") ip_sum = pool.available[:size] & pool.reserved[:size] pprint_pool(None, bitarray_to_map(ip_sum), 80, stdout) stdout.write("\n\n")
def handle(self, *args, **options): write = self.stderr.write fix = options['fix'] check_unexpected = options["include_unexpected_holdings"] projects = Project.objects.all() local_proj_quotas, local_user_quotas = \ quotas.astakos_project_quotas(projects) qh_proj_quotas, qh_user_quotas = \ quotas.get_projects_quota_limits() unsynced, unexpected = differences(local_proj_quotas, qh_proj_quotas) unsync_u, unexpect_u = differences(local_user_quotas, qh_user_quotas) unsynced += unsync_u unexpected += unexpect_u headers = ("Holder", "Source", "Resource", "Astakos", "Quotaholder") if not unsynced and (not check_unexpected or not unexpected): write("Everything in sync.\n") return printable = (unsynced if not check_unexpected else unsynced + unexpected) pprint_table(self.stdout, printable, headers, title="Inconsistencies") if fix: to_sync = [] for holder, source, resource, value, qh_value in unsynced: to_sync.append(((holder, source, resource), value)) quotas.qh.set_quota(to_sync) if check_unexpected: to_del = [] for holder, source, resource, value, qh_value in unexpected: to_del.append((holder, source, resource)) quotas.qh.delete_quota(to_del)
def pprint_port_in_ganeti(port, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "State of Port %s in Ganeti" % port.id vm = port.machine if vm is None: stdout.write("Port is not attached to any instance.\n") return client = vm.get_client() try: vm_info = client.GetInstance(vm.backend_vm_id) except GanetiApiError as e: if e.code == 404: stdout.write("Port seems attached to server %s, but" " server does not exist in backend.\n" % vm) return raise e nics = nics_from_instance(vm_info) try: gnt_nic = filter(lambda nic: nic.get("name") == port.backend_uuid, nics)[0] gnt_nic["instance"] = vm_info["name"] except IndexError: stdout.write("Port %s is not attached to instance %s\n" % (port.id, vm.id)) return pprint_table(stdout, gnt_nic.items(), None, separator=" | ", title=title) vm.put_client(client)
def pprint_ippool(subnet, stdout=None, title=None): """Pretty print IP Pools of a subnet. Only IPv4 subnets have IP Pools""" if int(subnet.ipversion) != 4: return 0 if stdout is None: stdout = sys.stdout stdout.write("IP Pools of subnet %s:\n\n" % subnet.id) for pool in subnet.get_ip_pools(): size = pool.pool_size available = pool.available.count() info = OrderedDict([("First_IP", pool.return_start()), ("Last_IP", pool.return_end()), ("Size", size), ("Available", available)]) pprint_table(stdout, info.items(), None, separator=" | ", title=None) reserved = [pool.index_to_value(index) for index, ip in enumerate(pool.reserved[:size]) if ip is False] if reserved != []: stdout.write("\nExternally Reserved IPs:\n\n") stdout.write(", ".join(reserved) + "\n") ip_sum = pool.available[:size] & pool.reserved[:size] pprint_pool(None, bitarray_to_map(ip_sum), 80, stdout) stdout.write("\n\n")
def pprint_network(network, display_mails=False, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "State of Network %s in DB" % network.id ucache = UserCache(ASTAKOS_AUTH_URL, ASTAKOS_TOKEN) userid = network.userid db_network = OrderedDict([ ("name", network.name), ("backend-name", network.backend_id), ("state", network.state), ("userid", userid), ("username", ucache.get_name(userid) if display_mails else None), ("public", network.public), ("floating_ip_pool", network.floating_ip_pool), ("external_router", network.external_router), ("drained", network.drained), ("MAC prefix", network.mac_prefix), ("flavor", network.flavor), ("link", network.link), ("mode", network.mode), ("deleted", network.deleted), ("tags", "), ".join(network.backend_tag)), ("action", network.action)]) pprint_table(stdout, db_network.items(), None, separator=" | ", title=title)
def help_resources(self, options): headers = ("Name", "Enforce action", "Soft enforce action") pprint_table(self.stdout, RESOURCES_HELP, headers, options["output_format"], title="Resources")
def pprint_network(network, display_mails=False, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "State of Network %s in DB" % network.id ucache = UserCache(ASTAKOS_AUTH_URL, ASTAKOS_TOKEN) userid = network.userid db_network = OrderedDict([ ("name", network.name), ("backend-name", network.backend_id), ("state", network.state), ("userid", userid), ("username", ucache.get_name(userid) if display_mails else None), ("public", network.public), ("floating_ip_pool", network.floating_ip_pool), ("external_router", network.external_router), ("drained", network.drained), ("MAC prefix", network.mac_prefix), ("flavor", network.flavor), ("link", network.link), ("mode", network.mode), ("deleted", network.deleted), ("tags", "), ".join(network.backend_tag)), ("action", network.action) ]) pprint_table(stdout, db_network.items(), None, separator=" | ", title=title)
def handle(self, *args, **options): write = self.stderr.write userid = options['userid'] project = options["project"] # Get holdings from Cyclades DB db_holdings = util.get_db_holdings(user=userid, project=project) db_project_holdings = util.get_db_holdings(project=project, for_users=False) # Get holdings from QuotaHolder try: qh_holdings = util.get_qh_users_holdings( [userid] if userid is not None else None, [project] if project is not None else None) qh_project_holdings = util.get_qh_project_holdings( [project] if project is not None else None) except errors.AstakosClientException as e: raise CommandError(e) unsynced_users, users_pending, users_unknown =\ reconcile.check_users(self.stderr, quotas.RESOURCES, db_holdings, qh_holdings) unsynced_projects, projects_pending, projects_unknown =\ reconcile.check_projects(self.stderr, quotas.RESOURCES, db_project_holdings, qh_project_holdings) pending_exists = users_pending or projects_pending unknown_exists = users_unknown or projects_unknown headers = ("Type", "Holder", "Source", "Resource", "Database", "Quotaholder") unsynced = unsynced_users + unsynced_projects if unsynced: pprint_table(self.stdout, unsynced, headers) if options["fix"]: qh = quotas.Quotaholder.get() force = options["force"] name = ("client: reconcile-resources-cyclades, time: %s" % datetime.now()) user_provisions = reconcile.create_user_provisions( unsynced_users) project_provisions = reconcile.create_project_provisions( unsynced_projects) try: qh.issue_commission_generic( user_provisions, project_provisions, name=name, force=force, auto_accept=True) except quotas.errors.QuotaLimit: write("Reconciling failed because a limit has been " "reached. Use --force to ignore the check.\n") return write("Fixed unsynced resources\n") if pending_exists: write("Found pending commissions. Run 'snf-manage" " reconcile-commissions-cyclades'\n") elif not (unsynced or unknown_exists): write("Everything in sync.\n")
def pprint_networks(networks, stdout): values = [] for flavor, stats in sorted(networks.items()): active = int(stats.get("active", 0)) error = int(stats.get("error", 0)) values.append((flavor, active + error, active, error)) headers = ("Flavor", "Total", "Active", "Error") pprint_table(stdout, values, headers, separator=" | ", title="Statistics for Networks") stdout.write("\n")
def pprint_port_ips(port, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "IP Addresses of Port %s" % port.id ips = list(port.ips.values_list("address", "network_id", "subnet_id", "subnet__cidr", "floating_ip")) headers = ["Address", "Network", "Subnet", "CIDR", "is_floating"] pprint_table(stdout, ips, headers, separator=" | ", title=title)
def pprint_port_ips(port, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "IP Addresses of Port %s" % port.id ips = list( port.ips.values_list("address", "network_id", "subnet_id", "subnet__cidr", "floating_ip")) headers = ["Address", "Network", "Subnet", "CIDR", "is_floating"] pprint_table(stdout, ips, headers, separator=" | ", title=title)
def pprint_ip_pools(ip_pools, stdout): values = [] for state, stats in sorted(ip_pools.items()): count = stats["count"] free = stats["free"] total = stats["total"] values.append((state, count, free, total)) headers = ("State", "Number", "Free IPs", "Total IPs") pprint_table(stdout, values, headers, separator=" | ", title="Statistics for Public IPv4 Pools") stdout.write("\n")
def pprint_network_subnets(network, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "Subnets of network %s" % network.id subnets = list( network.subnets.values_list("id", "name", "ipversion", "cidr", "gateway", "dhcp", "deleted")) headers = ["ID", "Name", "Version", "CIDR", "Gateway", "DHCP", "Deleted"] pprint_table(stdout, subnets, headers, separator=" | ", title=title)
def print_expired(self, projects, execute): length = len(projects) if length == 0: s = "No expired projects.\n" self.stderr.write(s) return labels = ("Project", "Name", "Status", "Expiration date") utils.pprint_table(self.stdout, projects, labels, self.output_format, title="Expired projects") if execute: self.stderr.write("%d projects have been terminated.\n" % (length,))
def pretty_print_stats(stats, stdout): newline = lambda: stdout.write("\n") _datetime = stats.get("datetime") stdout.write("datetime: %s\n" % _datetime) newline() clusters = stats.get("clusters") if clusters is not None: fields = ["total", "drained", "offline"] table = columns_from_fields(fields, clusters) pprint_table(stdout, table, None, title="Statistics for Ganeti Clusters") newline() servers = stats.get("servers") if servers is not None: fields = ["total", "STARTED", "STOPPED", "BUILD", "ERROR", "DESTROYED"] table = columns_from_fields(fields, servers) pprint_table(stdout, table, None, title="Statistics for Virtual Servers") newline() networks = stats.get("networks") if networks is not None: public_ips = networks.pop("public_ips") networks["total_public_ips"] = public_ips.get("total", 0) networks["free_public_ips"] = public_ips.get("free", 0) fields = ["total", "ACTIVE", "DELETED", "ERROR", "total_public_ips", "free_public_ips"] table = columns_from_fields(fields, networks) pprint_table(stdout, table, None, title="Statistics for Virtual Networks") newline() resources = stats.get("resources") if resources is not None: for resource_name, resource in sorted(resources.items()): fields = ["total", "allocated"] for res, num in sorted(resource.pop("servers", {}).items()): name = "servers_with_%s" % res resource[name] = num fields.append(name) table = columns_from_fields(fields, resource) pprint_table(stdout, table, None, title="Statistics for %s" % resource_name) newline() images = stats.get("images") if images is not None: pprint_table(stdout, sorted(images.items()), None, title="Statistics for Images") newline()
def pprint_port(port, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "State of Port %s in DB" % port.id port = OrderedDict([("id", port.id), ("name", port.name), ("userid", port.userid), ("server", port.machine_id), ("network", port.network_id), ("device_owner", port.device_owner), ("mac", port.mac), ("state", port.state)]) pprint_table(stdout, port.items(), None, separator=" | ", title=title)
def pprint_network_backends(network, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "State of Network %s in DB for each backend" % network.id bnets = list( network.backend_networks.values_list("backend__clustername", "operstate", "deleted", "backendjobid", "backendopcode", "backendjobstatus")) headers = ["Backend", "State", "Deleted", "JobID", "Opcode", "JobStatus"] pprint_table(stdout, bnets, headers, separator=" | ", title=title)
def print_expired(self, projects, execute): length = len(projects) if length == 0: s = 'No expired projects.\n' self.stderr.write(s) return labels = ('Project', 'Name', 'Status', 'Expiration date') utils.pprint_table(self.stdout, projects, labels, self.output_format, title="Expired projects") if execute: self.stderr.write('%d projects have been terminated.\n' % (length,))
def pprint_volume_type(volume_type, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "Volume Type %s" % volume_type.id vtype_info = OrderedDict([ ("name", volume_type.name), ("disk template", volume_type.disk_template), ("deleted", volume_type.deleted), ]) pprint_table(stdout, vtype_info.items(), separator=" | ", title=title)
def pprint_network_subnets(network, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "Subnets of network %s" % network.id subnets = list(network.subnets.values_list("id", "name", "ipversion", "cidr", "gateway", "dhcp", "deleted")) headers = ["ID", "Name", "Version", "CIDR", "Gateway", "DHCP", "Deleted"] pprint_table(stdout, subnets, headers, separator=" | ", title=title)
def pprint_network_backends(network, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "State of Network %s in DB for each backend" % network.id bnets = list(network.backend_networks.values_list( "backend__clustername", "operstate", "deleted", "backendjobid", "backendopcode", "backendjobstatus")) headers = ["Backend", "State", "Deleted", "JobID", "Opcode", "JobStatus"] pprint_table(stdout, bnets, headers, separator=" | ", title=title)
def handle(self, **options): user = options['userid'] with image_backend(user) as backend: images = backend._list_images(user) images.sort(key=lambda x: x['created_at'], reverse=True) headers = ("id", "name", "owner", "public") table = [] for img in images: fields = (img["id"], img["name"], img["owner"], str(img["is_public"])) table.append(fields) pprint_table(self.stdout, table, headers)
def handle(self, *args, **options): if len(args) != 1: raise CommandError("Please provide an image ID") image_id = args[0] with image_backend(None) as backend: images = backend._list_images(None) try: image = filter(lambda x: x["id"] == image_id, images)[0] except IndexError: raise CommandError("Image not found. Use snf-manage image-list" " to get the list of all images.") utils.pprint_table(out=self.stdout, table=[image.values()], headers=image.keys(), vertical=True)
def list(args): try: utils = ManageAccounts() if args.only_duplicate: accounts = utils.duplicate_accounts() else: accounts = utils.existing_accounts() headers = ['uuid'] table = [(a,) for a in accounts] if args.output_format != "json" and not args.headers: headers = None pprint_table(sys.stdout, table, headers, args.output_format) except Exception, e: sys.stderr.write('%s\n' % e)
def list(args): try: utils = ManageAccounts() if args.only_duplicate: accounts = utils.duplicate_accounts() else: accounts = utils.existing_accounts() headers = ['uuid'] table = [(a, ) for a in accounts] if args.output_format != "json" and not args.headers: headers = None pprint_table(sys.stdout, table, headers, args.output_format) except Exception, e: sys.stderr.write('%s\n' % e)
def handle(self, *args, **options): if len(args) != 1: raise CommandError("Please provide an image ID") image_id = args[0] try: with PlanktonBackend(None) as backend: image = backend.get_image(image_id, check_permissions=False) except: raise CommandError("An error occurred, verify that image or " "user ID are valid") utils.pprint_table(out=self.stdout, table=[image.values()], headers=image.keys(), vertical=True)
def pprint_volume_type(volume_type, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "Volume Type %s" % volume_type.id specs_str = ", ".join(str(s) for s in volume_type.specs.all()) vtype_info = OrderedDict([ ("name", volume_type.name), ("disk template", volume_type.disk_template), ("deleted", volume_type.deleted), ("specs", specs_str), ]) pprint_table(stdout, vtype_info.items(), separator=" | ", title=title)
def pprint_server_in_ganeti(server, print_jobs=False, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "State of Server %s in Ganeti" % server.id client = server.get_client() try: server_info = client.GetInstance(server.backend_vm_id) except GanetiApiError as e: if e.code == 404: stdout.write("Server '%s' does not exist in backend '%s'\n" % (server.id, server.backend.clustername)) return raise e server.put_client(client) GANETI_INSTANCE_FIELDS = ('name', 'oper_state', 'admin_state', 'status', 'pnode', 'snode', 'network_port', 'disk_template', 'disk_usage', 'oper_ram', 'oper_vcpus', 'mtime') server_dict = OrderedDict([(k, server_info.get(k)) for k in GANETI_INSTANCE_FIELDS]) pprint_table(stdout, server_dict.items(), None, separator=" | ", title=title) stdout.write("\n") nics = nics_from_instance(server_info) nics_keys = ["ip", "mac", "name", "network"] nics_values = [[nic[key] for key in nics_keys] for nic in nics] pprint_table(stdout, nics_values, nics_keys, separator=" | ", title="NICs of Server %s in Ganeti" % server.id) stdout.write("\n") disks = disks_from_instance(server_info) disks_keys = ["name", "size"] disks_values = [[disk[key] for key in disks_keys] for disk in disks] pprint_table(stdout, disks_values, disks_keys, separator=" | ", title="Disks of Server %s in Ganeti" % server.id) if not print_jobs: return client = server.get_client() jobs = client.GetJobs(bulk=True) server_jobs = filter( lambda x: server.backend_vm_id in (" ".join(x.get("summary"))), jobs) GANETI_JOB_FIELDS = ('id', 'status', 'summary', 'opresult', 'opstatus', 'oplog', 'start_ts', 'end_ts') for server_job in server_jobs: stdout.write("\n") values = [server_job.get(k) for k in GANETI_JOB_FIELDS] pprint_table(stdout, zip(GANETI_JOB_FIELDS, values), None, separator=" | ", title="Ganeti Job %s" % server_job["id"]) server.put_client(client)
def pprint_server_nics(server, stdout=None, title=None): if title is None: title = "Ports of Server %s" % server.id if stdout is None: stdout = sys.stdout nics = [] for nic in server.nics.all(): nics.append((nic.id, nic.name, nic.index, nic.mac, nic.ipv4_address, nic.ipv6_address, nic.network, nic.firewall_profile, nic.state)) headers = ["ID", "Name", "Index", "MAC", "IPv4 Address", "IPv6 Address", "Network", "Firewall", "State"] pprint_table(stdout, nics, headers, separator=" | ", title=title)
def handle(self, *args, **options): output_format = options["output_format"] displayname = bool(options["displayname"]) unit_style = options["unit_style"] common.check_style(unit_style) filteropt = options["filter_by"] if filteropt is not None: filters = filteropt.split(",") else: filters = [] QHQ, INITQ = Q(), Q() for flt in filters: q = filtering.make_query(flt, self.QHFLT) if q is not None: QHQ &= q q = filtering.make_query(flt, self.INITFLT) if q is not None: INITQ &= q overlimit = bool(options["overlimit"]) if overlimit: QHQ &= Q(usage_max__gt=F("limit")) with_custom = options["with_custom"] if with_custom is not None: qeq = Q(capacity=F("resource__uplimit")) try: INITQ &= ~qeq if utils.parse_bool(with_custom) else qeq except ValueError as e: raise CommandError(e) users = AstakosUser.objects.accepted() qh_quotas, astakos_i = list_user_quotas( users, qhflt=QHQ, initflt=INITQ) if displayname: info = {} for user in users: info[user.uuid] = user.email else: info = None print_data, labels = common.show_quotas( qh_quotas, astakos_i, info, style=unit_style) utils.pprint_table(self.stdout, print_data, labels, output_format)
def handle(self, *args, **options): success_status = False try: b = get_backend() b.pre_exec() if len(args) == 3: account, container, name = args elif len(args) == 1: if not is_uuid(args[0]): raise CommandError('Invalid UUID') try: account, container, name = b.get_uuid( None, args[0], check_permissions=False) except NameError: raise CommandError('Unknown UUID') else: raise CommandError("Invalid number of arguments") kv = b.get_object_meta(account, account, container, name, options['domain'], options['obj_version']) if options['obj_version'] is None: _, path, permissions = b.get_object_permissions(account, account, container, name) if path is not None: kv['permissions'] = path, dict(permissions) public = b.get_object_public(account, account, container, name) if public is not None: update_public_meta(public, kv) if options['hashmap']: _, size, kv['hashmap'] = b.get_object_hashmap( account, account, container, name, options['obj_version']) utils.pprint_table(self.stdout, [kv.values()], kv.keys(), options["output_format"], vertical=True) success_status = True except Exception as e: raise CommandError(e) finally: b.post_exec(success_status) b.close()
def handle(self, *args, **options): success_status = False try: b = get_backend() b.pre_exec() if len(args) == 3: account, container, name = args elif len(args) == 1: if not is_uuid(args[0]): raise CommandError('Invalid UUID') try: account, container, name = b.get_uuid( None, args[0], check_permissions=False) except NameError: raise CommandError('Unknown UUID') else: raise CommandError("Invalid number of arguments") kv = b.get_object_meta(account, account, container, name, options['domain'], options['obj_version']) if options['obj_version'] is None: _, path, permissions = b.get_object_permissions( account, account, container, name) if path is not None: kv['permissions'] = path, dict(permissions) public = b.get_object_public(account, account, container, name) if public is not None: update_public_meta(public, kv) if options['hashmap']: _, size, kv['hashmap'] = b.get_object_hashmap( account, account, container, name, options['obj_version']) utils.pprint_table(self.stdout, [kv.values()], kv.keys(), options["output_format"], vertical=True) success_status = True except Exception as e: raise CommandError(e) finally: b.post_exec(success_status) b.close()
def pprint_port(port, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "State of Port %s in DB" % port.id port = OrderedDict([ ("id", port.id), ("name", port.name), ("userid", port.userid), ("server", port.machine_id), ("network", port.network_id), ("device_owner", port.device_owner), ("mac", port.mac), ("state", port.state)]) pprint_table(stdout, port.items(), None, separator=" | ", title=title)
def handle(self, *args, **options): if len(args) != 1: raise CommandError("Please provide a component name or ID.") identifier = args[0] if identifier.isdigit(): try: component = Component.objects.get(id=int(identifier)) except Component.DoesNotExist: raise CommandError('No component found with ID %s.' % identifier) else: try: component = Component.objects.get(name=identifier) except Component.DoesNotExist: raise CommandError('No component found named %s.' % identifier) kv = OrderedDict([ ('id', component.id), ('name', component.name), ('base url', component.base_url), ('ui url', component.url), ('token', component.auth_token), ('token created', component.auth_token_created), ('token expires', component.auth_token_expires), ]) utils.pprint_table(self.stdout, [kv.values()], kv.keys(), options["output_format"], vertical=True) services = component.service_set.all() service_data = [] for service in services: service_data.append((service.id, service.name, service.type)) if service_data: self.stdout.write('\n') labels = ('id', 'name', 'type') utils.pprint_table(self.stdout, service_data, labels, options["output_format"], title='Registered services')
def pprint_server_nics(server, stdout=None, title=None): if title is None: title = "Ports of Server %s" % server.id if stdout is None: stdout = sys.stdout nics = [] for nic in server.nics.all(): nics.append( (nic.id, nic.name, nic.index, nic.mac, nic.ipv4_address, nic.ipv6_address, nic.network, nic.firewall_profile, nic.state)) headers = [ "ID", "Name", "Index", "MAC", "IPv4 Address", "IPv6 Address", "Network", "Firewall", "State" ] pprint_table(stdout, nics, headers, separator=" | ", title=title)
def handle(self, **options): user = options['userid'] check_perm = user is not None with PlanktonBackend(user) as backend: images = backend.list_images(user, check_permissions=check_perm) if options["public"]: images = filter(lambda x: x['is_public'], images) images.sort(key=lambda x: x['created_at'], reverse=True) headers = ("id", "name", "user.uuid", "public", "snapshot") table = [] for img in images: fields = (img["id"], img["name"], img["owner"], str(img["is_public"]), str(img["is_snapshot"])) table.append(fields) pprint_table(self.stdout, table, headers)
def pprint_server_volumes(server, stdout=None, title=None): if title is None: title = "Volumes of Server %s" % server.id if stdout is None: stdout = sys.stdout vols = [] for vol in server.volumes.filter(deleted=False): volume_type = vol.volume_type vols.append((vol.id, vol.name, vol.index, vol.size, volume_type.template, volume_type.provider, vol.status, vol.source)) headers = ["ID", "Name", "Index", "Size", "Template", "Provider", "Status", "Source"] pprint_table(stdout, vols, headers, separator=" | ", title=title)
def handle(self, *args, **options): if len(args) != 1: raise CommandError("Please provide a snapshot ID") snapshot_id = args[0] try: with PlanktonBackend(None) as backend: snapshot = backend.get_snapshot(snapshot_id, check_permissions=False) except: raise CommandError("An error occurred, verify that snapshot and " "user ID are valid") utils.pprint_table(out=self.stdout, table=[snapshot.values()], headers=snapshot.keys(), vertical=True)
def pprint_server(server, display_mails=False, stdout=None, title=None): if stdout is None: stdout = sys.stdout if title is None: title = "State of Server %s in DB" % server.id ucache = UserCache(ASTAKOS_AUTH_URL, ASTAKOS_TOKEN) userid = server.userid try: image = get_image(server.imageid, server.userid)['name'] except: image = server.imageid server_dict = OrderedDict([ ("id", server.id), ("name", server.name), ("userid", server.userid), ("username", ucache.get_name(userid) if display_mails else None), ("project", server.project), ("shared_to_project", server.shared_to_project), ("flavor_id", server.flavor_id), ("flavor_name", server.flavor.name), ("imageid", server.imageid), ("image_name", image), ("created", server.created), ("state", server.operstate), ("backend", server.backend), ("deleted", server.deleted), ("action", server.action), ("task", server.task), ("rescue", server.rescue), ("rescue_image", server.rescue_image), ("task_job_id", server.task_job_id), ("backendjobid", server.backendjobid), ("backendopcode", server.backendopcode), ("backendjobstatus", server.backendjobstatus), ("backend_time", server.backendtime), ]) pprint_table(stdout, server_dict.items(), None, separator=" | ", title=title)