Skip to content

refactor vsi create-option #1337

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
allmightyspiff merged 4 commits into from
Sep 17, 2020
Merged

refactor vsi create-option #1337

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
93356bb
refactor vsi create-option
Sep 1, 2020
7669134
fix the Christopher code review
Sep 10, 2020
f4af694
fix tox tool and fix unit test
Sep 15, 2020
9599d22
fix tox tool and fix unit test
Sep 15, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
275 changes: 77 additions & 198 deletions SoftLayer/CLI/virt/create_options.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,213 +6,92 @@
import SoftLayer
from SoftLayer.CLI import environment
from SoftLayer.CLI import formatting
from SoftLayer import utils


@click.command(short_help="Get options to use for creating virtual servers.")
@click.option('--vsi-type', required=False, show_default=True, default='PUBLIC_CLOUD_SERVER',
type=click.Choice(['TRANSIENT_CLOUD_SERVER', 'SUSPEND_CLOUD_SERVER', 'PUBLIC_CLOUD_SERVER']),
help="Display options for a specific virtual server packages, for default is PUBLIC_CLOUD_SERVER, "
"choose between TRANSIENT_CLOUD_SERVER, SUSPEND_CLOUD_SERVER, PUBLIC_CLOUD_SERVER")
@environment.pass_env
def cli(env):
def cli(env, vsi_type):
"""Virtual server order options."""

vsi = SoftLayer.VSManager(env.client)
options = vsi.get_create_options()

tables = [
_get_datacenter_table(options),
_get_flavors_table(options),
_get_cpu_table(options),
_get_memory_table(options),
_get_os_table(options),
_get_disk_table(options),
_get_network_table(options),
]

env.fout(formatting.listing(tables, separator='\n'))
options = vsi.get_create_options(vsi_type)

tables = []

def _get_datacenter_table(create_options):
datacenters = [dc['template']['datacenter']['name']
for dc in create_options['datacenters']]
# Datacenters
dc_table = formatting.Table(['datacenter', 'Value'], title="Datacenters")
dc_table.sortby = 'Value'
dc_table.align = 'l'

datacenters = sorted(datacenters)
for location in options['locations']:
dc_table.add_row([location['name'], location['key']])
tables.append(dc_table)

dc_table = formatting.Table(['datacenter'], title='Datacenters')
dc_table.sortby = 'datacenter'
dc_table.align = 'l'
for datacenter in datacenters:
dc_table.add_row([datacenter])
return dc_table


def _get_flavors_table(create_options):
flavor_table = formatting.Table(['flavor', 'value'], title='Flavors')
flavor_table.sortby = 'flavor'
flavor_table.align = 'l'
grouping = {
'balanced': {'key_starts_with': 'B1', 'flavors': []},
'balanced local - hdd': {'key_starts_with': 'BL1', 'flavors': []},
'balanced local - ssd': {'key_starts_with': 'BL2', 'flavors': []},
'compute': {'key_starts_with': 'C1', 'flavors': []},
'memory': {'key_starts_with': 'M1', 'flavors': []},
'GPU': {'key_starts_with': 'AC', 'flavors': []},
'transient': {'transient': True, 'flavors': []},
}

if create_options.get('flavors', None) is None:
return flavor_table

for flavor_option in create_options['flavors']:
flavor_key_name = utils.lookup(flavor_option, 'flavor', 'keyName')

for name, group in grouping.items():
if utils.lookup(flavor_option, 'template', 'transientGuestFlag') is True:
if utils.lookup(group, 'transient') is True:
group['flavors'].append(flavor_key_name)
break

elif utils.lookup(group, 'key_starts_with') is not None \
and flavor_key_name.startswith(group['key_starts_with']):
group['flavors'].append(flavor_key_name)
break

for name, group in grouping.items():
if len(group['flavors']) > 0:
flavor_table.add_row(['{}'.format(name),
formatting.listing(group['flavors'],
separator='\n')])
return flavor_table


def _get_cpu_table(create_options):
cpu_table = formatting.Table(['cpu', 'value'], title='CPUs')
cpu_table.sortby = 'cpu'
cpu_table.align = 'l'
standard_cpus = [int(x['template']['startCpus']) for x in create_options['processors']
if not x['template'].get('dedicatedAccountHostOnlyFlag',
False)
and not x['template'].get('dedicatedHost', None)]
ded_cpus = [int(x['template']['startCpus']) for x in create_options['processors']
if x['template'].get('dedicatedAccountHostOnlyFlag', False)]
ded_host_cpus = [int(x['template']['startCpus']) for x in create_options['processors']
if x['template'].get('dedicatedHost', None)]

