def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network, tag):
"""List hardware servers."""
manager = SoftLayer.HardwareManager(env.client)
servers = manager.list_hardware(hostname=hostname,
domain=domain,
cpus=cpu,
memory=memory,
datacenter=datacenter,
nic_speed=network,
tags=tag)
table = formatting.Table([
'id',
'hostname',
'primary_ip',
'backend_ip',
'datacenter',
'action',
])
table.sortby = sortby or 'hostname'
for server in servers:
table.add_row([
utils.lookup(server, 'id'),
utils.lookup(server, 'hostname') or formatting.blank(),
utils.lookup(server, 'primaryIpAddress') or formatting.blank(),
utils.lookup(server, 'primaryBackendIpAddress')
or formatting.blank(),
utils.lookup(server, 'datacenter', 'name') or formatting.blank(),
formatting.active_txn(server),
])
return table
def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network, tag):
"""List hardware servers."""
manager = SoftLayer.HardwareManager(env.client)
servers = manager.list_hardware(hostname=hostname,
domain=domain,
cpus=cpu,
memory=memory,
datacenter=datacenter,
nic_speed=network,
tags=tag)
table = formatting.Table([
'id',
'hostname',
'primary_ip',
'backend_ip',
'datacenter',
'action',
])
table.sortby = sortby or 'hostname'
for server in servers:
table.add_row([
utils.lookup(server, 'id'),
utils.lookup(server, 'hostname') or formatting.blank(),
utils.lookup(server, 'primaryIpAddress') or formatting.blank(),
utils.lookup(server, 'primaryBackendIpAddress') or
formatting.blank(),
utils.lookup(server, 'datacenter', 'name') or formatting.blank(),
formatting.active_txn(server),
])
return table
def cli(env, identifier):
"""View details of a placement group.
IDENTIFIER can be either the Name or Id of the placement group you want to view
"""
manager = PlacementManager(env.client)
group_id = helpers.resolve_id(manager.resolve_ids, identifier,
'placement_group')
result = manager.get_object(group_id)
table = formatting.Table(
["Id", "Name", "Backend Router", "Rule", "Created"])
table.add_row([
result['id'], result['name'], result['backendRouter']['hostname'],
result['rule']['name'], result['createDate']
])
guest_table = formatting.Table([
"Id", "FQDN", "Primary IP", "Backend IP", "CPU", "Memory",
"Provisioned", "Transaction"
])
for guest in result['guests']:
guest_table.add_row([
guest.get('id'),
guest.get('fullyQualifiedDomainName'),
guest.get('primaryIpAddress'),
guest.get('primaryBackendIpAddress'),
guest.get('maxCpu'),
guest.get('maxMemory'),
guest.get('provisionDate'),
formatting.active_txn(guest)
])
env.fout(table)
env.fout(guest_table)
def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network, tag):
"""List hardware servers."""
manager = SoftLayer.HardwareManager(env.client)
servers = manager.list_hardware(
hostname=hostname, domain=domain, cpus=cpu, memory=memory, datacenter=datacenter, nic_speed=network, tags=tag
)
table = formatting.Table(["id", "hostname", "primary_ip", "backend_ip", "datacenter", "action"])
table.sortby = sortby or "hostname"
for server in servers:
table.add_row(
[
utils.lookup(server, "id"),
utils.lookup(server, "hostname") or formatting.blank(),
utils.lookup(server, "primaryIpAddress") or formatting.blank(),
utils.lookup(server, "primaryBackendIpAddress") or formatting.blank(),
utils.lookup(server, "datacenter", "name") or formatting.blank(),
formatting.active_txn(server),
]
)
return table
def test_active_txn_missing(self):
""" a dict with activeTransaction but not transactionStatus
should return blank() instead of raising an exception
"""
b = formatting.blank()
result = formatting.active_txn({"activeTransaction": {}})
self.assertIsInstance(result, formatting.FormattedItem)
self.assertEqual(result.original, b.original)
def test_active_txn_missing(self):
# A dict with activeTransaction but not transactionStatus
# should return blank() instead of raising an exception
b = formatting.blank()
result = formatting.active_txn({'activeTransaction': {}})
self.assertIsInstance(result, formatting.FormattedItem)
self.assertEqual(result.original, b.original)
def test_active_txn(self):
result = formatting.active_txn({
'activeTransaction': {
'transactionStatus': {
'name': 'a',
'friendlyName': 'b'
}
}
})
self.assertEqual(result.original, 'a')
self.assertEqual(result.formatted, 'b')
self.assertIsInstance(result, formatting.FormattedItem)
def test_active_txn(self):
result = formatting.active_txn({
'activeTransaction': {
'transactionStatus': {
'name': 'a',
'friendlyName': 'b'
}
}
})
self.assertEqual(result.original, 'a')
self.assertEqual(result.formatted, 'b')
self.assertIsInstance(result, formatting.FormattedItem)
def execute(self, args):
manager = SoftLayer.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 = formatting.Table([
'id',
'datacenter',
'host',
'cores',
'memory',
'primary_ip',
'backend_ip',
'active_transaction',
'owner'
])
table.sortby = args.get('--sortby') or 'host'
for server in servers:
server = utils.NestedDict(server)
user = None
if 'billingItem' in server:
if 'orderItem' in server['billingItem']:
user = (server['billingItem']['orderItem']['order']
['userRecord']['username'])
table.add_row([
server['id'],
server['datacenter']['name'] or formatting.blank(),
server['fullyQualifiedDomainName'],
server['processorPhysicalCoreAmount'],
formatting.gb(server['memoryCapacity'] or 0),
server['primaryIpAddress'] or formatting.blank(),
server['primaryBackendIpAddress'] or formatting.blank(),
formatting.active_txn(server),
user or formatting.blank(),
])
return table
def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network,
hourly, monthly, tags, columns):
"""List virtual servers."""
vsi = SoftLayer.VSManager(env.client)
columns_clean = [col.strip() for col in columns.split(',')]
tag_list = None
if tags:
tag_list = [tag.strip() for tag in tags.split(',')]
guests = vsi.list_instances(hourly=hourly,
monthly=monthly,
hostname=hostname,
domain=domain,
cpus=cpu,
memory=memory,
datacenter=datacenter,
nic_speed=network,
tags=tag_list)
table = formatting.Table(columns_clean)
table.sortby = sortby
column_map = {}
column_map['guid'] = 'globalIdentifier'
column_map['primary_ip'] = 'primaryIpAddress'
column_map['backend_ip'] = 'primaryBackendIpAddress'
column_map['datacenter'] = 'datacenter-name'
column_map['action'] = 'formatted-action'
column_map['powerState'] = 'powerState-name'
for guest in guests:
guest = utils.NestedDict(guest)
guest['datacenter-name'] = guest['datacenter']['name']
guest['formatted-action'] = formatting.active_txn(guest)
guest['powerState-name'] = guest['powerState']['name']
row_column = []
for col in columns_clean:
entry = None
if col in column_map:
entry = guest[column_map[col]]
else:
entry = guest[col]
row_column.append(entry or formatting.blank())
table.add_row(row_column)
return table
def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network,
hourly, monthly, tags, columns):
"""List virtual servers."""
vsi = SoftLayer.VSManager(env.client)
columns_clean = [col.strip() for col in columns.split(',')]
tag_list = None
if tags:
tag_list = [tag.strip() for tag in tags.split(',')]
guests = vsi.list_instances(hourly=hourly,
monthly=monthly,
hostname=hostname,
domain=domain,
cpus=cpu,
memory=memory,
datacenter=datacenter,
nic_speed=network,
tags=tag_list)
table = formatting.Table(columns_clean)
table.sortby = sortby
column_map = {}
column_map['guid'] = 'globalIdentifier'
column_map['primary_ip'] = 'primaryIpAddress'
column_map['backend_ip'] = 'primaryBackendIpAddress'
column_map['datacenter'] = 'datacenter-name'
column_map['action'] = 'formatted-action'
column_map['powerState'] = 'powerState-name'
for guest in guests:
guest = utils.NestedDict(guest)
guest['datacenter-name'] = guest['datacenter']['name']
guest['formatted-action'] = formatting.active_txn(guest)
guest['powerState-name'] = guest['powerState']['name']
row_column = []
for col in columns_clean:
entry = None
if col in column_map:
entry = guest[column_map[col]]
else:
entry = guest[col]
row_column.append(entry or formatting.blank())
table.add_row(row_column)
return table
def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network, tag):
"""List hardware servers."""
manager = SoftLayer.HardwareManager(env.client)
servers = manager.list_hardware(
hostname=hostname,
domain=domain,
cpus=cpu,
memory=memory,
datacenter=datacenter,
nic_speed=network,
tags=tag)
table = formatting.Table([
'id',
'datacenter',
'host',
'cores',
'memory',
'primary_ip',
'backend_ip',
'active_transaction',
'owner'
])
table.sortby = sortby
for server in servers:
server = utils.NestedDict(server)
table.add_row([
server['id'],
server['datacenter']['name'] or formatting.blank(),
server['fullyQualifiedDomainName'],
server['processorPhysicalCoreAmount'],
formatting.gb(server['memoryCapacity'] or 0),
server['primaryIpAddress'] or formatting.blank(),
server['primaryBackendIpAddress'] or formatting.blank(),
formatting.active_txn(server),
utils.lookup(
server, 'billingItem', 'orderItem', 'order', 'userRecord',
'username') or formatting.blank(),
])
return table
def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network, tag,
columns):
"""List hardware servers."""
manager = SoftLayer.HardwareManager(env.client)
columns_clean = [col.strip() for col in columns.split(',')]
servers = manager.list_hardware(hostname=hostname,
domain=domain,
cpus=cpu,
memory=memory,
datacenter=datacenter,
nic_speed=network,
tags=tag)
table = formatting.Table(columns_clean)
table.sortby = sortby
column_map = {}
column_map['guid'] = 'globalIdentifier'
column_map['primary_ip'] = 'primaryIpAddress'
column_map['backend_ip'] = 'primaryBackendIpAddress'
column_map['datacenter'] = 'datacenter-name'
column_map['action'] = 'formatted-action'
column_map['powerState'] = 'powerState-name'
for server in servers:
server = utils.NestedDict(server)
server['datacenter-name'] = server['datacenter']['name']
server['formatted-action'] = formatting.active_txn(server)
server['powerState-name'] = server['powerState']['name']
row_column = []
for col in columns_clean:
entry = None
if col in column_map:
entry = server[column_map[col]]
else:
entry = server[col]
row_column.append(entry or formatting.blank())
table.add_row(row_column)
return table
def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network,
hourly, monthly, tags):
"""List virtual servers."""
vsi = SoftLayer.VSManager(env.client)
tag_list = None
if tags:
tag_list = [tag.strip() for tag in tags.split(',')]
guests = vsi.list_instances(hourly=hourly,
monthly=monthly,
hostname=hostname,
domain=domain,
cpus=cpu,
memory=memory,
datacenter=datacenter,
nic_speed=network,
tags=tag_list)
table = formatting.Table([
'id', 'datacenter', 'host', 'cores', 'memory', 'primary_ip',
'backend_ip', 'active_transaction', 'owner'
])
table.sortby = sortby or 'host'
for guest in guests:
guest = utils.NestedDict(guest)
table.add_row([
guest['id'],
guest['datacenter']['name'] or formatting.blank(),
guest['fullyQualifiedDomainName'],
guest['maxCpu'],
formatting.mb_to_gb(guest['maxMemory']),
guest['primaryIpAddress'] or formatting.blank(),
guest['primaryBackendIpAddress'] or formatting.blank(),
formatting.active_txn(guest),
utils.lookup(guest, 'billingItem', 'orderItem', 'order',
'userRecord', 'username') or formatting.blank(),
])
return table
def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network,
hourly, monthly, tags):
"""List virtual servers."""
vsi = SoftLayer.VSManager(env.client)
tag_list = None
if tags:
tag_list = [tag.strip() for tag in tags.split(',')]
guests = vsi.list_instances(hourly=hourly,
monthly=monthly,
hostname=hostname,
domain=domain,
cpus=cpu,
memory=memory,
datacenter=datacenter,
nic_speed=network,
tags=tag_list)
table = formatting.Table([
'id',
'hostname',
'primary_ip',
'backend_ip',
'datacenter',
'action',
])
table.sortby = sortby or 'hostname'
for guest in guests:
table.add_row([
utils.lookup(guest, 'id'),
utils.lookup(guest, 'hostname') or formatting.blank(),
utils.lookup(guest, 'primaryIpAddress') or formatting.blank(),
utils.lookup(guest, 'primaryBackendIpAddress') or
formatting.blank(),
utils.lookup(guest, 'datacenter', 'name') or formatting.blank(),
formatting.active_txn(guest),
])
return table
def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network,
hourly, monthly, tags):
"""List virtual servers."""
vsi = SoftLayer.VSManager(env.client)
tag_list = None
if tags:
tag_list = [tag.strip() for tag in tags.split(',')]
guests = vsi.list_instances(hourly=hourly,
monthly=monthly,
hostname=hostname,
domain=domain,
cpus=cpu,
memory=memory,
datacenter=datacenter,
nic_speed=network,
tags=tag_list)
table = formatting.Table([
'guid',
'hostname',
'primary_ip',
'backend_ip',
'datacenter',
'action',
])
table.sortby = sortby or 'hostname'
for guest in guests:
guest = utils.NestedDict(guest)
table.add_row([
guest['globalIdentifier'] or guest['id'],
guest['hostname'],
guest['primaryIpAddress'] or formatting.blank(),
guest['primaryBackendIpAddress'] or formatting.blank(),
guest['datacenter']['name'] or formatting.blank(),
formatting.active_txn(guest),
])
return table
def cli(env, identifier):
"""View details of a placement group.
IDENTIFIER can be either the Name or Id of the placement group you want to view
"""
manager = PlacementManager(env.client)
group_id = helpers.resolve_id(manager.resolve_ids, identifier, 'placement_group')
result = manager.get_object(group_id)
table = formatting.Table(["Id", "Name", "Backend Router", "Rule", "Created"])
table.add_row([
result['id'],
result['name'],
result['backendRouter']['hostname'],
result['rule']['name'],
result['createDate']
])
guest_table = formatting.Table([
"Id",
"FQDN",
"Primary IP",
"Backend IP",
"CPU",
"Memory",
"Provisioned",
"Transaction"
])
for guest in result['guests']:
guest_table.add_row([
guest.get('id'),
guest.get('fullyQualifiedDomainName'),
guest.get('primaryIpAddress'),
guest.get('primaryBackendIpAddress'),
guest.get('maxCpu'),
guest.get('maxMemory'),
guest.get('provisionDate'),
formatting.active_txn(guest)
])
env.fout(table)
env.fout(guest_table)
def execute(self, args):
vsi = SoftLayer.VSManager(self.client)
tags = None
if args.get('--tags'):
tags = [tag.strip() for tag in args.get('--tags').split(',')]
guests = vsi.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)
table = formatting.Table([
'id', 'datacenter', 'host',
'cores', 'memory', 'primary_ip',
'backend_ip', 'active_transaction', 'owner'
])
table.sortby = args.get('--sortby') or 'host'
for guest in guests:
guest = utils.NestedDict(guest)
table.add_row([
guest['id'],
guest['datacenter']['name'] or formatting.blank(),
guest['fullyQualifiedDomainName'],
guest['maxCpu'],
formatting.mb_to_gb(guest['maxMemory']),
guest['primaryIpAddress'] or formatting.blank(),
guest['primaryBackendIpAddress'] or formatting.blank(),
formatting.active_txn(guest),
utils.lookup(guest, 'billingItem', 'orderItem', 'order',
'userRecord', 'username') or formatting.blank(),
])
return table
def execute(self, args):
vsi = SoftLayer.VSManager(self.client)
tags = None
if args.get('--tags'):
tags = [tag.strip() for tag in args.get('--tags').split(',')]
guests = vsi.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)
table = formatting.Table([
'id', 'datacenter', 'host',
'cores', 'memory', 'primary_ip',
'backend_ip', 'active_transaction', 'owner'
])
table.sortby = args.get('--sortby') or 'host'
for guest in guests:
guest = utils.NestedDict(guest)
table.add_row([
guest['id'],
guest['datacenter']['name'] or formatting.blank(),
guest['fullyQualifiedDomainName'],
guest['maxCpu'],
formatting.mb_to_gb(guest['maxMemory']),
guest['primaryIpAddress'] or formatting.blank(),
guest['primaryBackendIpAddress'] or formatting.blank(),
formatting.active_txn(guest),
guest['billingItem']['orderItem']['order']
['userRecord']['username'] or formatting.blank(),
])
return table
def execute(self, args):
manager = SoftLayer.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 = formatting.Table([
'id', 'datacenter', 'host', 'cores', 'memory', 'primary_ip',
'backend_ip', 'active_transaction', 'owner'
])
table.sortby = args.get('--sortby') or 'host'
for server in servers:
server = utils.NestedDict(server)
table.add_row([
server['id'],
server['datacenter']['name'] or formatting.blank(),
server['fullyQualifiedDomainName'],
server['processorPhysicalCoreAmount'],
formatting.gb(server['memoryCapacity'] or 0),
server['primaryIpAddress'] or formatting.blank(),
server['primaryBackendIpAddress'] or formatting.blank(),
formatting.active_txn(server),
utils.lookup(server, 'billingItem', 'orderItem', 'order',
'userRecord', 'username') or formatting.blank(),
])
return table
def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network, tag):
"""List hardware servers."""
manager = SoftLayer.HardwareManager(env.client)
servers = manager.list_hardware(hostname=hostname,
domain=domain,
cpus=cpu,
memory=memory,
datacenter=datacenter,
nic_speed=network,
tags=tag)
table = formatting.Table([
'guid',
'hostname',
'primary_ip',
'backend_ip',
'datacenter',
'action',
])
table.sortby = sortby or 'hostname'
for server in servers:
server = utils.NestedDict(server)
# NOTE(kmcdonald): There are cases where a server might not have a
# globalIdentifier.
table.add_row([
server['globalIdentifier'] or server['id'],
server['hostname'],
server['primaryIpAddress'] or formatting.blank(),
server['primaryBackendIpAddress'] or formatting.blank(),
server['datacenter']['name'] or formatting.blank(),
formatting.active_txn(server),
])
return table
def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network, tag):
"""List hardware servers."""
manager = SoftLayer.HardwareManager(env.client)
servers = manager.list_hardware(hostname=hostname,
domain=domain,
cpus=cpu,
memory=memory,
datacenter=datacenter,
nic_speed=network,
tags=tag)
table = formatting.Table([
'guid',
'hostname',
'primary_ip',
'backend_ip',
'datacenter',
'action',
])
table.sortby = sortby or 'hostname'
for server in servers:
server = utils.NestedDict(server)
# NOTE(kmcdonald): There are cases where a server might not have a
# globalIdentifier.
table.add_row([
server['globalIdentifier'] or server['id'],
server['hostname'],
server['primaryIpAddress'] or formatting.blank(),
server['primaryBackendIpAddress'] or formatting.blank(),
server['datacenter']['name'] or formatting.blank(),
formatting.active_txn(server),
])
return table
def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network, tag):
"""List hardware servers."""
manager = SoftLayer.HardwareManager(env.client)
servers = manager.list_hardware(hostname=hostname,
domain=domain,
cpus=cpu,
memory=memory,
datacenter=datacenter,
nic_speed=network,
tags=tag)
table = formatting.Table([
'id', 'datacenter', 'host', 'cores', 'memory', 'primary_ip',
'backend_ip', 'active_transaction', 'owner'
])
table.sortby = sortby
for server in servers:
server = utils.NestedDict(server)
table.add_row([
server['id'],
server['datacenter']['name'] or formatting.blank(),
server['fullyQualifiedDomainName'],
server['processorPhysicalCoreAmount'],
formatting.gb(server['memoryCapacity'] or 0),
server['primaryIpAddress'] or formatting.blank(),
server['primaryBackendIpAddress'] or formatting.blank(),
formatting.active_txn(server),
utils.lookup(server, 'billingItem', 'orderItem', 'order',
'userRecord', 'username') or formatting.blank(),
])
return table
import SoftLayer
from SoftLayer.CLI import columns as column_helper
from SoftLayer.CLI import environment
from SoftLayer.CLI import formatting
from SoftLayer.CLI import helpers
import click
# pylint: disable=unnecessary-lambda
COLUMN_MAP = {
'guid': ('globalIdentifier',),
'primary_ip': ('primaryIpAddress',),
'backend_ip': ('primaryBackendIpAddress',),
'datacenter': ('datacenter', 'name'),
'action': lambda guest: formatting.active_txn(guest),
'power_state': ('powerState', 'name'),
}
@click.command()
@click.option('--sortby', help='Column to sort by', default='hostname')
@click.option('--cpu', '-c', help='Number of CPU cores', type=click.INT)
@click.option('--domain', '-D', help='Domain portion of the FQDN')
@click.option('--datacenter', '-d', help='Datacenter shortname')
@click.option('--hostname', '-H', help='Host portion of the FQDN')
@click.option('--memory', '-m', help='Memory in mebibytes', type=click.INT)
@click.option('--network', '-n', help='Network port speed in Mbps')
@click.option('--hourly', is_flag=True, help='Show only hourly instances')
@click.option('--monthly', is_flag=True, help='Show only monthly instances')
@helpers.multi_option('--tag', help='Filter by tags')
def cli(env, identifier, passwords=False, price=False):
"""Get details for a virtual server."""
vsi = SoftLayer.VSManager(env.client)
table = formatting.KeyValueTable(['Name', 'Value'])
table.align['Name'] = 'r'
table.align['Value'] = 'l'
vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS')
result = vsi.get_instance(vs_id)
result = utils.NestedDict(result)
table.add_row(['id', result['id']])
table.add_row(['guid', result['globalIdentifier']])
table.add_row(['hostname', result['hostname']])
table.add_row(['domain', result['domain']])
table.add_row(['fqdn', result['fullyQualifiedDomainName']])
table.add_row(['status', formatting.FormattedItem(
result['status']['keyName'] or formatting.blank(),
result['status']['name'] or formatting.blank()
)])
table.add_row(['state', formatting.FormattedItem(
utils.lookup(result, 'powerState', 'keyName'),
utils.lookup(result, 'powerState', 'name'),
)])
table.add_row(['active_transaction', formatting.active_txn(result)])
table.add_row(['datacenter',
result['datacenter']['name'] or formatting.blank()])
operating_system = utils.lookup(result,
'operatingSystem',
'softwareLicense',
'softwareDescription') or {}
table.add_row([
'os',
formatting.FormattedItem(
operating_system.get('version') or formatting.blank(),
operating_system.get('name') or formatting.blank()
)])
table.add_row(['os_version',
operating_system.get('version') or formatting.blank()])
table.add_row(['cores', result['maxCpu']])
table.add_row(['memory', formatting.mb_to_gb(result['maxMemory'])])
table.add_row(['public_ip',
result['primaryIpAddress'] or formatting.blank()])
table.add_row(['private_ip',
result['primaryBackendIpAddress'] or formatting.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']])
if utils.lookup(result, 'billingItem') != []:
table.add_row(['owner', formatting.FormattedItem(
utils.lookup(result, 'billingItem', 'orderItem',
'order', 'userRecord',
'username') or formatting.blank(),
)])
else:
table.add_row(['owner', formatting.blank()])
vlan_table = formatting.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 price:
table.add_row(['price rate',
result['billingItem']['recurringFee']])
if passwords:
pass_table = formatting.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_detail in result['tagReferences']:
tag = utils.lookup(tag_detail, 'tag', 'name')
if tag is not None:
tag_row.append(tag)
if tag_row:
table.add_row(['tags', formatting.listing(tag_row, separator=', ')])
# Test to see if this actually has a primary (public) ip address
try:
if not result['privateNetworkOnlyFlag']:
ptr_domains = env.client.call(
'Virtual_Guest', 'getReverseDomainRecords',
id=vs_id,
)
for ptr_domain in ptr_domains:
for ptr in ptr_domain['resourceRecords']:
table.add_row(['ptr', ptr['data']])
except SoftLayer.SoftLayerAPIError:
pass
env.fout(table)
import SoftLayer
from SoftLayer.CLI import columns as column_helper
from SoftLayer.CLI import environment
from SoftLayer.CLI import formatting
from SoftLayer.CLI import helpers
# pylint: disable=unnecessary-lambda
COLUMNS = [
column_helper.Column('guid', ('globalIdentifier', )),
column_helper.Column('primary_ip', ('primaryIpAddress', )),
column_helper.Column('backend_ip', ('primaryBackendIpAddress', )),
column_helper.Column('datacenter', ('datacenter', 'name')),
column_helper.Column('action',
lambda guest: formatting.active_txn(guest),
mask='''
activeTransaction[
id,transactionStatus[name,friendlyName]
]'''),
column_helper.Column('power_state', ('powerState', 'name')),
column_helper.Column(
'created_by',
('billingItem', 'orderItem', 'order', 'userRecord', 'username')),
column_helper.Column(
'tags',
lambda server: formatting.tags(server.get('tagReferences')),
mask="tagReferences.tag.name"),
]
DEFAULT_COLUMNS = [
def cli(env, identifier, passwords=False, price=False):
"""Get details for a virtual server."""
vsi = SoftLayer.VSManager(env.client)
table = formatting.KeyValueTable(["name", "value"])
table.align["name"] = "r"
table.align["value"] = "l"
vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, "VS")
result = vsi.get_instance(vs_id)
result = utils.NestedDict(result)
table.add_row(["id", result["id"]])
table.add_row(["guid", result["globalIdentifier"]])
table.add_row(["hostname", result["hostname"]])
table.add_row(["domain", result["domain"]])
table.add_row(["fqdn", result["fullyQualifiedDomainName"]])
table.add_row(
[
"status",
formatting.FormattedItem(
result["status"]["keyName"] or formatting.blank(), result["status"]["name"] or formatting.blank()
),
]
)
table.add_row(
[
"state",
formatting.FormattedItem(
utils.lookup(result, "powerState", "keyName"), utils.lookup(result, "powerState", "name")
),
]
)
table.add_row(["active_transaction", formatting.active_txn(result)])
table.add_row(["datacenter", result["datacenter"]["name"] or formatting.blank()])
operating_system = utils.lookup(result, "operatingSystem", "softwareLicense", "softwareDescription") or {}
table.add_row(
[
"os",
formatting.FormattedItem(
operating_system.get("version") or formatting.blank(),
operating_system.get("name") or formatting.blank(),
),
]
)
table.add_row(["os_version", operating_system.get("version") or formatting.blank()])
table.add_row(["cores", result["maxCpu"]])
table.add_row(["memory", formatting.mb_to_gb(result["maxMemory"])])
table.add_row(["public_ip", result["primaryIpAddress"] or formatting.blank()])
table.add_row(["private_ip", result["primaryBackendIpAddress"] or formatting.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"]])
if utils.lookup(result, "billingItem") != []:
table.add_row(
[
"owner",
formatting.FormattedItem(
utils.lookup(result, "billingItem", "orderItem", "order", "userRecord", "username")
or formatting.blank()
),
]
)
else:
table.add_row(["owner", formatting.blank()])
vlan_table = formatting.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 price:
table.add_row(["price rate", result["billingItem"]["recurringFee"]])
if passwords:
pass_table = formatting.Table(["software", "username", "password"])
for component in result["softwareComponents"]:
for item in component["passwords"]:
pass_table.add_row(
[
utils.lookup(component, "softwareLicense", "softwareDescription", "name"),
item["username"],
item["password"],
]
)
table.add_row(["users", pass_table])
table.add_row(["tags", formatting.tags(result["tagReferences"])])
# Test to see if this actually has a primary (public) ip address
try:
if not result["privateNetworkOnlyFlag"]:
ptr_domains = env.client.call("Virtual_Guest", "getReverseDomainRecords", id=vs_id)
for ptr_domain in ptr_domains:
for ptr in ptr_domain["resourceRecords"]:
table.add_row(["ptr", ptr["data"]])
except SoftLayer.SoftLayerAPIError:
pass
env.fout(table)
def execute(self, args):
vsi = SoftLayer.VSManager(self.client)
table = formatting.KeyValueTable(['Name', 'Value'])
table.align['Name'] = 'r'
table.align['Value'] = 'l'
vs_id = helpers.resolve_id(vsi.resolve_ids, args.get('<identifier>'),
'VS')
result = vsi.get_instance(vs_id)
result = utils.NestedDict(result)
table.add_row(['id', result['id']])
table.add_row(['hostname', result['fullyQualifiedDomainName']])
table.add_row([
'status',
formatting.FormattedItem(
result['status']['keyName'] or formatting.blank(),
result['status']['name'] or formatting.blank())
])
table.add_row(['active_transaction', formatting.active_txn(result)])
table.add_row([
'state',
formatting.FormattedItem(
utils.lookup(result, 'powerState', 'keyName'),
utils.lookup(result, 'powerState', 'name'),
)
])
table.add_row(
['datacenter', result['datacenter']['name'] or formatting.blank()])
operating_system = utils.lookup(result, 'operatingSystem',
'softwareLicense',
'softwareDescription') or {}
table.add_row([
'os',
formatting.FormattedItem(
operating_system.get('version') or formatting.blank(),
operating_system.get('name') or formatting.blank())
])
table.add_row([
'os_version',
operating_system.get('version') or formatting.blank()
])
table.add_row(['cores', result['maxCpu']])
table.add_row(['memory', formatting.mb_to_gb(result['maxMemory'])])
table.add_row(
['public_ip', result['primaryIpAddress'] or formatting.blank()])
table.add_row([
'private_ip', result['primaryBackendIpAddress']
or formatting.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']])
table.add_row([
'owner',
formatting.FormattedItem(
utils.lookup(result, 'billingItem', 'orderItem', 'order',
'userRecord', 'username') or formatting.blank(), )
])
vlan_table = formatting.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 = formatting.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', formatting.listing(tag_row, separator=',')])
# Test to see if this actually has a primary (public) ip address
if result['primaryIpAddress']:
ptr_domains = (
self.client['Virtual_Guest'].getReverseDomainRecords(id=vs_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):
vsi = SoftLayer.VSManager(self.client)
table = formatting.KeyValueTable(['Name', 'Value'])
table.align['Name'] = 'r'
table.align['Value'] = 'l'
vs_id = helpers.resolve_id(vsi.resolve_ids,
args.get('<identifier>'),
'VS')
result = vsi.get_instance(vs_id)
result = utils.NestedDict(result)
table.add_row(['id', result['id']])
table.add_row(['hostname', result['fullyQualifiedDomainName']])
table.add_row(['status', formatting.FormattedItem(
result['status']['keyName'] or formatting.blank(),
result['status']['name'] or formatting.blank()
)])
table.add_row(['active_transaction', formatting.active_txn(result)])
table.add_row(['state', formatting.FormattedItem(
utils.lookup(result, 'powerState', 'keyName'),
utils.lookup(result, 'powerState', 'name'),
)])
table.add_row(['datacenter',
result['datacenter']['name'] or formatting.blank()])
operating_system = utils.lookup(result,
'operatingSystem',
'softwareLicense',
'softwareDescription') or {}
table.add_row([
'os',
formatting.FormattedItem(
operating_system.get('version') or formatting.blank(),
operating_system.get('name') or formatting.blank()
)])
table.add_row(['os_version',
operating_system.get('version') or formatting.blank()])
table.add_row(['cores', result['maxCpu']])
table.add_row(['memory', formatting.mb_to_gb(result['maxMemory'])])
table.add_row(['public_ip',
result['primaryIpAddress'] or formatting.blank()])
table.add_row(['private_ip',
result['primaryBackendIpAddress']
or formatting.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']])
table.add_row(['owner', FormattedItem(
lookup(result, 'billingItem', 'orderItem',
'order', 'userRecord', 'username'),
)])
vlan_table = formatting.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 = formatting.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', formatting.listing(tag_row, separator=',')])
# Test to see if this actually has a primary (public) ip address
if result['primaryIpAddress']:
ptr_domains = (self.client['Virtual_Guest']
.getReverseDomainRecords(id=vs_id))
for ptr_domain in ptr_domains:
for ptr in ptr_domain['resourceRecords']:
table.add_row(['ptr', ptr['data']])
return table
import SoftLayer
from SoftLayer.CLI import columns as column_helper
from SoftLayer.CLI import environment
from SoftLayer.CLI import formatting
from SoftLayer.CLI import helpers
import click
# pylint: disable=unnecessary-lambda
COLUMN_MAP = {
"guid": ("globalIdentifier",),
"primary_ip": ("primaryIpAddress",),
"backend_ip": ("primaryBackendIpAddress",),
"datacenter": ("datacenter", "name"),
"action": lambda server: formatting.active_txn(server),
"power_state": ("powerState", "name"),
}
@click.command()
@click.option("--sortby", help="Column to sort by", default="hostname")
@click.option("--cpu", "-c", help="Filter by number of CPU cores")
@click.option("--domain", "-D", help="Filter by domain")
@click.option("--datacenter", "-d", help="Filter by datacenter")
@click.option("--hostname", "-H", help="Filter by hostname")
@click.option("--memory", "-m", help="Filter by memory in gigabytes")
@click.option("--network", "-n", help="Filter by network port speed in Mbps")
@helpers.multi_option("--tag", help="Filter by tags")
@click.option(
"--columns",
import SoftLayer
from SoftLayer.CLI import columns as column_helper
from SoftLayer.CLI import environment
from SoftLayer.CLI import formatting
from SoftLayer.CLI import helpers
# pylint: disable=unnecessary-lambda
COLUMNS = [
column_helper.Column('guid', ('globalIdentifier',)),
column_helper.Column('primary_ip', ('primaryIpAddress',)),
column_helper.Column('backend_ip', ('primaryBackendIpAddress',)),
column_helper.Column('datacenter', ('datacenter', 'name')),
column_helper.Column('action', lambda guest: formatting.active_txn(guest),
mask='''
activeTransaction[
id,transactionStatus[name,friendlyName]
]'''),
column_helper.Column('power_state', ('powerState', 'name')),
column_helper.Column(
'created_by',
('billingItem', 'orderItem', 'order', 'userRecord', 'username')),
column_helper.Column(
'tags',
lambda server: formatting.tags(server.get('tagReferences')),
mask="tagReferences.tag.name"),
]
DEFAULT_COLUMNS = [
def test_active_txn_empty(self):
result = formatting.active_txn({})
self.assertEqual(str(result), 'NULL')
def cli(env, identifier, passwords=False, price=False):
"""Get details for a virtual server."""
vsi = SoftLayer.VSManager(env.client)
table = formatting.KeyValueTable(['name', 'value'])
table.align['name'] = 'r'
table.align['value'] = 'l'
vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS')
result = vsi.get_instance(vs_id)
result = utils.NestedDict(result)
table.add_row(['id', result['id']])
table.add_row(['guid', result['globalIdentifier']])
table.add_row(['hostname', result['hostname']])
table.add_row(['domain', result['domain']])
table.add_row(['fqdn', result['fullyQualifiedDomainName']])
table.add_row([
'status',
formatting.FormattedItem(
result['status']['keyName'] or formatting.blank(),
result['status']['name'] or formatting.blank())
])
table.add_row([
'state',
formatting.FormattedItem(
utils.lookup(result, 'powerState', 'keyName'),
utils.lookup(result, 'powerState', 'name'),
)
])
table.add_row(['active_transaction', formatting.active_txn(result)])
table.add_row(
['datacenter', result['datacenter']['name'] or formatting.blank()])
operating_system = utils.lookup(result, 'operatingSystem',
'softwareLicense',
'softwareDescription') or {}
table.add_row(['os', operating_system.get('name') or formatting.blank()])
table.add_row(
['os_version',
operating_system.get('version') or formatting.blank()])
table.add_row(['cores', result['maxCpu']])
table.add_row(['memory', formatting.mb_to_gb(result['maxMemory'])])
table.add_row(
['public_ip', result['primaryIpAddress'] or formatting.blank()])
table.add_row([
'private_ip', result['primaryBackendIpAddress'] or formatting.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']])
if utils.lookup(result, 'billingItem') != []:
table.add_row([
'owner',
formatting.FormattedItem(
utils.lookup(result, 'billingItem', 'orderItem', 'order',
'userRecord', 'username') or formatting.blank(), )
])
else:
table.add_row(['owner', formatting.blank()])
vlan_table = formatting.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('networkComponents'):
secgroup_table = formatting.Table(['interface', 'id', 'name'])
has_secgroups = False
for comp in result.get('networkComponents'):
interface = 'PRIVATE' if comp['port'] == 0 else 'PUBLIC'
for binding in comp['securityGroupBindings']:
has_secgroups = True
secgroup = binding['securityGroup']
secgroup_table.add_row([
interface, secgroup['id'],
secgroup.get('name') or formatting.blank()
])
if has_secgroups:
table.add_row(['security_groups', secgroup_table])
if result.get('notes'):
table.add_row(['notes', result['notes']])
if price:
total_price = utils.lookup(result, 'billingItem',
'nextInvoiceTotalRecurringAmount') or 0
total_price += sum(
p['nextInvoiceTotalRecurringAmount']
for p in utils.lookup(result, 'billingItem', 'children') or [])
table.add_row(['price_rate', total_price])
if passwords:
pass_table = formatting.Table(['software', 'username', 'password'])
for component in result['softwareComponents']:
for item in component['passwords']:
pass_table.add_row([
utils.lookup(component, 'softwareLicense',
'softwareDescription', 'name'),
item['username'],
item['password'],
])
table.add_row(['users', pass_table])
table.add_row(['tags', formatting.tags(result['tagReferences'])])
# Test to see if this actually has a primary (public) ip address
try:
if not result['privateNetworkOnlyFlag']:
ptr_domains = env.client.call(
'Virtual_Guest',
'getReverseDomainRecords',
id=vs_id,
)
for ptr_domain in ptr_domains:
for ptr in ptr_domain['resourceRecords']:
table.add_row(['ptr', ptr['data']])
except SoftLayer.SoftLayerAPIError:
pass
env.fout(table)
import SoftLayer
from SoftLayer.CLI import columns as column_helper
from SoftLayer.CLI import environment
from SoftLayer.CLI import formatting
from SoftLayer.CLI import helpers
# pylint: disable=unnecessary-lambda
COLUMNS = [
column_helper.Column('guid', ('globalIdentifier',)),
column_helper.Column('primary_ip', ('primaryIpAddress',)),
column_helper.Column('backend_ip', ('primaryBackendIpAddress',)),
column_helper.Column('datacenter', ('datacenter', 'name')),
column_helper.Column('action', lambda guest: formatting.active_txn(guest),
mask='''
activeTransaction[
id,transactionStatus[name,friendlyName]
]'''),
column_helper.Column('power_state', ('powerState', 'name')),
column_helper.Column(
'created_by',
('billingItem', 'orderItem', 'order', 'userRecord', 'username')),
column_helper.Column(
'tags',
lambda server: formatting.tags(server.get('tagReferences')),
mask="tagReferences.tag.name"),
]
DEFAULT_COLUMNS = [
def test_active_txn_empty(self):
result = formatting.active_txn({})
self.assertEqual(str(result), 'NULL')
def cli(env, identifier, passwords=False, price=False):
"""Get details for a virtual server."""
vsi = SoftLayer.VSManager(env.client)
table = formatting.KeyValueTable(['Name', 'Value'])
table.align['Name'] = 'r'
table.align['Value'] = 'l'
vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS')
result = vsi.get_instance(vs_id)
result = utils.NestedDict(result)
table.add_row(['id', result['id']])
table.add_row(['guid', result['globalIdentifier']])
table.add_row(['hostname', result['hostname']])
table.add_row(['domain', result['domain']])
table.add_row(['fqdn', result['fullyQualifiedDomainName']])
table.add_row([
'status',
formatting.FormattedItem(
result['status']['keyName'] or formatting.blank(),
result['status']['name'] or formatting.blank())
])
table.add_row([
'state',
formatting.FormattedItem(
utils.lookup(result, 'powerState', 'keyName'),
utils.lookup(result, 'powerState', 'name'),
)
])
table.add_row(['active_transaction', formatting.active_txn(result)])
table.add_row(
['datacenter', result['datacenter']['name'] or formatting.blank()])
operating_system = utils.lookup(result, 'operatingSystem',
'softwareLicense',
'softwareDescription') or {}
table.add_row([
'os',
formatting.FormattedItem(
operating_system.get('version') or formatting.blank(),
operating_system.get('name') or formatting.blank())
])
table.add_row(
['os_version',
operating_system.get('version') or formatting.blank()])
table.add_row(['cores', result['maxCpu']])
table.add_row(['memory', formatting.mb_to_gb(result['maxMemory'])])
table.add_row(
['public_ip', result['primaryIpAddress'] or formatting.blank()])
table.add_row([
'private_ip', result['primaryBackendIpAddress'] or formatting.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']])
if utils.lookup(result, 'billingItem') != []:
table.add_row([
'owner',
formatting.FormattedItem(
utils.lookup(result, 'billingItem', 'orderItem', 'order',
'userRecord', 'username') or formatting.blank(), )
])
else:
table.add_row(['owner', formatting.blank()])
vlan_table = formatting.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 price:
table.add_row(['price rate', result['billingItem']['recurringFee']])
if passwords:
pass_table = formatting.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_detail in result['tagReferences']:
tag = utils.lookup(tag_detail, 'tag', 'name')
if tag is not None:
tag_row.append(tag)
if tag_row:
table.add_row(['tags', formatting.listing(tag_row, separator=', ')])
# Test to see if this actually has a primary (public) ip address
try:
if not result['privateNetworkOnlyFlag']:
ptr_domains = env.client.call(
'Virtual_Guest',
'getReverseDomainRecords',
id=vs_id,
)
for ptr_domain in ptr_domains:
for ptr in ptr_domain['resourceRecords']:
table.add_row(['ptr', ptr['data']])
except SoftLayer.SoftLayerAPIError:
pass
env.fout(table)
def cli(env, identifier, passwords=False, price=False):
"""Get details for a virtual server."""
vsi = SoftLayer.VSManager(env.client)
table = formatting.KeyValueTable(['name', 'value'])
table.align['name'] = 'r'
table.align['value'] = 'l'
vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS')
result = vsi.get_instance(vs_id)
result = utils.NestedDict(result)
table.add_row(['id', result['id']])
table.add_row(['guid', result['globalIdentifier']])
table.add_row(['hostname', result['hostname']])
table.add_row(['domain', result['domain']])
table.add_row(['fqdn', result['fullyQualifiedDomainName']])
table.add_row(['status', formatting.FormattedItem(
result['status']['keyName'] or formatting.blank(),
result['status']['name'] or formatting.blank()
)])
table.add_row(['state', formatting.FormattedItem(
utils.lookup(result, 'powerState', 'keyName'),
utils.lookup(result, 'powerState', 'name'),
)])
table.add_row(['active_transaction', formatting.active_txn(result)])
table.add_row(['datacenter',
result['datacenter']['name'] or formatting.blank()])
_cli_helper_dedicated_host(env, result, table)
operating_system = utils.lookup(result,
'operatingSystem',
'softwareLicense',
'softwareDescription') or {}
table.add_row(['os', operating_system.get('name') or formatting.blank()])
table.add_row(['os_version',
operating_system.get('version') or formatting.blank()])
table.add_row(['cores', result['maxCpu']])
table.add_row(['memory', formatting.mb_to_gb(result['maxMemory'])])
table.add_row(['public_ip',
result['primaryIpAddress'] or formatting.blank()])
table.add_row(['private_ip',
result['primaryBackendIpAddress'] or formatting.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']])
if utils.lookup(result, 'billingItem') != []:
table.add_row(['owner', formatting.FormattedItem(
utils.lookup(result, 'billingItem', 'orderItem',
'order', 'userRecord',
'username') or formatting.blank(),
)])
else:
table.add_row(['owner', formatting.blank()])
vlan_table = formatting.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('networkComponents'):
secgroup_table = formatting.Table(['interface', 'id', 'name'])
has_secgroups = False
for comp in result.get('networkComponents'):
interface = 'PRIVATE' if comp['port'] == 0 else 'PUBLIC'
for binding in comp['securityGroupBindings']:
has_secgroups = True
secgroup = binding['securityGroup']
secgroup_table.add_row([
interface, secgroup['id'],
secgroup.get('name') or formatting.blank()])
if has_secgroups:
table.add_row(['security_groups', secgroup_table])
if result.get('notes'):
table.add_row(['notes', result['notes']])
if price:
total_price = utils.lookup(result,
'billingItem',
'nextInvoiceTotalRecurringAmount') or 0
total_price += sum(p['nextInvoiceTotalRecurringAmount']
for p
in utils.lookup(result,
'billingItem',
'children') or [])
table.add_row(['price_rate', total_price])
if passwords:
pass_table = formatting.Table(['software', 'username', 'password'])
for component in result['softwareComponents']:
for item in component['passwords']:
pass_table.add_row([
utils.lookup(component,
'softwareLicense',
'softwareDescription',
'name'),
item['username'],
item['password'],
])
table.add_row(['users', pass_table])
table.add_row(['tags', formatting.tags(result['tagReferences'])])
# Test to see if this actually has a primary (public) ip address
try:
if not result['privateNetworkOnlyFlag']:
ptr_domains = env.client.call(
'Virtual_Guest', 'getReverseDomainRecords',
id=vs_id,
)
for ptr_domain in ptr_domains:
for ptr in ptr_domain['resourceRecords']:
table.add_row(['ptr', ptr['data']])
except SoftLayer.SoftLayerAPIError:
pass
env.fout(table)
import SoftLayer
from SoftLayer.CLI import columns as column_helper
from SoftLayer.CLI import environment
from SoftLayer.CLI import formatting
from SoftLayer.CLI import helpers
# pylint: disable=unnecessary-lambda
COLUMNS = [
column_helper.Column('guid', ('globalIdentifier', )),
column_helper.Column('primary_ip', ('primaryIpAddress', )),
column_helper.Column('backend_ip', ('primaryBackendIpAddress', )),
column_helper.Column('datacenter', ('datacenter', 'name')),
column_helper.Column(
'action',
lambda server: formatting.active_txn(server),
mask='activeTransaction[id, transactionStatus[name, friendlyName]]'),
column_helper.Column(
'created_by',
('billingItem', 'orderItem', 'order', 'userRecord', 'username')),
column_helper.Column(
'tags',
lambda server: formatting.tags(server.get('tagReferences')),
mask="tagReferences.tag.name"),
]
DEFAULT_COLUMNS = [
'id',
'hostname',
'primary_ip',
'backend_ip',
def cli(env, identifier, passwords=False, price=False):
"""Get details for a virtual server."""
vsi = SoftLayer.VSManager(env.client)
table = formatting.KeyValueTable(['name', 'value'])
table.align['name'] = 'r'
table.align['value'] = 'l'
vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS')
result = vsi.get_instance(vs_id)
result = utils.NestedDict(result)
local_disks = vsi.get_local_disks(vs_id)
table_local_disks = formatting.Table(['Type', 'Name', 'Capacity'])
for disks in local_disks:
if 'diskImage' in disks:
table_local_disks.add_row([
get_local_type(disks), disks['mountType'],
str(disks['diskImage']['capacity']) + " " +
str(disks['diskImage']['units'])
])
table.add_row(['id', result['id']])
table.add_row(['guid', result['globalIdentifier']])
table.add_row(['hostname', result['hostname']])
table.add_row(['domain', result['domain']])
table.add_row(['fqdn', result['fullyQualifiedDomainName']])
table.add_row([
'status',
formatting.FormattedItem(result['status']['keyName'],
result['status']['name'])
])
table.add_row([
'state',
formatting.FormattedItem(
utils.lookup(result, 'powerState', 'keyName'),
utils.lookup(result, 'powerState', 'name'),
)
])
table.add_row(['active_transaction', formatting.active_txn(result)])
table.add_row(
['datacenter', result['datacenter']['name'] or formatting.blank()])
_cli_helper_dedicated_host(env, result, table)
operating_system = utils.lookup(result, 'operatingSystem',
'softwareLicense',
'softwareDescription') or {}
table.add_row(['os', operating_system.get('name', '-')])
table.add_row(['os_version', operating_system.get('version', '-')])
table.add_row(['cores', result['maxCpu']])
table.add_row(['memory', formatting.mb_to_gb(result['maxMemory'])])
table.add_row(['drives', table_local_disks])
table.add_row(['public_ip', result.get('primaryIpAddress', '-')])
table.add_row(['private_ip', result.get('primaryBackendIpAddress', '-')])
table.add_row(['private_only', result['privateNetworkOnlyFlag']])
table.add_row(['private_cpu', result['dedicatedAccountHostOnlyFlag']])
table.add_row(['transient', result.get('transientGuestFlag', False)])
table.add_row(['created', result['createDate']])
table.add_row(['modified', result['modifyDate']])
table.add_row(_get_owner_row(result))
table.add_row(_get_vlan_table(result))
bandwidth = vsi.get_bandwidth_allocation(vs_id)
table.add_row(['Bandwidth', _bw_table(bandwidth)])
security_table = _get_security_table(result)
if security_table is not None:
table.add_row(['security_groups', security_table])
table.add_row(['notes', result.get('notes', '-')])
if price:
total_price = utils.lookup(result, 'billingItem',
'nextInvoiceTotalRecurringAmount') or 0
total_price += sum(
p['nextInvoiceTotalRecurringAmount']
for p in utils.lookup(result, 'billingItem', 'children') or [])
table.add_row(['price_rate', total_price])
if passwords:
pass_table = formatting.Table(['software', 'username', 'password'])
for component in result['softwareComponents']:
for item in component['passwords']:
pass_table.add_row([
utils.lookup(component, 'softwareLicense',
'softwareDescription', 'name'),
item['username'],
item['password'],
])
table.add_row(['users', pass_table])
table.add_row(['tags', formatting.tags(result['tagReferences'])])
# Test to see if this actually has a primary (public) ip address
try:
if not result['privateNetworkOnlyFlag']:
ptr_domains = env.client.call(
'Virtual_Guest',
'getReverseDomainRecords',
id=vs_id,
)
for ptr_domain in ptr_domains:
for ptr in ptr_domain['resourceRecords']:
table.add_row(['ptr', ptr['data']])
except SoftLayer.SoftLayerAPIError:
pass
env.fout(table)
def test_active_txn(self):
result = formatting.active_txn({"activeTransaction": {"transactionStatus": {"name": "a", "friendlyName": "b"}}})
self.assertEqual(result.original, "a")
self.assertEqual(result.formatted, "b")
self.assertIsInstance(result, formatting.FormattedItem)
