Search is not available for this dataset
text stringlengths 75 104k |
|---|
def get_translation(self, context_id, translation_id):
"""Retrieves a translation entry for the given id values.
:param int context_id: The id-value representing the context instance.
:param int translation_id: The id-value representing the translation
instance.
:return d... |
def get_translations(self, context_id):
"""Retrieves all translation entries for a tunnel context.
:param int context_id: The id-value representing the context instance.
:return list(dict): Translations associated with the given context
"""
_mask = ('[mask[addressTranslations[cu... |
def remove_internal_subnet(self, context_id, subnet_id):
"""Remove an internal subnet from a tunnel context.
:param int context_id: The id-value representing the context instance.
:param int subnet_id: The id-value representing the internal subnet.
:return bool: True if internal subnet ... |
def remove_remote_subnet(self, context_id, subnet_id):
"""Removes a remote subnet from a tunnel context.
:param int context_id: The id-value representing the context instance.
:param int subnet_id: The id-value representing the remote subnet.
:return bool: True if remote subnet removal ... |
def remove_service_subnet(self, context_id, subnet_id):
"""Removes a service subnet from a tunnel context.
:param int context_id: The id-value representing the context instance.
:param int subnet_id: The id-value representing the service subnet.
:return bool: True if service subnet remo... |
def remove_translation(self, context_id, translation_id):
"""Removes a translation entry from a tunnel context.
:param int context_id: The id-value representing the context instance.
:param int translation_id: The id-value representing the translation.
:return bool: True if translation ... |
def update_translation(self, context_id, translation_id, static_ip=None,
remote_ip=None, notes=None):
"""Updates an address translation entry using the given values.
:param int context_id: The id-value representing the context instance.
:param dict template: A key-val... |
def update_tunnel_context(self, context_id, friendly_name=None,
remote_peer=None, preshared_key=None,
phase1_auth=None, phase1_crypto=None,
phase1_dh=None, phase1_key_ttl=None,
phase2_auth=None, phase... |
def cli(env, identifier):
"""Create credentials for an IBM Cloud Object Storage Account"""
mgr = SoftLayer.ObjectStorageManager(env.client)
credential = mgr.create_credential(identifier)
table = formatting.Table(['id', 'password', 'username', 'type_name'])
table.sortby = 'id'
table.add_row([
... |
def cli(env, name, public):
"""List images."""
image_mgr = SoftLayer.ImageManager(env.client)
images = []
if public in [False, None]:
for image in image_mgr.list_private_images(name=name,
mask=image_mod.MASK):
images.append(image)
... |
def cli(env, context_id, subnet_id, subnet_type, network_identifier):
"""Add a subnet to an IPSEC tunnel context.
A subnet id may be specified to link to the existing tunnel context.
Otherwise, a network identifier in CIDR notation should be specified,
indicating that a subnet resource should first be... |
def cli(env):
"""List placement groups."""
manager = PlacementManager(env.client)
result = manager.list()
table = formatting.Table(
["Id", "Name", "Backend Router", "Rule", "Guests", "Created"],
title="Placement Groups"
)
for group in result:
table.add_row([
g... |
def cli(env, ack_all):
"""Summary and acknowledgement of upcoming and ongoing maintenance events"""
manager = AccountManager(env.client)
events = manager.get_upcoming_events()
if ack_all:
for event in events:
result = manager.ack_event(event['id'])
event['acknowledgedFl... |
def event_table(events):
"""Formats a table for events"""
table = formatting.Table([
"Id",
"Start Date",
"End Date",
"Subject",
"Status",
"Acknowledged",
"Updates",
"Impacted Resources"
], title="Upcoming Events")
table.align['Subject'] = '... |
def cli(env, access_id, password):
"""Changes a password for a volume's access.
access id is the allowed_host_id from slcli block access-list
"""
block_manager = SoftLayer.BlockStorageManager(env.client)
result = block_manager.set_credential_password(access_id=access_id, password=password)
i... |
def cli(env, account_id):
"""Detail a CDN Account."""
manager = SoftLayer.CDNManager(env.client)
account = manager.get_account(account_id)
table = formatting.KeyValueTable(['name', 'value'])
table.align['name'] = 'r'
table.align['value'] = 'l'
table.add_row(['id', account['id']])
tabl... |
def lookup(dic, key, *keys):
"""A generic dictionary access helper.
This helps simplify code that uses heavily nested dictionaries. It will
return None if any of the keys in *keys do not exist.
::
>>> lookup({'this': {'is': 'nested'}}, 'this', 'is')
nested
>>> lookup({}, 'thi... |
def query_filter(query):
"""Translate a query-style string to a 'filter'.
Query can be the following formats:
Case Insensitive
'value' OR '*= value' Contains
'value*' OR '^= value' Begins with value
'*value' OR '$= value' Ends with value
'*value*' OR '_= value' Contains val... |
def query_filter_date(start, end):
"""Query filters given start and end date.
:param start:YY-MM-DD
:param end: YY-MM-DD
"""
sdate = datetime.datetime.strptime(start, "%Y-%m-%d")
edate = datetime.datetime.strptime(end, "%Y-%m-%d")
startdate = "%s/%s/%s" % (sdate.month, sdate.day, sdate.year... |
def format_event_log_date(date_string, utc):
"""Gets a date in the format that the SoftLayer_EventLog object likes.
:param string date_string: date in mm/dd/yyyy format
:param string utc: utc offset. Defaults to '+0000'
"""
user_date_format = "%m/%d/%Y"
user_date = datetime.datetime.strptime(d... |
def event_log_filter_between_date(start, end, utc):
"""betweenDate Query filter that SoftLayer_EventLog likes
:param string start: lower bound date in mm/dd/yyyy format
:param string end: upper bound date in mm/dd/yyyy format
:param string utc: utc offset. Defaults to '+0000'
"""
return {
... |
def resolve_ids(identifier, resolvers):
"""Resolves IDs given a list of functions.
:param string identifier: identifier string
:param list resolvers: a list of functions
:returns list:
"""
# Before doing anything, let's see if this is an integer
try:
return [int(identifier)]
ex... |
def is_ready(instance, pending=False):
"""Returns True if instance is ready to be used
:param Object instance: Hardware or Virt with transaction data retrieved from the API
:param bool pending: Wait for ALL transactions to finish?
:returns bool:
"""
last_reload = lookup(instance, 'lastOperatin... |
def clean_time(sltime, in_format='%Y-%m-%dT%H:%M:%S%z', out_format='%Y-%m-%d %H:%M'):
"""Easy way to format time strings
:param string sltime: A softlayer formatted time string
:param string in_format: Datetime format for strptime
:param string out_format: Datetime format for strftime
"""
try:
... |
def to_dict(self):
"""Converts a NestedDict instance into a real dictionary.
This is needed for places where strict type checking is done.
"""
return {key: val.to_dict() if isinstance(val, NestedDict) else val
for key, val in self.items()} |
def cli(env, identifier):
"""Cancels a firewall."""
mgr = SoftLayer.FirewallManager(env.client)
firewall_type, firewall_id = firewall.parse_id(identifier)
if not (env.skip_confirmations or
formatting.confirm("This action will cancel a firewall from your "
"ac... |
def cli(env, label, in_file, key, note):
"""Add a new SSH key."""
if in_file is None and key is None:
raise exceptions.ArgumentError(
'Either [-f | --in-file] or [-k | --key] arguments are required to add a key'
)
if in_file and key:
raise exceptions.ArgumentError(
... |
def cli(env):
"""Display the RWhois information for your account."""
mgr = SoftLayer.NetworkManager(env.client)
result = mgr.get_rwhois()
table = formatting.KeyValueTable(['name', 'value'])
table.align['name'] = 'r'
table.align['value'] = 'l'
table.add_row(['Name', result['firstName'] + ' ... |
def cli(env, context_id, static_ip, remote_ip, note):
"""Add an address translation to an IPSEC tunnel context.
A separate configuration request should be made to realize changes on
network devices.
"""
manager = SoftLayer.IPSECManager(env.client)
# ensure context can be retrieved by given id
... |
def cli(env, identifier, a_record, aaaa_record, ptr, ttl):
"""Sync DNS records."""
items = ['id',
'globalIdentifier',
'fullyQualifiedDomainName',
'hostname',
'domain',
'primaryBackendIpAddress',
'primaryIpAddress',
'''pr... |
def cli(env, volume_id, schedule_type):
"""Disables snapshots on the specified schedule for a given volume"""
if (schedule_type not in ['INTERVAL', 'HOURLY', 'DAILY', 'WEEKLY']):
raise exceptions.CLIAbort(
'--schedule-type must be INTERVAL, HOURLY, DAILY, or WEEKLY')
block_manager = So... |
def cli(env, status, sortby):
"""List SSL certificates."""
manager = SoftLayer.SSLManager(env.client)
certificates = manager.list_certs(status)
table = formatting.Table(['id',
'common_name',
'days_until_expire',
... |
def cli(env):
"""List health check types."""
mgr = SoftLayer.LoadBalancerManager(env.client)
hc_types = mgr.get_hc_types()
table = formatting.KeyValueTable(['ID', 'Name'])
table.align['ID'] = 'l'
table.align['Name'] = 'l'
table.sortby = 'ID'
for hc_type in hc_types:
table.add_r... |
def cli(env, identifier):
"""Credential limits for this IBM Cloud Object Storage account."""
mgr = SoftLayer.ObjectStorageManager(env.client)
credential_limit = mgr.limit_credential(identifier)
table = formatting.Table(['limit'])
table.add_row([
credential_limit,
])
env.fout(table) |
def cli(env, context_id, include):
"""List IPSEC VPN tunnel context details.
Additional resources can be joined using multiple instances of the
include option, for which the following choices are available.
\b
at: address translations
is: internal subnets
rs: remote subnets
sr: statica... |
def _get_address_translations_table(address_translations):
"""Yields a formatted table to print address translations.
:param List[dict] address_translations: List of address translations.
:return Table: Formatted for address translation output.
"""
table = formatting.Table(['id',
... |
def _get_subnets_table(subnets):
"""Yields a formatted table to print subnet details.
:param List[dict] subnets: List of subnets.
:return Table: Formatted for subnet output.
"""
table = formatting.Table(['id',
'network identifier',
'cidr',... |
def _get_tunnel_context_mask(address_translations=False,
internal_subnets=False,
remote_subnets=False,
static_subnets=False,
service_subnets=False):
"""Yields a mask object for a tunnel context.
... |
def _get_context_table(context):
"""Yields a formatted table to print context details.
:param dict context: The tunnel context
:return Table: Formatted for tunnel context output
"""
table = formatting.KeyValueTable(['name', 'value'])
table.align['name'] = 'r'
table.align['value'] = 'l'
... |
def cli(env, volume_id, replicant_id, immediate):
"""Failover a file volume to the given replicant volume."""
file_storage_manager = SoftLayer.FileStorageManager(env.client)
success = file_storage_manager.failover_to_replicant(
volume_id,
replicant_id,
immediate
)
if succes... |
def cli(env, sortby, datacenter):
"""List number of file storage volumes per datacenter."""
file_manager = SoftLayer.FileStorageManager(env.client)
mask = "mask[serviceResource[datacenter[name]],"\
"replicationPartners[serviceResource[datacenter[name]]]]"
file_volumes = file_manager.list_file... |
def cli(env):
"""Server order options for a given chassis."""
hardware_manager = hardware.HardwareManager(env.client)
options = hardware_manager.get_create_options()
tables = []
# Datacenters
dc_table = formatting.Table(['datacenter', 'value'])
dc_table.sortby = 'value'
for location i... |
def parse_id(input_id):
"""Helper package to retrieve the actual IDs.
:param input_id: the ID provided by the user
:returns: A list of valid IDs
"""
key_value = input_id.split(':')
if len(key_value) != 2:
raise exceptions.CLIAbort(
'Invalid ID %s: ID should be of the form x... |
def _build_filters(_filters):
"""Builds filters using the filter options passed into the CLI.
This only supports the equals keyword at the moment.
"""
root = utils.NestedDict({})
for _filter in _filters:
operation = None
for operation, token in SPLIT_TOKENS:
# split "som... |
def cli(env, service, method, parameters, _id, _filters, mask, limit, offset,
output_python=False):
"""Call arbitrary API endpoints with the given SERVICE and METHOD.
Example::
slcli call-api Account getObject
slcli call-api Account getVirtualGuests --limit=10 --mask=id,hostname
... |
def cli(env, volume_id, sortby, columns):
"""List block storage snapshots."""
block_manager = SoftLayer.BlockStorageManager(env.client)
snapshots = block_manager.get_block_volume_snapshot_list(
volume_id,
mask=columns.mask()
)
table = formatting.Table(columns.columns)
table.sort... |
def cli(env, identifier, passwords, price):
"""Get details for a hardware device."""
hardware = SoftLayer.HardwareManager(env.client)
table = formatting.KeyValueTable(['name', 'value'])
table.align['name'] = 'r'
table.align['value'] = 'l'
hardware_id = helpers.resolve_id(hardware.resolve_ids,... |
def cli(env):
"""Virtual server order options."""
vsi = SoftLayer.VSManager(env.client)
result = vsi.get_create_options()
table = formatting.KeyValueTable(['name', 'value'])
table.align['name'] = 'r'
table.align['value'] = 'l'
# Datacenters
datacenters = [dc['template']['datacenter'][... |
def cli(env, package_keyname, location, preset, verify, billing, complex_type,
quantity, extras, order_items):
"""Place or verify an order.
This CLI command is used for placing/verifying an order of the specified package in
the given location (denoted by a datacenter's long name). Orders made via t... |
def cli(env, identifier, label, note):
"""Edits an SSH key."""
mgr = SoftLayer.SshKeyManager(env.client)
key_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'SshKey')
if not mgr.edit_key(key_id, label=label, notes=note):
raise exceptions.CLIAbort('Failed to edit SSH key') |
def cli(env, securitygroup_id):
"""Deletes the given security group"""
mgr = SoftLayer.NetworkManager(env.client)
if not mgr.delete_securitygroup(securitygroup_id):
raise exceptions.CLIAbort("Failed to delete security group") |
def cli(env, ipv6, test):
"""Creates a global IP."""
mgr = SoftLayer.NetworkManager(env.client)
version = 4
if ipv6:
version = 6
if not (test or env.skip_confirmations):
if not formatting.confirm("This action will incur charges on your "
"account.... |
def cli(env, context_id, translation_id):
"""Remove a translation entry from an IPSEC tunnel context.
A separate configuration request should be made to realize changes on
network devices.
"""
manager = SoftLayer.IPSECManager(env.client)
# ensure translation can be retrieved by given id
man... |
def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network,
hourly, monthly, tag, columns, limit):
"""List virtual servers."""
vsi = SoftLayer.VSManager(env.client)
guests = vsi.list_instances(hourly=hourly,
monthly=monthly,
... |
def cli(env, volume_id, schedule_type):
"""Disables snapshots on the specified schedule for a given volume"""
if (schedule_type not in ['INTERVAL', 'HOURLY', 'DAILY', 'WEEKLY']):
raise exceptions.CLIAbort(
'--schedule_type must be INTERVAL, HOURLY, DAILY, or WEEKLY')
file_manager = Sof... |
def cli(env, name, description):
"""Create a security group."""
mgr = SoftLayer.NetworkManager(env.client)
result = mgr.create_securitygroup(name, description)
table = formatting.KeyValueTable(['name', 'value'])
table.align['name'] = 'r'
table.align['value'] = 'l'
table.add_row(['id', resul... |
def cli(env, identifier):
"""Permanently removes an SSH key."""
mgr = SoftLayer.SshKeyManager(env.client)
key_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'SshKey')
if not (env.skip_confirmations or formatting.no_going_back(key_id)):
raise exceptions.CLIAbort('Aborted')
mgr.delete_... |
def format_output(data, fmt='table'): # pylint: disable=R0911,R0912
"""Given some data, will format it for console output.
:param data: One of: String, Table, FormattedItem, List, Tuple,
SequentialOutput
:param string fmt (optional): One of: table, raw, json, python
"""
if isinsta... |
def format_prettytable(table):
"""Converts SoftLayer.CLI.formatting.Table instance to a prettytable."""
for i, row in enumerate(table.rows):
for j, item in enumerate(row):
table.rows[i][j] = format_output(item)
ptable = table.prettytable()
ptable.hrules = prettytable.FRAME
ptabl... |
def format_no_tty(table):
"""Converts SoftLayer.CLI.formatting.Table instance to a prettytable."""
for i, row in enumerate(table.rows):
for j, item in enumerate(row):
table.rows[i][j] = format_output(item, fmt='raw')
ptable = table.prettytable()
for col in table.columns:
pt... |
def transaction_status(transaction):
"""Returns a FormattedItem describing the given transaction.
:param item: An object capable of having an active transaction
"""
if not transaction or not transaction.get('transactionStatus'):
return blank()
return FormattedItem(
transaction[... |
def tags(tag_references):
"""Returns a formatted list of tags."""
if not tag_references:
return blank()
tag_row = []
for tag_detail in tag_references:
tag = utils.lookup(tag_detail, 'tag', 'name')
if tag is not None:
tag_row.append(tag)
return listing(tag_row, s... |
def confirm(prompt_str, default=False):
"""Show a confirmation prompt to a command-line user.
:param string prompt_str: prompt to give to the user
:param bool default: Default value to True or False
"""
if default:
default_str = 'y'
prompt = '%s [Y/n]' % prompt_str
else:
... |
def no_going_back(confirmation):
"""Show a confirmation to a user.
:param confirmation str: the string the user has to enter in order to
confirm their action.
"""
if not confirmation:
confirmation = 'yes'
prompt = ('This action cannot be undone! Type "%s" or pr... |
def iter_to_table(value):
"""Convert raw API responses to response tables."""
if isinstance(value, list):
return _format_list(value)
if isinstance(value, dict):
return _format_dict(value)
return value |
def _format_dict(result):
"""Format dictionary responses into key-value table."""
table = KeyValueTable(['name', 'value'])
table.align['name'] = 'r'
table.align['value'] = 'l'
for key, value in result.items():
value = iter_to_table(value)
table.add_row([key, value])
return tab... |
def _format_list(result):
"""Format list responses into a table."""
if not result:
return result
if isinstance(result[0], dict):
return _format_list_objects(result)
table = Table(['value'])
for item in result:
table.add_row([iter_to_table(item)])
return table |
def _format_list_objects(result):
"""Format list of objects into a table."""
all_keys = set()
for item in result:
all_keys = all_keys.union(item.keys())
all_keys = sorted(all_keys)
table = Table(all_keys)
for item in result:
values = []
for key in all_keys:
... |
def default(self, obj):
"""Encode object if it implements to_python()."""
if hasattr(obj, 'to_python'):
return obj.to_python()
return super(CLIJSONEncoder, self).default(obj) |
def to_python(self):
"""Decode this Table object to standard Python types."""
# Adding rows
items = []
for row in self.rows:
formatted_row = [_format_python_value(v) for v in row]
items.append(dict(zip(self.columns, formatted_row)))
return items |
def prettytable(self):
"""Returns a new prettytable instance."""
table = prettytable.PrettyTable(self.columns)
if self.sortby:
if self.sortby in self.columns:
table.sortby = self.sortby
else:
msg = "Column (%s) doesn't exist to sort by" % ... |
def to_python(self):
"""Decode this KeyValueTable object to standard Python types."""
mapping = {}
for row in self.rows:
mapping[row[0]] = _format_python_value(row[1])
return mapping |
def cli(env, username, email, password, from_user, template, api_key):
"""Creates a user Users.
:Example: slcli user create my@email.com -e my@email.com -p generate -a
-t '{"firstName": "Test", "lastName": "Testerson"}'
Remember to set the permissions and access for this new user.
"""
mgr = S... |
def generate_password():
"""Returns a 23 character random string, with 3 special characters at the end"""
if sys.version_info > (3, 6):
import secrets # pylint: disable=import-error
alphabet = string.ascii_letters + string.digits
password = ''.join(secrets.choice(alphabet) for i in rang... |
def cli(env, volume_id, notes):
"""Creates a snapshot on a given volume"""
block_manager = SoftLayer.BlockStorageManager(env.client)
snapshot = block_manager.create_snapshot(volume_id, notes=notes)
if 'id' in snapshot:
click.echo('New snapshot created with id: %s' % snapshot['id'])
else:
... |
def cli(env):
"""Get Event Log Types"""
mgr = SoftLayer.EventLogManager(env.client)
event_log_types = mgr.get_event_log_types()
table = formatting.Table(COLUMNS)
for event_log_type in event_log_types:
table.add_row([event_log_type])
env.fout(table) |
def _get_extra_price_id(items, key_name, hourly, location):
"""Returns a price id attached to item with the given key_name."""
for item in items:
if utils.lookup(item, 'keyName') != key_name:
continue
for price in item['prices']:
if not _matches_billing(price, hourly):
... |
def _get_default_price_id(items, option, hourly, location):
"""Returns a 'free' price id given an option."""
for item in items:
if utils.lookup(item, 'itemCategory', 'categoryCode') != option:
continue
for price in item['prices']:
if all([float(price.get('hourlyRecurrin... |
def _get_bandwidth_price_id(items,
hourly=True,
no_public=False,
location=None):
"""Choose a valid price id for bandwidth."""
# Prefer pay-for-use data transfer with hourly
for item in items:
capacity = float(item.... |
def _get_os_price_id(items, os, location):
"""Returns the price id matching."""
for item in items:
if any([utils.lookup(item,
'itemCategory',
'categoryCode') != 'os',
utils.lookup(item,
'softwareDescr... |
def _get_port_speed_price_id(items, port_speed, no_public, location):
"""Choose a valid price id for port speed."""
for item in items:
if utils.lookup(item,
'itemCategory',
'categoryCode') != 'port_speed':
continue
# Check for correct... |
def _matches_billing(price, hourly):
"""Return True if the price object is hourly and/or monthly."""
return any([hourly and price.get('hourlyRecurringFee') is not None,
not hourly and price.get('recurringFee') is not None]) |
def _matches_location(price, location):
"""Return True if the price object matches the location."""
# the price has no location restriction
if not price.get('locationGroupId'):
return True
# Check to see if any of the location groups match the location group
# of this price object
for g... |
def _get_location(package, location):
"""Get the longer key with a short location name."""
for region in package['regions']:
if region['location']['location']['name'] == location:
return region
raise SoftLayer.SoftLayerError("Could not find valid location for: '%s'" % location) |
def _get_preset_id(package, size):
"""Get the preset id given the keyName of the preset."""
for preset in package['activePresets'] + package['accountRestrictedActivePresets']:
if preset['keyName'] == size or preset['id'] == size:
return preset['id']
raise SoftLayer.SoftLayerError("Could... |
def cancel_hardware(self, hardware_id, reason='unneeded', comment='', immediate=False):
"""Cancels the specified dedicated server.
Example::
# Cancels hardware id 1234
result = mgr.cancel_hardware(hardware_id=1234)
:param int hardware_id: The ID of the hardware to be c... |
def list_hardware(self, tags=None, cpus=None, memory=None, hostname=None,
domain=None, datacenter=None, nic_speed=None,
public_ip=None, private_ip=None, **kwargs):
"""List all hardware (servers and bare metal computing instances).
:param list tags: filter bas... |
def get_hardware(self, hardware_id, **kwargs):
"""Get details about a hardware device.
:param integer id: the hardware ID
:returns: A dictionary containing a large amount of information about
the specified server.
Example::
object_mask = "mask[id,networkV... |
def reload(self, hardware_id, post_uri=None, ssh_keys=None):
"""Perform an OS reload of a server with its current configuration.
:param integer hardware_id: the instance ID to reload
:param string post_uri: The URI of the post-install script to run
after reload
... |
def change_port_speed(self, hardware_id, public, speed):
"""Allows you to change the port speed of a server's NICs.
:param int hardware_id: The ID of the server
:param bool public: Flag to indicate which interface to change.
True (default) means the public interface.... |
def place_order(self, **kwargs):
"""Places an order for a piece of hardware.
See get_create_options() for valid arguments.
:param string size: server size name or presetId
:param string hostname: server hostname
:param string domain: server domain name
:param string loc... |
def verify_order(self, **kwargs):
"""Verifies an order for a piece of hardware.
See :func:`place_order` for a list of available options.
"""
create_options = self._generate_create_dict(**kwargs)
return self.client['Product_Order'].verifyOrder(create_options) |
def get_create_options(self):
"""Returns valid options for ordering hardware."""
package = self._get_package()
# Locations
locations = []
for region in package['regions']:
locations.append({
'name': region['location']['location']['longName'],
... |
def _get_package(self):
"""Get the package related to simple hardware ordering."""
mask = '''
items[
keyName,
capacity,
description,
attributes[id,attributeTypeKeyName],
itemCategory[id,categoryCode],
... |
def _generate_create_dict(self,
size=None,
hostname=None,
domain=None,
location=None,
os=None,
port_speed=None,
... |
def _get_ids_from_hostname(self, hostname):
"""Returns list of matching hardware IDs for a given hostname."""
results = self.list_hardware(hostname=hostname, mask="id")
return [result['id'] for result in results] |
def _get_ids_from_ip(self, ip): # pylint: disable=inconsistent-return-statements
"""Returns list of matching hardware IDs for a given ip address."""
try:
# Does it look like an ip address?
socket.inet_aton(ip)
except socket.error:
return []
# Find th... |
def edit(self, hardware_id, userdata=None, hostname=None, domain=None,
notes=None, tags=None):
"""Edit hostname, domain name, notes, user data of the hardware.
Parameters set to None will be ignored and not attempted to be updated.
:param integer hardware_id: the instance ID to ed... |
def update_firmware(self,
hardware_id,
ipmi=True,
raid_controller=True,
bios=True,
hard_drive=True):
"""Update hardware firmware.
This will cause the server to be unavailable for ~20 ... |
def reflash_firmware(self,
hardware_id,
ipmi=True,
raid_controller=True,
bios=True):
"""Reflash hardware firmware.
This will cause the server to be unavailable for ~60 minutes.
The firmware will ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.