Search is not available for this dataset
text stringlengths 75 104k |
|---|
def out(self, output, newline=True):
"""Outputs a string to the console (stdout)."""
click.echo(output, nl=newline) |
def err(self, output, newline=True):
"""Outputs an error string to the console (stderr)."""
click.echo(output, nl=newline, err=True) |
def fout(self, output, newline=True):
"""Format the input and output to the console (stdout)."""
if output is not None:
self.out(self.fmt(output), newline=newline) |
def input(self, prompt, default=None, show_default=True):
"""Provide a command prompt."""
return click.prompt(prompt, default=default, show_default=show_default) |
def getpass(self, prompt, default=None):
"""Provide a password prompt."""
return click.prompt(prompt, hide_input=True, default=default) |
def list_commands(self, *path):
"""Command listing."""
path_str = ':'.join(path)
commands = []
for command in self.commands:
# Filter based on prefix and the segment length
if all([command.startswith(path_str),
len(path) == command.count(":")... |
def get_command(self, *path):
"""Return command at the given path or raise error."""
path_str = ':'.join(path)
if path_str in self.commands:
return self.commands[path_str].load()
return None |
def resolve_alias(self, path_str):
"""Returns the actual command name. Uses the alias mapping."""
if path_str in self.aliases:
return self.aliases[path_str]
return path_str |
def load(self):
"""Loads all modules."""
if self._modules_loaded is True:
return
self.load_modules_from_python(routes.ALL_ROUTES)
self.aliases.update(routes.ALL_ALIASES)
self._load_modules_from_entry_points('softlayer.cli')
self._modules_loaded = True |
def load_modules_from_python(self, route_list):
"""Load modules from the native python source."""
for name, modpath in route_list:
if ':' in modpath:
path, attr = modpath.split(':', 1)
else:
path, attr = modpath, None
self.commands[name... |
def _load_modules_from_entry_points(self, entry_point_group):
"""Load modules from the entry_points (slower).
Entry points can be used to add new commands to the CLI.
Usage:
entry_points={'softlayer.cli': ['new-cmd = mymodule.new_cmd.cli']}
"""
for obj in pkg_reso... |
def ensure_client(self, config_file=None, is_demo=False, proxy=None):
"""Create a new SLAPI client to the environment.
This will be a no-op if there is already a client in this environment.
"""
if self.client is not None:
return
# Environment can be passed in explic... |
def load(self):
"""load and return the module/attribute."""
module = importlib.import_module(self.import_path)
if self.attr:
return getattr(module, self.attr)
return module |
def cli(env, zone):
"""Delete zone."""
manager = SoftLayer.DNSManager(env.client)
zone_id = helpers.resolve_id(manager.resolve_ids, zone, name='zone')
if not (env.skip_confirmations or formatting.no_going_back(zone)):
raise exceptions.CLIAbort("Aborted.")
manager.delete_zone(zone_id) |
def multi_option(*param_decls, **attrs):
"""modify help text and indicate option is permitted multiple times
:param param_decls:
:param attrs:
:return:
"""
attrhelp = attrs.get('help', None)
if attrhelp is not None:
newhelp = attrhelp + " (multiple occurrence permitted)"
at... |
def resolve_id(resolver, identifier, name='object'):
"""Resolves a single id using a resolver function.
:param resolver: function that resolves ids. Should return None or a list of ids.
:param string identifier: a string identifier used to resolve ids
:param string name: the object type, to be used in ... |
def cli(env, identifier):
"""Remove SSL certificate."""
manager = SoftLayer.SSLManager(env.client)
if not (env.skip_confirmations or formatting.no_going_back('yes')):
raise exceptions.CLIAbort("Aborted.")
manager.remove_certificate(identifier) |
def cli(env, volume_id, capacity, tier, upgrade):
"""Order snapshot space for a file storage volume."""
file_manager = SoftLayer.FileStorageManager(env.client)
if tier is not None:
tier = float(tier)
try:
order = file_manager.order_snapshot_space(
volume_id,
cap... |
def cli(env, identifier, domain, userfile, tag, hostname, userdata,
public_speed, private_speed):
"""Edit a virtual server's details."""
if userdata and userfile:
raise exceptions.ArgumentError(
'[-u | --userdata] not allowed with [-F | --userfile]')
data = {}
if userdata:... |
def cli(env, volume_id, snapshot_schedule, location, tier):
"""Order a file storage replica volume."""
file_manager = SoftLayer.FileStorageManager(env.client)
if tier is not None:
tier = float(tier)
try:
order = file_manager.order_replicant_volume(
volume_id,
sn... |
def cli(env, volume_id, replicant_id):
"""Failback a block volume from the given replicant volume."""
block_storage_manager = SoftLayer.BlockStorageManager(env.client)
success = block_storage_manager.failback_from_replicant(
volume_id,
replicant_id
)
if success:
click.echo(... |
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_objec... |
def cli(env, columns):
"""List Users."""
mgr = SoftLayer.UserManager(env.client)
users = mgr.list_users()
table = formatting.Table(columns.columns)
for user in users:
table.add_row([value or formatting.blank()
for value in columns.row(user)])
env.fout(table) |
def cli(env, identifier, body):
"""Adds an update to an existing ticket."""
mgr = SoftLayer.TicketManager(env.client)
ticket_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'ticket')
if body is None:
body = click.edit('\n\n' + ticket.TEMPLATE_MSG)
mgr.update_ticket(ticket_id=ticket_i... |
def cli(env, quote):
"""View a quote"""
manager = ordering.OrderingManager(env.client)
result = manager.get_quote_details(quote)
package = result['order']['items'][0]['package']
title = "{} - Package: {}, Id {}".format(result.get('name'), package['keyName'], package['id'])
table = formatting.T... |
def cli(env, sortby, limit):
"""List security groups."""
mgr = SoftLayer.NetworkManager(env.client)
table = formatting.Table(COLUMNS)
table.sortby = sortby
sgs = mgr.list_securitygroups(limit=limit)
for secgroup in sgs:
table.add_row([
secgroup['id'],
secgroup.... |
def parse_rules(content=None):
"""Helper to parse the input from the user into a list of rules.
:param string content: the content of the editor
:returns: a list of rules
"""
rules = content.split(DELIMITER)
parsed_rules = list()
order = 1
for rule in rules:
if rule.strip() == '... |
def open_editor(rules=None, content=None):
"""Helper to open an editor for editing the firewall rules.
This method takes two parameters, if content is provided,
that means that submitting the rules failed and we are allowing
the user to re-edit what they provided. If content is not provided, the
ru... |
def get_formatted_rule(rule=None):
"""Helper to format the rule into a user friendly format.
:param dict rule: A dict containing one rule of the firewall
:returns: a formatted string that get be pushed into the editor
"""
rule = rule or {}
return ('action: %s\n'
'protocol: %s\n'
... |
def cli(env, identifier):
"""Edit firewall rules."""
mgr = SoftLayer.FirewallManager(env.client)
firewall_type, firewall_id = firewall.parse_id(identifier)
if firewall_type == 'vlan':
orig_rules = mgr.get_dedicated_fwl_rules(firewall_id)
else:
orig_rules = mgr.get_standard_fwl_rule... |
def rule_list(env, securitygroup_id, sortby):
"""List security group rules."""
mgr = SoftLayer.NetworkManager(env.client)
table = formatting.Table(COLUMNS)
table.sortby = sortby
rules = mgr.list_securitygroup_rules(securitygroup_id)
for rule in rules:
port_min = rule.get('portRangeMin... |
def add(env, securitygroup_id, remote_ip, remote_group,
direction, ethertype, port_max, port_min, protocol):
"""Add a security group rule to a security group.
\b
Examples:
# Add an SSH rule (TCP port 22) to a security group
slcli sg rule-add 384727 \\
--direction ingress... |
def edit(env, securitygroup_id, rule_id, remote_ip, remote_group,
direction, ethertype, port_max, port_min, protocol):
"""Edit a security group rule in a security group."""
mgr = SoftLayer.NetworkManager(env.client)
data = {}
if remote_ip:
data['remote_ip'] = remote_ip
if remote_gr... |
def remove(env, securitygroup_id, rule_id):
"""Remove a rule from a security group."""
mgr = SoftLayer.NetworkManager(env.client)
ret = mgr.remove_securitygroup_rule(securitygroup_id, rule_id)
if not ret:
raise exceptions.CLIAbort("Failed to remove security group rule")
table = formatting... |
def main():
"""Main function for the deprecated 'sl' command."""
print("ERROR: Use the 'slcli' command instead.", file=sys.stderr)
print("> slcli %s" % ' '.join(sys.argv[1:]), file=sys.stderr)
exit(-1) |
def cli(env, identifier, allocation, port, routing_type, routing_method):
"""Edit an existing load balancer service group."""
mgr = SoftLayer.LoadBalancerManager(env.client)
loadbal_id, group_id = loadbal.parse_id(identifier)
# check if any input is provided
if not any([allocation, port, routing_t... |
def cli(env, identifier, ack):
"""Details of a specific event, and ability to acknowledge event."""
# Print a list of all on going maintenance
manager = AccountManager(env.client)
event = manager.get_event(identifier)
if ack:
manager.ack_event(identifier)
env.fout(basic_event_table(ev... |
def basic_event_table(event):
"""Formats a basic event table"""
table = formatting.Table(["Id", "Status", "Type", "Start", "End"],
title=utils.clean_splitlines(event.get('subject')))
table.add_row([
event.get('id'),
utils.lookup(event, 'statusCode', 'name'),
... |
def impacted_table(event):
"""Formats a basic impacted resources table"""
table = formatting.Table([
"Type", "Id", "Hostname", "PrivateIp", "Label"
])
for item in event.get('impactedResources', []):
table.add_row([
item.get('resourceType'),
item.get('resourceTable... |
def update_table(event):
"""Formats a basic event update table"""
update_number = 0
for update in event.get('updates', []):
header = "======= Update #%s on %s =======" % (update_number, utils.clean_time(update.get('startDate')))
click.secho(header, fg='green')
update_number = update_... |
def cli(env, sortby, columns, datacenter, username, storage_type):
"""List block storage."""
block_manager = SoftLayer.BlockStorageManager(env.client)
block_volumes = block_manager.list_block_volumes(datacenter=datacenter,
username=username,
... |
def cli(env):
"""List object storage endpoints."""
mgr = SoftLayer.ObjectStorageManager(env.client)
endpoints = mgr.list_endpoints()
table = formatting.Table(['datacenter', 'public', 'private'])
for endpoint in endpoints:
table.add_row([
endpoint['datacenter']['name'],
... |
def cli(env, identifier):
"""Cancel virtual servers."""
vsi = SoftLayer.VSManager(env.client)
vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS')
if not (env.skip_confirmations or formatting.no_going_back(vs_id)):
raise exceptions.CLIAbort('Aborted')
vsi.cancel_instance(vs_id) |
def cli(env, identifier):
"""Reflash server firmware."""
mgr = SoftLayer.HardwareManager(env.client)
hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'hardware')
if not (env.skip_confirmations or
formatting.confirm('This will power off the server with id %s and '
... |
def cli(env, volume_id):
"""Lists snapshot schedules for a given volume"""
file_manager = SoftLayer.FileStorageManager(env.client)
snapshot_schedules = file_manager.list_volume_schedules(volume_id)
table = formatting.Table(['id',
'active',
'... |
def cli(env):
"""List firewalls."""
mgr = SoftLayer.FirewallManager(env.client)
table = formatting.Table(['firewall id',
'type',
'features',
'server/vlan id'])
fwvlans = mgr.get_firewalls()
dedicated_firewalls... |
def cli(env, identifier):
"""Cancel a subnet."""
mgr = SoftLayer.NetworkManager(env.client)
subnet_id = helpers.resolve_id(mgr.resolve_subnet_ids, identifier,
name='subnet')
if not (env.skip_confirmations or formatting.no_going_back(subnet_id)):
raise excepti... |
def get_settings_from_client(client):
"""Pull out settings from a SoftLayer.BaseClient instance.
:param client: SoftLayer.BaseClient instance
"""
settings = {
'username': '',
'api_key': '',
'timeout': '',
'endpoint_url': '',
}
try:
settings['username'] = ... |
def config_table(settings):
"""Returns a config table."""
table = formatting.KeyValueTable(['name', 'value'])
table.align['name'] = 'r'
table.align['value'] = 'l'
table.add_row(['Username', settings['username'] or 'not set'])
table.add_row(['API Key', settings['api_key'] or 'not set'])
table... |
def cli(env, name, backend_router_id, flavor, instances, test=False):
"""Create a Reserved Capacity instance.
*WARNING*: Reserved Capacity is on a yearly contract and not cancelable until the contract is expired.
"""
manager = CapacityManager(env.client)
result = manager.create(
name=name,... |
def cli(env, account_id):
"""List origin pull mappings."""
manager = SoftLayer.CDNManager(env.client)
origins = manager.get_origins(account_id)
table = formatting.Table(['id', 'media_type', 'cname', 'origin_url'])
for origin in origins:
table.add_row([origin['id'],
... |
def cli(env):
"""List options for creating a placement group."""
manager = PlacementManager(env.client)
routers = manager.get_routers()
env.fout(get_router_table(routers))
rules = manager.get_all_rules()
env.fout(get_rule_table(rules)) |
def get_router_table(routers):
"""Formats output from _get_routers and returns a table. """
table = formatting.Table(['Datacenter', 'Hostname', 'Backend Router Id'], "Available Routers")
for router in routers:
datacenter = router['topLevelLocation']['longName']
table.add_row([datacenter, rou... |
def get_rule_table(rules):
"""Formats output from get_all_rules and returns a table. """
table = formatting.Table(['Id', 'KeyName'], "Rules")
for rule in rules:
table.add_row([rule['id'], rule['keyName']])
return 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,... |
def _cli_helper_dedicated_host(env, result, table):
"""Get details on dedicated host for a virtual server."""
dedicated_host_id = utils.lookup(result, 'dedicatedHost', 'id')
if dedicated_host_id:
table.add_row(['dedicated_host_id', dedicated_host_id])
# Try to find name of dedicated host
... |
def cli(env, identifier, wait):
"""Check if a virtual server is ready."""
vsi = SoftLayer.VSManager(env.client)
vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS')
ready = vsi.wait_for_ready(vs_id, wait)
if ready:
env.fout("READY")
else:
raise exceptions.CLIAbort("Inst... |
def cli(env, volume_id, replicant_id, immediate):
"""Failover a block volume to the given replicant volume."""
block_storage_manager = SoftLayer.BlockStorageManager(env.client)
success = block_storage_manager.failover_to_replicant(
volume_id,
replicant_id,
immediate
)
if su... |
def cli(env, identifier):
"""Cancel a dedicated host server immediately"""
mgr = SoftLayer.DedicatedHostManager(env.client)
host_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'dedicated host')
if not (env.skip_confirmations or formatting.no_going_back(host_id)):
raise exceptions.CLIAbo... |
def get_image(self, image_id, **kwargs):
"""Get details about an image.
:param int image: The ID of the image.
:param dict \\*\\*kwargs: response-level options (mask, limit, etc.)
"""
if 'mask' not in kwargs:
kwargs['mask'] = IMAGE_MASK
return self.vgbdtg.ge... |
def list_private_images(self, guid=None, name=None, **kwargs):
"""List all private images.
:param string guid: filter based on GUID
:param string name: filter based on name
:param dict \\*\\*kwargs: response-level options (mask, limit, etc.)
"""
if 'mask' not in kwargs:
... |
def list_public_images(self, guid=None, name=None, **kwargs):
"""List all public images.
:param string guid: filter based on GUID
:param string name: filter based on name
:param dict \\*\\*kwargs: response-level options (mask, limit, etc.)
"""
if 'mask' not in kwargs:
... |
def _get_ids_from_name_public(self, name):
"""Get public images which match the given name."""
results = self.list_public_images(name=name)
return [result['id'] for result in results] |
def _get_ids_from_name_private(self, name):
"""Get private images which match the given name."""
results = self.list_private_images(name=name)
return [result['id'] for result in results] |
def edit(self, image_id, name=None, note=None, tag=None):
"""Edit image related details.
:param int image_id: The ID of the image
:param string name: Name of the Image.
:param string note: Note of the image.
:param string tag: Tags of the image to be updated to.
"""
... |
def import_image_from_uri(self, name, uri, os_code=None, note=None,
ibm_api_key=None, root_key_crn=None,
wrapped_dek=None, cloud_init=False,
byol=False, is_encrypted=False):
"""Import a new image from object storage.
... |
def export_image_to_uri(self, image_id, uri, ibm_api_key=None):
"""Export image into the given object storage
:param int image_id: The ID of the image
:param string uri: The URI for object storage of the format
swift://<objectStorageAccount>@<cluster>/<container>/<objectPath>
... |
def cli(env, identifier, credential_id):
"""Delete the credential of an Object Storage Account."""
mgr = SoftLayer.ObjectStorageManager(env.client)
credential = mgr.delete_credential(identifier, credential_id=credential_id)
env.fout(credential) |
def list(self):
"""List Reserved Capacities"""
mask = """mask[availableInstanceCount, occupiedInstanceCount,
instances[id, billingItem[description, hourlyRecurringFee]], instanceCount, backendRouter[datacenter]]"""
results = self.client.call('Account', 'getReservedCapacityGroups', mask=mask)
... |
def get_object(self, identifier, mask=None):
"""Get a Reserved Capacity Group
:param int identifier: Id of the SoftLayer_Virtual_ReservedCapacityGroup
:param string mask: override default object Mask
"""
if mask is None:
mask = "mask[instances[billingItem[item[keyNam... |
def get_create_options(self):
"""List available reserved capacity plans"""
mask = "mask[attributes,prices[pricingLocationGroup]]"
results = self.ordering_manager.list_items(self.capacity_package, mask=mask)
return results |
def get_available_routers(self, dc=None):
"""Pulls down all backendRouterIds that are available
:param string dc: A specific location to get routers for, like 'dal13'.
:returns list: A list of locations where RESERVED_CAPACITY can be ordered.
"""
mask = "mask[locations]"
... |
def create(self, name, backend_router_id, flavor, instances, test=False):
"""Orders a Virtual_ReservedCapacityGroup
:param string name: Name for the new reserved capacity
:param int backend_router_id: This selects the pod. See create_options for a list
:param string flavor: Capacity Key... |
def create_guest(self, capacity_id, test, guest_object):
"""Turns an empty Reserve Capacity into a real Virtual Guest
:param int capacity_id: ID of the RESERVED_CAPACITY_GROUP to create this guest into
:param bool test: True will use verifyOrder, False will use placeOrder
:param diction... |
def cli(env):
"""List Reserved Capacity groups."""
manager = CapacityManager(env.client)
result = manager.list()
table = formatting.Table(
["ID", "Name", "Capacity", "Flavor", "Location", "Created"],
title="Reserved Capacity"
)
for r_c in result:
occupied_string = "#" * i... |
def cli(env, package_keyname, location, preset, name, send_email, complex_type,
extras, order_items):
"""Place a quote.
This CLI command is used for creating a quote of the specified package in
the given location (denoted by a datacenter's long name). Orders made via the CLI
can then be conver... |
def cli(env, volume_id, notes):
"""Creates a snapshot on a given volume"""
file_storage_manager = SoftLayer.FileStorageManager(env.client)
snapshot = file_storage_manager.create_snapshot(volume_id, notes=notes)
if 'id' in snapshot:
click.echo('New snapshot created with id: %s' % snapshot['id'])... |
def cli(env):
"""List all active quotes on an account"""
table = formatting.Table([
'Id', 'Name', 'Created', 'Expiration', 'Status', 'Package Name', 'Package Id'
])
table.align['Name'] = 'l'
table.align['Package Name'] = 'r'
table.align['Package Id'] = 'l'
manager = ordering.Orderin... |
def cli(env, identifier):
"""Delete an image."""
image_mgr = SoftLayer.ImageManager(env.client)
image_id = helpers.resolve_id(image_mgr.resolve_ids, identifier, 'image')
image_mgr.delete_image(image_id) |
def cli(env, snapshot_id):
"""Deletes a snapshot on a given volume"""
file_storage_manager = SoftLayer.FileStorageManager(env.client)
deleted = file_storage_manager.delete_snapshot(snapshot_id)
if deleted:
click.echo('Snapshot %s deleted' % snapshot_id) |
def cli(env, identifier, enabled, port, weight, healthcheck_type, ip_address):
"""Adds a new load balancer service."""
mgr = SoftLayer.LoadBalancerManager(env.client)
loadbal_id, group_id = loadbal.parse_id(identifier)
# check if the IP is valid
ip_address_id = None
if ip_address:
ip_... |
def cli(ctx, env):
"""Enters a shell for slcli."""
# Set up the environment
env = copy.deepcopy(env)
env.load_modules_from_python(routes.ALL_ROUTES)
env.aliases.update(routes.ALL_ALIASES)
env.vars['global_args'] = ctx.parent.params
env.vars['is_shell'] = True
env.vars['last_exit_code'] ... |
def get_env_args(env):
"""Yield options to inject into the slcli command from the environment."""
for arg, val in env.vars.get('global_args', {}).items():
if val is True:
yield '--%s' % arg
elif isinstance(val, int):
for _ in range(val):
yield '--%s' % arg... |
def cli(env, identifier, purge):
"""Delete a placement group.
Placement Group MUST be empty before you can delete it.
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, id... |
def cli(env):
"""List routing types."""
mgr = SoftLayer.LoadBalancerManager(env.client)
routing_types = mgr.get_routing_types()
table = formatting.KeyValueTable(['ID', 'Name'])
table.align['ID'] = 'l'
table.align['Name'] = 'l'
table.sortby = 'ID'
for routing_type in routing_types:
... |
def cli(env, context_id, translation_id, static_ip, remote_ip, note):
"""Update an address translation for an IPSEC tunnel context.
A separate configuration request should be made to realize changes on
network devices.
"""
manager = SoftLayer.IPSECManager(env.client)
succeeded = manager.update_... |
def cli(env, identifier, details):
"""Invoices and all that mess"""
manager = AccountManager(env.client)
top_items = manager.get_billing_items(identifier)
title = "Invoice %s" % identifier
table = formatting.Table(["Item Id", "Category", "Description", "Single",
"Mont... |
def cli(ctx, env):
"""Print shell help text."""
env.out("Welcome to the SoftLayer shell.")
env.out("")
formatter = formatting.HelpFormatter()
commands = []
shell_commands = []
for name in cli_core.cli.list_commands(ctx):
command = cli_core.cli.get_command(ctx, name)
if comma... |
def cli(env, identifier, postinstall, key):
"""Reload operating system on a server."""
hardware = SoftLayer.HardwareManager(env.client)
hardware_id = helpers.resolve_id(hardware.resolve_ids,
identifier,
'hardware')
key_list = []
... |
def cli(env, identifier, enabled, port, weight, healthcheck_type, ip_address):
"""Edit the properties of a service group."""
mgr = SoftLayer.LoadBalancerManager(env.client)
loadbal_id, service_id = loadbal.parse_id(identifier)
# check if any input is provided
if ((not any([ip_address, weight, por... |
def cli(env, sortby, datacenter, identifier, subnet_type, network_space, ipv4, ipv6):
"""List subnets."""
mgr = SoftLayer.NetworkManager(env.client)
table = formatting.Table([
'id', 'identifier', 'type', 'network_space', 'datacenter', 'vlan_id',
'IPs', 'hardware', 'vs',
])
table.so... |
def cli(env, target, firewall_type, high_availability):
"""Create new firewall.
TARGET: Id of the server the firewall will protect
"""
mgr = SoftLayer.FirewallManager(env.client)
if not env.skip_confirmations:
if firewall_type == 'vlan':
pkg = mgr.get_dedicated_package(ha_enab... |
def cli(env, account_id, content_url):
"""Purge cached files from all edge nodes.
Examples:
slcli cdn purge 97794 http://example.com/cdn/file.txt
slcli cdn purge 97794 http://example.com/cdn/file.txt https://dal01.example.softlayer.net/image.png
"""
manager = SoftLayer.CDNManager(env... |
def retry(ex=RETRIABLE, tries=4, delay=5, backoff=2, logger=None):
"""Retry calling the decorated function using an exponential backoff.
http://www.saltycrane.com/blog/2009/11/trying-out-retry-decorator-python/
original from: http://wiki.python.org/moin/PythonDecoratorLibrary#Retry
:param ex: the exce... |
def cli(env, package_keyname):
"""List Datacenters a package can be ordered in.
Use the location Key Name to place orders
"""
manager = ordering.OrderingManager(env.client)
table = formatting.Table(COLUMNS)
locations = manager.package_locations(package_keyname)
for region in locations:
... |
def cli(env, abuse, address1, address2, city, company, country, firstname,
lastname, postal, public, state):
"""Edit the RWhois data on the account."""
mgr = SoftLayer.NetworkManager(env.client)
update = {
'abuse_email': abuse,
'address1': address1,
'address2': address2,
... |
def _parse_create_args(client, args):
"""Converts CLI arguments to args for VSManager.create_instance.
:param dict args: CLI arguments
"""
data = {}
if args.get('quantity'):
data['quantity'] = int(args.get('quantity'))
if args.get('postinstall'):
data['provisionScripts'] = [arg... |
def cli(env, quote, **args):
"""View and Order a quote
\f
:note:
The hostname and domain are split out from the fully qualified domain name.
If you want to order multiple servers, you need to specify each FQDN. Postinstall, userdata, and
sshkeys are applied to all servers in an ord... |
def authorize_host_to_volume(self, volume_id,
hardware_ids=None,
virtual_guest_ids=None,
ip_address_ids=None,
**kwargs):
"""Authorizes hosts to Block Storage Volumes
:para... |
def order_replicant_volume(self, volume_id, snapshot_schedule,
location, tier=None, os_type=None):
"""Places an order for a replicant block volume.
:param volume_id: The ID of the primary volume to be replicated
:param snapshot_schedule: The primary volume's snaps... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.