def execute(self, args):
mgr = LoadBalancerManager(self.client)
routing_types = mgr.get_routing_types()
table = KeyValueTable(['ID', 'Name'])
table.align['ID'] = 'l'
table.align['Name'] = 'l'
table.sortby = 'ID'
for routing_type in routing_types:
table.add_row([routing_type['id'], routing_type['name']])
return table
def execute(self, args):
table = KeyValueTable(['Name', 'Value'])
table.align['Name'] = 'r'
table.align['Value'] = 'l'
show_all = True
for opt_name in self.options:
if args.get("--" + opt_name):
show_all = False
break
mgr = HardwareManager(self.client)
bmi_options = mgr.get_bare_metal_create_options()
if args['--all']:
show_all = True
if args['--datacenter'] or show_all:
results = self.get_create_options(bmi_options, 'datacenter')[0]
table.add_row([results[0], listing(sorted(results[1]))])
if args['--cpu'] or args['--memory'] or show_all:
results = self.get_create_options(bmi_options, 'cpu')
memory_cpu_table = Table(['memory', 'cpu'])
for result in results:
memory_cpu_table.add_row([
result[0],
listing(
[item[0] for item in sorted(
result[1], key=lambda x: int(x[0])
)])])
table.add_row(['memory/cpu', memory_cpu_table])
if args['--os'] or show_all:
results = self.get_create_options(bmi_options, 'os')
for result in results:
table.add_row([
result[0],
listing(
[item[0] for item in sorted(result[1])],
separator=linesep
)])
if args['--disk'] or show_all:
results = self.get_create_options(bmi_options, 'disk')[0]
table.add_row([results[0], listing(
[item[0] for item in sorted(results[1])])])
if args['--nic'] or show_all:
results = self.get_create_options(bmi_options, 'nic')
for result in results:
table.add_row([result[0], listing(
[item[0] for item in sorted(result[1],)])])
return table
def get_local_lb_table(load_balancer):
""" Helper package to format the local loadbal details into a table.
:param dict load_balancer: A dictionary representing the loadbal
:returns: A table containing the local loadbal details
"""
table = KeyValueTable(['Name', 'Value'])
table.align['Name'] = 'l'
table.align['Value'] = 'l'
table.add_row(['General properties', '----------'])
table.add_row([' ID', 'local:%s' % load_balancer['id']])
table.add_row([' IP Address', load_balancer['ipAddress']['ipAddress']])
name = load_balancer['loadBalancerHardware'][0]['datacenter']['name']
table.add_row([' Datacenter', name])
table.add_row([' Connections limit', load_balancer['connectionLimit']])
table.add_row([' Dedicated', load_balancer['dedicatedFlag']])
table.add_row([' HA', load_balancer['highAvailabilityFlag']])
table.add_row([' SSL Enabled', load_balancer['sslEnabledFlag']])
table.add_row([' SSL Active', load_balancer['sslActiveFlag']])
index0 = 1
for virtual_server in load_balancer['virtualServers']:
table.add_row(['Service group %s' % index0,
'**************'])
index0 += 1
table2 = Table(['Service group ID', 'Port', 'Allocation',
'Routing type', 'Routing Method'])
for group in virtual_server['serviceGroups']:
table2.add_row([
'%s:%s' % (load_balancer['id'], virtual_server['id']),
virtual_server['port'],
'%s %%' % virtual_server['allocation'],
'%s:%s' % (group['routingTypeId'],
group['routingType']['name']),
'%s:%s' % (group['routingMethodId'],
group['routingMethod']['name'])
])
table.add_row([' Group Properties', table2])
table3 = Table(['Service_ID', 'IP Address', 'Port',
'Health Check', 'Weight', 'Enabled', 'Status'])
service_exist = False
for service in group['services']:
service_exist = True
health_check = service['healthChecks'][0]
table3.add_row([
'%s:%s' % (load_balancer['id'], service['id']),
service['ipAddress']['ipAddress'],
service['port'],
'%s:%s' % (health_check['healthCheckTypeId'],
health_check['type']['name']),
service['groupReferences'][0]['weight'],
service['enabled'],
service['status']
])
if service_exist:
table.add_row([' Services', table3])
else:
table.add_row([' Services', 'None'])
return table
def execute(self, args):
mgr = NetworkManager(self.client)
vlan_id = resolve_id(mgr.resolve_vlan_ids,
args.get('<identifier>'),
'VLAN')
vlan = mgr.get_vlan(vlan_id)
table = KeyValueTable(['Name', 'Value'])
table.align['Name'] = 'r'
table.align['Value'] = 'l'
table.add_row(['id', vlan['id']])
table.add_row(['number', vlan['vlanNumber']])
table.add_row(['datacenter',
vlan['primaryRouter']['datacenter']['longName']])
table.add_row(['primary router',
vlan['primaryRouter']['fullyQualifiedDomainName']])
table.add_row(['firewall',
'Yes' if vlan['firewallInterfaces'] else 'No'])
subnets = []
for subnet in vlan['subnets']:
subnet_table = KeyValueTable(['Name', 'Value'])
subnet_table.align['Name'] = 'r'
subnet_table.align['Value'] = 'l'
subnet_table.add_row(['id', subnet['id']])
subnet_table.add_row(['identifier', subnet['networkIdentifier']])
subnet_table.add_row(['netmask', subnet['netmask']])
subnet_table.add_row(['gateway', subnet.get('gateway', '-')])
subnet_table.add_row(['type', subnet['subnetType']])
subnet_table.add_row(['usable ips',
subnet['usableIpAddressCount']])
subnets.append(subnet_table)
table.add_row(['subnets', subnets])
if not args.get('--no-cci'):
if vlan['virtualGuests']:
cci_table = KeyValueTable(['Hostname', 'Domain', 'IP'])
cci_table.align['Hostname'] = 'r'
cci_table.align['IP'] = 'l'
for cci in vlan['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 vlan['hardware']:
hw_table = Table(['Hostname', 'Domain', 'IP'])
hw_table.align['Hostname'] = 'r'
hw_table.align['IP'] = 'l'
for hardware in vlan['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):
t = KeyValueTable(["Name", "Value"])
t.align["Name"] = "r"
t.align["Value"] = "l"
show_all = True
for opt_name in self.options:
if args.get("--" + opt_name):
show_all = False
break
mgr = HardwareManager(self.client)
bmi_options = mgr.get_bare_metal_create_options()
if args["--all"]:
show_all = True
if args["--datacenter"] or show_all:
results = self.get_create_options(bmi_options, "datacenter")[0]
t.add_row([results[0], listing(sorted(results[1]))])
if args["--cpu"] or args["--memory"] or show_all:
results = self.get_create_options(bmi_options, "cpu")
memory_cpu_table = Table(["memory", "cpu"])
for result in results:
memory_cpu_table.add_row(
[result[0], listing([item[0] for item in sorted(result[1], key=lambda x: int(x[0]))])]
)
t.add_row(["memory/cpu", memory_cpu_table])
if args["--os"] or show_all:
results = self.get_create_options(bmi_options, "os")
for result in results:
t.add_row([result[0], listing([item[0] for item in sorted(result[1])], separator=linesep)])
if args["--disk"] or show_all:
results = self.get_create_options(bmi_options, "disk")[0]
t.add_row([results[0], listing([item[0] for item in sorted(results[1])])])
if args["--nic"] or show_all:
results = self.get_create_options(bmi_options, "nic")
for result in results:
t.add_row([result[0], listing([item[0] for item in sorted(result[1])])])
return t
def execute(self, args):
mgr = NetworkManager(self.client)
result = mgr.get_rwhois()
table = KeyValueTable(['Name', 'Value'])
table.align['Name'] = 'r'
table.align['Value'] = 'l'
table.add_row(['Name', result['firstName'] + ' ' + result['lastName']])
table.add_row(['Company', result['companyName']])
table.add_row(['Abuse Email', result['abuseEmail']])
table.add_row(['Address 1', result['address1']])
if result.get('address2'):
table.add_row(['Address 2', result['address2']])
table.add_row(['City', result['city']])
table.add_row(['State', result.get('state', '-')])
table.add_row(['Postal Code', result.get('postalCode', '-')])
table.add_row(['Country', result['country']])
return table
def execute(self, args):
image_mgr = ImageManager(self.client)
image_id = resolve_id(image_mgr.resolve_ids,
args.get('<identifier>'),
'image')
image = image_mgr.get_image(image_id)
t = KeyValueTable(['Name', 'Value'])
t.align['Name'] = 'r'
t.align['Value'] = 'l'
t.add_row(['id', image['id']])
t.add_row(['account', image.get('accountId', blank())])
t.add_row(['name', image['name'].strip()])
t.add_row(['global_identifier',
image.get('globalIdentifier', blank())])
return t
def execute(self, args):
mgr = NetworkManager(self.client)
addr_info = mgr.ip_lookup(args['<ip>'])
if not addr_info:
return 'Not found'
table = KeyValueTable(['Name', 'Value'])
table.align['Name'] = 'r'
table.align['Value'] = 'l'
table.add_row(['id', addr_info['id']])
table.add_row(['ip', addr_info['ipAddress']])
subnet_table = KeyValueTable(['Name', 'Value'])
subnet_table.align['Name'] = 'r'
subnet_table.align['Value'] = 'l'
subnet_table.add_row(['id', addr_info['subnet']['id']])
subnet_table.add_row(['identifier',
'%s/%s'
% (addr_info['subnet']['networkIdentifier'],
str(addr_info['subnet']['cidr']))])
subnet_table.add_row(['netmask', addr_info['subnet']['netmask']])
if addr_info['subnet'].get('gateway'):
subnet_table.add_row(['gateway', addr_info['subnet']['gateway']])
subnet_table.add_row(['type', addr_info['subnet'].get('subnetType')])
table.add_row(['subnet', subnet_table])
if addr_info.get('virtualGuest') or addr_info.get('hardware'):
device_table = KeyValueTable(['Name', 'Value'])
device_table.align['Name'] = 'r'
device_table.align['Value'] = 'l'
if addr_info.get('virtualGuest'):
device = addr_info['virtualGuest']
device_type = 'vs'
else:
device = addr_info['hardware']
device_type = 'server'
device_table.add_row(['id', device['id']])
device_table.add_row(['name', device['fullyQualifiedDomainName']])
device_table.add_row(['type', device_type])
table.add_row(['device', device_table])
return table
def get_ticket_results(mgr, ticket_id, update_count=1):
""" Get output about a ticket
:param integer id: the ticket ID
:param integer update_count: number of entries to retrieve from ticket
:returns: a KeyValue table containing the details of the ticket
"""
result = mgr.get_ticket(ticket_id)
result = NestedDict(result)
table = KeyValueTable(['Name', 'Value'])
table.align['Name'] = 'r'
table.align['Value'] = 'l'
table.add_row(['id', result['id']])
table.add_row(['title', result['title']])
if result['assignedUser']:
table.add_row(['assignedUser',
"%s %s" % (result['assignedUser']['firstName'],
result['assignedUser']['lastName'])])
table.add_row(['createDate', result['createDate']])
table.add_row(['lastEditDate', result['lastEditDate']])
total_update_count = result['updateCount']
count = min(total_update_count, update_count)
for i, update in enumerate(result['updates'][:count]):
update = wrap_string(update['entry'])
table.add_row(['Update %s' % (i + 1,), update])
return table
def execute(self, args):
manager = CDNManager(self.client)
account = manager.get_account(args.get('<account>'))
table = KeyValueTable(['Name', 'Value'])
table.align['Name'] = 'r'
table.align['Value'] = 'l'
table.add_row(['id', account['id']])
table.add_row(['account_name', account['cdnAccountName']])
table.add_row(['type', account['cdnSolutionName']])
table.add_row(['status', account['status']['name']])
table.add_row(['created', account['createDate']])
table.add_row(['notes', account.get('cdnAccountNote', blank())])
return table
def _execute(self, args):
meta = MetadataManager()
if args['<public>']:
t = KeyValueTable(['Name', 'Value'])
t.align['Name'] = 'r'
t.align['Value'] = 'l'
network = meta.public_network()
t.add_row([
'mac addresses',
listing(network['mac_addresses'], separator=',')])
t.add_row([
'router', network['router']])
t.add_row([
'vlans', listing(network['vlans'], separator=',')])
t.add_row([
'vlan ids',
listing(network['vlan_ids'], separator=',')])
return t
if args['<private>']:
t = KeyValueTable(['Name', 'Value'])
t.align['Name'] = 'r'
t.align['Value'] = 'l'
network = meta.private_network()
t.add_row([
'mac addresses',
listing(network['mac_addresses'], separator=',')])
t.add_row([
'router', network['router']])
t.add_row([
'vlans', listing(network['vlans'], separator=',')])
t.add_row([
'vlan ids',
listing(network['vlan_ids'], separator=',')])
return t
def config_table(settings):
""" Returns a config table """
table = KeyValueTable(["Name", "Value"])
table.align["Name"] = "r"
table.align["Value"] = "l"
table.add_row(["Username", settings["username"] or "not set"])
table.add_row(["API Key", settings["api_key"] or "not set"])
table.add_row(["Endpoint URL", settings["endpoint_url"] or "not set"])
table.add_row(["Timeout", settings["timeout"] or "not set"])
return table
def get_ticket_results(mgr, ticket_id, update_count=1):
""" Get output about a ticket
:param integer id: the ticket ID
:param integer update_count: number of entries to retrieve from ticket
:returns: a KeyValue table containing the details of the ticket
"""
result = mgr.get_ticket(ticket_id)
result = NestedDict(result)
t = KeyValueTable(['Name', 'Value'])
t.align['Name'] = 'r'
t.align['Value'] = 'l'
t.add_row(['id', result['id']])
t.add_row(['title', result['title']])
if result['assignedUser']:
t.add_row(['assignedUser',
"%s %s" % (result['assignedUser']['firstName'],
result['assignedUser']['lastName'])])
t.add_row(['createDate', result['createDate']])
t.add_row(['lastEditDate', result['lastEditDate']])
totalUpdates = len(result['updates'])
count = min(totalUpdates, update_count)
for index in range(0, count):
i = totalUpdates - index
update = wrap_string(result['updates'][i - 1]['entry'])
t.add_row(['Update %s' % (i), update])
return t
def execute(self, args):
mgr = NetworkManager(self.client)
subnet_id = mgr.resolve_subnet_ids(args.get('<identifier>'))
subnet = mgr.get_subnet(subnet_id)
t = KeyValueTable(['Name', 'Value'])
t.align['Name'] = 'r'
t.align['Value'] = 'l'
t.add_row(['id', subnet['id']])
t.add_row(['identifier',
subnet['networkIdentifier']+'/'+str(subnet['cidr'])])
t.add_row(['subnet type', subnet['subnetType']])
t.add_row(['gateway', subnet.get('gateway', '-')])
t.add_row(['broadcast', subnet.get('broadcastAddress', '-')])
t.add_row(['datacenter', subnet['datacenter']['name']])
t.add_row(['usable ips', subnet.get('usableIpAddressCount', '-')])
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')])
t.add_row(['ccis', cci_table])
else:
t.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 hw in subnet['hardware']:
hw_table.add_row([hw['hostname'],
hw['domain'],
hw.get('primaryIpAddress')])
t.add_row(['hardware', hw_table])
else:
t.add_row(['hardware', 'none'])
return t
def config_table(settings):
t = KeyValueTable(['Name', 'Value'])
t.align['Name'] = 'r'
t.align['Value'] = 'l'
t.add_row(['Username', settings['username'] or 'not set'])
t.add_row(['API Key', settings['api_key'] or 'not set'])
t.add_row(['Endpoint URL', settings['endpoint_url'] or 'not set'])
t.add_row(['Timeout', settings['timeout'] or 'not set'])
return t
def execute(self, args):
mgr = NetworkManager(self.client)
ip = mgr.ip_lookup(args['<ip>'])
if not ip:
return 'Not found'
t = KeyValueTable(['Name', 'Value'])
t.align['Name'] = 'r'
t.align['Value'] = 'l'
t.add_row(['id', ip['id']])
t.add_row(['ip', ip['ipAddress']])
subnet_table = KeyValueTable(['Name', 'Value'])
subnet_table.align['Name'] = 'r'
subnet_table.align['Value'] = 'l'
subnet_table.add_row(['id', ip['subnet']['id']])
subnet_table.add_row(['identifier', ip['subnet']['networkIdentifier']
+ '/' + str(ip['subnet']['cidr'])])
subnet_table.add_row(['netmask', ip['subnet']['netmask']])
if ip['subnet'].get('gateway'):
subnet_table.add_row(['gateway', ip['subnet']['gateway']])
subnet_table.add_row(['type', ip['subnet'].get('subnetType')])
t.add_row(['subnet', subnet_table])
if ip.get('virtualGuest') or ip.get('hardware'):
device_table = KeyValueTable(['Name', 'Value'])
device_table.align['Name'] = 'r'
device_table.align['Value'] = 'l'
if ip.get('virtualGuest'):
device = ip['virtualGuest']
device_type = 'cci'
else:
device = ip['hardware']
device_type = 'server'
device_table.add_row(['id', device['id']])
device_table.add_row(['name', device['fullyQualifiedDomainName']])
device_table.add_row(['type', device_type])
t.add_row(['device', device_table])
return t
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-vs'):
if subnet['virtualGuests']:
vs_table = Table(['Hostname', 'Domain', 'IP'])
vs_table.align['Hostname'] = 'r'
vs_table.align['IP'] = 'l'
for vsi in subnet['virtualGuests']:
vs_table.add_row([vsi['hostname'],
vsi['domain'],
vsi.get('primaryIpAddress')])
table.add_row(['vs', vs_table])
else:
table.add_row(['vs', '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