standard_cpus = sorted(standard_cpus)
cpu_table.add_row(['standard', formatting.listing(standard_cpus, separator=',')])
ded_cpus = sorted(ded_cpus)
cpu_table.add_row(['dedicated', formatting.listing(ded_cpus, separator=',')])
ded_host_cpus = sorted(ded_host_cpus)
cpu_table.add_row(['dedicated host', formatting.listing(ded_host_cpus, separator=',')])
return cpu_table


def _get_memory_table(create_options):
memory_table = formatting.Table(['memory', 'value'], title='Memories')
memory_table.sortby = 'memory'
memory_table.align = 'l'
memory = [int(m['template']['maxMemory']) for m in create_options['memory']
if not m['itemPrice'].get('dedicatedHostInstanceFlag', False)]
ded_host_memory = [int(m['template']['maxMemory']) for m in create_options['memory']
if m['itemPrice'].get('dedicatedHostInstanceFlag', False)]

memory = sorted(memory)
memory_table.add_row(['standard',
formatting.listing(memory, separator=',')])

ded_host_memory = sorted(ded_host_memory)
memory_table.add_row(['dedicated host',
formatting.listing(ded_host_memory, separator=',')])
return memory_table


def _get_os_table(create_options):
os_table = formatting.Table(['KeyName', 'Description'], title='Operating Systems')
os_table.sortby = 'KeyName'
# Operation system
os_table = formatting.Table(['OS', 'Key', 'Reference Code'], title="Operating Systems")
os_table.sortby = 'Key'
os_table.align = 'l'
op_sys = []
for operating_system in create_options['operatingSystems']:
os_option = {
'referenceCode': operating_system['template']['operatingSystemReferenceCode'],
'description': operating_system['itemPrice']['item']['description']
}
op_sys.append(os_option)

for operating_system in op_sys:
os_table.add_row([
operating_system['referenceCode'],
operating_system['description']
])
return os_table


def _get_disk_table(create_options):
disk_table = formatting.Table(['disk', 'value'], title='Disks')
disk_table.sortby = 'disk'
disk_table.align = 'l'
local_disks = [x for x in create_options['blockDevices']
if x['template'].get('localDiskFlag', False)
and not x['itemPrice'].get('dedicatedHostInstanceFlag',
False)]

ded_host_local_disks = [x for x in create_options['blockDevices']
if x['template'].get('localDiskFlag', False)
and x['itemPrice'].get('dedicatedHostInstanceFlag',
False)]

san_disks = [x for x in create_options['blockDevices']
if not x['template'].get('localDiskFlag', False)]

def add_block_rows(disks, name):
"""Add block rows to the table."""
simple = {}
for disk in disks:
block = disk['template']['blockDevices'][0]
bid = block['device']

if bid not in simple:
simple[bid] = []

simple[bid].append(str(block['diskImage']['capacity']))

for label in sorted(simple):
disk_table.add_row(['%s disk(%s)' % (name, label),
formatting.listing(simple[label],
separator=',')])

add_block_rows(san_disks, 'san')
add_block_rows(local_disks, 'local')
add_block_rows(ded_host_local_disks, 'local (dedicated host)')
return disk_table


def _get_network_table(create_options):
network_table = formatting.Table(['network', 'value'], title='Network')
network_table.sortby = 'network'
network_table.align = 'l'
speeds = []
ded_host_speeds = []
for option in create_options['networkComponents']:
template = option.get('template', None)
price = option.get('itemPrice', None)

if not template or not price \
or not template.get('networkComponents', None):
continue

if not template['networkComponents'][0] \
or not template['networkComponents'][0].get('maxSpeed', None):
continue

max_speed = str(template['networkComponents'][0]['maxSpeed'])
if price.get('dedicatedHostInstanceFlag', False) \
and max_speed not in ded_host_speeds:
ded_host_speeds.append(max_speed)
elif max_speed not in speeds:
speeds.append(max_speed)

speeds = sorted(speeds)
network_table.add_row(['nic', formatting.listing(speeds, separator=',')])

ded_host_speeds = sorted(ded_host_speeds)
network_table.add_row(['nic (dedicated host)',
formatting.listing(ded_host_speeds, separator=',')])
return network_table

for operating_system in options['operating_systems']:
os_table.add_row([operating_system['name'], operating_system['key'], operating_system['referenceCode']])
tables.append(os_table)

# Sizes
preset_table = formatting.Table(['Size', 'Value'], title="Sizes")
preset_table.sortby = 'Value'
preset_table.align = 'l'

for size in options['sizes']:
preset_table.add_row([size['name'], size['key']])
tables.append(preset_table)

