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_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 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_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 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_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 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 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 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 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_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_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 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 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, **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]
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 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_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 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)
