def execute(self, args):
mgr = NetworkManager(self.client)
table = Table([
'id', 'identifier', 'type', 'datacenter', 'vlan id', 'IPs',
'hardware', 'ccis',
])
table.sortby = args.get('--sortby') or 'id'
version = 0
if args.get('--v4'):
version = 4
elif args.get('--v6'):
version = 6
subnets = mgr.list_subnets(
datacenter=args.get('--datacenter'),
version=version,
identifier=args.get('--identifier'),
subnet_type=args.get('--type'),
)
for subnet in subnets:
table.add_row([
subnet['id'],
'%s/%s' % (subnet['networkIdentifier'], str(subnet['cidr'])),
subnet.get('subnetType', blank()),
lookup(subnet, 'datacenter', 'name',) or blank(),
subnet['networkVlanId'],
subnet['ipAddressCount'],
len(subnet['hardware']),
len(subnet['virtualGuests']),
])
return table
def execute(self, args):
account = self.client['Account']
iscsi_list = account.getIscsiNetworkStorage(
mask='eventCount,serviceResource[datacenter.name]')
iscsi_list = [NestedDict(iscsi) for iscsi in iscsi_list]
table = Table([
'id',
'datacenter',
'size',
'username',
'password',
'server'
])
for iscsi in iscsi_list:
table.add_row([
iscsi['id'],
iscsi['serviceResource']['datacenter'].get('name', blank()),
FormattedItem(
iscsi.get('capacityGb', blank()),
"%dGB" % iscsi.get('capacityGb', 0)),
iscsi.get('username', blank()),
iscsi.get('password', blank()),
iscsi.get('serviceResourceBackendIpAddress', blank())])
return table
def execute(client, args):
account = client['Account']
iscsi = account.getIscsiNetworkStorage(
mask='eventCount,serviceResource[datacenter.name]')
iscsi = [NestedDict(n) for n in iscsi]
t = Table([
'id',
'datacenter',
'size',
'username',
'password',
'server'
])
for n in iscsi:
t.add_row([
n['id'],
n['serviceResource']['datacenter'].get('name', blank()),
FormattedItem(
n.get('capacityGb', blank()),
"%dGB" % n.get('capacityGb', 0)),
n.get('username', blank()),
n.get('password', blank()),
n.get('serviceResourceBackendIpAddress', blank())])
return t
def execute(client, args):
f = FirewallManager(client)
fwvlans = f.get_firewalls()
t = Table(['vlan', 'type', 'features'])
dedicatedfws = filter(lambda x: x['dedicatedFirewallFlag'], fwvlans)
for vlan in dedicatedfws:
features = []
if vlan['highAvailabilityFirewallFlag']:
features.append('HA')
if features:
feature_list = listing(features, separator=',')
else:
feature_list = blank()
t.add_row([
vlan['vlanNumber'],
'dedicated',
feature_list,
])
shared_vlan = filter(lambda x: not x['dedicatedFirewallFlag'], fwvlans)
for vlan in shared_vlan:
t.add_row([vlan['vlanNumber'], 'standard', blank()])
return t
def execute(client, args):
account = client['Account']
neither = not any([args['--private'], args['--public']])
results = []
if args['--private'] or neither:
account = client['Account']
mask = 'id,accountId,name,globalIdentifier,blockDevices,parentId'
r = account.getPrivateBlockDeviceTemplateGroups(mask=mask)
results.append(r)
if args['--public'] or neither:
vgbd = client['Virtual_Guest_Block_Device_Template_Group']
r = vgbd.getPublicImages()
results.append(r)
t = Table(['id', 'account', 'type', 'name', 'guid', ])
t.sortby = 'name'
for result in results:
images = filter(lambda x: x['parentId'] == '', result)
for image in images:
t.add_row([
image['id'],
image.get('accountId', blank()),
image.get('type', blank()),
image['name'].strip(),
image.get('globalIdentifier', blank()),
])
return t
def execute(self, args):
mgr = FirewallManager(self.client)
fwvlans = mgr.get_firewalls()
table = Table(['vlan', 'type', 'features'])
dedicatedfws = [vlan['dedicatedFirewallFlag'] for vlan in fwvlans]
for vlan in dedicatedfws:
features = []
if vlan['highAvailabilityFirewallFlag']:
features.append('HA')
if features:
feature_list = listing(features, separator=',')
else:
feature_list = blank()
table.add_row([
vlan['vlanNumber'],
'dedicated',
feature_list,
])
shared_vlan = [vlan['dedicatedFirewallFlag'] for vlan in fwvlans]
for vlan in shared_vlan:
table.add_row([vlan['vlanNumber'], 'standard', blank()])
return table
def execute(self, args):
mgr = NetworkManager(self.client)
subnet_id = resolve_id(mgr.resolve_subnet_ids,
args.get('<identifier>'),
name='subnet')
subnet = mgr.get_subnet(subnet_id)
table = KeyValueTable(['Name', 'Value'])
table.align['Name'] = 'r'
table.align['Value'] = 'l'
table.add_row(['id', subnet['id']])
table.add_row(['identifier',
'%s/%s' % (subnet['networkIdentifier'],
str(subnet['cidr']))])
table.add_row(['subnet type', subnet['subnetType']])
table.add_row(['gateway', subnet.get('gateway', blank())])
table.add_row(['broadcast', subnet.get('broadcastAddress', blank())])
table.add_row(['datacenter', subnet['datacenter']['name']])
table.add_row(['usable ips',
subnet.get('usableIpAddressCount', blank())])
if not args.get('--no-cci'):
if subnet['virtualGuests']:
cci_table = Table(['Hostname', 'Domain', 'IP'])
cci_table.align['Hostname'] = 'r'
cci_table.align['IP'] = 'l'
for cci in subnet['virtualGuests']:
cci_table.add_row([cci['hostname'],
cci['domain'],
cci.get('primaryIpAddress')])
table.add_row(['ccis', cci_table])
else:
table.add_row(['cci', 'none'])
if not args.get('--no-hardware'):
if subnet['hardware']:
hw_table = Table(['Hostname', 'Domain', 'IP'])
hw_table.align['Hostname'] = 'r'
hw_table.align['IP'] = 'l'
for hardware in subnet['hardware']:
hw_table.add_row([hardware['hostname'],
hardware['domain'],
hardware.get('primaryIpAddress')])
table.add_row(['hardware', hw_table])
else:
table.add_row(['hardware', 'none'])
return table
def execute(self, args):
manager = MessagingManager(self.client)
regions = manager.get_endpoints()
table = Table([
'name', 'public', 'private'
])
for region, endpoints in regions.items():
table.add_row([
region,
endpoints.get('public') or blank(),
endpoints.get('private') or blank(),
])
return table
def execute(self, args):
manager = HardwareManager(self.client)
tags = None
if args.get('--tags'):
tags = [tag.strip() for tag in args.get('--tags').split(',')]
servers = manager.list_hardware(
hostname=args.get('--hostname'),
domain=args.get('--domain'),
cpus=args.get('--cpu'),
memory=args.get('--memory'),
datacenter=args.get('--datacenter'),
nic_speed=args.get('--network'),
tags=tags)
table = Table([
'id',
'datacenter',
'host',
'cores',
'memory',
'primary_ip',
'backend_ip',
'active_transaction'
])
table.sortby = args.get('--sortby') or 'host'
for server in servers:
server = NestedDict(server)
table.add_row([
server['id'],
server['datacenter']['name'] or blank(),
server['fullyQualifiedDomainName'],
server['processorPhysicalCoreAmount'],
gb(server['memoryCapacity'] or 0),
server['primaryIpAddress'] or blank(),
server['primaryBackendIpAddress'] or blank(),
active_txn(server),
])
return table
def execute(self, args):
mgr = FirewallManager(self.client)
table = Table(['firewall id',
'type',
'features',
'server/vlan id'])
fwvlans = mgr.get_firewalls()
dedicatedfws = [firewall for firewall in fwvlans
if firewall['dedicatedFirewallFlag']]
for vlan in dedicatedfws:
features = []
if vlan['highAvailabilityFirewallFlag']:
features.append('HA')
if features:
feature_list = listing(features, separator=',')
else:
feature_list = blank()
table.add_row([
'vlan:%s' % vlan['networkVlanFirewall']['id'],
'VLAN - dedicated',
feature_list,
vlan['id']
])
shared_vlan = [firewall for firewall in fwvlans
if not firewall['dedicatedFirewallFlag']]
for vlan in shared_vlan:
fwls = [guest for guest in vlan['firewallGuestNetworkComponents']
if has_firewall_component(guest)]
for firewall in fwls:
table.add_row([
'cci:%s' % firewall['id'],
'CCI - standard',
'-',
firewall['guestNetworkComponent']['guest']['id']
])
fwls = [server for server in vlan['firewallNetworkComponents']
if has_firewall_component(server)]
for fwl in fwls:
table.add_row([
'server:%s' % fwl['id'],
'Server - standard',
'-',
fwl['networkComponent']['downlinkComponent']['hardwareId']
])
return table
def execute(self, args):
cci = CCIManager(self.client)
tags = None
if args.get('--tags'):
tags = [tag.strip() for tag in args.get('--tags').split(',')]
guests = cci.list_instances(
hourly=args.get('--hourly'),
monthly=args.get('--monthly'),
hostname=args.get('--hostname'),
domain=args.get('--domain'),
cpus=args.get('--cpu'),
memory=args.get('--memory'),
datacenter=args.get('--datacenter'),
nic_speed=args.get('--network'),
tags=tags)
t = Table([
'id', 'datacenter', 'host',
'cores', 'memory', 'primary_ip',
'backend_ip', 'active_transaction',
])
t.sortby = args.get('--sortby') or 'host'
for guest in guests:
guest = NestedDict(guest)
t.add_row([
guest['id'],
guest['datacenter']['name'] or blank(),
guest['fullyQualifiedDomainName'],
guest['maxCpu'],
mb_to_gb(guest['maxMemory']),
guest['primaryIpAddress'] or blank(),
guest['primaryBackendIpAddress'] or blank(),
active_txn(guest),
])
return t
def execute(self, args):
account = self.client['Account']
nas_accounts = account.getNasNetworkStorage(
mask='eventCount,serviceResource[datacenter.name]')
nas_accounts = [NestedDict(n) for n in nas_accounts]
table = Table(['id', 'datacenter', 'size', 'username', 'password',
'server'])
for nas_account in nas_accounts:
table.add_row([
nas_account['id'],
nas_account['serviceResource']['datacenter'].get('name',
blank()),
FormattedItem(
nas_account.get('capacityGb', blank()),
"%dGB" % nas_account.get('capacityGb', 0)),
nas_account.get('username', blank()),
nas_account.get('password', blank()),
nas_account.get('serviceResourceBackendIpAddress', blank())])
return table
def execute(self, args):
manager = SSLManager(self.client)
certificates = manager.list_certs(args['--status'])
table = Table(['id', 'common_name', 'days_until_expire', 'notes'])
for certificate in certificates:
table.add_row([
certificate['id'],
certificate['commonName'],
certificate['validityDays'],
certificate.get('notes', blank())
])
table.sortby = args['--sortby']
return table
def execute(self, args):
hardware = HardwareManager(self.client)
table = KeyValueTable(['Name', 'Value'])
table.align['Name'] = 'r'
table.align['Value'] = 'l'
hardware_id = resolve_id(
hardware.resolve_ids, args.get('<identifier>'), 'hardware')
result = hardware.get_hardware(hardware_id)
result = NestedDict(result)
table.add_row(['id', result['id']])
table.add_row(['hostname', result['fullyQualifiedDomainName']])
table.add_row(['status', result['hardwareStatus']['status']])
table.add_row(['datacenter', result['datacenter']['name'] or blank()])
table.add_row(['cores', result['processorPhysicalCoreAmount']])
table.add_row(['memory', gb(result['memoryCapacity'])])
table.add_row(['public_ip', result['primaryIpAddress'] or blank()])
table.add_row(
['private_ip', result['primaryBackendIpAddress'] or blank()])
table.add_row(['ipmi_ip',
result['networkManagementIpAddress'] or blank()])
table.add_row([
'os',
FormattedItem(
result['operatingSystem']['softwareLicense']
['softwareDescription']['referenceCode'] or blank(),
result['operatingSystem']['softwareLicense']
['softwareDescription']['name'] or blank()
)])
table.add_row(['created', result['provisionDate'] or blank()])
vlan_table = Table(['type', 'number', 'id'])
for vlan in result['networkVlans']:
vlan_table.add_row([
vlan['networkSpace'], vlan['vlanNumber'], vlan['id']])
table.add_row(['vlans', vlan_table])
if result.get('notes'):
table.add_row(['notes', result['notes']])
if args.get('--price'):
table.add_row(['price rate',
result['billingItem']['recurringFee']])
if args.get('--passwords'):
user_strs = []
for item in result['operatingSystem']['passwords']:
user_strs.append(
"%s %s" % (item['username'], item['password']))
table.add_row(['users', listing(user_strs)])
tag_row = []
for tag in result['tagReferences']:
tag_row.append(tag['tag']['name'])
if tag_row:
table.add_row(['tags', listing(tag_row, separator=',')])
if not result['privateNetworkOnlyFlag']:
ptr_domains = self.client['Hardware_Server']\
.getReverseDomainRecords(id=hardware_id)
for ptr_domain in ptr_domains:
for ptr in ptr_domain['resourceRecords']:
table.add_row(['ptr', ptr['data']])
return table
def execute(self, args):
cci = CCIManager(self.client)
table = KeyValueTable(['Name', 'Value'])
table.align['Name'] = 'r'
table.align['Value'] = 'l'
cci_id = resolve_id(cci.resolve_ids, args.get('<identifier>'), 'CCI')
result = cci.get_instance(cci_id)
result = NestedDict(result)
table.add_row(['id', result['id']])
table.add_row(['hostname', result['fullyQualifiedDomainName']])
table.add_row(['status', FormattedItem(
result['status']['keyName'] or blank(),
result['status']['name'] or blank()
)])
table.add_row(['active_transaction', active_txn(result)])
table.add_row(['state', FormattedItem(
lookup(result, 'powerState', 'keyName'),
lookup(result, 'powerState', 'name'),
)])
table.add_row(['datacenter', result['datacenter']['name'] or blank()])
operating_system = lookup(result,
'operatingSystem',
'softwareLicense',
'softwareDescription') or {}
table.add_row([
'os',
FormattedItem(
operating_system.get('version') or blank(),
operating_system.get('name') or blank()
)])
table.add_row(['os_version',
operating_system.get('version') or blank()])
table.add_row(['cores', result['maxCpu']])
table.add_row(['memory', mb_to_gb(result['maxMemory'])])
table.add_row(['public_ip', result['primaryIpAddress'] or blank()])
table.add_row(['private_ip',
result['primaryBackendIpAddress'] or blank()])
table.add_row(['private_only', result['privateNetworkOnlyFlag']])
table.add_row(['private_cpu', result['dedicatedAccountHostOnlyFlag']])
table.add_row(['created', result['createDate']])
table.add_row(['modified', result['modifyDate']])
vlan_table = Table(['type', 'number', 'id'])
for vlan in result['networkVlans']:
vlan_table.add_row([
vlan['networkSpace'], vlan['vlanNumber'], vlan['id']])
table.add_row(['vlans', vlan_table])
if result.get('notes'):
table.add_row(['notes', result['notes']])
if args.get('--price'):
table.add_row(['price rate',
result['billingItem']['recurringFee']])
if args.get('--passwords'):
pass_table = Table(['username', 'password'])
for item in result['operatingSystem']['passwords']:
pass_table.add_row([item['username'], item['password']])
table.add_row(['users', pass_table])
tag_row = []
for tag in result['tagReferences']:
tag_row.append(tag['tag']['name'])
if tag_row:
table.add_row(['tags', listing(tag_row, separator=',')])
if not result['privateNetworkOnlyFlag']:
ptr_domains = self.client['Virtual_Guest'].\
getReverseDomainRecords(id=cci_id)
for ptr_domain in ptr_domains:
for ptr in ptr_domain['resourceRecords']:
table.add_row(['ptr', ptr['data']])
return table
def execute(client, args):
cci = CCIManager(client)
t = Table(['Name', 'Value'])
t.align['Name'] = 'r'
t.align['Value'] = 'l'
cci_id = resolve_id(cci, args.get('<identifier>'))
result = cci.get_instance(cci_id)
result = NestedDict(result)
t.add_row(['id', result['id']])
t.add_row(['hostname', result['fullyQualifiedDomainName']])
t.add_row(['status', result['status']['name']])
t.add_row(['state', result['powerState']['name']])
t.add_row(['datacenter', result['datacenter'].get('name', blank())])
t.add_row(['cores', result['maxCpu']])
t.add_row(['memory', mb_to_gb(result['maxMemory'])])
t.add_row(['public_ip', result.get('primaryIpAddress', blank())])
t.add_row(
['private_ip', result.get('primaryBackendIpAddress', blank())])
t.add_row([
'os',
FormattedItem(
result['operatingSystem']['softwareLicense']
['softwareDescription'].get('referenceCode', blank()),
result['operatingSystem']['softwareLicense']
['softwareDescription'].get('name', blank())
)])
t.add_row(['private_only', result['privateNetworkOnlyFlag']])
t.add_row(['private_cpu', result['dedicatedAccountHostOnlyFlag']])
t.add_row(['created', result['createDate']])
t.add_row(['modified', result['modifyDate']])
if result.get('notes'):
t.add_row(['notes', result['notes']])
if args.get('--price'):
t.add_row(['price rate', result['billingItem']['recurringFee']])
if args.get('--passwords'):
user_strs = []
for item in result['operatingSystem']['passwords']:
user_strs.append(
"%s %s" % (item['username'], item['password']))
t.add_row(['users', listing(user_strs)])
tag_row = []
for tag in result['tagReferences']:
tag_row.append(tag['tag']['name'])
if tag_row:
t.add_row(['tags', listing(tag_row, separator=',')])
ptr_domains = client['Virtual_Guest'].\
getReverseDomainRecords(id=cci_id)
for ptr_domain in ptr_domains:
for ptr in ptr_domain['resourceRecords']:
t.add_row(['ptr', ptr['data']])
return t