# RAM
ram_table = formatting.Table(['memory', 'Value'], title="RAM")
ram_table.sortby = 'Value'
ram_table.align = 'l'

for ram in options['ram']:
ram_table.add_row([ram['name'], ram['key']])
tables.append(ram_table)

# Data base
database_table = formatting.Table(['database', 'Value'], title="Databases")
database_table.sortby = 'Value'
database_table.align = 'l'

for database in options['database']:
database_table.add_row([database['name'], database['key']])
tables.append(database_table)

# Guest_core
guest_core_table = formatting.Table(['cpu', 'Value', 'Capacity'], title="Guest_core")
guest_core_table.sortby = 'Value'
guest_core_table.align = 'l'

for guest_core in options['guest_core']:
guest_core_table.add_row([guest_core['name'], guest_core['key'], guest_core['capacity']])
tables.append(guest_core_table)

# Guest_core
guest_disk_table = formatting.Table(['guest_disk', 'Value', 'Capacity', 'Disk'], title="Guest_disks")
guest_disk_table.sortby = 'Value'
guest_disk_table.align = 'l'

for guest_disk in options['guest_disk']:
guest_disk_table.add_row([guest_disk['name'], guest_disk['key'], guest_disk['capacity'], guest_disk['disk']])
tables.append(guest_disk_table)

# Port speed
port_speed_table = formatting.Table(['network', 'Key'], title="Network Options")
port_speed_table.sortby = 'Key'
port_speed_table.align = 'l'

for speed in options['port_speed']:
port_speed_table.add_row([speed['name'], speed['key']])
tables.append(port_speed_table)

env.fout(formatting.listing(tables, separator='\n'))
105 changes: 105 additions & 0 deletions SoftLayer/fixtures/SoftLayer_Product_Package.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1779,3 +1779,108 @@
]
}
]

getObject = {
'id': 200,
'regions': [{'description': 'WDC01 - Washington, DC - East Coast U.S.',
'keyname': 'WASHINGTON_DC',
'location': {'location': {'id': 37473,
'longName': 'Washington 1',
'name': 'wdc01'}},
'sortOrder': 10}],
'accountRestrictedActivePresets': [],
'activePresets': [
{
'description': 'AC2.8x60x25',
'id': 861,
'isActive': '1',
'keyName': 'AC2_8X60X25',
'name': 'AC2.8x60x25',
'packageId': 835
},
{
'description': 'AC2.8x60x100',
'id': 863,
'isActive': '1',
'keyName': 'AC2_8X60X100',
'name': 'AC2.8x60x100',
'packageId': 835
}],
"items": [{
"capacity": "56",
"description": "56 Cores x 360 RAM x 1.2 TB x 2 GPU P100 [encryption enabled]",
"bundleItems": [
{
"capacity": "1200",
"keyName": "1.2 TB Local Storage (Dedicated Host Capacity)",
"categories": [{
"categoryCode": "dedicated_host_disk"
}]
},
{
"capacity": "242",
"keyName": "2_GPU_P100_DEDICATED",
"hardwareGenericComponentModel": {
"capacity": "16",
"id": 849,
"hardwareComponentType": {
"id": 20,
"keyName": "GPU"
}
},
"categories": [{
"categoryCode": "dedicated_host_ram"
}, {
"capacity": "2",
"description": "2 x 2.0 GHz or higher Cores",
"keyName": "GUEST_CORES_2",
"attributes": [
{
"id": 8261,
"attributeTypeKeyName": "ORDER_SAVES_USAGE_FEES"
}
],
"itemCategory": {
"categoryCode": "guest_core",
"id": 80
}}]
}
],
"prices": [
{
"itemId": 10195,
"setupFee": "0",
"recurringFee": "2099",
"tierMinimumThreshold": "",
"hourlyRecurringFee": "3.164",
"oneTimeFee": "0",
"currentPriceFlag": "",
"id": 200269,
"sort": 0,
"onSaleFlag": "",
"laborFee": "0",
"locationGroupId": "",
"quantity": ""
},
{
"itemId": 10195,
"setupFee": "0",
"recurringFee": "2161.97",
"tierMinimumThreshold": "",
"hourlyRecurringFee": "3.258",
"oneTimeFee": "0",
"currentPriceFlag": "",
"id": 200271,
"sort": 0,
"onSaleFlag": "",
"laborFee": "0",
"locationGroupId": 503,
"quantity": ""
}
],
"keyName": "56_CORES_X_484_RAM_X_1_5_TB_X_2_GPU_P100",
"id": 10195,
"itemCategory": {
"categoryCode": "dedicated_virtual_hosts"
}
}]}
Loading