def __aki_display(aki, disp, pg):
"""Display AMI info
"""
if disp.display == DisplayOptions.LONG:
pg.prt("%-14s %-10s %-5s",
aki.id, aki.architecture, aki.virtualization_type)
elif disp.display == DisplayOptions.EXTENDED:
pg.prt("%s:", aki.id)
pg.prt("%15s : %-12s", "State", aki.state)
pg.prt("%15s : %s", "Location", aki.location)
pg.prt("%15s : %s", "Public", aki.is_public)
pg.prt("%15s : %s", "Owner", aki.owner_id)
if aki.description:
pg.prt("%15s : %s", "Description", aki.description)
pg.prt("%15s : %s %s %s", "Hardware",
aki.architecture,
aki.virtualization_type,
aki.hypervisor,
)
if disp.display_tags:
common.display_tags(aki.tags, pg)
else:
pg.prt("%s", aki.id)
if disp.display_tags:
common.display_tags(aki.tags)
def __nacl_display(network_acl, disp, pg):
"""Display nacl info
"""
if disp.display == DisplayOptions.LONG:
pg.prt("%-20s", network_acl.id)
elif disp.display == DisplayOptions.EXTENDED:
pg.prt("%s", network_acl.id)
pg.prt("%15s : %s", "VPC", network_acl.vpc_id)
pg.prt("%15s : %s", "Default", network_acl.default)
for entry in network_acl.network_acl_entries:
rule = "Rule %s" % entry.rule_number
if entry.protocol == -1:
proto_spec = "ALL"
else:
proto_spec = "%s:%s-%s" % (entry.protocol,
entry.port_range.from_port,
entry.port_range.to_port)
if entry.egress:
direction = "egress"
else:
direction = "ingress"
pg.prt("%15s: %-8s %-10s %-20s %s ",
rule, direction, entry.rule_action,
proto_spec, entry.cidr_block)
for assoc in network_acl.associations:
pg.prt("%15s: %s", "Subnet", assoc.subnet_id)
if disp.display_tags:
common.display_tags(network_acl.tags, pg)
else:
pg.prt("%s", network_acl.id)
if disp.display_tags:
common.display_tags(network_acl.tags, pg)
def __eni_display(eni, disp, pg):
"""Display eni info
"""
if disp.display == DisplayOptions.LONG:
pg.prt("%-14s %-8s %-14s %-18s %-10s", eni.id, eni.status, eni.vpc_id, eni.subnet_id, eni.availability_zone)
elif disp.display == DisplayOptions.EXTENDED:
pg.prt("%s", eni.id)
pg.prt("%15s : %s", "Status", eni.status)
if eni.description:
pg.prt("%15s : %s", "Description", eni.description)
pg.prt("%15s : %s", "MAC", eni.mac_address)
pg.prt("%15s : %s", "Zone", eni.availability_zone)
pg.prt("%15s : %s", "VPC", eni.vpc_id)
pg.prt("%15s : %s", "Subnet", eni.subnet_id)
pg.prt("%15s : %s", "Req-managed", eni.requester_managed)
if eni.private_ip_address:
pg.prt("%15s : %s", "Primary-IP", eni.private_ip_address)
if eni.private_ip_addresses:
pg.prt("%15s : %s", "Private-IPs", ", ".join([x.private_ip_address for x in eni.private_ip_addresses]))
if eni.groups:
pg.prt("%15s : %s", "Groups", " ".join([group.id for group in eni.groups]))
pg.prt("%15s : %s", "SRC/DST-check", eni.source_dest_check)
if eni.attachment:
att = eni.attachment
pg.prt("%15s : %s", "Instance", optional(att.instance_id))
pg.prt("%15s : %s", "Device-index", att.device_index)
pg.prt("%15s : %s", "Attach-time", amazon2localtime(att.attach_time))
pg.prt("%15s : %s", "DoT", att.delete_on_termination)
if disp.display_tags:
common.display_tags(eni.tags, pg)
else:
pg.prt("%s", eni.id)
if disp.display_tags:
common.display_tags(eni.tags, pg)
def __sg_display(self, sg, disp, pg):
"""Display all security group info
"""
if disp.display == DisplayOptions.LONG:
access_map = sg_access_map(sg.rules)
out_str = "%-12s %-20s" % (sg.id, sg.name)
for target in access_map:
out_str += " %s:%s:%s" % (target[0], _make_port_spec(target),
",".join(list(access_map[target])))
pg.prt("%s", out_str)
elif disp.display == DisplayOptions.EXTENDED:
pg.prt("%s", sg.id)
pg.prt("%15s : %s", "Name", sg.name)
pg.prt("%15s : %s", "Description", sg.description)
pg.prt("%15s : %s", "Owner", sg.owner_id)
access_map = sg_access_map(sg.rules)
for target in access_map:
pg.prt("%15s : %-22s from %s",
"In-rule",
_PortSpec.make_str(target),
",".join(list(access_map[target])))
if disp.display_tags:
common.display_tags(sg.tags, pg)
else:
pg.prt("%s", sg.id)
if disp.display_tags:
common.display_tags(sg.tags, pg)
def __vol_display(self, vol, disp, pg, region):
"""Display volume info
"""
self.cache_insert(region, [vol.id])
if disp.display_size:
pg.prt("%-14s %4s", vol.id, vol.size)
else:
if disp.display == DisplayOptions.LONG:
snapshot_id = vol.snapshot_id.strip()
if not snapshot_id:
snapshot_id = '-'
pg.wrt("%-14s %-10s %-12s %4s %-14s",
vol.id, vol.status, vol.zone, vol.size, snapshot_id)
if vol.snapshot_id:
self.cache_insert(region, [vol.snapshot_id])
if vol.attach_data and vol.attach_data.instance_id:
attach_str = "%s:%s" % (vol.attach_data.instance_id,
vol.attach_data.device)
else:
attach_str = "-"
pg.wrt(" %-22s", attach_str)
if disp.display_name:
vol_name = vol.tags.get("Name")
if vol_name:
pg.wrt(" %s", vol_name)
pg.wrt("\n")
elif disp.display == DisplayOptions.EXTENDED:
pg.prt("%s", vol.id)
pg.prt("%15s : %s", "Status", vol.status)
pg.prt("%15s : %s", "Size", vol.size)
pg.prt("%15s : %s", "Creation-time",
amazon2localtime(vol.create_time))
if vol.snapshot_id:
pg.prt("%15s : %s", "Snapshot", vol.snapshot_id)
self.cache_insert(region, [vol.snapshot_id])
pg.prt("%15s : %s", "Zone", vol.zone)
pg.prt("%15s : %s", "Type", vol.type)
if vol.iops:
pg.prt("%15s : %s", "IOPS", vol.iops)
if vol.attach_data:
atd = vol.attach_data
if atd.instance_id:
pg.prt("%15s : %s", "Instance-id", atd.instance_id)
if atd.device:
pg.prt("%15s : %s", "Device", atd.device)
if atd.status:
pg.prt("%15s : %s", "Attach-status", atd.status)
if atd.attach_time:
pg.prt("%15s : %s", "Attach-time",
amazon2localtime(atd.attach_time))
if disp.display_tags:
common.display_tags(vol.tags, pg)
else:
pg.prt("%s", vol.id)
if disp.display_tags:
common.display_tags(vol.tags, pg)
def __vpc_display(vpc, disp, pg):
"""Display VPC info
"""
if disp.display == DisplayOptions.LONG:
pg.prt("%-14s %-10s %-20s", vpc.id, vpc.state, vpc.cidr_block)
elif disp.display == DisplayOptions.EXTENDED:
pg.prt("%s", vpc.id)
pg.prt("%15s : %s", "State", vpc.state)
pg.prt("%15s : %s", "CIDR-block", vpc.cidr_block)
pg.prt("%15s : %s", "DCHP-options", vpc.dhcp_options_id)
if disp.display_tags:
common.display_tags(vpc.tags, pg)
else:
pg.prt("%s", vpc.id)
if disp.display_tags:
common.display_tags(vpc.tags, pg)
def __ami_display(self, ami, disp, pg, region):
"""Display AMI info
"""
if disp.display == DisplayOptions.LONG:
if disp.display_name:
last_field = ami.name
else:
last_field = ''
pg.prt("%-14s %-10s %-14s %-5s %s",
ami.id, ami.architecture, ami.kernel_id,
ami.virtualization_type,
last_field)
elif disp.display == DisplayOptions.EXTENDED:
pg.prt("%s", ami.id)
pg.prt("%15s : %-12s", "State", ami.state)
pg.prt("%15s : %s", "Location", ami.location)
pg.prt("%15s : %s", "Name", ami.name)
pg.prt("%15s : %s", "Public", ami.is_public)
pg.prt("%15s : %s", "Owner", ami.owner_id)
pg.prt("%15s : %s", "Description", ami.description)
pg.prt("%15s : %s %s %s", "Hardware",
ami.architecture,
ami.virtualization_type,
ami.hypervisor,
)
pg.prt("%15s : %s %s %s", "Software",
ami.platform,
ami.kernel_id,
ami.ramdisk_id)
pg.prt("%15s : %-12s %s", "Root",
ami.root_device_name,
ami.root_device_type)
bdev_list = ami.block_device_mapping.keys()
bdev_list.sort()
for bdev in bdev_list:
bdev_info = ami.block_device_mapping[bdev]
pg.prt("%15s : %-12s %12s dot=%s",
"Device", bdev,
bdev_info.snapshot_id if bdev_info.snapshot_id else
bdev_info.ephemeral_name,
bdev_info.delete_on_termination)
if disp.display_tags:
common.display_tags(ami.tags, pg)
else:
pg.prt("%s", ami.id)
if disp.display_tags:
common.display_tags(ami.tags)
def __igw_display(igw, disp, pg):
"""Display internet gateway info
"""
if disp.display == DisplayOptions.LONG:
attachment_list = ["%s:%s" % (attachment.vpc_id, attachment.state)
for attachment in igw.attachments]
disp_list = ["%-24s" % (a,) for a in attachment_list]
pg.prt("%-14s %s", igw.id, " ".join(disp_list))
elif disp.display == DisplayOptions.EXTENDED:
pg.prt("%s", igw.id)
for attachment in igw.attachments:
pg.prt("%15s : %s", attachment.vpc_id, attachment.state)
if disp.display_tags:
common.display_tags(igw.tags, pg)
else:
pg.prt("%s", igw.id)
if disp.display_tags:
common.display_tags(igw.tags, pg)
def __dhcp_display(dhcp_opt, disp, pg):
"""Display dhcp info
"""
if disp.display == DisplayOptions.LONG:
pg.prt("%-20s", dhcp_opt.id)
elif disp.display == DisplayOptions.EXTENDED:
pg.prt("%s", dhcp_opt.id)
for option_name in dhcp_opt.options:
option_value = dhcp_opt.options[option_name]
if isinstance(option_value, list):
disp_str = ", ".join(option_value)
else:
disp_str = option_value
pg.prt("%25s : %s", option_name, disp_str)
if disp.display_tags:
common.display_tags(dhcp_opt.tags, pg)
else:
pg.prt("%s", dhcp_opt.id)
if disp.display_tags:
common.display_tags(dhcp_opt.tags, pg)
def __subnet_display(subnet, disp, pg):
"""Display subnet info
"""
if disp.display == DisplayOptions.LONG:
pg.prt("%-20s %-8s %-18s %-4s %-12s",
subnet.id, subnet.state, subnet.cidr_block,
subnet.available_ip_address_count,
subnet.availability_zone)
elif disp.display == DisplayOptions.EXTENDED:
pg.prt("%s", subnet.id)
pg.prt("%15s : %s", "State", subnet.state)
pg.prt("%15s : %s", "CIDR-block", subnet.cidr_block)
pg.prt("%15s : %s", "Avail-IP", subnet.available_ip_address_count)
pg.prt("%15s : %s", "Zone", subnet.availability_zone)
pg.prt("%15s : %s", "VPC", subnet.vpc_id)
if disp.display_tags:
common.display_tags(subnet.tags, pg)
else:
pg.prt("%s", subnet.id)
if disp.display_tags:
common.display_tags(subnet.tags, pg)
def __snap_display(self, snapshot, disp, pg, region):
"""Display snapshot info
"""
self.cache_insert(region, [snapshot.id])
if disp.display_size:
pg.prt("%-14s %4s", snapshot.id, snapshot.volume_size)
else:
if disp.display == DisplayOptions.LONG:
if disp.display_name:
last_field = snapshot.tags.get("Name", "-")
else:
last_field = snapshot.description
pg.prt("%-14s %-10s %6s %4s '%s'",
snapshot.id, snapshot.status,
amazon2localtime(snapshot.start_time),
snapshot.volume_size, last_field)
elif disp.display == DisplayOptions.EXTENDED:
pg.prt("%s", snapshot.id)
pg.prt("%15s : %s", "Status", snapshot.status)
pg.prt("%15s : %s", "Progress", snapshot.progress)
pg.prt("%15s : %s", "Description", snapshot.description)
pg.prt("%15s : %s", "Start-time",
amazon2localtime(snapshot.start_time))
pg.prt("%15s : %s", "Size", snapshot.volume_size)
pg.prt("%15s : %s", "Volume", snapshot.volume_id)
self.cache_insert(region, [snapshot.volume_id])
try:
snapshot_attr_list = snapshot.get_permissions()
for snapshot_attr in snapshot_attr_list:
pg.prt("%15s : %s",
snapshot_attr,
", ".join(snapshot_attr_list[snapshot_attr]))
except Exception, ex:
pg.prt("No permissions for %s: %s", snapshot.id, ex)
if disp.display_tags:
common.display_tags(snapshot.tags, pg)
else:
def __rtb_display(rtb, disp, pg):
"""Display route-table info
"""
if disp.display == DisplayOptions.LONG:
pg.prt("%-14s %-10s", rtb.id, rtb.vpc_id)
elif disp.display == DisplayOptions.EXTENDED:
pg.prt("%s", rtb.id)
pg.prt("%15s : %s", "VPC", rtb.vpc_id)
for route in rtb.routes:
if route.gateway_id:
dest = route.gateway_id
else:
dest = route.instance_id
pg.prt("%15s : %-16s %-12s %s",
"Route",
route.destination_cidr_block,
dest,
route.state)
if disp.display_tags:
common.display_tags(rtb.tags, pg)
else:
pg.prt("%s", rtb.id)
if disp.display_tags:
common.display_tags(rtb.tags, pg)
def __inst_display(self, instance, disp, pg, region):
"""Display information about the specified instance.
"""
res_id_list = [instance.id]
if disp.display == DisplayOptions.LONG:
if disp.display_name:
last_field = instance.tags.get("Name", "-")
else:
last_field = amazon2localtime(instance.launch_time)
pg.prt("%-12s %-10s %-12s %-10s %s",
instance.id, instance.state,
instance.placement,
instance.instance_type,
last_field)
elif disp.display == DisplayOptions.EXTENDED:
pg.prt("%s", instance.id)
pg.prt("%15s : %-12s", "State", instance.state)
pg.prt("%15s : %s", "Launch-time",
amazon2localtime(instance.launch_time))
pg.prt("%15s : %s", "Location", instance.placement)
pg.prt("%15s : %s %s %s %s", "Hardware",
instance.instance_type,
instance.architecture,
instance.virtualization_type,
instance.hypervisor,
)
pg.prt("%15s : %s %s %s %s", "Software",
instance.platform,
instance.image_id,
instance.kernel,
instance.ramdisk)
res_id_list.append(instance.image_id)
if instance.kernel:
res_id_list.append(instance.kernel)
if instance.ramdisk:
res_id_list.append(instance.ramdisk)
pg.prt("%15s : %-12s %s", "Root",
instance.root_device_name,
instance.root_device_type)
pg.prt("%15s : %s", "EBS-optimized",
"True" if instance.ebs_optimized else "False")
if instance.vpc_id:
pg.prt("%15s : %-14s %-16s", "VPC-info",
instance.vpc_id, instance.subnet_id)
res_id_list.extend([instance.vpc_id, instance.subnet_id])
if instance.private_ip_address:
pg.prt("%15s : %s %s", "IP",
instance.ip_address,
instance.private_ip_address)
for netif in instance.interfaces:
pg.prt("%15s : %-15s idx=%-2s %-16s SDC=%s",
"Interface",
netif.id,
netif.attachment.device_index,
netif.private_ip_address,
"on" if netif.source_dest_check else "off"
)
res_id_list.append(netif.id)
if instance.groups:
group_id_list = [group.id for group in instance.groups]
pg.prt("%15s : %s", "Groups", " ".join(group_id_list))
res_id_list.extend(group_id_list)
bdev_list = instance.block_device_mapping.keys()
bdev_list.sort()
for bdev in bdev_list:
bdev_info = instance.block_device_mapping[bdev]
pg.prt("%15s : %-12s %-12s %s dot=%s",
"Device", bdev,
bdev_info.volume_id,
bdev_info.status,
bdev_info.delete_on_termination)
res_id_list.append(bdev_info.volume_id)
if disp.display_tags:
common.display_tags(instance.tags, pg)
else:
pg.prt("%s", instance.id)
if disp.display_tags:
common.display_tags(instance.tags, pg)
self.cache_insert(region, res_id_list)
pg.prt("%15s : %s", "Volume", snapshot.volume_id)
self.cache_insert(region, [snapshot.volume_id])
try:
snapshot_attr_list = snapshot.get_permissions()
for snapshot_attr in snapshot_attr_list:
pg.prt("%15s : %s",
snapshot_attr,
", ".join(snapshot_attr_list[snapshot_attr]))
except Exception, ex:
pg.prt("No permissions for %s: %s", snapshot.id, ex)
if disp.display_tags:
common.display_tags(snapshot.tags, pg)
else:
pg.prt("%s", snapshot.id)
if disp.display_tags:
common.display_tags(snapshot.tags, pg)
def __snap_list_cmd(self, region, selector, disp):
"""Implements the list function of the snap command
"""
if not selector.has_selection():
return
ec2_conn = self.get_ec2_conn(region)
snapshot_list = ec2_conn.get_all_snapshots(
snapshot_ids=selector.resource_id_list,
owner='self',
filters=selector.get_filter_dict())
snapshot_list = selector.filter_resources(snapshot_list)
with CommandOutput(output_path=disp.get_output_file()) as pg:
if disp.display_count:
if disp.display_size:
