pax_global_header00006660000000000000000000000064126770372110014520gustar00rootroot0000000000000052 comment=0c2ad48ea6f8e237e6d98b97c744fcca0c32b5a9 softlayer-python-5.0.1/000077500000000000000000000000001267703721100150525ustar00rootroot00000000000000softlayer-python-5.0.1/.gitignore000066400000000000000000000001601267703721100170370ustar00rootroot00000000000000.DS_Store *.swp Thumbs.db .svn ._* *.pyc .coverage htmlcov cover/* .tox docs/_build/* build/* dist/* *.egg-info softlayer-python-5.0.1/.travis.yml000066400000000000000000000010021267703721100171540ustar00rootroot00000000000000language: python sudo: false matrix: include: - python: "2.7" env: TOX_ENV=py27 - python: "3.3" env: TOX_ENV=py33 - python: "3.4" env: TOX_ENV=py34 - python: "3.5" env: TOX_ENV=py35 - python: "pypy" env: TOX_ENV=pypy - python: "2.7" env: TOX_ENV=analysis - python: "2.7" env: TOX_ENV=coverage install: - pip install tox - pip install coveralls script: - tox -e $TOX_ENV after_success: - if [[ $TOX_ENV = "coverage" ]]; then coveralls; fi softlayer-python-5.0.1/CHANGELOG000066400000000000000000000256671267703721100163040ustar00rootroot000000000000005.0.1 * Adds missing depdendency that was previously pulled in by prompt_toolkit * Fix a bug by updating the CDN manager to use the new purge method * Fixes bug that occured when iscsi listings with resources have no datacenter 5.0.0 * Adds a shell (accessable with `slcli shell`) which provides autocomplete for slcli commands and options * Move modifying nic speed to `slcli virtual edit` and `slcli hardware edit` instead of having its own command * How filters work with `slcli call-api` has changed significantly. Instead of accepting JSON, it now accepts an easier-to-use format. See `slcli call-api -h` for examples * Adds manager for object storage * 'virtual' and 'hardware' are preferred over 'vs' and 'server' in the CLI * Improved REST transport support * Many bug fixes 4.1.1 * Fixes to work with Click v5 * Re-adds `--no-public` option to only provision private interfaces with servers via `slcli server create` * Removes non-functional `--vlan-public` and `--vlan-private` from `slcli server create` * VSManager.wait_for_ready will now behave as it is documented to behave. 4.1.0 * Adds a shell which provides a shell interface for `slcli`. This is available by using `slcli shell` * `slcli vs create` and `slcli server create` will now prompt for missing required options * Fixes `slcli firewall add` command * Handles case where `slcli vs detail` and `slcli server detail` was causing an error when trying to display the creator * Fixes VSManager.verify_create_instance() with tags (and, in turn, `slcli vs create --test` with tags) * Fixes `vs resume` command * Updates hardware ordering to deal with location-specific prices * Fixes several description errors in the CLI * Running `vs edit` without a tag option will no longer remove all tags * Adds editing of hardware tags 4.0.4 * Fixes bug with pulling the userData property for the virtual server detail * Fixes a class of bugs invloving unicode from the API 4.0.3 * Fixes bug with `slcli vs ready` command * Fixes bug with `slcli loadbal service-add` command * Fixes bug with `slcli vlan list` with vlans that don't have a datacenter * Improves validation of virtual server and hardware create commands 4.0.2 * Fixes a bug that breaks user confirmation prompts * Fixes general issue with sorting on certain row types in the CLI * Fixes image capture for Windows guests 4.0.1 * Fixes bug in `sl setup` command not properly defaulting to current values. * Fixes bug where turning off compression headers would still send compression headers. * Reverts to using ids over global identifiers for `sl vs list` and `sl server list`. 4.0.0 * Because there are many changes between version 3 and version 4, it is strongly recommend to pin the version of the SoftLayer python bindings as soon as you can in order to prevent unintentional breakage when upgrading. To keep yourself on version 3, you can use this directive: softlayer>=3,<4. That can be used with pip (pip install softlayer>=3,<4), requirements in your setup.py and/or in your requirements.txt file. * CLI: The command is renamed from `sl` to `slcli` to avoid package conflicts. * CLI: Global options now need to be specified right after the `slcli` command. For example, you would now use `slcli --format=raw list` over `slcli vs list --format=raw`. This is a change for the following options: * --format * -c or --config * --debug * --proxy * -y or --really * --version * API: The hardware manager has a significant update to how place_order() works. It will now only support the fast server provisioning package which has presets for options like CPU, Memory and disk. * API: The client transport is now pluggable. If you want to add extra logging or accounting, you can now subclass or wrap softlayer.transports.XmlRpcTransport in order to do so. A good example of that is done with softlayer.transports.TimingTransport. * API: Removed deprecated SoftLayer.CCIManager. * API: Adds virtual server rescue command to SoftLayer.VSManager * API+CLI: Adds ability to import virtual images from a given URI. The API only supports importing from a swift account using 'swift://'. For more details, see http://developer.softlayer.com/reference/services/SoftLayer_Virtual_Guest_Block_Device_Template_Group/createFromExternalSource. * CLI: A `--fixtures` global flag was added to pull from fixture data instead of the API. This is useful for discovery, demonstration and testing purposes. * CLI: A `--verbose` or `-v` flag was added to eventually replace `--debug`. To make a command more verbose, simply add more `-v` flags. For example `sl -vvv vs list` will be the most verbose and show everything down to request/response tracing. * CLI: Significant changes were done to the CLI argument parsing. Docopt was dropped in favor of click. Therefore, some subtle differences which aren't documented here may exist. * CLI: Credentials can now be requested using `sl vs credentials `, `sl hardware credentials ` and `sl nas credentials ` for virtual servers, hardware servers and NAS accounts respectively. * CLI: Adds virtual server rescue command, `sl vs rescue ` 3.3.0 * CLI+API: Load balancer support * CLI: More detail added to the `sl image detail` and `sl image list` commands * CLI: Adds command to import DNS entries from BIND zone files * CLI+API: Adds support for booting into rescue images for virtual servers and hardware * API: Adds ability to order virtual and hardare servers from a quote to the ordering manager * CLI: Fixes bug with `sl server list-chassis` and `sl server list-chassis` * API: Restructure of the way custom authentication can be plugged in the API client * Several other bug fixes 3.2.0 * CLI+API: Added firewall manager and CLI module * CLI+API: Added iscsi manager and CLI module * API: Added ability to create multiple virtual servers at once to VSManager * API: Added OrderingManager. Remove hard-coded price IDs * Fixed several small bugs 3.1.0 * CLI+API: Added CDN manager and CLI module * CLI+API: Added ticket manager and CLI module * CLI+API: Added image manager and improves image CLI module * CLI+API: Added the ability to specify a proxy URL for API bindings and the CLI * API: six is now used to provide support for Python 2 and Python 3 with the same source * CLI+API: Added ability to resize a virtual machine * CLI+API: Implemented product name changes in accordance with SoftLayer's new product names. Existing managers should continue to work as before. Minor CLI changes were necessary. * CLI+API: Added firewall manager and CLI module * CLI+API: Added load balancer manager and CLI module * Many bug fixes and minor suggested improvements 3.0.2 * CLI+API: Simplified object mask reformatting and added support for more complex masks. * CLI: Fixed the sl bmc create --network argument. * CLI+API: Improved output of the message queue feature and fixed some minor bugs. * CLI: Fixed an error when using --test and ordering a non-private subnet. * API: Fix to prevent double counting results in summary_by_datacenter(). * CLI+API: Added IPMI IP address to hardware details. * CLI: Added support for ordering multiple disks when creating a CCI. * API: Added flag to disable compression on HTTP requests. * CLI: Added CIDR information to subnet displays. 3.0.1 * CLI: Fixed an error message about pricing information that appeared when ordering a new private subnet. * CLI+API: Added ability to specify SSH keys when reloading CCIs and servers. 3.0.0 * Many bug fixes and consistency improvements * API: Removes old API client interfaces which have been deprecated in the v2. See link for more details: https://softlayer-api-python-client.readthedocs.org/en/latest/api/client/#backwards-compatibility * CLI+API: Improved dedicated server ordering. Adds power management for hardware servers: power-on, power-off, power-cycle, reboot * CLI+API: Adds a networking manager and adds several network-related CLI modules. This includes the ability to: * list, create, cancel and assign global IPs * list, create, cancel and detail subnets. Also has the ability to lookup details about an IP address with 'sl subnet lookup' * list, detail VLANs * show and edit RWhois data * CLI+API: Adds SoftLayer Message Queue Service bindings (as a manager) and a CLI counterpart. With this you can interact with existing message queue accounts * CLI+API: Ability to manage SSH Keys with a manager and a CLI module * CLI+API: Adds the ability to create CCIs with the following options: metadata, post-install script, SSH key * CLI: Adds templating for creating CCIs and hardware nodes which can be used to create more CCIs and hardware with the same settings * CLI+API: Adds the ability to create hardware servers with a default SSH key * CLI: Adds a --debug option to print out debugging information. --debug=3 is the highest log level which prints full HTTP request/responses including the body * CLI: The commands in the main help are now organized into categories 2.3.0 * Several bug fixes and improvements * Removed Python 2.5 support. Some stuff MIGHT work with 2.5 but it is no longer tested * API: Refactored managers into their own module to not clutter the top level * CLI+API: Added much more hardware support: Filters for hardware listing, dedicated server/bare metal cloud ordering, hardware cancellation * CLI+API: Added DNS Zone filtering (server side) * CLI+API: Added Post Install script support for CCIs and hardware * CLI: Added Message queue functionality * CLI: Added --debug option to CLI commands * API: Added more logging * API: Added token-based auth so you can use the API bindings with your username/password if you want. (It's still highly recommended to use your API key instead of your password) 2.2.0 * Consistency changes/bug fixes * Added sphinx documentation. See it here: https://softlayer-api-python-client.readthedocs.org * CCI: Adds Support for Additional Disks * CCI: Adds a way to block until transactions are done on a CCI * CLI: For most CCI commands, you can specify id, hostname, private ip or public ip as * CLI: Adds the ability to filter list results for CCIs * API: for large result sets, requests can now be chunked into smaller batches on the server side. Using service.iter_call('getObjects', ...) or service.getObjects(..., iter=True) will return a generator regardless of the results returned. offset and limit can be passed in like normal. An additional named parameter of 'chunk' is used to limit the number of items coming back in a single request, defaults to 100 softlayer-python-5.0.1/CONTRIBUTING.md000066400000000000000000000011521267703721100173020ustar00rootroot00000000000000# Contributing to softlayer-python We are happy to accept contributions to softlayer-python. Please follow the guidelines below. * Sign our contributor agreement (CLA) You can find the [CLA here](./docs/cla-individual.md). * If you're contributing on behalf of your employer we'll need a signed copy of our corporate contributor agreement (CCLA) as well. You can find the [CCLA here](./docs/cla-corporate.md). * Fork the repo, make your changes, and open a pull request. * Additional infomration can be found in our [contribution guide](http://softlayer-python.readthedocs.org/en/latest/dev/index.html) softlayer-python-5.0.1/CONTRIBUTORS000066400000000000000000000021541267703721100167340ustar00rootroot00000000000000Amol Jadhav Aparna Patil Boden Russell Brian Cline chechuironman Christopher Gallo David Ibarra Hans Kristian Moen Jake Williams Jason Johnson Kevin Landreth Kevin McDonald Łukasz Oleś Nathan Beittenmiller Neetu Jain Paul Sroufe Phil Jackson Robert Chumbley Ryan Hanson Scott Thompson Sergio Carlos Shane Poage simplydave SoftLayer suppandi Swapnil Khanapurkar The SoftLayer Developer Network Tim Ariyeh Wissam Elriachy softlayer-python-5.0.1/ISSUE_TEMPLATE000066400000000000000000000002101267703721100171510ustar00rootroot00000000000000### Expected Behavior ### Actual Behavior ### Environment Information Operating System: softlayer-python version (`slcli --version`): softlayer-python-5.0.1/LICENSE000066400000000000000000000021051267703721100160550ustar00rootroot00000000000000Copyright (c) 2016 SoftLayer Technologies, Inc. All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. softlayer-python-5.0.1/MANIFEST.in000066400000000000000000000000431267703721100166050ustar00rootroot00000000000000include LICENSE include README.rst softlayer-python-5.0.1/README.rst000066400000000000000000000051371267703721100165470ustar00rootroot00000000000000SoftLayer API Python Client =========================== .. image:: https://travis-ci.org/softlayer/softlayer-python.svg?branch=master :target: https://travis-ci.org/softlayer/softlayer-python .. image:: https://landscape.io/github/softlayer/softlayer-python/master/landscape.svg :target: https://landscape.io/github/softlayer/softlayer-python/master .. image:: https://badge.fury.io/py/SoftLayer.svg :target: http://badge.fury.io/py/SoftLayer .. image:: https://coveralls.io/repos/softlayer/softlayer-python/badge.svg :target: https://coveralls.io/r/softlayer/softlayer-python This library provides a simple Python client to interact with `SoftLayer's XML-RPC API `_. A command-line interface is also included and can be used to manage various SoftLayer products and services. Documentation ------------- Documentation for the Python client is available at http://softlayer.github.io/softlayer-python/. Additional API documentation can be found on the SoftLayer Development Network: * `SoftLayer API reference `_ * `Object mask information and examples `_ Installation ------------ Install via pip: .. code-block:: bash $ pip install softlayer Or you can install from source. Download source and run: .. code-block:: bash $ python setup.py install The most up-to-date version of this library can be found on the SoftLayer GitHub public repositories at http://github.com/softlayer. Please post to Stack Overflow at https://stackoverflow.com/ or open a support ticket in the customer portal if you have any questions regarding use of this library. If you use Stack Overflow please tag your posts with “SoftLayer” so our team can easily find your post. InsecurePlatformWarning Notice ------------------------------ This library relies on the `requests `_ library to make HTTP requests. On Python versions below Python 2.7.9, requests has started emitting a security warning (InsecurePlatformWarning) due to insecurities with creating SSL connections. To resolve this, upgrade to Python 2.7.9+ or follow the instructions here: http://stackoverflow.com/a/29099439. System Requirements ------------------- * Python 2.7, 3.3, or 3.4. * A valid SoftLayer API username and key. * A connection to SoftLayer's private network is required to use our private network API endpoints. Copyright --------- This software is Copyright (c) 2016 SoftLayer Technologies, Inc. See the bundled LICENSE file for more information. softlayer-python-5.0.1/SoftLayer/000077500000000000000000000000001267703721100167625ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/API.py000066400000000000000000000312241267703721100177470ustar00rootroot00000000000000""" SoftLayer.API ~~~~~~~~~~~~~ SoftLayer API bindings :license: MIT, see LICENSE for more details. """ import warnings from SoftLayer import auth as slauth from SoftLayer import config from SoftLayer import consts from SoftLayer import transports # pylint: disable=invalid-name API_PUBLIC_ENDPOINT = consts.API_PUBLIC_ENDPOINT API_PRIVATE_ENDPOINT = consts.API_PRIVATE_ENDPOINT __all__ = [ 'create_client_from_env', 'Client', 'BaseClient', 'API_PUBLIC_ENDPOINT', 'API_PRIVATE_ENDPOINT', ] VALID_CALL_ARGS = set(( 'id', 'mask', 'filter', 'headers', 'compress', 'raw_headers', 'limit', 'offset', )) def create_client_from_env(username=None, api_key=None, endpoint_url=None, timeout=None, auth=None, config_file=None, proxy=None, user_agent=None, transport=None): """Creates a SoftLayer API client using your environment. Settings are loaded via keyword arguments, environemtal variables and config file. :param username: an optional API username if you wish to bypass the package's built-in username :param api_key: an optional API key if you wish to bypass the package's built in API key :param endpoint_url: the API endpoint base URL you wish to connect to. Set this to API_PRIVATE_ENDPOINT to connect via SoftLayer's private network. :param proxy: proxy to be used to make API calls :param integer timeout: timeout for API requests :param auth: an object which responds to get_headers() to be inserted into the xml-rpc headers. Example: `BasicAuthentication` :param config_file: A path to a configuration file used to load settings :param user_agent: an optional User Agent to report when making API calls if you wish to bypass the packages built in User Agent string :param transport: An object that's callable with this signature: transport(SoftLayer.transports.Request) Usage: >>> import SoftLayer >>> client = SoftLayer.create_client_from_env() >>> resp = client.call('Account', 'getObject') >>> resp['companyName'] 'Your Company' """ settings = config.get_client_settings(username=username, api_key=api_key, endpoint_url=endpoint_url, timeout=timeout, proxy=proxy, config_file=config_file) # Default the transport to use XMLRPC if transport is None: transport = transports.XmlRpcTransport( endpoint_url=settings.get('endpoint_url'), proxy=settings.get('proxy'), timeout=settings.get('timeout'), user_agent=user_agent, ) # If we have enough information to make an auth driver, let's do it if auth is None and settings.get('username') and settings.get('api_key'): # NOTE(kmcdonald): some transports mask other transports, so this is # a way to find the 'real' one real_transport = getattr(transport, 'transport', transport) if isinstance(real_transport, transports.XmlRpcTransport): auth = slauth.BasicAuthentication( settings.get('username'), settings.get('api_key'), ) elif isinstance(real_transport, transports.RestTransport): auth = slauth.BasicHTTPAuthentication( settings.get('username'), settings.get('api_key'), ) return BaseClient(auth=auth, transport=transport) def Client(**kwargs): """Get a SoftLayer API Client using environmental settings. Deprecated in favor of create_client_from_env() """ warnings.warn("use SoftLayer.create_client_from_env() instead", DeprecationWarning) return create_client_from_env(**kwargs) class BaseClient(object): """Base SoftLayer API client. :param auth: auth driver that looks like SoftLayer.auth.AuthenticationBase :param transport: An object that's callable with this signature: transport(SoftLayer.transports.Request) """ _prefix = "SoftLayer_" def __init__(self, auth=None, transport=None): self.auth = auth self.transport = transport def authenticate_with_password(self, username, password, security_question_id=None, security_question_answer=None): """Performs Username/Password Authentication :param string username: your SoftLayer username :param string password: your SoftLayer password :param int security_question_id: The security question id to answer :param string security_question_answer: The answer to the security question """ self.auth = None res = self.call('User_Customer', 'getPortalLoginToken', username, password, security_question_id, security_question_answer) self.auth = slauth.TokenAuthentication(res['userId'], res['hash']) return res['userId'], res['hash'] def __getitem__(self, name): """Get a SoftLayer Service. :param name: The name of the service. E.G. Account Usage: >>> import SoftLayer >>> client = SoftLayer.create_client_from_env() >>> client['Account'] """ return Service(self, name) def call(self, service, method, *args, **kwargs): """Make a SoftLayer API call :param service: the name of the SoftLayer API service :param method: the method to call on the service :param \\*args: same optional arguments that ``Service.call`` takes :param \\*\\*kwargs: same optional keyword arguments that ``Service.call`` takes :param service: the name of the SoftLayer API service Usage: >>> import SoftLayer >>> client = SoftLayer.create_client_from_env() >>> client.call('Account', 'getVirtualGuests', mask="id", limit=10) [...] """ if kwargs.pop('iter', False): return self.iter_call(service, method, *args, **kwargs) invalid_kwargs = set(kwargs.keys()) - VALID_CALL_ARGS if invalid_kwargs: raise TypeError( 'Invalid keyword arguments: %s' % ','.join(invalid_kwargs)) if self._prefix and not service.startswith(self._prefix): service = self._prefix + service http_headers = {'Accept': '*/*'} if kwargs.get('compress', True): http_headers['Accept-Encoding'] = 'gzip, deflate, compress' else: http_headers['Accept-Encoding'] = None if kwargs.get('raw_headers'): http_headers.update(kwargs.get('raw_headers')) request = transports.Request() request.service = service request.method = method request.args = args request.transport_headers = http_headers request.identifier = kwargs.get('id') request.mask = kwargs.get('mask') request.filter = kwargs.get('filter') request.limit = kwargs.get('limit') request.offset = kwargs.get('offset') if self.auth: extra_headers = self.auth.get_headers() if extra_headers: warnings.warn("auth.get_headers() is deprecated and will be " "removed in the next major version", DeprecationWarning) request.headers.update(extra_headers) request = self.auth.get_request(request) request.headers.update(kwargs.get('headers', {})) return self.transport(request) __call__ = call def iter_call(self, service, method, *args, **kwargs): """A generator that deals with paginating through results. :param service: the name of the SoftLayer API service :param method: the method to call on the service :param integer chunk: result size for each API call (defaults to 100) :param \\*args: same optional arguments that ``Service.call`` takes :param \\*\\*kwargs: same optional keyword arguments that ``Service.call`` takes """ chunk = kwargs.pop('chunk', 100) limit = kwargs.pop('limit', None) offset = kwargs.pop('offset', 0) if chunk <= 0: raise AttributeError("Chunk size should be greater than zero.") if limit: chunk = min(chunk, limit) result_count = 0 kwargs['iter'] = False while True: if limit: # We've reached the end of the results if result_count >= limit: break # Don't over-fetch past the given limit if chunk + result_count > limit: chunk = limit - result_count results = self.call(service, method, offset=offset, limit=chunk, *args, **kwargs) # It looks like we ran out results if not results: break # Apparently this method doesn't return a list. # Why are you even iterating over this? if not isinstance(results, list): yield results break for item in results: yield item result_count += 1 offset += chunk if len(results) < chunk: break def __repr__(self): return "Client(transport=%r, auth=%r)" % (self.transport, self.auth) __str__ = __repr__ def __len__(self): return 0 class Service(object): """A SoftLayer Service. :param client: A SoftLayer.API.Client instance :param name str: The service name """ def __init__(self, client, name): self.client = client self.name = name def call(self, name, *args, **kwargs): """Make a SoftLayer API call. :param method: the method to call on the service :param \\*args: (optional) arguments for the remote call :param id: (optional) id for the resource :param mask: (optional) object mask :param dict filter: (optional) filter dict :param dict headers: (optional) optional XML-RPC headers :param boolean compress: (optional) Enable/Disable HTTP compression :param dict raw_headers: (optional) HTTP transport headers :param int limit: (optional) return at most this many results :param int offset: (optional) offset results by this many :param boolean iter: (optional) if True, returns a generator with the results :param bool verify: verify SSL cert :param cert: client certificate path Usage: >>> import SoftLayer >>> client = SoftLayer.create_client_from_env() >>> client['Account'].getVirtualGuests(mask="id", limit=10) [...] """ return self.client.call(self.name, name, *args, **kwargs) __call__ = call def iter_call(self, name, *args, **kwargs): """A generator that deals with paginating through results. :param method: the method to call on the service :param integer chunk: result size for each API call :param \\*args: same optional arguments that ``Service.call`` takes :param \\*\\*kwargs: same optional keyword arguments that ``Service.call`` takes Usage: >>> import SoftLayer >>> client = SoftLayer.create_client_from_env() >>> gen = client.call('Account', 'getVirtualGuests', iter=True) >>> for virtual_guest in gen: ... virtual_guest['id'] ... 1234 4321 """ return self.client.iter_call(self.name, name, *args, **kwargs) def __getattr__(self, name): if name in ["__name__", "__bases__"]: raise AttributeError("'Obj' object has no attribute '%s'" % name) def call_handler(*args, **kwargs): " Handler that actually makes the API call " return self(name, *args, **kwargs) return call_handler def __repr__(self): return "" % (self.name,) __str__ = __repr__ softlayer-python-5.0.1/SoftLayer/CLI/000077500000000000000000000000001267703721100173715ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/__init__.py000066400000000000000000000003271267703721100215040ustar00rootroot00000000000000""" SoftLayer.CLI ~~~~~~~~~~~~~~ Contains all code related to the CLI interface :license: MIT, see LICENSE for more details. """ # pylint: disable=w0401 from SoftLayer.CLI.helpers import * # NOQA softlayer-python-5.0.1/SoftLayer/CLI/call_api.py000066400000000000000000000062531267703721100215150ustar00rootroot00000000000000"""Call arbitrary API endpoints.""" import click from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers from SoftLayer import utils 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: # split "some.key=value" into ["some.key", "value"] key, value = _filter.split('=', 1) current = root # split "some.key" into ["some", "key"] parts = [part.strip() for part in key.split('.')] # Actually drill down and add the filter for part in parts[:-1]: current = current[part] current[parts[-1]] = utils.query_filter(value.strip()) return root.to_dict() def _build_python_example(args, kwargs): sorted_kwargs = sorted(kwargs.items()) call_str = 'import SoftLayer\n\n' call_str += 'client = SoftLayer.create_client_from_env()\n' call_str += 'result = client.call(' arg_list = [repr(arg) for arg in args] arg_list += [key + '=' + repr(value) for key, value in sorted_kwargs if value] call_str += ',\n '.join(arg_list) call_str += ')' return call_str @click.command('call', short_help="Call arbitrary API endpoints.") @click.argument('service') @click.argument('method') @click.argument('parameters', nargs=-1) @click.option('--id', '_id', help="Init parameter") @helpers.multi_option('--filter', '-f', '_filters', help="Object filters. This should be of the form: " "'property=value' or 'nested.property=value'. Complex " "filters like betweenDate are not currently supported.") @click.option('--mask', help="String-based object mask") @click.option('--limit', type=click.INT, help="Result limit") @click.option('--offset', type=click.INT, help="Result offset") @click.option('--output-python / --no-output-python', help="Show python example code instead of executing the call") @environment.pass_env def cli(env, service, method, parameters, _id, _filters, mask, limit, offset, output_python=False): """Call arbitrary API endpoints with the given SERVICE and METHOD. \b Examples: slcli call-api Account getObject slcli call-api Account getVirtualGuests --limit=10 --mask=id,hostname slcli call-api Virtual_Guest getObject --id=12345 slcli call-api Metric_Tracking_Object getBandwidthData --id=1234 \\ "2015-01-01 00:00:00" "2015-01-1 12:00:00" public slcli call-api Account getVirtualGuests \\ -f 'virtualGuests.datacenter.name=dal05' \\ -f 'virtualGuests.maxCpu=4' \\ --mask=id,hostname,datacenter.name,maxCpu """ args = [service, method] + list(parameters) kwargs = { 'id': _id, 'filter': _build_filters(_filters), 'mask': mask, 'limit': limit, 'offset': offset, } if output_python: env.out(_build_python_example(args, kwargs)) else: result = env.client.call(*args, **kwargs) env.fout(formatting.iter_to_table(result)) softlayer-python-5.0.1/SoftLayer/CLI/cdn/000077500000000000000000000000001267703721100201355ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/cdn/__init__.py000066400000000000000000000001171267703721100222450ustar00rootroot00000000000000"""Content Delivery Network.""" # :license: MIT, see LICENSE for more details. softlayer-python-5.0.1/SoftLayer/CLI/cdn/detail.py000066400000000000000000000016231267703721100217530ustar00rootroot00000000000000"""Detail a CDN Account.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @click.argument('account_id') @environment.pass_env 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']]) table.add_row(['account_name', account['cdnAccountName']]) table.add_row(['type', account['cdnSolutionName']]) table.add_row(['status', account['status']['name']]) table.add_row(['created', account['createDate']]) table.add_row(['notes', account.get('cdnAccountNote', formatting.blank())]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/cdn/list.py000066400000000000000000000023441267703721100214650ustar00rootroot00000000000000"""List CDN Accounts.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @click.option('--sortby', help='Column to sort by', type=click.Choice(['id', 'datacenter', 'host', 'cores', 'memory', 'primary_ip', 'backend_ip'])) @environment.pass_env def cli(env, sortby): """List all CDN accounts.""" manager = SoftLayer.CDNManager(env.client) accounts = manager.list_accounts() table = formatting.Table(['id', 'account_name', 'type', 'created', 'notes']) for account in accounts: table.add_row([ account['id'], account['cdnAccountName'], account['cdnSolutionName'], account['createDate'], account.get('cdnAccountNote', formatting.blank()) ]) table.sortby = sortby env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/cdn/load.py000066400000000000000000000007241267703721100214310ustar00rootroot00000000000000"""Cache one or more files on all edge nodes.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment @click.command() @click.argument('account_id') @click.argument('content_url', nargs=-1) @environment.pass_env def cli(env, account_id, content_url): """Cache one or more files on all edge nodes.""" manager = SoftLayer.CDNManager(env.client) manager.load_content(account_id, content_url) softlayer-python-5.0.1/SoftLayer/CLI/cdn/origin_add.py000066400000000000000000000013551267703721100226120ustar00rootroot00000000000000"""Create an origin pull mapping.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment # pylint: disable=redefined-builtin @click.command() @click.argument('account_id') @click.argument('content_url') @click.option('--type', help='The media type for this mapping (http, flash, wm, ...)', default='http', show_default=True) @click.option('--cname', help='An optional CNAME to attach to the mapping') @environment.pass_env def cli(env, account_id, content_url, type, cname): """Create an origin pull mapping.""" manager = SoftLayer.CDNManager(env.client) manager.add_origin(account_id, type, content_url, cname) softlayer-python-5.0.1/SoftLayer/CLI/cdn/origin_list.py000066400000000000000000000013311267703721100230270ustar00rootroot00000000000000"""List origin pull mappings.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @click.argument('account_id') @environment.pass_env 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'], origin['mediaType'], origin.get('cname', formatting.blank()), origin['originUrl']]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/cdn/origin_remove.py000066400000000000000000000006551267703721100233610ustar00rootroot00000000000000"""Remove an origin pull mapping.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment @click.command() @click.argument('account_id') @click.argument('origin_id') @environment.pass_env def cli(env, account_id, origin_id): """Remove an origin pull mapping.""" manager = SoftLayer.CDNManager(env.client) manager.remove_origin(account_id, origin_id) softlayer-python-5.0.1/SoftLayer/CLI/cdn/purge.py000066400000000000000000000007171267703721100216360ustar00rootroot00000000000000"""Purge cached files from all edge nodes.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment @click.command() @click.argument('account_id') @click.argument('content_url', nargs=-1) @environment.pass_env def cli(env, account_id, content_url): """Purge cached files from all edge nodes.""" manager = SoftLayer.CDNManager(env.client) manager.purge_content(account_id, content_url) softlayer-python-5.0.1/SoftLayer/CLI/columns.py000066400000000000000000000043761267703721100214350ustar00rootroot00000000000000""" SoftLayer.CLI.columns ~~~~~~~~~~~~~~~~~~~~~~ Utilties for user-defined columns :license: MIT, see LICENSE for more details. """ import click from SoftLayer import utils # pylint: disable=unused-argument class Column(object): """Column desctribes an attribute and how to fetch/display it.""" def __init__(self, name, path, mask=None): self.name = name self.path = path self.mask = mask # If the mask is not set explicitly, infer it from the path if self.mask is None and isinstance(path, (tuple, list)): self.mask = '.'.join(path) class ColumnFormatter(object): """Maps each column using a function""" def __init__(self): self.columns = [] self.column_funcs = [] self.mask_parts = set() def add_column(self, column): """Add a new column along with a formatting function.""" self.columns.append(column.name) self.column_funcs.append(column.path) if column.mask is not None: self.mask_parts.add(column.mask) def row(self, data): """Return a formatted row for the given data.""" for column in self.column_funcs: if callable(column): yield column(data) else: yield utils.lookup(data, *column) def mask(self): """Returns a SoftLayer mask to fetch data needed for each column.""" return ','.join(self.mask_parts) def get_formatter(columns): """This function returns a callback to use with click options. The retuend function parses a comma-separated value and returns a new ColumnFormatter. :param columns: a list of Column instances """ column_map = dict((column.name, column) for column in columns) def validate(ctx, param, value): """Click validation function.""" if value == '': raise click.BadParameter('At least one column is required.') formatter = ColumnFormatter() for column in [col.strip() for col in value.split(',')]: if column in column_map: formatter.add_column(column_map[column]) else: formatter.add_column(Column(column, column.split('.'))) return formatter return validate softlayer-python-5.0.1/SoftLayer/CLI/config/000077500000000000000000000000001267703721100206365ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/config/__init__.py000066400000000000000000000027761267703721100227630ustar00rootroot00000000000000"""CLI configuration.""" # :license: MIT, see LICENSE for more details. from SoftLayer.CLI import formatting def _resolve_transport(transport): """recursively look for transports which refer to other transports.""" nested_transport = getattr(transport, 'transport', None) if nested_transport is not None: return nested_transport return _resolve_transport(nested_transport) 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'] = client.auth.username settings['api_key'] = client.auth.api_key except AttributeError: pass transport = _resolve_transport(client.transport) try: settings['timeout'] = transport.timeout settings['endpoint_url'] = transport.endpoint_url except AttributeError: pass return settings 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.add_row(['Endpoint URL', settings['endpoint_url'] or 'not set']) table.add_row(['Timeout', settings['timeout'] or 'not set']) return table softlayer-python-5.0.1/SoftLayer/CLI/config/setup.py000066400000000000000000000101761267703721100223550ustar00rootroot00000000000000"""Setup CLI configuration.""" # :license: MIT, see LICENSE for more details. import os.path import click import SoftLayer from SoftLayer import auth from SoftLayer.CLI import config from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer import utils def get_api_key(client, username, secret): """Attempts API-Key and password auth to get an API key. This will also generate an API key if one doesn't exist """ # Try to use a client with username/api key if len(secret) == 64: try: client.auth = auth.BasicAuthentication(username, secret) client['Account'].getCurrentUser() return secret except SoftLayer.SoftLayerAPIError as ex: if 'invalid api token' not in ex.faultString.lower(): raise else: # Try to use a client with username/password client.authenticate_with_password(username, secret) user_record = client['Account'].getCurrentUser( mask='id, apiAuthenticationKeys') api_keys = user_record['apiAuthenticationKeys'] if len(api_keys) == 0: return client['User_Customer'].addApiAuthenticationKey( id=user_record['id']) return api_keys[0]['authenticationKey'] @click.command() @environment.pass_env def cli(env): """Edit configuration.""" username, secret, endpoint_url, timeout = get_user_input(env) env.client.transport.transport.endpoint_url = endpoint_url api_key = get_api_key(env.client, username, secret) path = '~/.softlayer' if env.config_file: path = env.config_file config_path = os.path.expanduser(path) env.out(env.fmt(config.config_table({'username': username, 'api_key': api_key, 'endpoint_url': endpoint_url, 'timeout': timeout}))) if not formatting.confirm('Are you sure you want to write settings ' 'to "%s"?' % config_path, default=True): raise exceptions.CLIAbort('Aborted.') # Persist the config file. Read the target config file in before # setting the values to avoid clobbering settings parsed_config = utils.configparser.RawConfigParser() parsed_config.read(config_path) try: parsed_config.add_section('softlayer') except utils.configparser.DuplicateSectionError: pass parsed_config.set('softlayer', 'username', username) parsed_config.set('softlayer', 'api_key', api_key) parsed_config.set('softlayer', 'endpoint_url', endpoint_url) parsed_config.set('softlayer', 'timeout', timeout) config_fd = os.fdopen(os.open(config_path, (os.O_WRONLY | os.O_CREAT | os.O_TRUNC), 0o600), 'w') try: parsed_config.write(config_fd) finally: config_fd.close() env.fout("Configuration Updated Successfully") def get_user_input(env): """Ask for username, secret (api_key or password) and endpoint_url.""" defaults = config.get_settings_from_client(env.client) # Ask for username username = env.input('Username', default=defaults['username']) # Ask for 'secret' which can be api_key or their password secret = env.getpass('API Key or Password', default=defaults['api_key']) # Ask for which endpoint they want to use endpoint_type = env.input( 'Endpoint (public|private|custom)', default='public') endpoint_type = endpoint_type.lower() if endpoint_type is None: endpoint_url = SoftLayer.API_PUBLIC_ENDPOINT if endpoint_type == 'public': endpoint_url = SoftLayer.API_PUBLIC_ENDPOINT elif endpoint_type == 'private': endpoint_url = SoftLayer.API_PRIVATE_ENDPOINT elif endpoint_type == 'custom': endpoint_url = env.input('Endpoint URL', default=defaults['endpoint_url']) # Ask for timeout timeout = env.input('Timeout', default=defaults['timeout'] or 0) return username, secret, endpoint_url, timeout softlayer-python-5.0.1/SoftLayer/CLI/config/show.py000066400000000000000000000005601267703721100221710ustar00rootroot00000000000000"""Show current CLI configuration.""" # :license: MIT, see LICENSE for more details. import click from SoftLayer.CLI import config from SoftLayer.CLI import environment @click.command() @environment.pass_env def cli(env): """Show current configuration.""" settings = config.get_settings_from_client(env.client) env.fout(config.config_table(settings)) softlayer-python-5.0.1/SoftLayer/CLI/core.py000066400000000000000000000137651267703721100207070ustar00rootroot00000000000000""" SoftLayer.CLI.core ~~~~~~~~~~~~~~~~~~ Core for the SoftLayer CLI :license: MIT, see LICENSE for more details. """ from __future__ import print_function import logging import os import sys import time import types import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer import consts # pylint: disable=too-many-public-methods, broad-except, unused-argument # pylint: disable=redefined-builtin, super-init-not-called START_TIME = time.time() DEBUG_LOGGING_MAP = { 0: logging.CRITICAL, 1: logging.WARNING, 2: logging.INFO, 3: logging.DEBUG } VALID_FORMATS = ['table', 'raw', 'json'] DEFAULT_FORMAT = 'raw' if sys.stdout.isatty(): DEFAULT_FORMAT = 'table' class CommandLoader(click.MultiCommand): """Loads module for click.""" def __init__(self, *path, **attrs): click.MultiCommand.__init__(self, **attrs) self.path = path def list_commands(self, ctx): """List all sub-commands.""" env = ctx.ensure_object(environment.Environment) env.load() return sorted(env.list_commands(*self.path)) def get_command(self, ctx, name): """Get command for click.""" env = ctx.ensure_object(environment.Environment) env.load() # Do alias lookup (only available for root commands) if len(self.path) == 0: name = env.resolve_alias(name) new_path = list(self.path) new_path.append(name) module = env.get_command(*new_path) if isinstance(module, types.ModuleType): return CommandLoader(*new_path, help=module.__doc__ or '') else: return module @click.group(help="SoftLayer Command-line Client", epilog="""To use most commands your SoftLayer username and api_key need to be configured. The easiest way to do that is to use: 'slcli setup'""", cls=CommandLoader, context_settings={'help_option_names': ['-h', '--help'], 'auto_envvar_prefix': 'SLCLI'}) @click.option('--format', default=DEFAULT_FORMAT, show_default=True, help="Output format", type=click.Choice(VALID_FORMATS)) @click.option('--config', '-C', required=False, default=click.get_app_dir('softlayer', force_posix=True), show_default=True, help="Config file location", type=click.Path(resolve_path=True)) @click.option('--verbose', '-v', help="Sets the debug noise level, specify multiple times " "for more verbosity.", type=click.IntRange(0, 3, clamp=True), count=True) @click.option('--proxy', required=False, help="HTTP[S] proxy to be use to make API calls") @click.option('--really / --not-really', '-y', is_flag=True, required=False, help="Confirm all prompt actions") @click.option('--demo / --no-demo', is_flag=True, required=False, help="Use demo data instead of actually making API calls") @click.version_option(prog_name="slcli (SoftLayer Command-line)") @environment.pass_env def cli(env, format='table', config=None, verbose=0, proxy=None, really=False, demo=False, **kwargs): """Main click CLI entry-point.""" if verbose > 0: logger = logging.getLogger() logger.addHandler(logging.StreamHandler()) logger.setLevel(DEBUG_LOGGING_MAP.get(verbose, logging.DEBUG)) # Populate environement with client and set it as the context object env.skip_confirmations = really env.config_file = config env.format = format env.ensure_client(config_file=config, is_demo=demo, proxy=proxy) env.vars['_start'] = time.time() env.vars['_timings'] = SoftLayer.TimingTransport(env.client.transport) env.client.transport = env.vars['_timings'] @cli.resultcallback() @environment.pass_env def output_diagnostics(env, verbose=0, **kwargs): """Output diagnostic information.""" if verbose > 0: diagnostic_table = formatting.Table(['name', 'value']) diagnostic_table.add_row(['execution_time', '%fs' % (time.time() - START_TIME)]) api_call_value = [] for call, _, duration in env.vars['_timings'].get_last_calls(): api_call_value.append( "%s::%s (%fs)" % (call.service, call.method, duration)) diagnostic_table.add_row(['api_calls', api_call_value]) diagnostic_table.add_row(['version', consts.USER_AGENT]) diagnostic_table.add_row(['python_version', sys.version]) diagnostic_table.add_row(['library_location', os.path.dirname(SoftLayer.__file__)]) env.err(env.fmt(diagnostic_table)) def main(reraise_exceptions=False, **kwargs): """Main program. Catches several common errors and displays them nicely.""" exit_status = 0 try: cli.main(**kwargs) except SoftLayer.SoftLayerAPIError as ex: if 'invalid api token' in ex.faultString.lower(): print("Authentication Failed: To update your credentials," " use 'slcli config setup'") exit_status = 1 else: print(str(ex)) exit_status = 1 except SoftLayer.SoftLayerError as ex: print(str(ex)) exit_status = 1 except exceptions.CLIAbort as ex: print(str(ex.message)) exit_status = ex.code except Exception: if reraise_exceptions: raise import traceback print("An unexpected error has occured:") print(str(traceback.format_exc())) print("Feel free to report this error as it is likely a bug:") print(" https://github.com/softlayer/softlayer-python/issues") exit_status = 1 sys.exit(exit_status) if __name__ == '__main__': main() softlayer-python-5.0.1/SoftLayer/CLI/deprecated.py000066400000000000000000000006701267703721100220460ustar00rootroot00000000000000""" SoftLayer.CLI.deprecated ~~~~~~~~~~~~~~~~~~~~~~~~ Handles usage of the deprecated command name, 'sl'. :license: MIT, see LICENSE for more details. """ from __future__ import print_function import sys 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) softlayer-python-5.0.1/SoftLayer/CLI/dns/000077500000000000000000000000001267703721100201555ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/dns/__init__.py000066400000000000000000000001111267703721100222570ustar00rootroot00000000000000"""Domain Name System.""" # :license: MIT, see LICENSE for more details. softlayer-python-5.0.1/SoftLayer/CLI/dns/record_add.py000066400000000000000000000014221267703721100226140ustar00rootroot00000000000000"""Add resource record.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers # pylint: disable=redefined-builtin @click.command() @click.argument('zone') @click.argument('record') @click.argument('type') @click.argument('data') @click.option('--ttl', type=click.INT, default=7200, show_default=True, help='TTL value in seconds, such as 86400') @environment.pass_env def cli(env, zone, record, type, data, ttl): """Add resource record.""" manager = SoftLayer.DNSManager(env.client) zone_id = helpers.resolve_id(manager.resolve_ids, zone, name='zone') manager.create_record(zone_id, record, type, data, ttl=ttl) softlayer-python-5.0.1/SoftLayer/CLI/dns/record_edit.py000066400000000000000000000020731267703721100230140ustar00rootroot00000000000000"""Update DNS record.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers # pylint: disable=redefined-builtin @click.command() @click.argument('zone-id') @click.option('--by-record', help='Edit by host record, such as www') @click.option('--by-id', help='Edit a single record by its ID') @click.option('--data', help='Record data, such as an IP address') @click.option('--ttl', type=click.INT, help='TTL value in seconds, such as 86400') @environment.pass_env def cli(env, zone_id, by_record, by_id, data, ttl): """Update DNS record.""" manager = SoftLayer.DNSManager(env.client) zone_id = helpers.resolve_id(manager.resolve_ids, zone_id, name='zone') results = manager.get_records(zone_id, host=by_record) for result in results: if by_id and str(result['id']) != by_id: continue result['data'] = data or result['data'] result['ttl'] = ttl or result['ttl'] manager.edit_record(result) softlayer-python-5.0.1/SoftLayer/CLI/dns/record_list.py000066400000000000000000000026521267703721100230450ustar00rootroot00000000000000"""List all records in a zone.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers # pylint: disable=redefined-builtin @click.command() @click.argument('zone') @click.option('--data', help='Record data, such as an IP address') @click.option('--record', help='Host record, such as www') @click.option('--ttl', type=click.INT, help='TTL value in seconds, such as 86400') @click.option('--type', help='Record type, such as A or CNAME') @environment.pass_env def cli(env, zone, data, record, ttl, type): """List all records in a zone.""" manager = SoftLayer.DNSManager(env.client) table = formatting.Table(['id', 'record', 'type', 'ttl', 'data']) table.align['ttl'] = 'l' table.align['record'] = 'r' table.align['data'] = 'l' zone_id = helpers.resolve_id(manager.resolve_ids, zone, name='zone') records = manager.get_records(zone_id, record_type=type, host=record, ttl=ttl, data=data) for record in records: table.add_row([ record['id'], record['host'], record['type'].upper(), record['ttl'], record['data'] ]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/dns/record_remove.py000066400000000000000000000010531267703721100233610ustar00rootroot00000000000000"""Remove resource record.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting @click.command() @click.argument('record_id') @environment.pass_env def cli(env, record_id): """Remove resource record.""" manager = SoftLayer.DNSManager(env.client) if not (env.skip_confirmations or formatting.no_going_back('yes')): raise exceptions.CLIAbort("Aborted.") manager.delete_record(record_id) softlayer-python-5.0.1/SoftLayer/CLI/dns/zone_create.py000066400000000000000000000005061267703721100230260ustar00rootroot00000000000000"""Create a zone.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment @click.command() @click.argument('zone') @environment.pass_env def cli(env, zone): """Create a zone.""" manager = SoftLayer.DNSManager(env.client) manager.create_zone(zone) softlayer-python-5.0.1/SoftLayer/CLI/dns/zone_delete.py000066400000000000000000000011611267703721100230230ustar00rootroot00000000000000"""Delete zone.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('zone') @environment.pass_env 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) softlayer-python-5.0.1/SoftLayer/CLI/dns/zone_import.py000066400000000000000000000075211267703721100231010ustar00rootroot00000000000000"""Import zone based off a BIND zone file.""" # :license: MIT, see LICENSE for more details. import re import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import helpers RECORD_REGEX = re.compile(r"""^((?P([\w-]+(\.)?)*|\@)?\s+ (?P\d+)?\s+ (?P\w+)?)?\s+ (?P\w+)\s+ (?P.*)""", re.X) RECORD_FMT = "type={type}, record={record}, data={data}, ttl={ttl}" @click.command() @click.argument('zonefile', type=click.Path(exists=True, readable=True, resolve_path=True)) @click.option('--dry-run', is_flag=True, help="Don't actually create records") @environment.pass_env def cli(env, zonefile, dry_run): """Import zone based off a BIND zone file.""" manager = SoftLayer.DNSManager(env.client) with open(zonefile) as zone_f: zone_contents = zone_f.read() zone, records, bad_lines = parse_zone_details(zone_contents) env.out("Parsed: zone=%s" % zone) for record in records: env.out("Parsed: %s" % RECORD_FMT.format(**record)) for line in bad_lines: env.out("Unparsed: %s" % line) if dry_run: return # Find zone id or create the zone if it doesn't exist try: zone_id = helpers.resolve_id(manager.resolve_ids, zone, name='zone') except exceptions.CLIAbort: zone_id = manager.create_zone(zone)['id'] env.out(click.style("Created: %s" % zone, fg='green')) # Attempt to create each record for record in records: try: manager.create_record(zone_id, record['record'], record['type'], record['data'], record['ttl']) env.out(click.style("Created: %s" % RECORD_FMT.format(**record), fg='green')) except SoftLayer.SoftLayerAPIError as ex: env.out(click.style("Failed: %s" % RECORD_FMT.format(**record), fg='red')) env.out(click.style(str(ex), fg='red')) env.out(click.style("Finished", fg='green')) def parse_zone_details(zone_contents): """Parses a zone file into python data-structures.""" records = [] bad_lines = [] zone_lines = [line.strip() for line in zone_contents.split('\n')] zone_search = re.search(r'^\$ORIGIN (?P.*)\.', zone_lines[0]) zone = zone_search.group('zone') for line in zone_lines[1:]: record_search = re.search(RECORD_REGEX, line) if record_search is None: bad_lines.append(line) continue name = record_search.group('domain') # The API requires we send a host, although bind allows a blank # entry. @ is the same thing as blank if name is None: name = "@" ttl = record_search.group('ttl') # we don't do anything with the class # domain_class = domainSearch.group('class') record_type = record_search.group('type').upper() data = record_search.group('data') # the dns class doesn't support weighted MX records yet, so we chomp # that part out. if record_type == "MX": record_search = re.search(r'(?P\d+)\s+(?P.*)', data) data = record_search.group('data') # This will skip the SOA record bit. And any domain that gets # parsed oddly. if record_type == 'IN': bad_lines.append(line) continue records.append({ 'record': name, 'type': record_type, 'data': data, 'ttl': ttl, }) return zone, records, bad_lines softlayer-python-5.0.1/SoftLayer/CLI/dns/zone_list.py000066400000000000000000000012231267703721100225330ustar00rootroot00000000000000"""List all zones.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env def cli(env): """List all zones.""" manager = SoftLayer.DNSManager(env.client) zones = manager.list_zones() table = formatting.Table(['id', 'zone', 'serial', 'updated']) table.align['serial'] = 'c' table.align['updated'] = 'c' for zone in zones: table.add_row([ zone['id'], zone['name'], zone['serial'], zone['updateDate'], ]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/dns/zone_print.py000066400000000000000000000007241267703721100227210ustar00rootroot00000000000000"""Print zone in BIND format.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers @click.command() @click.argument('zone') @environment.pass_env def cli(env, zone): """Print zone in BIND format.""" manager = SoftLayer.DNSManager(env.client) zone_id = helpers.resolve_id(manager.resolve_ids, zone, name='zone') env.fout(manager.dump_zone(zone_id)) softlayer-python-5.0.1/SoftLayer/CLI/environment.py000066400000000000000000000123741267703721100223160ustar00rootroot00000000000000""" SoftLayer.CLI.environment ~~~~~~~~~~~~~~~~~~~~~~~~~ Abstracts everything related to the user's environment when running the CLI :license: MIT, see LICENSE for more details. """ import importlib import click import pkg_resources import SoftLayer from SoftLayer.CLI import formatting from SoftLayer.CLI import routes # pylint: disable=too-many-instance-attributes, invalid-name, no-self-use # Calling pkg_resources.iter_entry_points shows a false-positive # pylint: disable=no-member class Environment(object): """Provides access to the current CLI environment.""" def __init__(self): # {'path:to:command': ModuleLoader()} # {'vs:list': ModuleLoader()} self.commands = {} self.aliases = {} self.vars = {} self.client = None self.format = 'table' self.skip_confirmations = False self.config_file = None self._modules_loaded = False 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 fmt(self, output): """Format output based on current the environment format.""" return formatting.format_output(output, fmt=self.format) 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) # Command loading methods def list_commands(self, *path): """Command listing.""" path_str = ':'.join(path) commands = [] for command in self.commands.keys(): # Filter based on prefix and the segment length if all([command.startswith(path_str), len(path) == command.count(":")]): # offset is used to exclude the path that the caller requested. offset = len(path_str) + 1 if path_str else 0 commands.append(command[offset:]) return sorted(commands) 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] = ModuleLoader(path, attr=attr) 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_resources.iter_entry_points(group=entry_point_group, name=None): self.commands[obj.name] = obj 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 explicitly. This is used for testing if is_demo: client = SoftLayer.BaseClient( transport=SoftLayer.FixtureTransport(), auth=None, ) else: # Create SL Client client = SoftLayer.create_client_from_env( proxy=proxy, config_file=config_file, ) self.client = client class ModuleLoader(object): """Module loader that acts a little like an EntryPoint object.""" def __init__(self, import_path, attr=None): self.import_path = import_path self.attr = attr 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 pass_env = click.make_pass_decorator(Environment, ensure=True) softlayer-python-5.0.1/SoftLayer/CLI/exceptions.py000066400000000000000000000017521267703721100221310ustar00rootroot00000000000000""" SoftLayer.CLI.exceptions ~~~~~~~~~~~~~~~~~~~~~~~~ Exceptions to be used in the CLI modules. :license: MIT, see LICENSE for more details. """ class CLIHalt(SystemExit): """Smoothly halt the execution of the command. No error.""" def __init__(self, code=0, *args): super(CLIHalt, self).__init__(*args) self.code = code def __str__(self): return "" % (self.code, getattr(self, 'message')) __repr__ = __str__ class CLIAbort(CLIHalt): """Halt the execution of the command. Gives an exit code of 2.""" def __init__(self, msg, *args): super(CLIAbort, self).__init__(code=2, *args) self.message = msg class ArgumentError(CLIAbort): """Halt the execution of the command because of invalid arguments.""" def __init__(self, msg, *args): super(ArgumentError, self).__init__(msg, *args) self.message = "Argument Error: %s" % msg softlayer-python-5.0.1/SoftLayer/CLI/firewall/000077500000000000000000000000001267703721100211765ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/firewall/__init__.py000066400000000000000000000007471267703721100233170ustar00rootroot00000000000000"""Firewalls.""" # :license: MIT, see LICENSE for more details. from SoftLayer.CLI import exceptions 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 xxx:yyy' % input_id) return key_value[0], int(key_value[1]) softlayer-python-5.0.1/SoftLayer/CLI/firewall/add.py000066400000000000000000000036511267703721100223050ustar00rootroot00000000000000"""Create new firewall.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting @click.command() @click.argument('target') @click.option('--firewall-type', type=click.Choice(['vs', 'vlan', 'server']), help='Firewall type', required=True) @click.option('--ha', '--high-availability', is_flag=True, help='High available firewall option') @environment.pass_env 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_enabled=high_availability) elif firewall_type == 'vs': pkg = mgr.get_standard_package(target, is_virt=True) elif firewall_type == 'server': pkg = mgr.get_standard_package(target, is_virt=False) if not pkg: exceptions.CLIAbort( "Unable to add firewall - Is network public enabled?") env.out("******************") env.out("Product: %s" % pkg[0]['description']) env.out("Price: $%s monthly" % pkg[0]['prices'][0]['recurringFee']) env.out("******************") if not formatting.confirm("This action will incur charges on your " "account. Continue?"): raise exceptions.CLIAbort('Aborted.') if firewall_type == 'vlan': mgr.add_vlan_firewall(target, ha_enabled=high_availability) elif firewall_type == 'vs': mgr.add_standard_firewall(target, is_virt=True) elif firewall_type == 'server': mgr.add_standard_firewall(target, is_virt=False) env.fout("Firewall is being created!") softlayer-python-5.0.1/SoftLayer/CLI/firewall/cancel.py000066400000000000000000000020451267703721100227760ustar00rootroot00000000000000"""Cancels a firewall.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import firewall from SoftLayer.CLI import formatting @click.command() @click.argument('identifier') @environment.pass_env 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 " "account. Continue?")): raise exceptions.CLIAbort('Aborted.') if firewall_type in ['vs', 'server']: mgr.cancel_firewall(firewall_id, dedicated=False) elif firewall_type == 'vlan': mgr.cancel_firewall(firewall_id, dedicated=True) else: raise exceptions.CLIAbort('Unknown firewall type: %s' % firewall_type) env.fout('Firewall with id %s is being cancelled!' % identifier) softlayer-python-5.0.1/SoftLayer/CLI/firewall/detail.py000066400000000000000000000026621267703721100230200ustar00rootroot00000000000000"""Detail firewall.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import firewall from SoftLayer.CLI import formatting @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """Detail firewall.""" mgr = SoftLayer.FirewallManager(env.client) firewall_type, firewall_id = firewall.parse_id(identifier) if firewall_type == 'vlan': rules = mgr.get_dedicated_fwl_rules(firewall_id) else: rules = mgr.get_standard_fwl_rules(firewall_id) env.fout(get_rules_table(rules)) def get_rules_table(rules): """Helper to format the rules into a table. :param list rules: A list containing the rules of the firewall :returns: a formatted table of the firewall rules """ table = formatting.Table(['#', 'action', 'protocol', 'src_ip', 'src_mask', 'dest', 'dest_mask']) table.sortby = '#' for rule in rules: table.add_row([ rule['orderValue'], rule['action'], rule['protocol'], rule['sourceIpAddress'], rule['sourceIpSubnetMask'], '%s:%s-%s' % (rule['destinationIpAddress'], rule['destinationPortRangeStart'], rule['destinationPortRangeEnd']), rule['destinationIpSubnetMask']]) return table softlayer-python-5.0.1/SoftLayer/CLI/firewall/edit.py000066400000000000000000000150011267703721100224720ustar00rootroot00000000000000"""List firewalls.""" # :license: MIT, see LICENSE for more details. import os import subprocess import tempfile import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import firewall from SoftLayer.CLI import formatting DELIMITER = "=========================================\n" 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() == '': continue parsed_rule = {} lines = rule.split("\n") parsed_rule['orderValue'] = order order += 1 for line in lines: if line.strip() == '': continue key_value = line.strip().split(':') key = key_value[0].strip() value = key_value[1].strip() if key == 'action': parsed_rule['action'] = value elif key == 'protocol': parsed_rule['protocol'] = value elif key == 'source_ip_address': parsed_rule['sourceIpAddress'] = value elif key == 'source_ip_subnet_mask': parsed_rule['sourceIpSubnetMask'] = value elif key == 'destination_ip_address': parsed_rule['destinationIpAddress'] = value elif key == 'destination_ip_subnet_mask': parsed_rule['destinationIpSubnetMask'] = value elif key == 'destination_port_range_start': parsed_rule['destinationPortRangeStart'] = int(value) elif key == 'destination_port_range_end': parsed_rule['destinationPortRangeEnd'] = int(value) elif key == 'version': parsed_rule['version'] = int(value) parsed_rules.append(parsed_rule) return parsed_rules 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 rules retrieved from the firewall will be displayed to the user. :param list rules: A list containing the rules of the firewall :param string content: the content that the user provided in the editor :returns: a formatted string that get be pushed into the editor """ # Let's get the default EDITOR of the environment, # use nano if none is specified editor = os.environ.get('EDITOR', 'nano') with tempfile.NamedTemporaryFile(suffix=".tmp") as tfile: if content: # if content is provided, just display it as is tfile.write(content) tfile.flush() subprocess.call([editor, tfile.name]) tfile.seek(0) data = tfile.read() return data if not rules: # if the firewall has no rules, provide a template tfile.write(DELIMITER) tfile.write(get_formatted_rule()) else: # if the firewall has rules, display those to the user for rule in rules: tfile.write(DELIMITER) tfile.write(get_formatted_rule(rule)) tfile.write(DELIMITER) tfile.flush() subprocess.call([editor, tfile.name]) tfile.seek(0) data = tfile.read() return data return 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' 'source_ip_address: %s\n' 'source_ip_subnet_mask: %s\n' 'destination_ip_address: %s\n' 'destination_ip_subnet_mask: %s\n' 'destination_port_range_start: %s\n' 'destination_port_range_end: %s\n' 'version: %s\n' % (rule.get('action', 'permit'), rule.get('protocol', 'tcp'), rule.get('sourceIpAddress', 'any'), rule.get('sourceIpSubnetMask', '255.255.255.255'), rule.get('destinationIpAddress', 'any'), rule.get('destinationIpSubnetMask', '255.255.255.255'), rule.get('destinationPortRangeStart', 1), rule.get('destinationPortRangeEnd', 1), rule.get('version', 4))) @click.command() @click.argument('identifier') @environment.pass_env 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_rules(firewall_id) # open an editor for the user to enter their rules edited_rules = open_editor(rules=orig_rules) env.out(edited_rules) if formatting.confirm("Would you like to submit the rules. " "Continue?"): while True: try: rules = parse_rules(edited_rules) if firewall_type == 'vlan': rules = mgr.edit_dedicated_fwl_rules(firewall_id, rules) else: rules = mgr.edit_standard_fwl_rules(firewall_id, rules) break except (SoftLayer.SoftLayerError, ValueError) as error: env.out("Unexpected error({%s})" % (error)) if formatting.confirm("Would you like to continue editing " "the rules. Continue?"): edited_rules = open_editor(content=edited_rules) env.out(edited_rules) if formatting.confirm("Would you like to submit the " "rules. Continue?"): continue else: raise exceptions.CLIAbort('Aborted.') else: raise exceptions.CLIAbort('Aborted.') env.fout('Firewall updated!') else: raise exceptions.CLIAbort('Aborted.') softlayer-python-5.0.1/SoftLayer/CLI/firewall/list.py000066400000000000000000000050061267703721100225240ustar00rootroot00000000000000"""List firewalls.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer import utils @click.command() @environment.pass_env 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 = [firewall for firewall in fwvlans if firewall['dedicatedFirewallFlag']] for vlan in dedicated_firewalls: features = [] if vlan['highAvailabilityFirewallFlag']: features.append('HA') if features: feature_list = formatting.listing(features, separator=',') else: feature_list = formatting.blank() table.add_row([ 'vlan:%s' % vlan['networkVlanFirewall']['id'], 'VLAN - dedicated', feature_list, vlan['id'] ]) shared_vlan = [firewall for firewall in fwvlans if not firewall['dedicatedFirewallFlag']] for vlan in shared_vlan: vs_firewalls = [guest for guest in vlan['firewallGuestNetworkComponents'] if has_firewall_component(guest)] for firewall in vs_firewalls: table.add_row([ 'vs:%s' % firewall['id'], 'Virtual Server - standard', '-', firewall['guestNetworkComponent']['guest']['id'] ]) server_firewalls = [server for server in vlan['firewallNetworkComponents'] if has_firewall_component(server)] for firewall in server_firewalls: table.add_row([ 'server:%s' % firewall['id'], 'Server - standard', '-', utils.lookup(firewall, 'networkComponent', 'downlinkComponent', 'hardwareId') ]) env.fout(table) def has_firewall_component(server): """Helper to determine whether or not a server has a firewall. :param dict server: A dictionary representing a server :returns: True if the Server has a firewall. """ if server['status'] != 'no_edit': return True return False softlayer-python-5.0.1/SoftLayer/CLI/formatting.py000066400000000000000000000267561267703721100221350ustar00rootroot00000000000000""" SoftLayer.formatting ~~~~~~~~~~~~~~~~~~~~ Provider classes and helper functions to display output onto a command-line. :license: MIT, see LICENSE for more details. """ # pylint: disable=E0202 import json import os import click import prettytable from SoftLayer.CLI import exceptions from SoftLayer import utils FALSE_VALUES = ['0', 'false', 'FALSE', 'no', 'False'] 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 isinstance(data, utils.string_types): if fmt == 'json': return json.dumps(data) return data # responds to .prettytable() if hasattr(data, 'prettytable'): if fmt == 'table': return str(format_prettytable(data)) elif fmt == 'raw': return str(format_no_tty(data)) # responds to .to_python() if hasattr(data, 'to_python'): if fmt == 'json': return json.dumps( format_output(data, fmt='python'), indent=4, cls=CLIJSONEncoder) elif fmt == 'python': return data.to_python() # responds to .formatted if hasattr(data, 'formatted'): if fmt == 'table': return data.formatted # responds to .separator if hasattr(data, 'separator'): output = [format_output(d, fmt=fmt) for d in data if d] return str(SequentialOutput(data.separator, output)) # is iterable if isinstance(data, list) or isinstance(data, tuple): output = [format_output(d, fmt=fmt) for d in data] if fmt == 'python': return output return format_output(listing(output, separator=os.linesep)) # fallback, convert this odd object to a string return data 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 ptable.horizontal_char = '.' ptable.vertical_char = ':' ptable.junction_char = ':' return ptable 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: ptable.align[col] = 'l' ptable.hrules = prettytable.NONE ptable.border = False ptable.header = False ptable.left_padding_width = 0 ptable.right_padding_width = 2 return ptable def mb_to_gb(megabytes): """Converts number of megabytes to a FormattedItem in gigabytes. :param int megabytes: number of megabytes """ return FormattedItem(megabytes, "%dG" % (float(megabytes) / 1024)) def b_to_gb(_bytes): """Converts number of bytes to a FormattedItem in gigabytes. :param int _bytes: number of bytes """ return FormattedItem(_bytes, "%.2fG" % (float(_bytes) / 1024 / 1024 / 1024)) def gb(gigabytes): # pylint: disable=C0103 """Converts number of gigabytes to a FormattedItem in gigabytes. :param int gigabytes: number of gigabytes """ return FormattedItem(int(float(gigabytes)) * 1024, "%dG" % int(float(gigabytes))) def blank(): """Returns a blank FormattedItem.""" return FormattedItem(None, '-') def listing(items, separator=','): """Given an iterable return a FormattedItem which display the list of items :param items: An iterable that outputs strings :param string separator: the separator to use """ return SequentialOutput(separator, items) def active_txn(item): """Returns a FormattedItem describing the active transaction on a object. If no active transaction is running, returns a blank FormattedItem. :param item: An object capable of having an active transaction """ return transaction_status(utils.lookup(item, 'activeTransaction')) 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['transactionStatus'].get('name'), transaction['transactionStatus'].get('friendlyName')) 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, separator=', ') 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: default_str = 'n' prompt = '%s [y/N]' % prompt_str ans = click.prompt(prompt, default=default_str, show_default=False) if ans.lower() in ('y', 'yes', 'yeah', 'yup', 'yolo'): return True return False 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 press Enter ' 'to abort' % confirmation) ans = click.prompt(prompt, default='', show_default=False) if ans.lower() == str(confirmation): return True return False class SequentialOutput(list): """SequentialOutput is used for outputting sequential items. The purpose is to de-couple the separator from the output itself. :param separator str: string to use as a default separator """ def __init__(self, separator=os.linesep, *args, **kwargs): self.separator = separator super(SequentialOutput, self).__init__(*args, **kwargs) def to_python(self): """returns itself, since it itself is a list.""" return self def __str__(self): return self.separator.join(str(x) for x in self) class CLIJSONEncoder(json.JSONEncoder): """A JSON encoder which is able to use a .to_python() method on objects.""" 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) class Table(object): """A Table structure used for output. :param list columns: a list of column names """ def __init__(self, columns): self.columns = columns self.rows = [] self.align = {} self.sortby = None def add_row(self, row): """Add a row to the table. :param list row: the row of string to be added """ self.rows.append(row) 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" % self.sortby raise exceptions.CLIAbort(msg) for a_col, alignment in self.align.items(): table.align[a_col] = alignment # Adding rows for row in self.rows: table.add_row(row) return table class KeyValueTable(Table): """A table that is oriented towards key-value pairs.""" 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 class FormattedItem(object): """This is an object that can be displayed as a human readable and raw. :param original: raw (machine-readable) value :param string formatted: human-readable value """ def __init__(self, original, formatted=None): self.original = original if formatted is not None: self.formatted = formatted else: self.formatted = self.original def to_python(self): """returns the original (raw) value.""" return self.original def __str__(self): """returns the formatted value.""" # If the original value is None, represent this as 'NULL' if self.original is None: return 'NULL' return str(self.original) __repr__ = __str__ # Implement sorting methods. # NOTE(kmcdonald): functools.total_ordering could be used once support for # Python 2.6 is dropped def __eq__(self, other): return self.original == getattr(other, 'original', other) def __lt__(self, other): if self.original is None: return True other_val = getattr(other, 'original', other) if other_val is None: return False return self.original < other_val def __gt__(self, other): return not (self < other or self == other) def __le__(self, other): return self < other or self == other def __ge__(self, other): return self >= other def _format_python_value(value): """If the value has to_python() defined then return that.""" if hasattr(value, 'to_python'): return value.to_python() return value 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 table 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: value = iter_to_table(item.get(key)) values.append(value) table.add_row(values) return table softlayer-python-5.0.1/SoftLayer/CLI/globalip/000077500000000000000000000000001267703721100211625ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/globalip/__init__.py000066400000000000000000000001121267703721100232650ustar00rootroot00000000000000"""Global IP addresses.""" # :license: MIT, see LICENSE for more details. softlayer-python-5.0.1/SoftLayer/CLI/globalip/assign.py000066400000000000000000000011241267703721100230160ustar00rootroot00000000000000"""Assigns the global IP to a target.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.argument('target') @environment.pass_env def cli(env, identifier, target): """Assigns the global IP to a target.""" mgr = SoftLayer.NetworkManager(env.client) global_ip_id = helpers.resolve_id(mgr.resolve_global_ip_ids, identifier, name='global ip') mgr.assign_global_ip(global_ip_id, target) softlayer-python-5.0.1/SoftLayer/CLI/globalip/cancel.py000066400000000000000000000013201267703721100227550ustar00rootroot00000000000000"""Cancel global IP.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """Cancel global IP.""" mgr = SoftLayer.NetworkManager(env.client) global_ip_id = helpers.resolve_id(mgr.resolve_global_ip_ids, identifier, name='global ip') if not (env.skip_confirmations or formatting.no_going_back(global_ip_id)): raise exceptions.CLIAbort('Aborted') mgr.cancel_global_ip(global_ip_id) softlayer-python-5.0.1/SoftLayer/CLI/globalip/create.py000066400000000000000000000023471267703721100230050ustar00rootroot00000000000000"""Creates a global IP.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting @click.command() @click.option('--v6', '--ipv6', is_flag=True, help='Order a IPv6 IP') @click.option('--test', help='test order') @environment.pass_env 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. Continue?"): raise exceptions.CLIAbort('Cancelling order.') result = mgr.add_global_ip(version=version, test_order=test) table = formatting.Table(['item', 'cost']) table.align['Item'] = 'r' table.align['cost'] = 'r' total = 0.0 for price in result['orderDetails']['prices']: total += float(price.get('recurringFee', 0.0)) rate = "%.2f" % float(price['recurringFee']) table.add_row([price['item']['description'], rate]) table.add_row(['Total monthly cost', "%.2f" % total]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/globalip/list.py000066400000000000000000000027101267703721100225070ustar00rootroot00000000000000"""List all global IPs.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @click.option('--ip-version', help='Display only IPv4', type=click.Choice(['v4', 'v6'])) @environment.pass_env def cli(env, ip_version): """List all global IPs.""" mgr = SoftLayer.NetworkManager(env.client) table = formatting.Table(['id', 'ip', 'assigned', 'target']) version = None if ip_version == 'v4': version = 4 elif ip_version == 'v6': version = 6 ips = mgr.list_global_ips(version=version) for ip_address in ips: assigned = 'No' target = 'None' if ip_address.get('destinationIpAddress'): dest = ip_address['destinationIpAddress'] assigned = 'Yes' target = dest['ipAddress'] virtual_guest = dest.get('virtualGuest') if virtual_guest: target += (' (%s)' % virtual_guest['fullyQualifiedDomainName']) elif ip_address['destinationIpAddress'].get('hardware'): target += (' (%s)' % dest['hardware']['fullyQualifiedDomainName']) table.add_row([ip_address['id'], ip_address['ipAddress']['ipAddress'], assigned, target]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/globalip/unassign.py000066400000000000000000000010601267703721100233600ustar00rootroot00000000000000"""Unassigns a global IP from a target.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """Unassigns a global IP from a target.""" mgr = SoftLayer.NetworkManager(env.client) global_ip_id = helpers.resolve_id(mgr.resolve_global_ip_ids, identifier, name='global ip') mgr.unassign_global_ip(global_ip_id) softlayer-python-5.0.1/SoftLayer/CLI/hardware/000077500000000000000000000000001267703721100211665ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/hardware/__init__.py000066400000000000000000000000301267703721100232700ustar00rootroot00000000000000"""Hardware servers.""" softlayer-python-5.0.1/SoftLayer/CLI/hardware/cancel.py000066400000000000000000000021671267703721100227730ustar00rootroot00000000000000"""Cancel a dedicated server.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.option('--immediate', is_flag=True, default=False, help="""Cancels the server immediately (instead of on the billing anniversary)""") @click.option('--comment', help="An optional comment to add to the cancellation ticket") @click.option('--reason', help="""An optional cancellation reason. See cancel-reasons for a list of available options""") @environment.pass_env def cli(env, identifier, immediate, comment, reason): """Cancel a dedicated server.""" mgr = SoftLayer.HardwareManager(env.client) hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'hardware') if not (env.skip_confirmations or formatting.no_going_back(hw_id)): raise exceptions.CLIAbort('Aborted') mgr.cancel_hardware(hw_id, reason, comment, immediate) softlayer-python-5.0.1/SoftLayer/CLI/hardware/cancel_reasons.py000066400000000000000000000011161267703721100245160ustar00rootroot00000000000000"""Display a list of cancellation reasons.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env def cli(env): """Display a list of cancellation reasons.""" table = formatting.Table(['Code', 'Reason']) table.align['Code'] = 'r' table.align['Reason'] = 'l' mgr = SoftLayer.HardwareManager(env.client) for code, reason in mgr.get_cancellation_reasons().items(): table.add_row([code, reason]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/hardware/create.py000066400000000000000000000115231267703721100230050ustar00rootroot00000000000000"""Order/create a dedicated server.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers from SoftLayer.CLI import template @click.command(epilog="See 'slcli server create-options' for valid options.") @click.option('--hostname', '-H', help="Host portion of the FQDN", required=True, prompt=True) @click.option('--domain', '-D', help="Domain portion of the FQDN", required=True, prompt=True) @click.option('--size', '-s', help="Hardware size", required=True, prompt=True) @click.option('--os', '-o', help="OS install code", required=True, prompt=True) @click.option('--datacenter', '-d', help="Datacenter shortname", required=True, prompt=True) @click.option('--port-speed', type=click.INT, help="Port speeds", required=True, prompt=True) @click.option('--billing', type=click.Choice(['hourly', 'monthly']), default='hourly', show_default=True, help="Billing rate") @click.option('--postinstall', '-i', help="Post-install script to download") @helpers.multi_option('--key', '-k', help="SSH keys to add to the root user") @click.option('--no-public', is_flag=True, help="Private network only") @helpers.multi_option('--extra', '-e', help="Extra options") @click.option('--test', is_flag=True, help="Do not actually create the virtual server") @click.option('--template', '-t', is_eager=True, callback=template.TemplateCallback(list_args=['key']), help="A template file that defaults the command-line options", type=click.Path(exists=True, readable=True, resolve_path=True)) @click.option('--export', type=click.Path(writable=True, resolve_path=True), help="Exports options to a template file") @click.option('--wait', type=click.INT, help="Wait until the server is finished provisioning for up to " "X seconds before returning") @environment.pass_env def cli(env, **args): """Order/create a dedicated server.""" mgr = SoftLayer.HardwareManager(env.client) # Get the SSH keys ssh_keys = [] for key in args.get('key'): resolver = SoftLayer.SshKeyManager(env.client).resolve_ids key_id = helpers.resolve_id(resolver, key, 'SshKey') ssh_keys.append(key_id) order = { 'hostname': args['hostname'], 'domain': args['domain'], 'size': args['size'], 'location': args.get('datacenter'), 'ssh_keys': ssh_keys, 'post_uri': args.get('postinstall'), 'os': args['os'], 'hourly': args.get('billing') == 'hourly', 'port_speed': args.get('port_speed'), 'no_public': args.get('no_public') or False, 'extras': args.get('extra'), } # Do not create hardware server with --test or --export do_create = not (args['export'] or args['test']) output = None if args.get('test'): result = mgr.verify_order(**order) table = formatting.Table(['Item', 'cost']) table.align['Item'] = 'r' table.align['cost'] = 'r' total = 0.0 for price in result['prices']: total += float(price.get('recurringFee', 0.0)) rate = "%.2f" % float(price['recurringFee']) table.add_row([price['item']['description'], rate]) table.add_row(['Total monthly cost', "%.2f" % total]) output = [] output.append(table) output.append(formatting.FormattedItem( '', ' -- ! Prices reflected here are retail and do not ' 'take account level discounts and are not guaranteed.')) if args['export']: export_file = args.pop('export') template.export_to_template(export_file, args, exclude=['wait', 'test']) env.fout('Successfully exported options to a template file.') return if do_create: if not (env.skip_confirmations or formatting.confirm( "This action will incur charges on your account. " "Continue?")): raise exceptions.CLIAbort('Aborting dedicated server order.') result = mgr.place_order(**order) table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'r' table.align['value'] = 'l' table.add_row(['id', result['orderId']]) table.add_row(['created', result['orderDate']]) output = table env.fout(output) softlayer-python-5.0.1/SoftLayer/CLI/hardware/create_options.py000066400000000000000000000033431267703721100245610ustar00rootroot00000000000000"""Server order options for a given chassis.""" # :license: MIT, see LICENSE for more details. import click from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.managers import hardware @click.command() @environment.pass_env 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 in options['locations']: dc_table.add_row([location['name'], location['key']]) tables.append(dc_table) # Presets preset_table = formatting.Table(['size', 'value']) preset_table.sortby = 'value' for size in options['sizes']: preset_table.add_row([size['name'], size['key']]) tables.append(preset_table) # Operating systems os_table = formatting.Table(['operating_system', 'value']) os_table.sortby = 'value' for operating_system in options['operating_systems']: os_table.add_row([operating_system['name'], operating_system['key']]) tables.append(os_table) # Port speed port_speed_table = formatting.Table(['port_speed', 'value']) port_speed_table.sortby = 'value' for speed in options['port_speeds']: port_speed_table.add_row([speed['name'], speed['key']]) tables.append(port_speed_table) # Extras extras_table = formatting.Table(['extras', 'value']) extras_table.sortby = 'value' for extra in options['extras']: extras_table.add_row([extra['name'], extra['key']]) tables.append(extras_table) env.fout(formatting.listing(tables, separator='\n')) softlayer-python-5.0.1/SoftLayer/CLI/hardware/credentials.py000066400000000000000000000014631267703721100240410ustar00rootroot00000000000000"""List virtual server credentials.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """List virtual server credentials.""" manager = SoftLayer.HardwareManager(env.client) hardware_id = helpers.resolve_id(manager.resolve_ids, identifier, 'hardware') instance = manager.get_hardware(hardware_id) table = formatting.Table(['username', 'password']) for item in instance['operatingSystem']['passwords']: table.add_row([item['username'], item['password']]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/hardware/detail.py000066400000000000000000000103701267703721100230030ustar00rootroot00000000000000"""Get details for a hardware device.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers from SoftLayer import utils @click.command() @click.argument('identifier') @click.option('--passwords', is_flag=True, help='Show passwords (check over your shoulder!)') @click.option('--price', is_flag=True, help='Show associated prices') @environment.pass_env 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, identifier, 'hardware') result = hardware.get_hardware(hardware_id) result = utils.NestedDict(result) table.add_row(['id', result['id']]) table.add_row(['guid', result['globalIdentifier'] or formatting.blank()]) table.add_row(['hostname', result['hostname']]) table.add_row(['domain', result['domain']]) table.add_row(['fqdn', result['fullyQualifiedDomainName']]) table.add_row(['status', result['hardwareStatus']['status']]) table.add_row(['datacenter', result['datacenter']['name'] or formatting.blank()]) table.add_row(['cores', result['processorPhysicalCoreAmount']]) table.add_row(['memory', formatting.gb(result['memoryCapacity'])]) table.add_row(['public_ip', result['primaryIpAddress'] or formatting.blank()]) table.add_row(['private_ip', result['primaryBackendIpAddress'] or formatting.blank()]) table.add_row(['ipmi_ip', result['networkManagementIpAddress'] or formatting.blank()]) table.add_row([ 'os', formatting.FormattedItem( result['operatingSystem']['softwareLicense'] ['softwareDescription']['referenceCode'] or formatting.blank(), result['operatingSystem']['softwareLicense'] ['softwareDescription']['name'] or formatting.blank() )]) table.add_row( ['created', result['provisionDate'] or formatting.blank()]) 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', utils.lookup(result, 'billingItem', 'nextInvoiceTotalRecurringAmount')]) 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]) pass_table = formatting.Table(['ipmi_username', 'password']) for item in result['remoteManagementAccounts']: pass_table.add_row([item['username'], item['password']]) table.add_row(['remote 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['Hardware_Server'] .getReverseDomainRecords(id=hardware_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) softlayer-python-5.0.1/SoftLayer/CLI/hardware/edit.py000066400000000000000000000040771267703721100224750ustar00rootroot00000000000000"""Edit hardware details.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.option('--domain', '-D', help="Domain portion of the FQDN") @click.option('--userfile', '-F', help="Read userdata from file", type=click.Path(exists=True, readable=True, resolve_path=True)) @click.option('--tag', '-g', multiple=True, help="Tags to set or empty string to remove all") @click.option('--hostname', '-H', help="Host portion of the FQDN") @click.option('--userdata', '-u', help="User defined metadata string") @click.option('--public-speed', help="Public port speed.", default=None, type=click.Choice(['0', '10', '100', '1000', '10000'])) @click.option('--private-speed', help="Private port speed.", default=None, type=click.Choice(['0', '10', '100', '1000', '10000'])) @environment.pass_env def cli(env, identifier, domain, userfile, tag, hostname, userdata, public_speed, private_speed): """Edit hardware details.""" if userdata and userfile: raise exceptions.ArgumentError( '[-u | --userdata] not allowed with [-F | --userfile]') data = { 'hostname': hostname, 'domain': domain, } if userdata: data['userdata'] = userdata elif userfile: with open(userfile, 'r') as userfile_obj: data['userdata'] = userfile_obj.read() if tag: data['tags'] = ','.join(tag) mgr = SoftLayer.HardwareManager(env.client) hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'hardware') if not mgr.edit(hw_id, **data): raise exceptions.CLIAbort("Failed to update hardware") if public_speed is not None: mgr.change_port_speed(hw_id, True, int(public_speed)) if private_speed is not None: mgr.change_port_speed(hw_id, False, int(private_speed)) softlayer-python-5.0.1/SoftLayer/CLI/hardware/list.py000066400000000000000000000056761267703721100225310ustar00rootroot00000000000000"""List hardware servers.""" # :license: MIT, see LICENSE for more details. import click 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=''' mask(SoftLayer_Hardware_Server)[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 = [ 'id', 'hostname', 'primary_ip', 'backend_ip', 'datacenter', 'action', ] @click.command() @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('--sortby', help='Column to sort by', default='hostname', show_default=True) @click.option('--columns', callback=column_helper.get_formatter(COLUMNS), help='Columns to display. [options: %s]' % ', '.join(column.name for column in COLUMNS), default=','.join(DEFAULT_COLUMNS), show_default=True) @environment.pass_env def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network, tag, columns): """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, mask=columns.mask()) table = formatting.Table(columns.columns) table.sortby = sortby for server in servers: table.add_row([value or formatting.blank() for value in columns.row(server)]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/hardware/power.py000066400000000000000000000046151267703721100227020ustar00rootroot00000000000000"""Power commands.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @environment.pass_env def power_off(env, identifier): """Power off an active server.""" 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 ' 'Continue?' % hw_id)): raise exceptions.CLIAbort('Aborted.') env.client['Hardware_Server'].powerOff(id=hw_id) @click.command() @click.argument('identifier') @click.option('--hard/--soft', default=None, help="Perform a hard or soft reboot") @environment.pass_env def reboot(env, identifier, hard): """Reboot an active server.""" hardware_server = env.client['Hardware_Server'] 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. ' 'Continue?' % hw_id)): raise exceptions.CLIAbort('Aborted.') if hard is True: hardware_server.rebootHard(id=hw_id) elif hard is False: hardware_server.rebootSoft(id=hw_id) else: hardware_server.rebootDefault(id=hw_id) @click.command() @click.argument('identifier') @environment.pass_env def power_on(env, identifier): """Power on a server.""" mgr = SoftLayer.HardwareManager(env.client) hw_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'hardware') env.client['Hardware_Server'].powerOn(id=hw_id) @click.command() @click.argument('identifier') @environment.pass_env def power_cycle(env, identifier): """Power cycle a server.""" 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. ' 'Continue?' % hw_id)): raise exceptions.CLIAbort('Aborted.') env.client['Hardware_Server'].powerCycle(id=hw_id) softlayer-python-5.0.1/SoftLayer/CLI/hardware/reload.py000066400000000000000000000024271267703721100230130ustar00rootroot00000000000000"""Reload operating system on a server.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.option('--postinstall', '-i', help=("Post-install script to download " "(Only HTTPS executes, HTTP leaves file in /root")) @helpers.multi_option('--key', '-k', help="SSH keys to add to the root user") @environment.pass_env 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 = [] if key: for single_key in key: resolver = SoftLayer.SshKeyManager(env.client).resolve_ids key_id = helpers.resolve_id(resolver, single_key, 'SshKey') key_list.append(key_id) if not (env.skip_confirmations or formatting.no_going_back(hardware_id)): raise exceptions.CLIAbort('Aborted') hardware.reload(hardware_id, postinstall, key_list) softlayer-python-5.0.1/SoftLayer/CLI/hardware/rescue.py000066400000000000000000000014031267703721100230240ustar00rootroot00000000000000"""Reboot server into a rescue image.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """Reboot server into a rescue image.""" server = SoftLayer.HardwareManager(env.client) server_id = helpers.resolve_id(server.resolve_ids, identifier, 'hardware') if not (env.skip_confirmations or formatting.confirm("This action will reboot this server. " "Continue?")): raise exceptions.CLIAbort('Aborted') server.rescue(server_id) softlayer-python-5.0.1/SoftLayer/CLI/hardware/update_firmware.py000066400000000000000000000014061267703721100247170ustar00rootroot00000000000000"""Update firmware.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """Update 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 ' 'update device firmware. Continue?' % hw_id)): raise exceptions.CLIAbort('Aborted.') mgr.update_firmware(hw_id) softlayer-python-5.0.1/SoftLayer/CLI/helpers.py000066400000000000000000000025561267703721100214150ustar00rootroot00000000000000""" SoftLayer.CLI.helpers ~~~~~~~~~~~~~~~~~~~~~ Helpers to be used in CLI modules in SoftLayer.CLI.modules.* :license: MIT, see LICENSE for more details. """ import click from SoftLayer.CLI import exceptions 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)" attrs['help'] = newhelp attrs['multiple'] = True return click.option(*param_decls, **attrs) 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 error messages """ ids = resolver(identifier) if len(ids) == 0: raise exceptions.CLIAbort("Error: Unable to find %s '%s'" % (name, identifier)) if len(ids) > 1: raise exceptions.CLIAbort( "Error: Multiple %s found for '%s': %s" % (name, identifier, ', '.join([str(_id) for _id in ids]))) return ids[0] softlayer-python-5.0.1/SoftLayer/CLI/image/000077500000000000000000000000001267703721100204535ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/image/__init__.py000066400000000000000000000007231267703721100225660ustar00rootroot00000000000000"""Compute images.""" # :license: MIT, see LICENSE for more details. from SoftLayer.CLI import formatting MASK = ('id,accountId,name,globalIdentifier,parentId,publicFlag,flexImageFlag,' 'imageType') DETAIL_MASK = MASK + (',children[id,blockDevicesDiskSpaceTotal,datacenter],' 'note,createDate,status,transaction') PUBLIC_TYPE = formatting.FormattedItem('PUBLIC', 'Public') PRIVATE_TYPE = formatting.FormattedItem('PRIVATE', 'Private') softlayer-python-5.0.1/SoftLayer/CLI/image/delete.py000066400000000000000000000007221267703721100222700ustar00rootroot00000000000000"""Delete an image.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @environment.pass_env 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) softlayer-python-5.0.1/SoftLayer/CLI/image/detail.py000066400000000000000000000044271267703721100222760ustar00rootroot00000000000000"""Get details for an image.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers from SoftLayer.CLI import image as image_mod from SoftLayer import utils @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """Get details for an image.""" image_mgr = SoftLayer.ImageManager(env.client) image_id = helpers.resolve_id(image_mgr.resolve_ids, identifier, 'image') image = image_mgr.get_image(image_id, mask=image_mod.DETAIL_MASK) disk_space = 0 datacenters = [] for child in image.get('children'): disk_space = int(child.get('blockDevicesDiskSpaceTotal', 0)) if child.get('datacenter'): datacenters.append(utils.lookup(child, 'datacenter', 'name')) table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'r' table.align['value'] = 'l' table.add_row(['id', image['id']]) table.add_row(['global_identifier', image.get('globalIdentifier', formatting.blank())]) table.add_row(['name', image['name'].strip()]) table.add_row(['status', formatting.FormattedItem( utils.lookup(image, 'status', 'keyname'), utils.lookup(image, 'status', 'name'), )]) table.add_row([ 'active_transaction', formatting.transaction_status(image.get('transaction')), ]) table.add_row(['account', image.get('accountId', formatting.blank())]) table.add_row(['visibility', image_mod.PUBLIC_TYPE if image['publicFlag'] else image_mod.PRIVATE_TYPE]) table.add_row(['type', formatting.FormattedItem( utils.lookup(image, 'imageType', 'keyName'), utils.lookup(image, 'imageType', 'name'), )]) table.add_row(['flex', image.get('flexImageFlag')]) table.add_row(['note', image.get('note')]) table.add_row(['created', image.get('createDate')]) table.add_row(['disk_space', formatting.b_to_gb(disk_space)]) table.add_row(['datacenters', formatting.listing(sorted(datacenters), separator=',')]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/image/edit.py000066400000000000000000000016031267703721100217520ustar00rootroot00000000000000"""Edit details of an image.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.option('--name', help="Name of the image") @click.option('--note', help="Additional note for the image") @click.option('--tag', help="Tags for the image") @environment.pass_env def cli(env, identifier, name, note, tag): """Edit details of an image.""" image_mgr = SoftLayer.ImageManager(env.client) data = {} if name: data['name'] = name if note: data['note'] = note if tag: data['tag'] = tag image_id = helpers.resolve_id(image_mgr.resolve_ids, identifier, 'image') if not image_mgr.edit(image_id, **data): raise exceptions.CLIAbort("Failed to Edit Image") softlayer-python-5.0.1/SoftLayer/CLI/image/export.py000066400000000000000000000014361267703721100223520ustar00rootroot00000000000000"""Export an image.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.argument('uri') @environment.pass_env def cli(env, identifier, uri): """Export an image to object storage. The URI for an object storage object (.vhd/.iso file) of the format: swift://@// """ image_mgr = SoftLayer.ImageManager(env.client) image_id = helpers.resolve_id(image_mgr.resolve_ids, identifier, 'image') result = image_mgr.export_image_to_uri(image_id, uri) if not result: raise exceptions.CLIAbort("Failed to export Image") softlayer-python-5.0.1/SoftLayer/CLI/image/import.py000066400000000000000000000026061267703721100223430ustar00rootroot00000000000000"""Import an image.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting @click.command() @click.argument('name') @click.argument('uri') @click.option('--note', default="", help="The note to be applied to the imported template") @click.option('--os-code', default="", help="The referenceCode of the operating system software" " description for the imported VHD") @environment.pass_env def cli(env, name, note, os_code, uri): """Import an image. The URI for an object storage object (.vhd/.iso file) of the format: swift://@// """ image_mgr = SoftLayer.ImageManager(env.client) result = image_mgr.import_image_from_uri( name=name, note=note, os_code=os_code, uri=uri, ) if not result: raise exceptions.CLIAbort("Failed to import Image") table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'r' table.align['value'] = 'l' table.add_row(['name', result['name']]) table.add_row(['id', result['id']]) table.add_row(['created', result['createDate']]) table.add_row(['guid', result['globalIdentifier']]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/image/list.py000066400000000000000000000035671267703721100220130ustar00rootroot00000000000000"""List images.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import image as image_mod from SoftLayer import utils @click.command() @click.option('--name', default=None, help='Filter on image name') @click.option('--public/--private', is_flag=True, default=None, help='Display only public or private images') @environment.pass_env 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) if public in [True, None]: for image in image_mgr.list_public_images(name=name, mask=image_mod.MASK): images.append(image) table = formatting.Table(['id', 'name', 'type', 'visibility', 'account']) images = [image for image in images if image['parentId'] == ''] for image in images: visibility = (image_mod.PUBLIC_TYPE if image['publicFlag'] else image_mod.PRIVATE_TYPE) table.add_row([ image.get('id', formatting.blank()), formatting.FormattedItem(image['name'], click.wrap_text(image['name'], width=50)), formatting.FormattedItem( utils.lookup(image, 'imageType', 'keyName'), utils.lookup(image, 'imageType', 'name')), visibility, image.get('accountId', formatting.blank()), ]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/iscsi/000077500000000000000000000000001267703721100205035ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/iscsi/__init__.py000066400000000000000000000000251267703721100226110ustar00rootroot00000000000000"""iSCSI storage.""" softlayer-python-5.0.1/SoftLayer/CLI/iscsi/cancel.py000066400000000000000000000017141267703721100223050ustar00rootroot00000000000000"""Cancel an existing iSCSI account.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.option('--reason', help="An optional reason for cancellation") @click.option('--immediate', is_flag=True, help="Cancels the iSCSI immediately instead of on the billing " "anniversary") @environment.pass_env def cli(env, identifier, reason, immediate): """Cancel an existing iSCSI account.""" iscsi_mgr = SoftLayer.ISCSIManager(env.client) iscsi_id = helpers.resolve_id(iscsi_mgr.resolve_ids, identifier, 'iSCSI') if not (env.skip_confirmations or formatting.no_going_back(iscsi_id)): raise exceptions.CLIAbort('Aborted') iscsi_mgr.cancel_iscsi(iscsi_id, reason, immediate) softlayer-python-5.0.1/SoftLayer/CLI/iscsi/create.py000066400000000000000000000012041267703721100223150ustar00rootroot00000000000000"""Creates an iSCSI target.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment @click.command() @click.option('--size', type=click.INT, required=True, help="Size of the iSCSI volume to create (in gibibytes)") @click.option('--datacenter', required=True, help="Datacenter shortname (sng01, dal05, ...)") @environment.pass_env def cli(env, size, datacenter): """Creates an iSCSI target.""" iscsi_mgr = SoftLayer.ISCSIManager(env.client) iscsi_mgr.create_iscsi(size=size, location=datacenter) softlayer-python-5.0.1/SoftLayer/CLI/iscsi/detail.py000066400000000000000000000035011267703721100223160ustar00rootroot00000000000000"""Get details for an iSCSI target.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers from SoftLayer import utils @click.command() @click.argument('identifier') @click.option('--password', is_flag=True, help="Show credentials to access the iSCSI target") @environment.pass_env def cli(env, identifier, password): """Get details for an iSCSI target.""" iscsi_mgr = SoftLayer.ISCSIManager(env.client) iscsi_id = helpers.resolve_id(iscsi_mgr.resolve_ids, identifier, 'iSCSI') result = iscsi_mgr.get_iscsi(iscsi_id) result = utils.NestedDict(result) table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'r' table.align['value'] = 'l' table.add_row(['id', result['id']]) table.add_row(['serviceResourceName', result['serviceResourceName']]) table.add_row(['createDate', result['createDate']]) table.add_row(['nasType', result['nasType']]) table.add_row(['capacityGb', result['capacityGb']]) if result['snapshotCapacityGb']: table.add_row(['snapshotCapacityGb', result['snapshotCapacityGb']]) table.add_row(['mountableFlag', result['mountableFlag']]) table.add_row(['serviceResourceBackendIpAddress', result['serviceResourceBackendIpAddress']]) table.add_row(['price', result['billingItem']['recurringFee']]) table.add_row(['BillingItemId', result['billingItem']['id']]) if result.get('notes'): table.add_row(['notes', result['notes']]) if password: pass_table = formatting.Table(['username', 'password']) pass_table.add_row([result['username'], result['password']]) table.add_row(['users', pass_table]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/iscsi/list.py000066400000000000000000000023741267703721100220360ustar00rootroot00000000000000"""List iSCSI targets.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer import utils @click.command() @environment.pass_env def cli(env): """List iSCSI targets.""" iscsi_mgr = SoftLayer.ISCSIManager(env.client) iscsi_list = iscsi_mgr.list_iscsi() iscsi_list = [utils.NestedDict(n) for n in iscsi_list] table = formatting.Table([ 'id', 'datacenter', 'size', 'username', 'password', 'server' ]) for iscsi in iscsi_list: table.add_row([ iscsi['id'], utils.lookup(iscsi, 'serviceResource', 'datacenter', 'name') or formatting.blank(), formatting.FormattedItem(iscsi.get('capacityGb', formatting.blank()), "%dGB" % iscsi.get('capacityGb', 0)), iscsi.get('username', formatting.blank()), iscsi.get('password', formatting.blank()), iscsi.get('serviceResourceBackendIpAddress', formatting.blank())]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/loadbal/000077500000000000000000000000001267703721100207675ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/loadbal/__init__.py000066400000000000000000000005561267703721100231060ustar00rootroot00000000000000"""Load balancers.""" from SoftLayer.CLI import exceptions def parse_id(input_id): """Parse the load balancer kind and actual id from the "kind:id" form.""" parts = input_id.split(':') if len(parts) != 2: raise exceptions.CLIAbort( 'Invalid ID %s: ID should be of the form "kind:id"' % input_id) return parts[0], int(parts[1]) softlayer-python-5.0.1/SoftLayer/CLI/loadbal/cancel.py000066400000000000000000000014641267703721100225730ustar00rootroot00000000000000"""Cancel an existing load balancer.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import loadbal @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """Cancel an existing load balancer.""" mgr = SoftLayer.LoadBalancerManager(env.client) _, loadbal_id = loadbal.parse_id(identifier) if not (env.skip_confirmations or formatting.confirm("This action will cancel a load balancer. " "Continue?")): raise exceptions.CLIAbort('Aborted.') mgr.cancel_lb(loadbal_id) env.fout('Load Balancer with id %s is being cancelled!' % identifier) softlayer-python-5.0.1/SoftLayer/CLI/loadbal/create.py000066400000000000000000000015471267703721100226130ustar00rootroot00000000000000"""Adds a load balancer given the id returned from create-options.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting @click.command() @click.argument('billing-id') @click.option('--datacenter', '-d', help='Datacenter shortname (sng01, dal05, ...)') @environment.pass_env def cli(env, billing_id, datacenter): """Adds a load balancer given the id returned from create-options.""" mgr = SoftLayer.LoadBalancerManager(env.client) if not formatting.confirm("This action will incur charges on your " "account. Continue?"): raise exceptions.CLIAbort('Aborted.') mgr.add_local_lb(billing_id, datacenter=datacenter) env.fout("Load balancer is being created!") softlayer-python-5.0.1/SoftLayer/CLI/loadbal/create_options.py000066400000000000000000000015271267703721100243640ustar00rootroot00000000000000"""Show load balancer options.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env def cli(env): """Get price options to create a load balancer with.""" mgr = SoftLayer.LoadBalancerManager(env.client) table = formatting.Table(['price_id', 'capacity', 'description', 'price']) table.sortby = 'price' table.align['price'] = 'r' table.align['capacity'] = 'r' table.align['id'] = 'r' packages = mgr.get_lb_pkgs() for package in packages: table.add_row([ package['prices'][0]['id'], package.get('capacity'), package['description'], '%.2f' % float(package['prices'][0]['recurringFee']) ]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/loadbal/detail.py000066400000000000000000000065711267703721100226140ustar00rootroot00000000000000"""Get Load balancer details.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import loadbal @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """Get Load balancer details.""" mgr = SoftLayer.LoadBalancerManager(env.client) _, loadbal_id = loadbal.parse_id(identifier) load_balancer = mgr.get_local_lb(loadbal_id) table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'l' table.align['value'] = 'l' table.add_row(['General properties', '----------']) table.add_row([' ID', 'local:%s' % load_balancer['id']]) table.add_row([' IP Address', load_balancer['ipAddress']['ipAddress']]) name = load_balancer['loadBalancerHardware'][0]['datacenter']['name'] table.add_row([' Datacenter', name]) table.add_row([' Connections limit', load_balancer['connectionLimit']]) table.add_row([' Dedicated', load_balancer['dedicatedFlag']]) table.add_row([' HA', load_balancer['highAvailabilityFlag']]) table.add_row([' SSL Enabled', load_balancer['sslEnabledFlag']]) table.add_row([' SSL Active', load_balancer['sslActiveFlag']]) index0 = 1 for virtual_server in load_balancer['virtualServers']: table.add_row(['Service group %s' % index0, '**************']) index0 += 1 table2 = formatting.Table(['Service group ID', 'Port', 'Allocation', 'Routing type', 'Routing Method']) for group in virtual_server['serviceGroups']: table2.add_row([ '%s:%s' % (load_balancer['id'], virtual_server['id']), virtual_server['port'], '%s %%' % virtual_server['allocation'], '%s:%s' % (group['routingTypeId'], group['routingType']['name']), '%s:%s' % (group['routingMethodId'], group['routingMethod']['name']) ]) table.add_row([' Group Properties', table2]) table3 = formatting.Table(['Service_ID', 'IP Address', 'Port', 'Health Check', 'Weight', 'Enabled', 'Status']) service_exist = False for service in group['services']: service_exist = True health_check = service['healthChecks'][0] table3.add_row([ '%s:%s' % (load_balancer['id'], service['id']), service['ipAddress']['ipAddress'], service['port'], '%s:%s' % (health_check['healthCheckTypeId'], health_check['type']['name']), service['groupReferences'][0]['weight'], service['enabled'], service['status'] ]) if service_exist: table.add_row([' Services', table3]) else: table.add_row([' Services', 'None']) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/loadbal/group_add.py000066400000000000000000000023511267703721100233060ustar00rootroot00000000000000"""Adds a new load_balancer service.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import loadbal @click.command() @click.argument('identifier') @click.option('--allocation', required=True, type=click.INT, help="The allocated percent of connections") @click.option('--port', required=True, help="The port number", type=click.INT) @click.option('--routing-type', required=True, help="The port routing type") @click.option('--routing-method', required=True, help="The routing method") @environment.pass_env def cli(env, identifier, allocation, port, routing_type, routing_method): """Adds a new load_balancer service.""" mgr = SoftLayer.LoadBalancerManager(env.client) _, loadbal_id = loadbal.parse_id(identifier) mgr.add_service_group(loadbal_id, allocation=allocation, port=port, routing_type=routing_type, routing_method=routing_method) env.fout('Load balancer service group is being added!') softlayer-python-5.0.1/SoftLayer/CLI/loadbal/group_delete.py000066400000000000000000000015161267703721100240220ustar00rootroot00000000000000"""Deletes an existing load balancer service group.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import loadbal @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """Deletes an existing load balancer service group.""" mgr = SoftLayer.LoadBalancerManager(env.client) _, group_id = loadbal.parse_id(identifier) if not (env.skip_confirmations or formatting.confirm("This action will cancel a service group. " "Continue?")): raise exceptions.CLIAbort('Aborted.') mgr.delete_service_group(group_id) env.fout('Service group %s is being deleted!' % identifier) softlayer-python-5.0.1/SoftLayer/CLI/loadbal/group_edit.py000066400000000000000000000027331267703721100235070ustar00rootroot00000000000000"""Edit an existing load balancer service group.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import loadbal @click.command() @click.argument('identifier') @click.option('--allocation', type=click.INT, help="Change the allocated percent of connections") @click.option('--port', help="Change the port number", type=click.INT) @click.option('--routing-type', help="Change the port routing type") @click.option('--routing-method', help="Change the routing method") @environment.pass_env 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_type, routing_method]): raise exceptions.CLIAbort( 'At least one property is required to be changed!') mgr.edit_service_group(loadbal_id, group_id, allocation=allocation, port=port, routing_type=routing_type, routing_method=routing_method) env.fout('Load balancer service group %s is being updated!' % identifier) softlayer-python-5.0.1/SoftLayer/CLI/loadbal/group_reset.py000066400000000000000000000011151267703721100236750ustar00rootroot00000000000000"""Reset connections on a certain service group.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import loadbal @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """Reset connections on a certain service group.""" mgr = SoftLayer.LoadBalancerManager(env.client) loadbal_id, group_id = loadbal.parse_id(identifier) mgr.reset_service_group(loadbal_id, group_id) env.fout('Load balancer service group connections are being reset!') softlayer-python-5.0.1/SoftLayer/CLI/loadbal/health_checks.py000066400000000000000000000011341267703721100241250ustar00rootroot00000000000000"""List health check types.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env 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_row([hc_type['id'], hc_type['name']]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/loadbal/list.py000066400000000000000000000026471267703721100223250ustar00rootroot00000000000000"""List active load balancers.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env def cli(env): """List active load balancers.""" mgr = SoftLayer.LoadBalancerManager(env.client) load_balancers = mgr.get_local_lbs() table = formatting.Table(['ID', 'VIP Address', 'Location', 'SSL Offload', 'Connections/second', 'Type']) table.align['Connections/second'] = 'r' for load_balancer in load_balancers: ssl_support = 'Not Supported' if load_balancer['sslEnabledFlag']: if load_balancer['sslActiveFlag']: ssl_support = 'On' else: ssl_support = 'Off' lb_type = 'Standard' if load_balancer['dedicatedFlag']: lb_type = 'Dedicated' elif load_balancer['highAvailabilityFlag']: lb_type = 'HA' table.add_row([ 'local:%s' % load_balancer['id'], load_balancer['ipAddress']['ipAddress'], load_balancer['loadBalancerHardware'][0]['datacenter']['name'], ssl_support, load_balancer['connectionLimit'], lb_type ]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/loadbal/routing_methods.py000066400000000000000000000011751267703721100245570ustar00rootroot00000000000000"""List routing methods.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env def cli(env): """List routing types.""" mgr = SoftLayer.LoadBalancerManager(env.client) routing_methods = mgr.get_routing_methods() table = formatting.KeyValueTable(['ID', 'Name']) table.align['ID'] = 'l' table.align['Name'] = 'l' table.sortby = 'ID' for routing_method in routing_methods: table.add_row([routing_method['id'], routing_method['name']]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/loadbal/routing_types.py000066400000000000000000000011561267703721100242570ustar00rootroot00000000000000"""List routing types.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env 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: table.add_row([routing_type['id'], routing_type['name']]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/loadbal/service_add.py000066400000000000000000000032461267703721100236160ustar00rootroot00000000000000"""Adds a new load balancer service.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import loadbal @click.command() @click.argument('identifier') @click.option('--enabled / --disabled', required=True, help="Create the service as enabled or disabled") @click.option('--port', required=True, help="The port number for the service", type=click.INT) @click.option('--weight', required=True, type=click.INT, help="The weight of the service") @click.option('--healthcheck-type', required=True, help="The health check type") @click.option('--ip-address', required=True, help="The IP address of the service") @environment.pass_env 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_service = env.client['Network_Subnet_IpAddress'] ip_record = ip_service.getByIpAddress(ip_address) if len(ip_record) > 0: ip_address_id = ip_record['id'] mgr.add_service(loadbal_id, group_id, ip_address_id=ip_address_id, enabled=enabled, port=port, weight=weight, hc_type=healthcheck_type) env.fout('Load balancer service is being added!') softlayer-python-5.0.1/SoftLayer/CLI/loadbal/service_delete.py000066400000000000000000000015341267703721100243260ustar00rootroot00000000000000"""Deletes an existing load balancer service.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import loadbal @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """Deletes an existing load balancer service.""" mgr = SoftLayer.LoadBalancerManager(env.client) _, service_id = loadbal.parse_id(identifier) if not (env.skip_confirmations or formatting.confirm("This action will cancel a service from your " "load balancer. Continue?")): raise exceptions.CLIAbort('Aborted.') mgr.delete_service(service_id) env.fout('Load balancer service %s is being cancelled!' % service_id) softlayer-python-5.0.1/SoftLayer/CLI/loadbal/service_edit.py000066400000000000000000000034561267703721100240160ustar00rootroot00000000000000"""Edit the properties of a service group.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import loadbal @click.command() @click.argument('identifier') @click.option('--enabled / --disabled', default=None, help="Enable or disable the service") @click.option('--port', help="Change the port number for the service", type=click.INT) @click.option('--weight', type=click.INT, help="Change the weight of the service") @click.option('--healthcheck-type', help="Change the health check type") @click.option('--ip-address', help="Change the IP address of the service") @environment.pass_env 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, port, healthcheck_type])) and enabled is None): raise exceptions.CLIAbort( 'At least one property is required to be changed!') # check if the IP is valid ip_address_id = None if ip_address: ip_service = env.client['Network_Subnet_IpAddress'] ip_record = ip_service.getByIpAddress(ip_address) ip_address_id = ip_record['id'] mgr.edit_service(loadbal_id, service_id, ip_address_id=ip_address_id, enabled=enabled, port=port, weight=weight, hc_type=healthcheck_type) env.fout('Load balancer service %s is being modified!' % identifier) softlayer-python-5.0.1/SoftLayer/CLI/loadbal/service_toggle.py000066400000000000000000000015611267703721100243450ustar00rootroot00000000000000"""Toggle the status of an existing load balancer service.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import loadbal @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """Toggle the status of an existing load balancer service.""" mgr = SoftLayer.LoadBalancerManager(env.client) _, service_id = loadbal.parse_id(identifier) if not (env.skip_confirmations or formatting.confirm("This action will toggle the status on the " "service. Continue?")): raise exceptions.CLIAbort('Aborted.') mgr.toggle_service_status(service_id) env.fout('Load balancer service %s status updated!' % identifier) softlayer-python-5.0.1/SoftLayer/CLI/metadata.py000066400000000000000000000047021267703721100215260ustar00rootroot00000000000000"""Find details about this machine.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting META_CHOICES = [ 'backend_ip', 'backend_mac', 'datacenter', 'datacenter_id', 'fqdn', 'frontend_mac', 'id', 'ip', 'network', 'provision_state', 'tags', 'user_data', ] META_MAPPING = { 'backend_ip': 'primary_backend_ip', 'ip': 'primary_ip', } HELP = """Find details about this machine \b PROP Choices %s \b Examples : %s """ % ('*'+'\n*'.join(META_CHOICES), 'slcli metadata '+'\nslcli metadata '.join(META_CHOICES)) @click.command(help=HELP, short_help="Find details about this machine.", epilog="These commands only work on devices on the backend " "SoftLayer network. This allows for self-discovery for " "newly provisioned resources.") @click.argument('prop', type=click.Choice(META_CHOICES)) @environment.pass_env def cli(env, prop): """Find details about this machine.""" try: if prop == 'network': env.fout(get_network()) return meta_prop = META_MAPPING.get(prop) or prop env.fout(SoftLayer.MetadataManager().get(meta_prop)) except SoftLayer.TransportError: raise exceptions.CLIAbort( 'Cannot connect to the backend service address. Make sure ' 'this command is being ran from a device on the backend ' 'network.') def get_network(): """Returns a list of tables with public and private network details.""" meta = SoftLayer.MetadataManager() network_tables = [] for network_func in [meta.public_network, meta.private_network]: network = network_func() table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'r' table.align['value'] = 'l' table.add_row(['mac addresses', formatting.listing(network['mac_addresses'], separator=',')]) table.add_row(['router', network['router']]) table.add_row(['vlans', formatting.listing(network['vlans'], separator=',')]) table.add_row(['vlan ids', formatting.listing(network['vlan_ids'], separator=',')]) network_tables.append(table) return network_tables softlayer-python-5.0.1/SoftLayer/CLI/mq/000077500000000000000000000000001267703721100200065ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/mq/__init__.py000066400000000000000000000036771267703721100221340ustar00rootroot00000000000000"""Message queue service.""" # :license: MIT, see LICENSE for more details. from SoftLayer.CLI import formatting def queue_table(queue): """Returns a table with details about a queue.""" table = formatting.Table(['property', 'value']) table.align['property'] = 'r' table.align['value'] = 'l' table.add_row(['name', queue['name']]) table.add_row(['message_count', queue['message_count']]) table.add_row(['visible_message_count', queue['visible_message_count']]) table.add_row(['tags', formatting.listing(queue['tags'] or [])]) table.add_row(['expiration', queue['expiration']]) table.add_row(['visibility_interval', queue['visibility_interval']]) return table def message_table(message): """Returns a table with details about a message.""" table = formatting.Table(['property', 'value']) table.align['property'] = 'r' table.align['value'] = 'l' table.add_row(['id', message['id']]) table.add_row(['initial_entry_time', message['initial_entry_time']]) table.add_row(['visibility_delay', message['visibility_delay']]) table.add_row(['visibility_interval', message['visibility_interval']]) table.add_row(['fields', message['fields']]) return [table, message['body']] def topic_table(topic): """Returns a table with details about a topic.""" table = formatting.Table(['property', 'value']) table.align['property'] = 'r' table.align['value'] = 'l' table.add_row(['name', topic['name']]) table.add_row(['tags', formatting.listing(topic['tags'] or [])]) return table def subscription_table(sub): """Returns a table with details about a subscription.""" table = formatting.Table(['property', 'value']) table.align['property'] = 'r' table.align['value'] = 'l' table.add_row(['id', sub['id']]) table.add_row(['endpoint_type', sub['endpoint_type']]) for key, val in sub['endpoint'].items(): table.add_row([key, val]) return table softlayer-python-5.0.1/SoftLayer/CLI/mq/accounts_list.py000066400000000000000000000013031267703721100232270ustar00rootroot00000000000000"""List SoftLayer Message Queue Accounts.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env def cli(env): """List SoftLayer Message Queue Accounts.""" manager = SoftLayer.MessagingManager(env.client) accounts = manager.list_accounts() table = formatting.Table(['id', 'name', 'status']) for account in accounts: if not account['nodes']: continue table.add_row([account['nodes'][0]['accountName'], account['name'], account['status']['name']]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/mq/endpoints_list.py000066400000000000000000000012731267703721100234210ustar00rootroot00000000000000"""List SoftLayer Message Queue Endpoints.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env def cli(env): """List SoftLayer Message Queue Endpoints.""" manager = SoftLayer.MessagingManager(env.client) regions = manager.get_endpoints() table = formatting.Table(['name', 'public', 'private']) for region, endpoints in regions.items(): table.add_row([ region, endpoints.get('public') or formatting.blank(), endpoints.get('private') or formatting.blank(), ]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/mq/ping.py000066400000000000000000000013151267703721100213150ustar00rootroot00000000000000"""Ping the SoftLayer Message Queue service.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions @click.command() @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @environment.pass_env def cli(env, datacenter, network): """Ping the SoftLayer Message Queue service.""" manager = SoftLayer.MessagingManager(env.client) okay = manager.ping(datacenter=datacenter, network=network) if okay: env.fout('OK') else: exceptions.CLIAbort('Ping failed') softlayer-python-5.0.1/SoftLayer/CLI/mq/queue_add.py000066400000000000000000000027161267703721100223220ustar00rootroot00000000000000"""Create a queue.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers from SoftLayer.CLI import mq @click.command() @click.argument('account-id') @click.argument('queue-name') @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @click.option('--visibility-interval', type=click.INT, default=30, show_default=True, help="Time in seconds that messages will re-appear after being " "popped") @click.option('--expiration', type=click.INT, default=604800, show_default=True, help="Time in seconds that messages will live") @helpers.multi_option('--tag', '-g', help="Tags to add to the queue") @environment.pass_env def cli(env, account_id, queue_name, datacenter, network, visibility_interval, expiration, tag): """Create a queue.""" manager = SoftLayer.MessagingManager(env.client) mq_client = manager.get_connection(account_id, datacenter=datacenter, network=network) queue = mq_client.create_queue( queue_name, visibility_interval=visibility_interval, expiration=expiration, tags=tag, ) env.fout(mq.queue_table(queue)) softlayer-python-5.0.1/SoftLayer/CLI/mq/queue_detail.py000066400000000000000000000014361267703721100230320ustar00rootroot00000000000000"""Detail a queue.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import mq @click.command() @click.argument('account-id') @click.argument('queue-name') @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @environment.pass_env def cli(env, account_id, queue_name, datacenter, network): """Detail a queue.""" manager = SoftLayer.MessagingManager(env.client) mq_client = manager.get_connection(account_id, datacenter=datacenter, network=network) queue = mq_client.get_queue(queue_name) env.fout(mq.queue_table(queue)) softlayer-python-5.0.1/SoftLayer/CLI/mq/queue_edit.py000066400000000000000000000027161267703721100225170ustar00rootroot00000000000000"""Modify a queue.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers from SoftLayer.CLI import mq @click.command() @click.argument('account-id') @click.argument('queue-name') @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @click.option('--visibility-interval', type=click.INT, default=30, show_default=True, help="Time in seconds that messages will re-appear after being " "popped") @click.option('--expiration', type=click.INT, default=604800, show_default=True, help="Time in seconds that messages will live") @helpers.multi_option('--tag', '-g', help="Tags to add to the queue") @environment.pass_env def cli(env, account_id, queue_name, datacenter, network, visibility_interval, expiration, tag): """Modify a queue.""" manager = SoftLayer.MessagingManager(env.client) mq_client = manager.get_connection(account_id, datacenter=datacenter, network=network) queue = mq_client.modify_queue( queue_name, visibility_interval=visibility_interval, expiration=expiration, tags=tag, ) env.fout(mq.queue_table(queue)) softlayer-python-5.0.1/SoftLayer/CLI/mq/queue_list.py000066400000000000000000000021001267703721100225300ustar00rootroot00000000000000"""List all queues on an account.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @click.argument('account-id') @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @environment.pass_env def cli(env, account_id, datacenter, network): """List all queues on an account.""" manager = SoftLayer.MessagingManager(env.client) mq_client = manager.get_connection(account_id, datacenter=datacenter, network=network) queues = mq_client.get_queues()['items'] table = formatting.Table(['name', 'message_count', 'visible_message_count']) for queue in queues: table.add_row([queue['name'], queue['message_count'], queue['visible_message_count']]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/mq/queue_pop.py000066400000000000000000000025571267703721100223730ustar00rootroot00000000000000"""Pops a message from a queue.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import mq @click.command() @click.argument('account-id') @click.argument('queue-name') @click.option('--count', default=1, show_default=True, type=click.INT, help="Count of messages to pop") @click.option('--delete-after', is_flag=True, help="Remove popped messages from the queue") @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @environment.pass_env def cli(env, account_id, queue_name, count, delete_after, datacenter, network): """Pops a message from a queue.""" manager = SoftLayer.MessagingManager(env.client) mq_client = manager.get_connection(account_id, datacenter=datacenter, network=network) messages = mq_client.pop_messages(queue_name, count) formatted_messages = [] for message in messages['items']: formatted_messages.append(mq.message_table(message)) if delete_after: for message in messages['items']: mq_client.delete_message(queue_name, message['id']) env.fout(formatted_messages) softlayer-python-5.0.1/SoftLayer/CLI/mq/queue_push.py000066400000000000000000000017141267703721100225460ustar00rootroot00000000000000"""Push a message into a queue.""" # :license: MIT, see LICENSE for more details. import sys import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import mq @click.command() @click.argument('account-id') @click.argument('queue-name') @click.argument('message') @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @environment.pass_env def cli(env, account_id, queue_name, message, datacenter, network): """Push a message into a queue.""" manager = SoftLayer.MessagingManager(env.client) mq_client = manager.get_connection(account_id, datacenter=datacenter, network=network) body = '' if message == '-': body = sys.stdin.read() else: body = message env.fout(mq.message_table(mq_client.push_queue_message(queue_name, body))) softlayer-python-5.0.1/SoftLayer/CLI/mq/queue_remove.py000066400000000000000000000017621267703721100230670ustar00rootroot00000000000000"""Delete a queue or a queued message.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment @click.command() @click.argument('account-id') @click.argument('queue-name') @click.argument('message-id', required=False) @click.option('--force', is_flag=True, help="Force the deletion of the queue") @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @environment.pass_env def cli(env, account_id, queue_name, message_id, force, datacenter, network): """Delete a queue or a queued message.""" manager = SoftLayer.MessagingManager(env.client) mq_client = manager.get_connection(account_id, datacenter=datacenter, network=network) if message_id: mq_client.delete_message(queue_name, message_id) else: mq_client.delete_queue(queue_name, force) softlayer-python-5.0.1/SoftLayer/CLI/mq/topic_add.py000066400000000000000000000027261267703721100223150ustar00rootroot00000000000000"""Create a new topic.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers from SoftLayer.CLI import mq @click.command() @click.argument('account-id') @click.argument('topic-name') @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @click.option('--visibility-interval', type=click.INT, default=30, show_default=True, help="Time in seconds that messages will re-appear after being " "popped") @click.option('--expiration', type=click.INT, default=604800, show_default=True, help="Time in seconds that messages will live") @helpers.multi_option('--tag', '-g', help="Tags to add to the topic") @environment.pass_env def cli(env, account_id, topic_name, datacenter, network, visibility_interval, expiration, tag): """Create a new topic.""" manager = SoftLayer.MessagingManager(env.client) mq_client = manager.get_connection(account_id, datacenter=datacenter, network=network) topic = mq_client.create_topic( topic_name, visibility_interval=visibility_interval, expiration=expiration, tags=tag, ) env.fout(mq.topic_table(topic)) softlayer-python-5.0.1/SoftLayer/CLI/mq/topic_detail.py000066400000000000000000000017151267703721100230240ustar00rootroot00000000000000"""Detail a topic.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import mq @click.command() @click.argument('account-id') @click.argument('topic-name') @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @environment.pass_env def cli(env, account_id, topic_name, datacenter, network): """Detail a topic.""" manager = SoftLayer.MessagingManager(env.client) mq_client = manager.get_connection(account_id, datacenter=datacenter, network=network) topic = mq_client.get_topic(topic_name) subscriptions = mq_client.get_subscriptions(topic_name) tables = [] for sub in subscriptions['items']: tables.append(mq.subscription_table(sub)) env.fout([mq.topic_table(topic), tables]) softlayer-python-5.0.1/SoftLayer/CLI/mq/topic_list.py000066400000000000000000000015631267703721100225360ustar00rootroot00000000000000"""List all topics on an account.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @click.argument('account-id') @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @environment.pass_env def cli(env, account_id, datacenter, network): """List all topics on an account.""" manager = SoftLayer.MessagingManager(env.client) mq_client = manager.get_connection(account_id, datacenter=datacenter, network=network) topics = mq_client.get_topics()['items'] table = formatting.Table(['name']) for topic in topics: table.add_row([topic['name']]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/mq/topic_push.py000066400000000000000000000020201267703721100225270ustar00rootroot00000000000000"""Push a message into a topic.""" # :license: MIT, see LICENSE for more details. import sys import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import mq @click.command() @click.argument('account-id') @click.argument('topic-name') @click.argument('message') @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @environment.pass_env def cli(env, account_id, topic_name, message, datacenter, network): """Push a message into a topic.""" manager = SoftLayer.MessagingManager(env.client) mq_client = manager.get_connection(account_id, datacenter=datacenter, network=network) # the message body comes from the positional argument or stdin body = '' if message == '-': body = sys.stdin.read() else: body = message env.fout(mq.message_table(mq_client.push_topic_message(topic_name, body))) softlayer-python-5.0.1/SoftLayer/CLI/mq/topic_remove.py000066400000000000000000000014651267703721100230610ustar00rootroot00000000000000"""Delete a topic.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment @click.command() @click.argument('account-id') @click.argument('topic-name') @click.option('--force', is_flag=True, help="Force the deletion of the queue") @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @environment.pass_env def cli(env, account_id, topic_name, force, datacenter, network): """Delete a topic.""" manager = SoftLayer.MessagingManager(env.client) mq_client = manager.get_connection(account_id, datacenter=datacenter, network=network) mq_client.delete_topic(topic_name, force) softlayer-python-5.0.1/SoftLayer/CLI/mq/topic_subscribe.py000066400000000000000000000033111267703721100235350ustar00rootroot00000000000000"""Create a subscription on a topic.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import mq @click.command() @click.argument('account-id') @click.argument('topic-name') @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @click.option('--sub-type', type=click.Choice(['http', 'queue']), help="Type of endpoint") @click.option('--queue-name', help="Queue name. Required if --type is queue") @click.option('--http-method', help="HTTP Method to use if --type is http") @click.option('--http-url', help="HTTP/HTTPS URL to use. Required if --type is http") @click.option('--http-body', help="HTTP Body template to use if --type is http") @environment.pass_env def cli(env, account_id, topic_name, datacenter, network, sub_type, queue_name, http_method, http_url, http_body): """Create a subscription on a topic.""" manager = SoftLayer.MessagingManager(env.client) mq_client = manager.get_connection(account_id, datacenter=datacenter, network=network) if sub_type == 'queue': subscription = mq_client.create_subscription(topic_name, 'queue', queue_name=queue_name) elif sub_type == 'http': subscription = mq_client.create_subscription( topic_name, 'http', method=http_method, url=http_url, body=http_body, ) env.fout(mq.subscription_table(subscription)) softlayer-python-5.0.1/SoftLayer/CLI/mq/topic_unsubscribe.py000066400000000000000000000015101267703721100240770ustar00rootroot00000000000000"""Remove a subscription on a topic.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment @click.command() @click.argument('account-id') @click.argument('topic-name') @click.argument('subscription-id') @click.option('--datacenter', help="Datacenter, E.G.: dal05") @click.option('--network', type=click.Choice(['public', 'private']), help="Network type") @environment.pass_env def cli(env, account_id, topic_name, subscription_id, datacenter, network): """Remove a subscription on a topic.""" manager = SoftLayer.MessagingManager(env.client) mq_client = manager.get_connection(account_id, datacenter=datacenter, network=network) mq_client.delete_subscription(topic_name, subscription_id) softlayer-python-5.0.1/SoftLayer/CLI/nas/000077500000000000000000000000001267703721100201525ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/nas/__init__.py000066400000000000000000000000401267703721100222550ustar00rootroot00000000000000"""Network Attached Storage.""" softlayer-python-5.0.1/SoftLayer/CLI/nas/credentials.py000066400000000000000000000011101267703721100230120ustar00rootroot00000000000000"""List NAS account credentials.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """List NAS account credentials.""" nw_mgr = SoftLayer.NetworkManager(env.client) result = nw_mgr.get_nas_credentials(identifier) table = formatting.Table(['username', 'password']) table.add_row([result['username'], result['password']]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/nas/list.py000066400000000000000000000020441267703721100214770ustar00rootroot00000000000000"""List NAS accounts.""" # :license: MIT, see LICENSE for more details. import click from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer import utils @click.command() @environment.pass_env def cli(env): """List NAS accounts.""" account = env.client['Account'] nas_accounts = account.getNasNetworkStorage( mask='eventCount,serviceResource[datacenter.name]') table = formatting.Table(['id', 'datacenter', 'size', 'server']) for nas_account in nas_accounts: table.add_row([ nas_account['id'], utils.lookup(nas_account, 'serviceResource', 'datacenter', 'name') or formatting.blank(), formatting.FormattedItem( nas_account.get('capacityGb', formatting.blank()), "%dGB" % nas_account.get('capacityGb', 0)), nas_account.get('serviceResourceBackendIpAddress', formatting.blank())]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/object_storage/000077500000000000000000000000001267703721100223635ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/object_storage/__init__.py000066400000000000000000000000261267703721100244720ustar00rootroot00000000000000"""Object Storage.""" softlayer-python-5.0.1/SoftLayer/CLI/object_storage/list_accounts.py000066400000000000000000000011141267703721100256040ustar00rootroot00000000000000"""List Object Storage accounts.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env def cli(env): """List object storage accounts.""" mgr = SoftLayer.ObjectStorageManager(env.client) accounts = mgr.list_accounts() table = formatting.Table(['id', 'name']) table.sortby = 'id' for account in accounts: table.add_row([ account['id'], account['username'], ]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/object_storage/list_endpoints.py000066400000000000000000000012011267703721100257650ustar00rootroot00000000000000"""List Object Storage endpoints.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env 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'], endpoint['public'], endpoint['private'], ]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/routes.py000066400000000000000000000232211267703721100212640ustar00rootroot00000000000000""" SoftLayer.CLI.routes ~~~~~~~~~~~~~~~~~~~~~ This is how all commands are registered with the CLI. :license: MIT, see LICENSE for more details. """ ALL_ROUTES = [ ('shell', 'SoftLayer.shell.core:cli'), ('call-api', 'SoftLayer.CLI.call_api:cli'), ('virtual', 'SoftLayer.CLI.virt'), ('virtual:cancel', 'SoftLayer.CLI.virt.cancel:cli'), ('virtual:capture', 'SoftLayer.CLI.virt.capture:cli'), ('virtual:create', 'SoftLayer.CLI.virt.create:cli'), ('virtual:create-options', 'SoftLayer.CLI.virt.create_options:cli'), ('virtual:detail', 'SoftLayer.CLI.virt.detail:cli'), ('virtual:dns-sync', 'SoftLayer.CLI.virt.dns:cli'), ('virtual:edit', 'SoftLayer.CLI.virt.edit:cli'), ('virtual:list', 'SoftLayer.CLI.virt.list:cli'), ('virtual:pause', 'SoftLayer.CLI.virt.power:pause'), ('virtual:power-off', 'SoftLayer.CLI.virt.power:power_off'), ('virtual:power-on', 'SoftLayer.CLI.virt.power:power_on'), ('virtual:rescue', 'SoftLayer.CLI.virt.power:rescue'), ('virtual:resume', 'SoftLayer.CLI.virt.power:resume'), ('virtual:ready', 'SoftLayer.CLI.virt.ready:cli'), ('virtual:reboot', 'SoftLayer.CLI.virt.power:reboot'), ('virtual:reload', 'SoftLayer.CLI.virt.reload:cli'), ('virtual:upgrade', 'SoftLayer.CLI.virt.upgrade:cli'), ('virtual:credentials', 'SoftLayer.CLI.virt.credentials:cli'), ('cdn', 'SoftLayer.CLI.cdn'), ('cdn:detail', 'SoftLayer.CLI.cdn.detail:cli'), ('cdn:list', 'SoftLayer.CLI.cdn.list:cli'), ('cdn:load', 'SoftLayer.CLI.cdn.load:cli'), ('cdn:origin-add', 'SoftLayer.CLI.cdn.origin_add:cli'), ('cdn:origin-list', 'SoftLayer.CLI.cdn.origin_list:cli'), ('cdn:origin-remove', 'SoftLayer.CLI.cdn.origin_remove:cli'), ('cdn:purge', 'SoftLayer.CLI.cdn.purge:cli'), ('config', 'SoftLayer.CLI.config'), ('config:setup', 'SoftLayer.CLI.config.setup:cli'), ('config:show', 'SoftLayer.CLI.config.show:cli'), ('setup', 'SoftLayer.CLI.config.setup:cli'), ('dns', 'SoftLayer.CLI.dns'), ('dns:import', 'SoftLayer.CLI.dns.zone_import:cli'), ('dns:record-add', 'SoftLayer.CLI.dns.record_add:cli'), ('dns:record-edit', 'SoftLayer.CLI.dns.record_edit:cli'), ('dns:record-list', 'SoftLayer.CLI.dns.record_list:cli'), ('dns:record-remove', 'SoftLayer.CLI.dns.record_remove:cli'), ('dns:zone-create', 'SoftLayer.CLI.dns.zone_create:cli'), ('dns:zone-delete', 'SoftLayer.CLI.dns.zone_delete:cli'), ('dns:zone-list', 'SoftLayer.CLI.dns.zone_list:cli'), ('dns:zone-print', 'SoftLayer.CLI.dns.zone_print:cli'), ('firewall', 'SoftLayer.CLI.firewall'), ('firewall:add', 'SoftLayer.CLI.firewall.add:cli'), ('firewall:cancel', 'SoftLayer.CLI.firewall.cancel:cli'), ('firewall:detail', 'SoftLayer.CLI.firewall.detail:cli'), ('firewall:edit', 'SoftLayer.CLI.firewall.edit:cli'), ('firewall:list', 'SoftLayer.CLI.firewall.list:cli'), ('globalip', 'SoftLayer.CLI.globalip'), ('globalip:assign', 'SoftLayer.CLI.globalip.assign:cli'), ('globalip:cancel', 'SoftLayer.CLI.globalip.cancel:cli'), ('globalip:create', 'SoftLayer.CLI.globalip.create:cli'), ('globalip:list', 'SoftLayer.CLI.globalip.list:cli'), ('globalip:unassign', 'SoftLayer.CLI.globalip.unassign:cli'), ('image', 'SoftLayer.CLI.image'), ('image:delete', 'SoftLayer.CLI.image.delete:cli'), ('image:detail', 'SoftLayer.CLI.image.detail:cli'), ('image:edit', 'SoftLayer.CLI.image.edit:cli'), ('image:list', 'SoftLayer.CLI.image.list:cli'), ('image:import', 'SoftLayer.CLI.image.import:cli'), ('image:export', 'SoftLayer.CLI.image.export:cli'), ('iscsi', 'SoftLayer.CLI.iscsi'), ('iscsi:cancel', 'SoftLayer.CLI.iscsi.cancel:cli'), ('iscsi:create', 'SoftLayer.CLI.iscsi.create:cli'), ('iscsi:detail', 'SoftLayer.CLI.iscsi.detail:cli'), ('iscsi:list', 'SoftLayer.CLI.iscsi.list:cli'), ('loadbal', 'SoftLayer.CLI.loadbal'), ('loadbal:cancel', 'SoftLayer.CLI.loadbal.cancel:cli'), ('loadbal:create', 'SoftLayer.CLI.loadbal.create:cli'), ('loadbal:create-options', 'SoftLayer.CLI.loadbal.create_options:cli'), ('loadbal:detail', 'SoftLayer.CLI.loadbal.detail:cli'), ('loadbal:group-add', 'SoftLayer.CLI.loadbal.group_add:cli'), ('loadbal:group-delete', 'SoftLayer.CLI.loadbal.group_delete:cli'), ('loadbal:group-edit', 'SoftLayer.CLI.loadbal.group_edit:cli'), ('loadbal:group-reset', 'SoftLayer.CLI.loadbal.group_reset:cli'), ('loadbal:health-checks', 'SoftLayer.CLI.loadbal.health_checks:cli'), ('loadbal:list', 'SoftLayer.CLI.loadbal.list:cli'), ('loadbal:routing-methods', 'SoftLayer.CLI.loadbal.routing_methods:cli'), ('loadbal:routing-types', 'SoftLayer.CLI.loadbal.routing_types:cli'), ('loadbal:service-add', 'SoftLayer.CLI.loadbal.service_add:cli'), ('loadbal:service-delete', 'SoftLayer.CLI.loadbal.service_delete:cli'), ('loadbal:service-edit', 'SoftLayer.CLI.loadbal.service_edit:cli'), ('loadbal:service-toggle', 'SoftLayer.CLI.loadbal.service_toggle:cli'), ('messaging', 'SoftLayer.CLI.mq'), ('messaging:accounts-list', 'SoftLayer.CLI.mq.accounts_list:cli'), ('messaging:endpoints-list', 'SoftLayer.CLI.mq.endpoints_list:cli'), ('messaging:ping', 'SoftLayer.CLI.mq.ping:cli'), ('messaging:queue-add', 'SoftLayer.CLI.mq.queue_add:cli'), ('messaging:queue-detail', 'SoftLayer.CLI.mq.queue_detail:cli'), ('messaging:queue-edit', 'SoftLayer.CLI.mq.queue_edit:cli'), ('messaging:queue-list', 'SoftLayer.CLI.mq.queue_list:cli'), ('messaging:queue-pop', 'SoftLayer.CLI.mq.queue_pop:cli'), ('messaging:queue-push', 'SoftLayer.CLI.mq.queue_push:cli'), ('messaging:queue-remove', 'SoftLayer.CLI.mq.queue_remove:cli'), ('messaging:topic-add', 'SoftLayer.CLI.mq.topic_add:cli'), ('messaging:topic-detail', 'SoftLayer.CLI.mq.topic_detail:cli'), ('messaging:topic-list', 'SoftLayer.CLI.mq.topic_list:cli'), ('messaging:topic-push', 'SoftLayer.CLI.mq.topic_push:cli'), ('messaging:topic-remove', 'SoftLayer.CLI.mq.topic_remove:cli'), ('messaging:topic-subscribe', 'SoftLayer.CLI.mq.topic_subscribe:cli'), ('messaging:topic-unsubscribe', 'SoftLayer.CLI.mq.topic_unsubscribe:cli'), ('metadata', 'SoftLayer.CLI.metadata:cli'), ('nas', 'SoftLayer.CLI.nas'), ('nas:list', 'SoftLayer.CLI.nas.list:cli'), ('nas:credentials', 'SoftLayer.CLI.nas.credentials:cli'), ('object-storage', 'SoftLayer.CLI.object_storage'), ('object-storage:accounts', 'SoftLayer.CLI.object_storage.list_accounts:cli'), ('object-storage:endpoints', 'SoftLayer.CLI.object_storage.list_endpoints:cli'), ('rwhois', 'SoftLayer.CLI.rwhois'), ('rwhois:edit', 'SoftLayer.CLI.rwhois.edit:cli'), ('rwhois:show', 'SoftLayer.CLI.rwhois.show:cli'), ('hardware', 'SoftLayer.CLI.hardware'), ('hardware:cancel', 'SoftLayer.CLI.hardware.cancel:cli'), ('hardware:cancel-reasons', 'SoftLayer.CLI.hardware.cancel_reasons:cli'), ('hardware:create', 'SoftLayer.CLI.hardware.create:cli'), ('hardware:create-options', 'SoftLayer.CLI.hardware.create_options:cli'), ('hardware:detail', 'SoftLayer.CLI.hardware.detail:cli'), ('hardware:edit', 'SoftLayer.CLI.hardware.edit:cli'), ('hardware:list', 'SoftLayer.CLI.hardware.list:cli'), ('hardware:power-cycle', 'SoftLayer.CLI.hardware.power:power_cycle'), ('hardware:power-off', 'SoftLayer.CLI.hardware.power:power_off'), ('hardware:power-on', 'SoftLayer.CLI.hardware.power:power_on'), ('hardware:reboot', 'SoftLayer.CLI.hardware.power:reboot'), ('hardware:reload', 'SoftLayer.CLI.hardware.reload:cli'), ('hardware:credentials', 'SoftLayer.CLI.hardware.credentials:cli'), ('hardware:update-firmware', 'SoftLayer.CLI.hardware.update_firmware:cli'), ('snapshot', 'SoftLayer.CLI.snapshot'), ('snapshot:cancel', 'SoftLayer.CLI.snapshot.cancel:cli'), ('snapshot:create', 'SoftLayer.CLI.snapshot.create:cli'), ('snapshot:create-space', 'SoftLayer.CLI.snapshot.create_space:cli'), ('snapshot:list', 'SoftLayer.CLI.snapshot.list:cli'), ('snapshot:restore-volume', 'SoftLayer.CLI.snapshot.restore_volume:cli'), ('sshkey', 'SoftLayer.CLI.sshkey'), ('sshkey:add', 'SoftLayer.CLI.sshkey.add:cli'), ('sshkey:remove', 'SoftLayer.CLI.sshkey.remove:cli'), ('sshkey:edit', 'SoftLayer.CLI.sshkey.edit:cli'), ('sshkey:list', 'SoftLayer.CLI.sshkey.list:cli'), ('sshkey:print', 'SoftLayer.CLI.sshkey.print:cli'), ('ssl', 'SoftLayer.CLI.ssl'), ('ssl:add', 'SoftLayer.CLI.ssl.add:cli'), ('ssl:download', 'SoftLayer.CLI.ssl.download:cli'), ('ssl:edit', 'SoftLayer.CLI.ssl.edit:cli'), ('ssl:list', 'SoftLayer.CLI.ssl.list:cli'), ('ssl:remove', 'SoftLayer.CLI.ssl.remove:cli'), ('subnet', 'SoftLayer.CLI.subnet'), ('subnet:cancel', 'SoftLayer.CLI.subnet.cancel:cli'), ('subnet:create', 'SoftLayer.CLI.subnet.create:cli'), ('subnet:detail', 'SoftLayer.CLI.subnet.detail:cli'), ('subnet:list', 'SoftLayer.CLI.subnet.list:cli'), ('subnet:lookup', 'SoftLayer.CLI.subnet.lookup:cli'), ('ticket', 'SoftLayer.CLI.ticket'), ('ticket:create', 'SoftLayer.CLI.ticket.create:cli'), ('ticket:detail', 'SoftLayer.CLI.ticket.detail:cli'), ('ticket:list', 'SoftLayer.CLI.ticket.list:cli'), ('ticket:update', 'SoftLayer.CLI.ticket.update:cli'), ('ticket:subjects', 'SoftLayer.CLI.ticket.subjects:cli'), ('ticket:summary', 'SoftLayer.CLI.ticket.summary:cli'), ('vlan', 'SoftLayer.CLI.vlan'), ('vlan:detail', 'SoftLayer.CLI.vlan.detail:cli'), ('vlan:list', 'SoftLayer.CLI.vlan.list:cli'), ('summary', 'SoftLayer.CLI.summary:cli'), ] ALL_ALIASES = { 'hw': 'hardware', 'lb': 'loadbal', 'meta': 'metadata', 'my': 'metadata', 'server': 'hardware', 'vm': 'virtual', 'vs': 'virtual', } softlayer-python-5.0.1/SoftLayer/CLI/rwhois/000077500000000000000000000000001267703721100207045ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/rwhois/__init__.py000066400000000000000000000000261267703721100230130ustar00rootroot00000000000000"""Referral Whois.""" softlayer-python-5.0.1/SoftLayer/CLI/rwhois/edit.py000066400000000000000000000035431267703721100222100ustar00rootroot00000000000000"""Edit the RWhois data on the account.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions @click.command() @click.option('--abuse', help='Set the abuse email address') @click.option('--address1', help='Update the address 1 field') @click.option('--address2', help='Update the address 2 field') @click.option('--city', help='Set the city name') @click.option('--company', help='Set the company name') @click.option('--country', help='Set the two-letter country code') @click.option('--firstname', help='Update the first name field') @click.option('--lastname', help='Update the last name field') @click.option('--postal', help='Set the postal code field') @click.option('--public/--private', default=None, help='Flags the address as a public or private residence.') @click.option('--state', help='Set the two-letter state code') @environment.pass_env 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, 'company_name': company, 'city': city, 'country': country, 'first_name': firstname, 'last_name': lastname, 'postal_code': postal, 'state': state, 'private_residence': public, } if public is True: update['private_residence'] = False elif public is False: update['private_residence'] = True check = [x for x in update.values() if x is not None] if not check: raise exceptions.CLIAbort( "You must specify at least one field to update.") mgr.edit_rwhois(**update) softlayer-python-5.0.1/SoftLayer/CLI/rwhois/show.py000066400000000000000000000022041267703721100222340ustar00rootroot00000000000000"""Display the RWhois information for your account.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env 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'] + ' ' + result['lastName']]) table.add_row(['Company', result['companyName']]) table.add_row(['Abuse Email', result['abuseEmail']]) table.add_row(['Address 1', result['address1']]) if result.get('address2'): table.add_row(['Address 2', result['address2']]) table.add_row(['City', result['city']]) table.add_row(['State', result.get('state', '-')]) table.add_row(['Postal Code', result.get('postalCode', '-')]) table.add_row(['Country', result['country']]) table.add_row(['Private Residence', result['privateResidenceFlag']]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/snapshot/000077500000000000000000000000001267703721100212305ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/snapshot/__init__.py000066400000000000000000000000211267703721100233320ustar00rootroot00000000000000"""Snapshots.""" softlayer-python-5.0.1/SoftLayer/CLI/snapshot/cancel.py000066400000000000000000000011011267703721100230200ustar00rootroot00000000000000"""Cancel/Delete iSCSI snapshot.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """Cancel/Delete iSCSI snapshot.""" iscsi_mgr = SoftLayer.ISCSIManager(env.client) snapshot_id = helpers.resolve_id(iscsi_mgr.resolve_ids, identifier, 'Snapshot') iscsi_mgr.delete_snapshot(snapshot_id) softlayer-python-5.0.1/SoftLayer/CLI/snapshot/create.py000066400000000000000000000011171267703721100230450ustar00rootroot00000000000000"""Create a snapshot of an iSCSI volume.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.option('--notes', help="An optional note for the snapshot") @environment.pass_env def cli(env, identifier, notes): """Create a snapshot of an iSCSI volume.""" iscsi_mgr = SoftLayer.ISCSIManager(env.client) iscsi_id = helpers.resolve_id(iscsi_mgr.resolve_ids, identifier, 'iSCSI') iscsi_mgr.create_snapshot(iscsi_id, notes) softlayer-python-5.0.1/SoftLayer/CLI/snapshot/create_space.py000066400000000000000000000012131267703721100242150ustar00rootroot00000000000000"""Orders snapshot space for given iSCSI.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.option('--capacity', type=click.INT, help="Size of snapshot space to create") @environment.pass_env def cli(env, identifier, capacity): """Orders snapshot space for given iSCSI.""" iscsi_mgr = SoftLayer.ISCSIManager(env.client) iscsi_id = helpers.resolve_id(iscsi_mgr.resolve_ids, identifier, 'iSCSI') iscsi_mgr.create_snapshot_space(iscsi_id, capacity) softlayer-python-5.0.1/SoftLayer/CLI/snapshot/list.py000066400000000000000000000021451267703721100225570ustar00rootroot00000000000000"""List iSCSI Snapshots.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers from SoftLayer import utils @click.command() @click.argument('iscsi-identifier') @environment.pass_env def cli(env, iscsi_identifier): """List iSCSI Snapshots.""" iscsi_mgr = SoftLayer.ISCSIManager(env.client) iscsi_id = helpers.resolve_id(iscsi_mgr.resolve_ids, iscsi_identifier, 'iSCSI') iscsi = env.client['Network_Storage_Iscsi'] snapshots = iscsi.getPartnerships( mask='volumeId,partnerVolumeId,createDate,type', id=iscsi_id) snapshots = [utils.NestedDict(n) for n in snapshots] table = formatting.Table(['id', 'createDate', 'name', 'description']) for snapshot in snapshots: table.add_row([ snapshot['partnerVolumeId'], snapshot['createDate'], snapshot['type']['name'], snapshot['type']['description'], ]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/snapshot/restore_volume.py000066400000000000000000000013361267703721100246570ustar00rootroot00000000000000"""Restores volume from existing snapshot.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers @click.command() @click.argument('snapshot-id') @click.argument('volume-id') @environment.pass_env def cli(env, snapshot_id, volume_id): """Restores volume from existing snapshot.""" iscsi_mgr = SoftLayer.ISCSIManager(env.client) volume_id = helpers.resolve_id(iscsi_mgr.resolve_ids, volume_id, 'iSCSI') snapshot_id = helpers.resolve_id(iscsi_mgr.resolve_ids, snapshot_id, 'Snapshot') iscsi_mgr.restore_from_snapshot(volume_id, snapshot_id) softlayer-python-5.0.1/SoftLayer/CLI/sshkey/000077500000000000000000000000001267703721100206775ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/sshkey/__init__.py000066400000000000000000000000201267703721100230000ustar00rootroot00000000000000"""SSH Keys.""" softlayer-python-5.0.1/SoftLayer/CLI/sshkey/add.py000066400000000000000000000016041267703721100220020ustar00rootroot00000000000000"""Add a new SSH key.""" # :license: MIT, see LICENSE for more details. from os import path import click import SoftLayer from SoftLayer.CLI import environment @click.command() @click.argument('label') @click.option('--in-file', '-f', type=click.Path(exists=True), help="The id_rsa.pub file to import for this key") @click.option('--key', '-k', help="The actual SSH key") @click.option('--note', help="Extra note that will be associated with key") @environment.pass_env def cli(env, label, in_file, key, note): """Add a new SSH key.""" if key: key_text = key else: key_file = open(path.expanduser(in_file), 'rU') key_text = key_file.read().strip() key_file.close() mgr = SoftLayer.SshKeyManager(env.client) result = mgr.add_key(key_text, label, note) env.fout("SSH key added: %s" % result.get('fingerprint')) softlayer-python-5.0.1/SoftLayer/CLI/sshkey/edit.py000066400000000000000000000013031267703721100221730ustar00rootroot00000000000000"""Edits an SSH key.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.option('--label', '-k', help="The new label for the key") @click.option('--note', help="New notes for the key") @environment.pass_env 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') softlayer-python-5.0.1/SoftLayer/CLI/sshkey/list.py000066400000000000000000000015651267703721100222330ustar00rootroot00000000000000"""List SSH keys.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @click.option('--sortby', help='Column to sort by', type=click.Choice(['id', 'label', 'fingerprint', 'notes'])) @environment.pass_env def cli(env, sortby): """List SSH keys.""" mgr = SoftLayer.SshKeyManager(env.client) keys = mgr.list_keys() table = formatting.Table(['id', 'label', 'fingerprint', 'notes']) table.sortby = sortby for key in keys: table.add_row([key['id'], key.get('label'), key.get('fingerprint'), key.get('notes', '-')]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/sshkey/print.py000066400000000000000000000020331267703721100224030ustar00rootroot00000000000000"""Prints out an SSH key to the screen.""" # :license: MIT, see LICENSE for more details. from os import path import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.option('--out-file', '-f', type=click.Path(exists=True, writable=True), help="The public SSH key will be written to this file") @environment.pass_env def cli(env, identifier, out_file): """Prints out an SSH key to the screen.""" mgr = SoftLayer.SshKeyManager(env.client) key_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'SshKey') key = mgr.get_key(key_id) if out_file: with open(path.expanduser(out_file), 'w') as pub_file: pub_file.write(key['key']) table = formatting.KeyValueTable(['name', 'value']) table.add_row(['id', key['id']]) table.add_row(['label', key.get('label')]) table.add_row(['notes', key.get('notes', '-')]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/sshkey/remove.py000066400000000000000000000012321267703721100225440ustar00rootroot00000000000000"""Permanently removes an SSH key.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @environment.pass_env 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_key(key_id) softlayer-python-5.0.1/SoftLayer/CLI/ssl/000077500000000000000000000000001267703721100201725ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/ssl/__init__.py000066400000000000000000000000301267703721100222740ustar00rootroot00000000000000"""SSL Certificates.""" softlayer-python-5.0.1/SoftLayer/CLI/ssl/add.py000066400000000000000000000023661267703721100213030ustar00rootroot00000000000000"""Add and upload SSL certificate details.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment @click.command() @click.option('--crt', type=click.Path(exists=True), help="Certificate file") @click.option('--csr', type=click.Path(exists=True), help="Certificate Signing Request file") @click.option('--icc', type=click.Path(exists=True), help="Intermediate Certificate file") @click.option('--key', type=click.Path(exists=True), help="Private Key file") @click.option('--notes', help="Additional notes") @environment.pass_env def cli(env, crt, csr, icc, key, notes): """Add and upload SSL certificate details.""" template = { 'intermediateCertificate': '', 'certificateSigningRequest': '', 'notes': notes, } template['certificate'] = open(crt).read() template['privateKey'] = open(key).read() if csr: body = open(csr).read() template['certificateSigningRequest'] = body if icc: body = open(icc).read() template['intermediateCertificate'] = body manager = SoftLayer.SSLManager(env.client) manager.add_certificate(template) softlayer-python-5.0.1/SoftLayer/CLI/ssl/download.py000066400000000000000000000020571267703721100223570ustar00rootroot00000000000000"""Download SSL certificate and key file.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """Download SSL certificate and key file.""" manager = SoftLayer.SSLManager(env.client) certificate = manager.get_certificate(identifier) write_cert(certificate['commonName'] + '.crt', certificate['certificate']) write_cert(certificate['commonName'] + '.key', certificate['privateKey']) if 'intermediateCertificate' in certificate: write_cert(certificate['commonName'] + '.icc', certificate['intermediateCertificate']) if 'certificateSigningRequest' in certificate: write_cert(certificate['commonName'] + '.csr', certificate['certificateSigningRequest']) def write_cert(filename, content): """Writes certificate body to the given file path.""" with open(filename, 'w') as cert_file: cert_file.write(content) softlayer-python-5.0.1/SoftLayer/CLI/ssl/edit.py000066400000000000000000000023061267703721100214720ustar00rootroot00000000000000"""Edit SSL certificate.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment @click.command() @click.argument('identifier') @click.option('--crt', type=click.Path(exists=True), help="Certificate file") @click.option('--csr', type=click.Path(exists=True), help="Certificate Signing Request file") @click.option('--icc', type=click.Path(exists=True), help="Intermediate Certificate file") @click.option('--key', type=click.Path(exists=True), help="Private Key file") @click.option('--notes', help="Additional notes") @environment.pass_env def cli(env, identifier, crt, csr, icc, key, notes): """Edit SSL certificate.""" template = {'id': identifier} if crt: template['certificate'] = open(crt).read() if key: template['privateKey'] = open(key).read() if csr: template['certificateSigningRequest'] = open(csr).read() if icc: template['intermediateCertificate'] = open(icc).read() if notes: template['notes'] = notes manager = SoftLayer.SSLManager(env.client) manager.edit_certificate(template) softlayer-python-5.0.1/SoftLayer/CLI/ssl/list.py000066400000000000000000000024221267703721100215170ustar00rootroot00000000000000"""List SSL certificates.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @click.option('--status', default="all", show_default=True, type=click.Choice(['all', 'valid', 'expired']), help="Show certificates with this status") @click.option('--sortby', type=click.Choice(['id', 'common_name', 'days_until_expire', 'notes']), help="Column to sort by") @environment.pass_env 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', 'notes']) for certificate in certificates: table.add_row([ certificate['id'], certificate['commonName'], certificate['validityDays'], certificate.get('notes', formatting.blank()) ]) table.sortby = sortby env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/ssl/remove.py000066400000000000000000000010621267703721100220400ustar00rootroot00000000000000"""Remove SSL certificate.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting @click.command() @click.argument('identifier') @environment.pass_env 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) softlayer-python-5.0.1/SoftLayer/CLI/subnet/000077500000000000000000000000001267703721100206715ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/subnet/__init__.py000066400000000000000000000000271267703721100230010ustar00rootroot00000000000000"""Network subnets.""" softlayer-python-5.0.1/SoftLayer/CLI/subnet/cancel.py000066400000000000000000000012711267703721100224710ustar00rootroot00000000000000"""Cancel a subnet.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @environment.pass_env 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 exceptions.CLIAbort('Aborted') mgr.cancel_subnet(subnet_id) softlayer-python-5.0.1/SoftLayer/CLI/subnet/create.py000066400000000000000000000040261267703721100225100ustar00rootroot00000000000000"""Add a new subnet to your account.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting @click.command(short_help="Add a new subnet to your account") @click.argument('network', type=click.Choice(['public', 'private'])) @click.argument('quantity', type=click.INT) @click.argument('vlan-id') @click.option('--v6', '--ipv6', is_flag=True, help="Order IPv6 Addresses") @click.option('--test', is_flag=True, help="Do not order the subnet; just get a quote") @environment.pass_env def cli(env, network, quantity, vlan_id, ipv6, test): """Add a new subnet to your account. Valid quantities vary by type. \b Type - Valid Quantities (IPv4) public - 4, 8, 16, 32 private - 4, 8, 16, 32, 64 \b Type - Valid Quantities (IPv6) public - 64 """ mgr = SoftLayer.NetworkManager(env.client) if not (test or env.skip_confirmations): if not formatting.confirm("This action will incur charges on your " "account. Continue?"): raise exceptions.CLIAbort('Cancelling order.') version = 4 if ipv6: version = 6 result = mgr.add_subnet(network, quantity=quantity, vlan_id=vlan_id, version=version, test_order=test) if not result: raise exceptions.CLIAbort( 'Unable to place order: No valid price IDs found.') table = formatting.Table(['Item', 'cost']) table.align['Item'] = 'r' table.align['cost'] = 'r' total = 0.0 if 'prices' in result: for price in result['prices']: total += float(price.get('recurringFee', 0.0)) rate = "%.2f" % float(price['recurringFee']) table.add_row([price['item']['description'], rate]) table.add_row(['Total monthly cost', "%.2f" % total]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/subnet/detail.py000066400000000000000000000050221267703721100225040ustar00rootroot00000000000000"""Get subnet details.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.option('--no-vs', is_flag=True, help="Hide virtual server listing") @click.option('--no-hardware', is_flag=True, help="Hide hardware listing") @environment.pass_env def cli(env, identifier, no_vs, no_hardware): """Get subnet details.""" mgr = SoftLayer.NetworkManager(env.client) subnet_id = helpers.resolve_id(mgr.resolve_subnet_ids, identifier, name='subnet') subnet = mgr.get_subnet(subnet_id) table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'r' table.align['value'] = 'l' table.add_row(['id', subnet['id']]) table.add_row(['identifier', '%s/%s' % (subnet['networkIdentifier'], str(subnet['cidr']))]) table.add_row(['subnet type', subnet['subnetType']]) table.add_row(['gateway', subnet.get('gateway', formatting.blank())]) table.add_row(['broadcast', subnet.get('broadcastAddress', formatting.blank())]) table.add_row(['datacenter', subnet['datacenter']['name']]) table.add_row(['usable ips', subnet.get('usableIpAddressCount', formatting.blank())]) if not no_vs: if subnet['virtualGuests']: vs_table = formatting.Table(['Hostname', 'Domain', 'IP']) vs_table.align['Hostname'] = 'r' vs_table.align['IP'] = 'l' for vsi in subnet['virtualGuests']: vs_table.add_row([vsi['hostname'], vsi['domain'], vsi.get('primaryIpAddress')]) table.add_row(['vs', vs_table]) else: table.add_row(['vs', 'none']) if not no_hardware: if subnet['hardware']: hw_table = formatting.Table(['Hostname', 'Domain', 'IP']) hw_table.align['Hostname'] = 'r' hw_table.align['IP'] = 'l' for hardware in subnet['hardware']: hw_table.add_row([hardware['hostname'], hardware['domain'], hardware.get('primaryIpAddress')]) table.add_row(['hardware', hw_table]) else: table.add_row(['hardware', 'none']) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/subnet/list.py000066400000000000000000000040351267703721100222200ustar00rootroot00000000000000"""List subnets.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer import utils @click.command() @click.option('--sortby', help='Column to sort by', type=click.Choice(['id', 'identifier', 'type', 'datacenter', 'vlan_id', 'IPs', 'hardware', 'vs'])) @click.option('--datacenter', '-d', help="Filter by datacenter shortname (sng01, dal05, ...)") @click.option('--identifier', help="Filter by network identifier") @click.option('--subnet-type', '-t', help="Filter by subnet type") @click.option('--v4', '--ipv4', is_flag=True, help="Display only IPv4 subnets") @click.option('--v6', '--ipv6', is_flag=True, help="Display only IPv6 subnets") @environment.pass_env def cli(env, sortby, datacenter, identifier, subnet_type, ipv4, ipv6): """List subnets.""" mgr = SoftLayer.NetworkManager(env.client) table = formatting.Table([ 'id', 'identifier', 'type', 'datacenter', 'vlan_id', 'IPs', 'hardware', 'vs', ]) table.sortby = sortby version = 0 if ipv4: version = 4 elif ipv6: version = 6 subnets = mgr.list_subnets( datacenter=datacenter, version=version, identifier=identifier, subnet_type=subnet_type, ) for subnet in subnets: table.add_row([ subnet['id'], '%s/%s' % (subnet['networkIdentifier'], str(subnet['cidr'])), subnet.get('subnetType', formatting.blank()), utils.lookup(subnet, 'datacenter', 'name',) or formatting.blank(), subnet['networkVlanId'], subnet['ipAddressCount'], len(subnet['hardware']), len(subnet['virtualGuests']), ]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/subnet/lookup.py000066400000000000000000000041701267703721100225560ustar00rootroot00000000000000"""Find an IP address and display its subnet and device info.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting @click.command() @click.argument('ip_address') @environment.pass_env def cli(env, ip_address): """Find an IP address and display its subnet and device info.""" mgr = SoftLayer.NetworkManager(env.client) addr_info = mgr.ip_lookup(ip_address) if not addr_info: raise exceptions.CLIAbort('Not found') table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'r' table.align['value'] = 'l' table.add_row(['id', addr_info['id']]) table.add_row(['ip', addr_info['ipAddress']]) subnet_table = formatting.KeyValueTable(['name', 'value']) subnet_table.align['name'] = 'r' subnet_table.align['value'] = 'l' subnet_table.add_row(['id', addr_info['subnet']['id']]) subnet_table.add_row(['identifier', '%s/%s' % (addr_info['subnet']['networkIdentifier'], str(addr_info['subnet']['cidr']))]) subnet_table.add_row(['netmask', addr_info['subnet']['netmask']]) if addr_info['subnet'].get('gateway'): subnet_table.add_row(['gateway', addr_info['subnet']['gateway']]) subnet_table.add_row(['type', addr_info['subnet'].get('subnetType')]) table.add_row(['subnet', subnet_table]) if addr_info.get('virtualGuest') or addr_info.get('hardware'): device_table = formatting.KeyValueTable(['name', 'value']) device_table.align['name'] = 'r' device_table.align['value'] = 'l' if addr_info.get('virtualGuest'): device = addr_info['virtualGuest'] device_type = 'vs' else: device = addr_info['hardware'] device_type = 'server' device_table.add_row(['id', device['id']]) device_table.add_row(['name', device['fullyQualifiedDomainName']]) device_table.add_row(['type', device_type]) table.add_row(['device', device_table]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/summary.py000066400000000000000000000020331267703721100214360ustar00rootroot00000000000000"""Account summary.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting COLUMNS = ['datacenter', 'hardware', 'virtual_servers', 'vlans', 'subnets', 'public_ips'] @click.command() @click.option('--sortby', help='Column to sort by', default='datacenter', type=click.Choice(COLUMNS)) @environment.pass_env def cli(env, sortby): """Account summary.""" mgr = SoftLayer.NetworkManager(env.client) datacenters = mgr.summary_by_datacenter() table = formatting.Table(COLUMNS) table.sortby = sortby for name, datacenter in datacenters.items(): table.add_row([ name, datacenter['hardware_count'], datacenter['virtual_guest_count'], datacenter['vlan_count'], datacenter['subnet_count'], datacenter['public_ip_count'], ]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/template.py000066400000000000000000000040251267703721100215570ustar00rootroot00000000000000""" SoftLayer.CLI.template ~~~~~~~~~~~~~~~~~~~~~~ Provides functions for loading/parsing and writing template files. Template files are used for storing CLI arguments in the form of a file to be used later with the --template option. :license: MIT, see LICENSE for more details. """ import os.path from SoftLayer import utils class TemplateCallback(object): """Callback to use to populate click arguments with a template.""" def __init__(self, list_args=None): self.list_args = list_args or [] def __call__(self, ctx, param, value): if value is None: return config = utils.configparser.ConfigParser() ini_str = '[settings]\n' + open( os.path.expanduser(value), 'r').read() ini_fp = utils.StringIO(ini_str) config.readfp(ini_fp) # Merge template options with the options passed in args = {} for key, value in config.items('settings'): if key in self.list_args: value = value.split(',') if not args.get(key): args[key] = value if ctx.default_map is None: ctx.default_map = {} ctx.default_map.update(args) def export_to_template(filename, args, exclude=None): """Exports given options to the given filename in INI format. :param filename: Filename to save options to :param dict args: Arguments to export :param list exclude (optional): Exclusion list for options that should not be exported """ exclude = exclude or [] exclude.append('config') exclude.append('really') exclude.append('format') exclude.append('debug') with open(filename, "w") as template_file: for k, val in args.items(): if val and k not in exclude: if isinstance(val, tuple): val = ','.join(val) if isinstance(val, list): val = ','.join(val) template_file.write('%s=%s\n' % (k, val)) softlayer-python-5.0.1/SoftLayer/CLI/ticket/000077500000000000000000000000001267703721100206545ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/ticket/__init__.py000066400000000000000000000037201267703721100227670ustar00rootroot00000000000000"""Support tickets.""" import click from SoftLayer.CLI import formatting TEMPLATE_MSG = "***** SoftLayer Ticket Content ******" def get_ticket_results(mgr, ticket_id, update_count=1): """Get output about a ticket. :param integer id: the ticket ID :param integer update_count: number of entries to retrieve from ticket :returns: a KeyValue table containing the details of the ticket """ ticket = mgr.get_ticket(ticket_id) table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'r' table.align['value'] = 'l' table.add_row(['id', ticket['id']]) table.add_row(['title', ticket['title']]) if ticket.get('assignedUser'): user = ticket['assignedUser'] table.add_row([ 'user', "%s %s" % (user.get('firstName'), user.get('lastName')), ]) table.add_row(['status', ticket['status']['name']]) table.add_row(['created', ticket.get('createDate')]) table.add_row(['edited', ticket.get('lastEditDate')]) # Only show up to the specified update count updates = ticket.get('updates', []) count = min(len(updates), update_count) count_offset = len(updates) - count + 1 # Display as one-indexed for i, update in enumerate(updates[-count:]): wrapped_entry = "" # Add user details (fields are different between employee and users) editor = update.get('editor') if editor: if editor.get('displayName'): wrapped_entry += "By %s (Employee)\n" % (editor['displayName']) if editor.get('firstName'): wrapped_entry += "By %s %s\n" % (editor.get('firstName'), editor.get('lastName')) # NOTE(kmcdonald): Windows new-line characters need to be stripped out wrapped_entry += click.wrap_text(update['entry'].replace('\r', '')) table.add_row(['update %s' % (count_offset + i,), wrapped_entry]) return table softlayer-python-5.0.1/SoftLayer/CLI/ticket/create.py000066400000000000000000000016531267703721100224760ustar00rootroot00000000000000"""Create a support ticket.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import ticket @click.command() @click.option('--title', required=True, help="The title of the ticket") @click.option('--subject-id', required=True, help="""The subject id to use for the ticket, issue 'slcli ticket subjects' to get the list""") @click.option('--body', help="The ticket body") @environment.pass_env def cli(env, title, subject_id, body): """Create a support ticket.""" mgr = SoftLayer.TicketManager(env.client) if body is None: body = click.edit('\n\n' + ticket.TEMPLATE_MSG) created_ticket = mgr.create_ticket(title=title, body=body, subject=subject_id) env.fout(ticket.get_ticket_results(mgr, created_ticket['id'])) softlayer-python-5.0.1/SoftLayer/CLI/ticket/detail.py000066400000000000000000000013041267703721100224660ustar00rootroot00000000000000"""Get details for a ticket.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers from SoftLayer.CLI import ticket @click.command() @click.argument('identifier') @click.option('--count', type=click.INT, help="Number of updates", show_default=True, default=10) @environment.pass_env def cli(env, identifier, count): """Get details for a ticket.""" mgr = SoftLayer.TicketManager(env.client) ticket_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'ticket') env.fout(ticket.get_ticket_results(mgr, ticket_id, update_count=count)) softlayer-python-5.0.1/SoftLayer/CLI/ticket/list.py000066400000000000000000000021721267703721100222030ustar00rootroot00000000000000"""List tickets.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @click.option('--open / --closed', 'is_open', help="Display only open or closed tickets", default=True) @environment.pass_env def cli(env, is_open): """List tickets.""" ticket_mgr = SoftLayer.TicketManager(env.client) tickets = ticket_mgr.list_tickets(open_status=is_open, closed_status=not is_open) table = formatting.Table(['id', 'assigned_user', 'title', 'last_edited', 'status']) for ticket in tickets: user = formatting.blank() if ticket.get('assignedUser'): user = "%s %s" % (ticket['assignedUser']['firstName'], ticket['assignedUser']['lastName']) table.add_row([ ticket['id'], user, click.wrap_text(ticket['title']), ticket['lastEditDate'], ticket['status']['name'], ]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/ticket/subjects.py000066400000000000000000000010171267703721100230470ustar00rootroot00000000000000"""List Subject IDs for ticket creation.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env def cli(env): """List Subject IDs for ticket creation.""" ticket_mgr = SoftLayer.TicketManager(env.client) table = formatting.Table(['id', 'subject']) for subject in ticket_mgr.list_subjects(): table.add_row([subject['id'], subject['name']]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/ticket/summary.py000066400000000000000000000022141267703721100227220ustar00rootroot00000000000000"""Summary info about tickets.""" # :license: MIT, see LICENSE for more details. import click from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env def cli(env): """Summary info about tickets.""" mask = ('openTicketCount, closedTicketCount, ' 'openBillingTicketCount, openOtherTicketCount, ' 'openSalesTicketCount, openSupportTicketCount, ' 'openAccountingTicketCount') account = env.client['Account'].getObject(mask=mask) table = formatting.Table(['Status', 'count']) nested = formatting.Table(['Type', 'count']) nested.add_row(['Accounting', account['openAccountingTicketCount']]) nested.add_row(['Billing', account['openBillingTicketCount']]) nested.add_row(['Sales', account['openSalesTicketCount']]) nested.add_row(['Support', account['openSupportTicketCount']]) nested.add_row(['Other', account['openOtherTicketCount']]) nested.add_row(['Total', account['openTicketCount']]) table.add_row(['Open', nested]) table.add_row(['Closed', account['closedTicketCount']]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/ticket/update.py000066400000000000000000000013471267703721100225150ustar00rootroot00000000000000"""Adds an update to an existing ticket.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import helpers from SoftLayer.CLI import ticket @click.command() @click.argument('identifier') @click.option('--body', help="The entry that will be appended to the ticket") @environment.pass_env 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_id, body=body) env.fout("Ticket Updated!") softlayer-python-5.0.1/SoftLayer/CLI/virt/000077500000000000000000000000001267703721100203555ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/virt/__init__.py000066400000000000000000000021441267703721100224670ustar00rootroot00000000000000"""Virtual Servers.""" # :license: MIT, see LICENSE for more details. import re import click MEMORY_RE = re.compile(r"^(?P[0-9]+)(?Pg|gb|m|mb)?$") class MemoryType(click.ParamType): """Memory type.""" name = 'integer' def convert(self, value, param, ctx): """Validate memory argument. Returns the memory value in megabytes.""" matches = MEMORY_RE.match(value.lower()) if matches is None: self.fail('%s is not a valid value for memory amount' % value, param, ctx) amount_str, unit = matches.groups() amount = int(amount_str) if unit in [None, 'm', 'mb']: # Assume the user intends gigabytes if they specify a number < 1024 if amount < 1024: return amount * 1024 else: if amount % 1024 != 0: self.fail('%s is not an integer that is divisable by 1024' % value, param, ctx) return amount elif unit in ['g', 'gb']: return amount * 1024 MEM_TYPE = MemoryType() softlayer-python-5.0.1/SoftLayer/CLI/virt/cancel.py000066400000000000000000000012041267703721100221510ustar00rootroot00000000000000"""Cancel virtual servers.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @environment.pass_env 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) softlayer-python-5.0.1/SoftLayer/CLI/virt/capture.py000066400000000000000000000024661267703721100224020ustar00rootroot00000000000000"""Capture virtual server image.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers # pylint: disable=redefined-builtin @click.command(short_help="Capture SoftLayer image.") @click.argument('identifier') @click.option('--name', '-n', required=True, help="Name of the image") @click.option('--all', help="Capture all disks belonging to the VS") @click.option('--note', help="Add a note to be associated with the image") @environment.pass_env def cli(env, identifier, name, all, note): """Capture one or all disks from a virtual server to a SoftLayer image.""" vsi = SoftLayer.VSManager(env.client) vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS') capture = vsi.capture(vs_id, name, all, note) table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'r' table.align['value'] = 'l' table.add_row(['vs_id', capture['guestId']]) table.add_row(['date', capture['createDate'][:10]]) table.add_row(['time', capture['createDate'][11:19]]) table.add_row(['transaction', formatting.transaction_status(capture)]) table.add_row(['transaction_id', capture['id']]) table.add_row(['all_disks', all]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/virt/create.py000066400000000000000000000260111267703721100221720ustar00rootroot00000000000000"""Manage, delete, order compute instances.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers from SoftLayer.CLI import template from SoftLayer.CLI import virt from SoftLayer import utils def _update_with_like_args(ctx, _, value): """Update arguments with options taken from a currently running VS.""" if value is None: return env = ctx.ensure_object(environment.Environment) vsi = SoftLayer.VSManager(env.client) vs_id = helpers.resolve_id(vsi.resolve_ids, value, 'VS') like_details = vsi.get_instance(vs_id) like_args = { 'hostname': like_details['hostname'], 'domain': like_details['domain'], 'cpu': like_details['maxCpu'], 'memory': '%smb' % like_details['maxMemory'], 'hourly': like_details['hourlyBillingFlag'], 'datacenter': like_details['datacenter']['name'], 'network': like_details['networkComponents'][0]['maxSpeed'], 'userdata': like_details['userData'] or None, 'postinstall': like_details.get('postInstallScriptUri'), 'dedicated': like_details['dedicatedAccountHostOnlyFlag'], 'private': like_details['privateNetworkOnlyFlag'], } tag_refs = like_details.get('tagReferences', None) if tag_refs is not None and len(tag_refs) > 0: like_args['tag'] = [t['tag']['name'] for t in tag_refs] # Handle mutually exclusive options like_image = utils.lookup(like_details, 'blockDeviceTemplateGroup', 'globalIdentifier') like_os = utils.lookup(like_details, 'operatingSystem', 'softwareLicense', 'softwareDescription', 'referenceCode') if like_image: like_args['image'] = like_image elif like_os: like_args['os'] = like_os if ctx.default_map is None: ctx.default_map = {} ctx.default_map.update(like_args) def _parse_create_args(client, args): """Converts CLI arguments to args for VSManager.create_instance. :param dict args: CLI arguments """ data = { "hourly": args['billing'] == 'hourly', "cpus": args['cpu'], "domain": args['domain'], "hostname": args['hostname'], "private": args['private'], "dedicated": args['dedicated'], "disks": args['disk'], "local_disk": not args['san'], } data["memory"] = args['memory'] if args.get('os'): data['os_code'] = args['os'] if args.get('image'): if args.get('image').isdigit(): image_mgr = SoftLayer.ImageManager(client) image_details = image_mgr.get_image(args.get('image'), mask="id,globalIdentifier") data['image_id'] = image_details['globalIdentifier'] else: data['image_id'] = args['image'] if args.get('datacenter'): data['datacenter'] = args['datacenter'] if args.get('network'): data['nic_speed'] = args.get('network') if args.get('userdata'): data['userdata'] = args['userdata'] elif args.get('userfile'): with open(args['userfile'], 'r') as userfile: data['userdata'] = userfile.read() if args.get('postinstall'): data['post_uri'] = args.get('postinstall') # Get the SSH keys if args.get('key'): keys = [] for key in args.get('key'): resolver = SoftLayer.SshKeyManager(client).resolve_ids key_id = helpers.resolve_id(resolver, key, 'SshKey') keys.append(key_id) data['ssh_keys'] = keys if args.get('vlan_public'): data['public_vlan'] = args['vlan_public'] if args.get('vlan_private'): data['private_vlan'] = args['vlan_private'] if args.get('tag'): data['tags'] = ','.join(args['tag']) return data @click.command(epilog="See 'slcli vs create-options' for valid options") @click.option('--hostname', '-H', help="Host portion of the FQDN", required=True, prompt=True) @click.option('--domain', '-D', help="Domain portion of the FQDN", required=True, prompt=True) @click.option('--cpu', '-c', help="Number of CPU cores", type=click.INT, required=True, prompt=True) @click.option('--memory', '-m', help="Memory in mebibytes", type=virt.MEM_TYPE, required=True, prompt=True) @click.option('--datacenter', '-d', help="Datacenter shortname", required=True, prompt=True) @click.option('--os', '-o', help="OS install code. Tip: you can specify _LATEST") @click.option('--image', help="Image ID. See: 'slcli image list' for reference") @click.option('--billing', type=click.Choice(['hourly', 'monthly']), default='hourly', show_default=True, help="Billing rate") @click.option('--dedicated/--public', is_flag=True, help="Create a dedicated Virtual Server (Private Node)") @click.option('--san', is_flag=True, help="Use SAN storage instead of local disk.") @click.option('--test', is_flag=True, help="Do not actually create the virtual server") @click.option('--export', type=click.Path(writable=True, resolve_path=True), help="Exports options to a template file") @click.option('--postinstall', '-i', help="Post-install script to download") @helpers.multi_option('--key', '-k', help="SSH keys to add to the root user") @helpers.multi_option('--disk', help="Disk sizes") @click.option('--private', is_flag=True, help="Forces the VS to only have access the private network") @click.option('--like', is_eager=True, callback=_update_with_like_args, help="Use the configuration from an existing VS") @click.option('--network', '-n', help="Network port speed in Mbps") @helpers.multi_option('--tag', '-g', help="Tags to add to the instance") @click.option('--template', '-t', is_eager=True, callback=template.TemplateCallback(list_args=['disk', 'key', 'tag']), help="A template file that defaults the command-line options", type=click.Path(exists=True, readable=True, resolve_path=True)) @click.option('--userdata', '-u', help="User defined metadata string") @click.option('--userfile', '-F', help="Read userdata from file", type=click.Path(exists=True, readable=True, resolve_path=True)) @click.option('--vlan-public', help="The ID of the public VLAN on which you want the virtual " "server placed", type=click.INT) @click.option('--vlan-private', help="The ID of the private VLAN on which you want the virtual " "server placed", type=click.INT) @click.option('--wait', type=click.INT, help="Wait until VS is finished provisioning for up to X " "seconds before returning") @environment.pass_env def cli(env, **args): """Order/create virtual servers.""" vsi = SoftLayer.VSManager(env.client) _validate_args(env, args) # Do not create a virtual server with test or export do_create = not (args['export'] or args['test']) table = formatting.Table(['Item', 'cost']) table.align['Item'] = 'r' table.align['cost'] = 'r' data = _parse_create_args(env.client, args) output = [] if args.get('test'): result = vsi.verify_create_instance(**data) total_monthly = 0.0 total_hourly = 0.0 table = formatting.Table(['Item', 'cost']) table.align['Item'] = 'r' table.align['cost'] = 'r' for price in result['prices']: total_monthly += float(price.get('recurringFee', 0.0)) total_hourly += float(price.get('hourlyRecurringFee', 0.0)) if args.get('billing') == 'hourly': rate = "%.2f" % float(price['hourlyRecurringFee']) elif args.get('billing') == 'monthly': rate = "%.2f" % float(price['recurringFee']) table.add_row([price['item']['description'], rate]) total = 0 if args.get('billing') == 'hourly': total = total_hourly elif args.get('billing') == 'monthly': total = total_monthly billing_rate = 'monthly' if args.get('billing') == 'hourly': billing_rate = 'hourly' table.add_row(['Total %s cost' % billing_rate, "%.2f" % total]) output.append(table) output.append(formatting.FormattedItem( None, ' -- ! Prices reflected here are retail and do not ' 'take account level discounts and are not guaranteed.')) if args['export']: export_file = args.pop('export') template.export_to_template(export_file, args, exclude=['wait', 'test']) env.fout('Successfully exported options to a template file.') if do_create: if not (env.skip_confirmations or formatting.confirm( "This action will incur charges on your account. Continue?")): raise exceptions.CLIAbort('Aborting virtual server order.') result = vsi.create_instance(**data) table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'r' table.align['value'] = 'l' table.add_row(['id', result['id']]) table.add_row(['created', result['createDate']]) table.add_row(['guid', result['globalIdentifier']]) output.append(table) if args.get('wait'): ready = vsi.wait_for_ready(result['id'], args.get('wait') or 1) table.add_row(['ready', ready]) if ready is False: env.out(env.fmt(output)) raise exceptions.CLIHalt(code=1) env.fout(output) def _validate_args(env, args): """Raises an ArgumentError if the given arguments are not valid.""" if all([args['userdata'], args['userfile']]): raise exceptions.ArgumentError( '[-u | --userdata] not allowed with [-F | --userfile]') image_args = [args['os'], args['image']] if all(image_args): raise exceptions.ArgumentError( '[-o | --os] not allowed with [--image]') while not any([args['os'], args['image']]): args['os'] = env.input("Operating System Code", default="", show_default=False) if not args['os']: args['image'] = env.input("Image", default="", show_default=False) softlayer-python-5.0.1/SoftLayer/CLI/virt/create_options.py000066400000000000000000000064721267703721100237560ustar00rootroot00000000000000"""Virtual server order options.""" # :license: MIT, see LICENSE for more details. import os import os.path import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env 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']['name'] for dc in result['datacenters']] table.add_row(['datacenter', formatting.listing(datacenters, separator='\n')]) # CPUs standard_cpu = [x for x in result['processors'] if not x['template'].get( 'dedicatedAccountHostOnlyFlag', False)] ded_cpu = [x for x in result['processors'] if x['template'].get('dedicatedAccountHostOnlyFlag', False)] def add_cpus_row(cpu_options, name): """Add CPU rows to the table.""" cpus = [] for cpu_option in cpu_options: cpus.append(str(cpu_option['template']['startCpus'])) table.add_row(['cpus (%s)' % name, formatting.listing(cpus, separator=',')]) add_cpus_row(ded_cpu, 'private') add_cpus_row(standard_cpu, 'standard') # Memory memory = [str(m['template']['maxMemory']) for m in result['memory']] table.add_row(['memory', formatting.listing(memory, separator=',')]) # Operating Systems op_sys = [o['template']['operatingSystemReferenceCode'] for o in result['operatingSystems']] op_sys = sorted(op_sys) os_summary = set() for operating_system in op_sys: os_summary.add(operating_system[0:operating_system.find('_')]) for summary in sorted(os_summary): table.add_row([ 'os (%s)' % summary, os.linesep.join(sorted([x for x in op_sys if x[0:len(summary)] == summary])) ]) # Disk local_disks = [x for x in result['blockDevices'] if x['template'].get('localDiskFlag', False)] san_disks = [x for x in result['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.keys()): table.add_row(['%s disk(%s)' % (name, label), formatting.listing(simple[label], separator=',')]) add_block_rows(local_disks, 'local') add_block_rows(san_disks, 'san') # Network speeds = [] for comp in result['networkComponents']: speed = comp['template']['networkComponents'][0]['maxSpeed'] speeds.append(str(speed)) speeds = sorted(speeds) table.add_row(['nic', formatting.listing(speeds, separator=',')]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/virt/credentials.py000066400000000000000000000013051267703721100232230ustar00rootroot00000000000000"""List virtual server credentials.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @environment.pass_env def cli(env, identifier): """List virtual server credentials.""" vsi = SoftLayer.VSManager(env.client) vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS') instance = vsi.get_instance(vs_id) table = formatting.Table(['username', 'password']) for item in instance['operatingSystem']['passwords']: table.add_row([item['username'], item['password']]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/virt/detail.py000066400000000000000000000105311267703721100221710ustar00rootroot00000000000000"""Get details for a virtual server.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers from SoftLayer import utils @click.command() @click.argument('identifier') @click.option('--passwords', is_flag=True, help='Show passwords (check over your shoulder!)') @click.option('--price', is_flag=True, help='Show associated prices') @environment.pass_env 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]) 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) softlayer-python-5.0.1/SoftLayer/CLI/virt/dns.py000066400000000000000000000126011267703721100215130ustar00rootroot00000000000000"""Sync DNS records.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command(epilog="""If you don't specify any arguments, it will attempt to update both the A and PTR records. If you don't want to update both records, you may use the -a or --ptr arguments to limit the records updated.""") @click.argument('identifier') @click.option('--a-record', '-a', is_flag=True, help="Sync the A record for the host") @click.option('--aaaa-record', is_flag=True, help="Sync the AAAA record for the host") @click.option('--ptr', is_flag=True, help="Sync the PTR record for the host") @click.option('--ttl', default=7200, show_default=True, type=click.INT, help="Sets the TTL for the A and/or PTR records") @environment.pass_env def cli(env, identifier, a_record, aaaa_record, ptr, ttl): """Sync DNS records.""" items = ['id', 'globalIdentifier', 'fullyQualifiedDomainName', 'hostname', 'domain', 'primaryBackendIpAddress', 'primaryIpAddress', '''primaryNetworkComponent[ id, primaryIpAddress, primaryVersion6IpAddressRecord[ipAddress] ]'''] mask = "mask[%s]" % ','.join(items) dns = SoftLayer.DNSManager(env.client) vsi = SoftLayer.VSManager(env.client) vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS') instance = vsi.get_instance(vs_id, mask=mask) zone_id = helpers.resolve_id(dns.resolve_ids, instance['domain'], name='zone') def sync_a_record(): """Sync A record.""" records = dns.get_records(zone_id, host=instance['hostname'], record_type='a') if not records: # don't have a record, lets add one to the base zone dns.create_record(zone['id'], instance['hostname'], 'a', instance['primaryIpAddress'], ttl=ttl) else: if len(records) != 1: raise exceptions.CLIAbort("Aborting A record sync, found " "%d A record exists!" % len(records)) rec = records[0] rec['data'] = instance['primaryIpAddress'] rec['ttl'] = ttl dns.edit_record(rec) def sync_aaaa_record(): """Sync AAAA record.""" records = dns.get_records(zone_id, host=instance['hostname'], record_type='aaaa') try: # done this way to stay within 80 character lines component = instance['primaryNetworkComponent'] record = component['primaryVersion6IpAddressRecord'] ip_address = record['ipAddress'] except KeyError: raise exceptions.CLIAbort("%s does not have an ipv6 address" % instance['fullyQualifiedDomainName']) if not records: # don't have a record, lets add one to the base zone dns.create_record(zone['id'], instance['hostname'], 'aaaa', ip_address, ttl=ttl) else: if len(records) != 1: raise exceptions.CLIAbort("Aborting A record sync, found " "%d A record exists!" % len(records)) rec = records[0] rec['data'] = ip_address rec['ttl'] = ttl dns.edit_record(rec) def sync_ptr_record(): """Sync PTR record.""" host_rec = instance['primaryIpAddress'].split('.')[-1] ptr_domains = (env.client['Virtual_Guest'] .getReverseDomainRecords(id=instance['id'])[0]) edit_ptr = None for ptr in ptr_domains['resourceRecords']: if ptr['host'] == host_rec: ptr['ttl'] = ttl edit_ptr = ptr break if edit_ptr: edit_ptr['data'] = instance['fullyQualifiedDomainName'] dns.edit_record(edit_ptr) else: dns.create_record(ptr_domains['id'], host_rec, 'ptr', instance['fullyQualifiedDomainName'], ttl=ttl) if not instance['primaryIpAddress']: raise exceptions.CLIAbort('No primary IP address associated with ' 'this VS') zone = dns.get_zone(zone_id) go_for_it = env.skip_confirmations or formatting.confirm( "Attempt to update DNS records for %s" % instance['fullyQualifiedDomainName']) if not go_for_it: raise exceptions.CLIAbort("Aborting DNS sync") both = False if not ptr and not a_record and not aaaa_record: both = True if both or a_record: sync_a_record() if both or ptr: sync_ptr_record() if aaaa_record: sync_aaaa_record() softlayer-python-5.0.1/SoftLayer/CLI/virt/edit.py000066400000000000000000000041531267703721100216570ustar00rootroot00000000000000"""Edit a virtual server's details.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.option('--domain', '-D', help="Domain portion of the FQDN") @click.option('--hostname', '-H', help="Host portion of the FQDN. example: server") @click.option('--tag', '-g', multiple=True, help="Tags to set or empty string to remove all") @click.option('--userdata', '-u', help="User defined metadata string") @click.option('--userfile', '-F', help="Read userdata from file", type=click.Path(exists=True, readable=True, resolve_path=True)) @click.option('--public-speed', help="Public port speed.", default=None, type=click.Choice(['0', '10', '100', '1000', '10000'])) @click.option('--private-speed', help="Private port speed.", default=None, type=click.Choice(['0', '10', '100', '1000', '10000'])) @environment.pass_env 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: data['userdata'] = userdata elif userfile: with open(userfile, 'r') as userfile_obj: data['userdata'] = userfile_obj.read() data['hostname'] = hostname data['domain'] = domain if tag: data['tags'] = ','.join(tag) vsi = SoftLayer.VSManager(env.client) vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS') if not vsi.edit(vs_id, **data): raise exceptions.CLIAbort("Failed to update virtual server") if public_speed is not None: vsi.change_port_speed(vs_id, True, int(public_speed)) if private_speed is not None: vsi.change_port_speed(vs_id, False, int(private_speed)) softlayer-python-5.0.1/SoftLayer/CLI/virt/list.py000066400000000000000000000063061267703721100217070ustar00rootroot00000000000000"""List virtual servers.""" # :license: MIT, see LICENSE for more details. import click 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 = [ 'id', 'hostname', 'primary_ip', 'backend_ip', 'datacenter', 'action', ] @click.command() @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') @click.option('--sortby', help='Column to sort by', default='hostname', show_default=True) @click.option('--columns', callback=column_helper.get_formatter(COLUMNS), help='Columns to display. [options: %s]' % ', '.join(column.name for column in COLUMNS), default=','.join(DEFAULT_COLUMNS), show_default=True) @environment.pass_env def cli(env, sortby, cpu, domain, datacenter, hostname, memory, network, hourly, monthly, tag, columns): """List virtual servers.""" vsi = SoftLayer.VSManager(env.client) guests = vsi.list_instances(hourly=hourly, monthly=monthly, hostname=hostname, domain=domain, cpus=cpu, memory=memory, datacenter=datacenter, nic_speed=network, tags=tag, mask=columns.mask()) table = formatting.Table(columns.columns) table.sortby = sortby for guest in guests: table.add_row([value or formatting.blank() for value in columns.row(guest)]) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/virt/power.py000066400000000000000000000063741267703721100220750ustar00rootroot00000000000000"""Command lines which modify power states.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @environment.pass_env def rescue(env, identifier): """Reboot into a rescue image.""" vsi = SoftLayer.VSManager(env.client) vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS') if not (env.skip_confirmations or formatting.confirm("This action will reboot this VSI. Continue?")): raise exceptions.CLIAbort('Aborted') vsi.rescue(vs_id) @click.command() @click.argument('identifier') @click.option('--hard/--soft', default=None, help="Perform a hard or soft reboot") @environment.pass_env def reboot(env, identifier, hard): """Reboot an active virtual server.""" virtual_guest = env.client['Virtual_Guest'] mgr = SoftLayer.HardwareManager(env.client) vs_id = helpers.resolve_id(mgr.resolve_ids, identifier, 'VS') if not (env.skip_confirmations or formatting.confirm('This will reboot the VS with id %s. ' 'Continue?' % vs_id)): raise exceptions.CLIAbort('Aborted.') if hard is True: virtual_guest.rebootHard(id=vs_id) elif hard is False: virtual_guest.rebootSoft(id=vs_id) else: virtual_guest.rebootDefault(id=vs_id) @click.command() @click.argument('identifier') @click.option('--hard/--soft', help="Perform a hard shutdown") @environment.pass_env def power_off(env, identifier, hard): """Power off an active virtual server.""" virtual_guest = env.client['Virtual_Guest'] vsi = SoftLayer.VSManager(env.client) vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS') if not (env.skip_confirmations or formatting.confirm('This will power off the VS with id %s. ' 'Continue?' % vs_id)): raise exceptions.CLIAbort('Aborted.') if hard: virtual_guest.powerOff(id=vs_id) else: virtual_guest.powerOffSoft(id=vs_id) @click.command() @click.argument('identifier') @environment.pass_env def power_on(env, identifier): """Power on a virtual server.""" vsi = SoftLayer.VSManager(env.client) vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS') env.client['Virtual_Guest'].powerOn(id=vs_id) @click.command() @click.argument('identifier') @environment.pass_env def pause(env, identifier): """Pauses an active virtual server.""" vsi = SoftLayer.VSManager(env.client) vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS') if not (env.skip_confirmations or formatting.confirm('This will pause the VS with id %s. Continue?' % vs_id)): raise exceptions.CLIAbort('Aborted.') env.client['Virtual_Guest'].pause(id=vs_id) @click.command() @click.argument('identifier') @environment.pass_env def resume(env, identifier): """Resumes a paused virtual server.""" vsi = SoftLayer.VSManager(env.client) vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS') env.client['Virtual_Guest'].resume(id=vs_id) softlayer-python-5.0.1/SoftLayer/CLI/virt/ready.py000066400000000000000000000014411267703721100220330ustar00rootroot00000000000000"""Check if a virtual server is ready.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.option('--wait', default=0, show_default=True, type=click.INT, help="Name of the image") @environment.pass_env 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("Instance %s not ready" % vs_id) softlayer-python-5.0.1/SoftLayer/CLI/virt/reload.py000066400000000000000000000025451267703721100222030ustar00rootroot00000000000000"""Reload the OS on a virtual server.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.option('--postinstall', '-i', help="Post-install script to download") @click.option( '--image', help="""Image ID. The default is to use the current operating system. See: 'slcli image list' for reference""") @helpers.multi_option('--key', '-k', help="SSH keys to add to the root user") @environment.pass_env def cli(env, identifier, postinstall, key, image): """Reload operating system on a virtual server.""" vsi = SoftLayer.VSManager(env.client) vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS') keys = [] if key: for single_key in key: resolver = SoftLayer.SshKeyManager(env.client).resolve_ids key_id = helpers.resolve_id(resolver, single_key, 'SshKey') keys.append(key_id) if not (env.skip_confirmations or formatting.no_going_back(vs_id)): raise exceptions.CLIAbort('Aborted') vsi.reload_instance(vs_id, post_uri=postinstall, ssh_keys=keys, image_id=image) softlayer-python-5.0.1/SoftLayer/CLI/virt/upgrade.py000066400000000000000000000035151267703721100223620ustar00rootroot00000000000000"""Upgrade a virtual server.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers from SoftLayer.CLI import virt @click.command(epilog="""Note: SoftLayer automatically reboots the VS once upgrade request is placed. The VS is halted until the Upgrade transaction is completed. However for Network, no reboot is required.""") @click.argument('identifier') @click.option('--cpu', type=click.INT, help="Number of CPU cores") @click.option('--private', is_flag=True, help="CPU core will be on a dedicated host server.") @click.option('--memory', type=virt.MEM_TYPE, help="Memory in megabytes") @click.option('--network', type=click.INT, help="Network port speed in Mbps") @environment.pass_env def cli(env, identifier, cpu, private, memory, network): """Upgrade a virtual server.""" vsi = SoftLayer.VSManager(env.client) if not any([cpu, memory, network]): raise exceptions.ArgumentError( "Must provide [--cpu], [--memory], or [--network] to upgrade") if private and not cpu: raise exceptions.ArgumentError( "Must specify [--cpu] when using [--private]") vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS') if not (env.skip_confirmations or formatting.confirm( "This action will incur charges on your account. " "Continue?")): raise exceptions.CLIAbort('Aborted') if memory: memory = int(memory / 1024) if not vsi.upgrade(vs_id, cpus=cpu, memory=memory, nic_speed=network, public=not private): raise exceptions.CLIAbort('VS Upgrade Failed') softlayer-python-5.0.1/SoftLayer/CLI/vlan/000077500000000000000000000000001267703721100203315ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/CLI/vlan/__init__.py000066400000000000000000000000251267703721100224370ustar00rootroot00000000000000"""Network VLANs.""" softlayer-python-5.0.1/SoftLayer/CLI/vlan/detail.py000066400000000000000000000057731267703721100221610ustar00rootroot00000000000000"""Get details about a VLAN.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers @click.command() @click.argument('identifier') @click.option('--no-vs', is_flag=True, help="Hide virtual server listing") @click.option('--no-hardware', is_flag=True, help="Hide hardware listing") @environment.pass_env def cli(env, identifier, no_vs, no_hardware): """Get details about a VLAN.""" mgr = SoftLayer.NetworkManager(env.client) vlan_id = helpers.resolve_id(mgr.resolve_vlan_ids, identifier, 'VLAN') vlan = mgr.get_vlan(vlan_id) table = formatting.KeyValueTable(['name', 'value']) table.align['name'] = 'r' table.align['value'] = 'l' table.add_row(['id', vlan['id']]) table.add_row(['number', vlan['vlanNumber']]) table.add_row(['datacenter', vlan['primaryRouter']['datacenter']['longName']]) table.add_row(['primary_router', vlan['primaryRouter']['fullyQualifiedDomainName']]) table.add_row(['firewall', 'Yes' if vlan['firewallInterfaces'] else 'No']) subnets = [] for subnet in vlan['subnets']: subnet_table = formatting.KeyValueTable(['name', 'value']) subnet_table.align['name'] = 'r' subnet_table.align['value'] = 'l' subnet_table.add_row(['id', subnet['id']]) subnet_table.add_row(['identifier', subnet['networkIdentifier']]) subnet_table.add_row(['netmask', subnet['netmask']]) subnet_table.add_row(['gateway', subnet.get('gateway', '-')]) subnet_table.add_row(['type', subnet['subnetType']]) subnet_table.add_row(['usable ips', subnet['usableIpAddressCount']]) subnets.append(subnet_table) table.add_row(['subnets', subnets]) server_columns = ['hostname', 'domain', 'public_ip', 'private_ip'] if not no_vs: if vlan['virtualGuests']: vs_table = formatting.KeyValueTable(server_columns) for vsi in vlan['virtualGuests']: vs_table.add_row([vsi['hostname'], vsi['domain'], vsi.get('primaryIpAddress'), vsi.get('primaryBackendIpAddress')]) table.add_row(['vs', vs_table]) else: table.add_row(['vs', 'none']) if not no_hardware: if vlan['hardware']: hw_table = formatting.Table(server_columns) for hardware in vlan['hardware']: hw_table.add_row([hardware['hostname'], hardware['domain'], hardware.get('primaryIpAddress'), hardware.get('primaryBackendIpAddress')]) table.add_row(['hardware', hw_table]) else: table.add_row(['hardware', 'none']) env.fout(table) softlayer-python-5.0.1/SoftLayer/CLI/vlan/list.py000066400000000000000000000027521267703721100216640ustar00rootroot00000000000000"""List VLANs.""" # :license: MIT, see LICENSE for more details. import click import SoftLayer from SoftLayer.CLI import environment from SoftLayer.CLI import formatting from SoftLayer import utils COLUMNS = ['id', 'number', 'name', 'firewall', 'datacenter', 'hardware', 'virtual_servers', 'public_ips'] @click.command() @click.option('--sortby', help='Column to sort by', type=click.Choice(COLUMNS)) @click.option('--datacenter', '-d', help='Filter by datacenter shortname (sng01, dal05, ...)') @click.option('--number', '-n', help='Filter by VLAN number') @click.option('--name', help='Filter by VLAN name') @environment.pass_env def cli(env, sortby, datacenter, number, name): """List VLANs.""" mgr = SoftLayer.NetworkManager(env.client) table = formatting.Table(COLUMNS) table.sortby = sortby vlans = mgr.list_vlans(datacenter=datacenter, vlan_number=number, name=name) for vlan in vlans: table.add_row([ vlan['id'], vlan['vlanNumber'], vlan.get('name') or formatting.blank(), 'Yes' if vlan['firewallInterfaces'] else 'No', utils.lookup(vlan, 'primaryRouter', 'datacenter', 'name'), vlan['hardwareCount'], vlan['virtualGuestCount'], vlan['totalPrimaryIpAddressCount'], ]) env.fout(table) softlayer-python-5.0.1/SoftLayer/__init__.py000066400000000000000000000021331267703721100210720ustar00rootroot00000000000000""" SoftLayer Python API Client ~~~~~~~~~~~~~~~~~~~~~~~~~~~ SoftLayer API bindings Usage: >>> import SoftLayer >>> client = SoftLayer.create_client_from_env(username="username", api_key="api_key") >>> resp = client.call('Account', 'getObject') >>> resp['companyName'] 'Your Company' :license: MIT, see LICENSE for more details. """ # pylint: disable=w0401 from SoftLayer import consts from SoftLayer.API import * # NOQA from SoftLayer.managers import * # NOQA from SoftLayer.exceptions import * # NOQA from SoftLayer.auth import * # NOQA from SoftLayer.transports import * # NOQA __title__ = 'SoftLayer' __version__ = consts.VERSION __author__ = 'SoftLayer Technologies, Inc.' __license__ = 'MIT' __copyright__ = 'Copyright 2016 SoftLayer Technologies, Inc.' __all__ = [ 'BaseClient', 'create_client_from_env', 'Client', 'BasicAuthentication', 'SoftLayerError', 'SoftLayerAPIError', 'SoftLayerListResult', 'API_PUBLIC_ENDPOINT', 'API_PRIVATE_ENDPOINT', ] softlayer-python-5.0.1/SoftLayer/auth.py000066400000000000000000000053671267703721100203100ustar00rootroot00000000000000""" SoftLayer.auth ~~~~~~~~~~~~~~ Module with the supported auth mechanisms for the SoftLayer API :license: MIT, see LICENSE for more details. """ # pylint: disable=no-self-use __all__ = [ 'BasicAuthentication', 'TokenAuthentication', 'BasicHTTPAuthentication', 'AuthenticationBase', ] class AuthenticationBase(object): """A base authentication class intended to be overridden.""" def get_request(self, request): """Receives request options and returns request options. :param options dict: dictionary of request options """ return request def get_headers(self): """Return a dictionary of headers to be inserted for authentication. .. deprecated:: 3.3.0 Use :func:`get_options` instead. """ return {} class TokenAuthentication(AuthenticationBase): """Token-based authentication class. :param user_id int: a user's id :param auth_token str: a user's auth token, attained through User_Customer::getPortalLoginToken """ def __init__(self, user_id, auth_token): self.user_id = user_id self.auth_token = auth_token def get_request(self, request): """Sets token-based auth headers.""" request.headers['authenticate'] = { 'complexType': 'PortalLoginToken', 'userId': self.user_id, 'authToken': self.auth_token, } return request def __repr__(self): return "TokenAuthentication(%r)" % self.user_id class BasicAuthentication(AuthenticationBase): """Token-based authentication class. :param username str: a user's username :param api_key str: a user's API key """ def __init__(self, username, api_key): self.username = username self.api_key = api_key def get_request(self, request): """Sets token-based auth headers.""" request.headers['authenticate'] = { 'username': self.username, 'apiKey': self.api_key, } return request def __repr__(self): return "BasicAuthentication(username=%r)" % self.username class BasicHTTPAuthentication(AuthenticationBase): """Token-based authentication class. :param username str: a user's username :param api_key str: a user's API key """ def __init__(self, username, api_key): self.username = username self.api_key = api_key def get_request(self, request): """Sets token-based auth headers.""" request.transport_user = self.username request.transport_password = self.api_key return request def __repr__(self): return "BasicHTTPAuthentication(username=%r)" % self.username softlayer-python-5.0.1/SoftLayer/config.py000066400000000000000000000054621267703721100206100ustar00rootroot00000000000000""" SoftLayer.config ~~~~~~~~~~~~~~~~ Handles different methods for loading configuration for the API bindings :license: MIT, see LICENSE for more details. """ import os import os.path from SoftLayer import utils def get_client_settings_args(**kwargs): """Retrieve client settings from user-supplied arguments. :param \\*\\*kwargs: Arguments that are passed into the client instance """ timeout = kwargs.get('timeout') if timeout is not None: timeout = float(timeout) return { 'endpoint_url': kwargs.get('endpoint_url'), 'timeout': timeout, 'proxy': kwargs.get('proxy'), 'username': kwargs.get('username'), 'api_key': kwargs.get('api_key'), } def get_client_settings_env(**_): """Retrieve client settings from environment settings. :param \\*\\*kwargs: Arguments that are passed into the client instance """ return { 'proxy': os.environ.get('https_proxy'), 'username': os.environ.get('SL_USERNAME'), 'api_key': os.environ.get('SL_API_KEY'), } def get_client_settings_config_file(**kwargs): """Retrieve client settings from the possible config file locations. :param \\*\\*kwargs: Arguments that are passed into the client instance """ config_files = ['/etc/softlayer.conf', '~/.softlayer'] if kwargs.get('config_file'): config_files.append(kwargs.get('config_file')) config_files = [os.path.expanduser(f) for f in config_files] config = utils.configparser.RawConfigParser({ 'username': '', 'api_key': '', 'endpoint_url': '', 'timeout': '0', 'proxy': '', }) config.read(config_files) if not config.has_section('softlayer'): return return { 'endpoint_url': config.get('softlayer', 'endpoint_url'), 'timeout': config.getfloat('softlayer', 'timeout'), 'proxy': config.get('softlayer', 'proxy'), 'username': config.get('softlayer', 'username'), 'api_key': config.get('softlayer', 'api_key'), } SETTING_RESOLVERS = [get_client_settings_args, get_client_settings_env, get_client_settings_config_file] def get_client_settings(**kwargs): """Parse client settings. Parses settings from various input methods, preferring earlier values to later ones. The settings currently come from explicit user arguments, environmental variables and config files. :param \\*\\*kwargs: Arguments that are passed into the client instance """ all_settings = {} for setting_method in SETTING_RESOLVERS: settings = setting_method(**kwargs) if settings: settings.update((k, v) for k, v in all_settings.items() if v) all_settings = settings return all_settings softlayer-python-5.0.1/SoftLayer/consts.py000066400000000000000000000007531267703721100206520ustar00rootroot00000000000000""" SoftLayer.consts ~~~~~~~~~~~~~~~~ Contains constants used throughout the library :license: MIT, see LICENSE for more details. """ VERSION = 'v5.0.1' API_PUBLIC_ENDPOINT = 'https://api.softlayer.com/xmlrpc/v3.1/' API_PRIVATE_ENDPOINT = 'https://api.service.softlayer.com/xmlrpc/v3.1/' API_PUBLIC_ENDPOINT_REST = 'https://api.softlayer.com/rest/v3.1/' API_PRIVATE_ENDPOINT_REST = 'https://api.service.softlayer.com/rest/v3.1/' USER_AGENT = "softlayer-python/%s" % VERSION softlayer-python-5.0.1/SoftLayer/exceptions.py000066400000000000000000000037101267703721100215160ustar00rootroot00000000000000""" SoftLayer.exceptions ~~~~~~~~~~~~~~~~~~~~ Exceptions used throughout the library :license: MIT, see LICENSE for more details. """ # pylint: disable=C0103 class SoftLayerError(Exception): """The base SoftLayer error.""" class Unauthenticated(SoftLayerError): """Unauthenticated.""" class SoftLayerAPIError(SoftLayerError): """SoftLayerAPIError is an exception raised during API errors. Provides faultCode and faultString properties. """ def __init__(self, fault_code, fault_string, *args): SoftLayerError.__init__(self, fault_string, *args) self.faultCode = fault_code self.reason = self.faultString = fault_string def __repr__(self): return '<%s(%s): %s>' % (self.__class__.__name__, self.faultCode, self.faultString) def __str__(self): return '%s(%s): %s' % (self.__class__.__name__, self.faultCode, self.faultString) class ParseError(SoftLayerAPIError): """Parse Error.""" class ServerError(SoftLayerAPIError): """Server Error.""" class ApplicationError(SoftLayerAPIError): """Application Error.""" class RemoteSystemError(SoftLayerAPIError): """System Error.""" class TransportError(SoftLayerAPIError): """Transport Error.""" # XMLRPC Errors class NotWellFormed(ParseError): """Request was not well formed.""" pass class UnsupportedEncoding(ParseError): """Encoding not supported.""" pass class InvalidCharacter(ParseError): """There was an invalid character.""" pass class SpecViolation(ServerError): """There was a spec violation.""" pass class MethodNotFound(ServerError): """Method name not found.""" pass class InvalidMethodParameters(ServerError): """Invalid method paramters.""" pass class InternalError(ServerError): """Internal Server Error.""" pass softlayer-python-5.0.1/SoftLayer/fixtures/000077500000000000000000000000001267703721100206335ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Account.py000066400000000000000000000332511267703721100245750ustar00rootroot00000000000000getPrivateBlockDeviceTemplateGroups = [{ 'accountId': 1234, 'blockDevices': [], 'createDate': '2013-12-05T21:53:03-06:00', 'globalIdentifier': 'E6DBD73B-1651-4B28-BCBA-A11DF7C9D79E', 'id': 200, 'name': 'test_image', 'parentId': '' }, { 'accountId': 1234, 'blockDevices': [], 'createDate': '2013-12-05T21:53:03-06:00', 'globalIdentifier': 'F9329795-4220-4B0A-B970-C86B950667FA', 'id': 201, 'name': 'private_image2', 'parentId': '' }] getVirtualGuests = [{ 'id': 100, 'hostname': 'vs-test1', 'domain': 'test.sftlyr.ws', 'fullyQualifiedDomainName': 'vs-test1.test.sftlyr.ws', 'status': {'keyName': 'ACTIVE', 'name': 'Active'}, 'datacenter': {'id': 50, 'name': 'TEST00', 'description': 'Test Data Center'}, 'powerState': {'keyName': 'RUNNING', 'name': 'Running'}, 'maxCpu': 2, 'maxMemory': 1024, 'primaryIpAddress': '172.16.240.2', 'globalIdentifier': '1a2b3c-1701', 'primaryBackendIpAddress': '10.45.19.37', 'hourlyBillingFlag': False, 'billingItem': { 'id': 6327, 'recurringFee': 1.54, 'orderItem': { 'order': { 'userRecord': { 'username': 'chechu', } } } }, }, { 'id': 104, 'hostname': 'vs-test2', 'domain': 'test.sftlyr.ws', 'fullyQualifiedDomainName': 'vs-test2.test.sftlyr.ws', 'status': {'keyName': 'ACTIVE', 'name': 'Active'}, 'datacenter': {'id': 50, 'name': 'TEST00', 'description': 'Test Data Center'}, 'powerState': {'keyName': 'RUNNING', 'name': 'Running'}, 'maxCpu': 4, 'maxMemory': 4096, 'primaryIpAddress': '172.16.240.7', 'globalIdentifier': '05a8ac-6abf0', 'primaryBackendIpAddress': '10.45.19.35', 'hourlyBillingFlag': True, 'billingItem': { 'id': 6327, 'recurringFee': 1.54, 'orderItem': { 'order': { 'userRecord': { 'username': 'chechu', } } } }, }] getMonthlyVirtualGuests = [vs for vs in getVirtualGuests if not vs['hourlyBillingFlag']] getHourlyVirtualGuests = [vs for vs in getVirtualGuests if vs['hourlyBillingFlag']] getHardware = [{ 'id': 1000, 'globalIdentifier': '1a2b3c-1701', 'datacenter': {'id': 50, 'name': 'TEST00', 'description': 'Test Data Center'}, 'billingItem': { 'id': 6327, 'recurringFee': 1.54, 'orderItem': { 'order': { 'userRecord': { 'username': 'chechu', } } } }, 'primaryIpAddress': '172.16.1.100', 'hostname': 'hardware-test1', 'domain': 'test.sftlyr.ws', 'fullyQualifiedDomainName': 'hardware-test1.test.sftlyr.ws', 'processorPhysicalCoreAmount': 2, 'memoryCapacity': 2, 'primaryBackendIpAddress': '10.1.0.2', 'networkManagementIpAddress': '10.1.0.3', 'hardwareStatus': {'status': 'ACTIVE'}, 'provisionDate': '2013-08-01 15:23:45', 'notes': 'These are test notes.', 'operatingSystem': { 'softwareLicense': { 'softwareDescription': { 'referenceCode': 'Ubuntu', 'name': 'Ubuntu 12.04 LTS', } }, 'passwords': [ {'username': 'root', 'password': 'abc123'} ], }, 'networkVlans': [ { 'networkSpace': 'PRIVATE', 'vlanNumber': 1800, 'id': 9653 }, { 'networkSpace': 'PUBLIC', 'vlanNumber': 3672, 'id': 19082 }, ], 'tagReferences': [ {'tag': {'name': 'test_tag'}} ], 'activeTransaction': { 'transactionStatus': { 'name': 'TXN_NAME', 'friendlyName': 'Friendly Transaction Name', 'id': 6660 } }, }, { 'id': 1001, 'globalIdentifier': '1a2b3c-1702', 'datacenter': {'name': 'TEST00', 'description': 'Test Data Center'}, 'billingItem': { 'id': 7112, 'orderItem': { 'order': { 'userRecord': { 'username': 'chechu', } } } }, 'primaryIpAddress': '172.16.4.94', 'hostname': 'hardware-test2', 'domain': 'test.sftlyr.ws', 'fullyQualifiedDomainName': 'hardware-test2.test.sftlyr.ws', 'processorPhysicalCoreAmount': 4, 'memoryCapacity': 4, 'primaryBackendIpAddress': '10.1.0.3', 'hardwareStatus': {'status': 'ACTIVE'}, 'provisionDate': '2013-08-03 07:15:22', 'operatingSystem': { 'softwareLicense': { 'softwareDescription': { 'referenceCode': 'Ubuntu', 'name': 'Ubuntu 12.04 LTS', } } }, 'networkVlans': [ { 'networkSpace': 'PRIVATE', 'vlanNumber': 1800, 'id': 9653 }, { 'networkSpace': 'PUBLIC', 'vlanNumber': 3672, 'id': 19082 }, ] }, { 'id': 1002, 'datacenter': {'name': 'TEST00', 'description': 'Test Data Center'}, 'billingItem': { 'id': 7112, 'orderItem': { 'order': { 'userRecord': { 'username': 'chechu', } } } }, 'primaryIpAddress': '172.16.4.95', 'hostname': 'hardware-bad-memory', 'domain': 'test.sftlyr.ws', 'fullyQualifiedDomainName': 'hardware-bad-memory.test.sftlyr.ws', 'processorPhysicalCoreAmount': 4, 'memoryCapacity': None, 'primaryBackendIpAddress': '10.1.0.4', 'hardwareStatus': {'status': 'ACTIVE'}, 'provisionDate': '2014-04-02 13:48:00', 'operatingSystem': { 'softwareLicense': { 'softwareDescription': { 'referenceCode': 'Ubuntu', 'name': 'Ubuntu 12.04 LTS', } } }, 'networkVlans': [ { 'networkSpace': 'PRIVATE', 'vlanNumber': 1800, 'id': 9653 }, { 'networkSpace': 'PUBLIC', 'vlanNumber': 3672, 'id': 19082 }, ] }, { 'id': 1003, }] getDomains = [{'name': 'example.com', 'id': 12345, 'serial': 2014030728, 'updateDate': '2014-03-07T13:52:31-06:00'}] getObject = { 'cdnAccounts': [ { "cdnAccountName": "1234a", "providerPortalAccessFlag": False, "createDate": "2012-06-25T14:05:28-07:00", "id": 1234, "legacyCdnFlag": False, "dependantServiceFlag": True, "cdnSolutionName": "ORIGIN_PULL", "statusId": 4, "accountId": 1234 }, { "cdnAccountName": "1234a", "providerPortalAccessFlag": False, "createDate": "2012-07-24T13:34:25-07:00", "id": 1234, "legacyCdnFlag": False, "dependantServiceFlag": False, "cdnSolutionName": "POP_PULL", "statusId": 4, "accountId": 1234 } ] } getRwhoisData = { 'abuseEmail': 'abuseEmail', 'accountId': 1234, 'address1': 'address1', 'address2': 'address2', 'city': 'city', 'companyName': 'companyName', 'country': 'country', 'createDate': 'createDate', 'firstName': 'firstName', 'id': 'id', 'lastName': 'lastName', 'modifyDate': 'modifyDate', 'postalCode': 'postalCode', 'privateResidenceFlag': True, } getGlobalIpRecords = [{ 'id': '200', 'ipAddress': { 'subnet': { 'networkIdentifier': '10.0.0.1', }, 'ipAddress': '127.0.0.1', }, 'destinationIpAddress': { 'ipAddress': '127.0.0.1', 'virtualGuest': {'fullyQualifiedDomainName': 'example.com'}} }, { 'id': '201', 'ipAddress': { 'subnet': { 'networkIdentifier': '10.0.0.1', }, 'ipAddress': '127.0.0.1', }, 'destinationIpAddress': { 'ipAddress': '127.0.0.1', 'hardware': {'fullyQualifiedDomainName': 'example.com'}} }] getSubnets = [ { 'id': '100', 'networkIdentifier': '10.0.0.1', 'datacenter': {'name': 'dal00'}, 'version': 4, 'subnetType': 'PRIMARY' }] getSshKeys = [{'id': '100', 'label': 'Test 1'}, {'id': '101', 'label': 'Test 2', 'finterprint': 'aa:bb:cc:dd', 'notes': 'my key'}] getSecurityCertificates = [{'certificate': '1234', 'commonName': 'cert', 'id': 1234}] getExpiredSecurityCertificates = getSecurityCertificates getValidSecurityCertificates = getSecurityCertificates getTickets = [ { "accountId": 1234, "assignedUserId": 12345, "createDate": "2013-08-01T14:14:04-07:00", "id": 100, "lastEditDate": "2013-08-01T14:16:47-07:00", "lastEditType": "AUTO", "modifyDate": "2013-08-01T14:16:47-07:00", "status": { "id": 1002, "name": "Closed" }, "statusId": 1002, "title": "Cloud Instance Cancellation - 08/01/13" }, { "accountId": 1234, "assignedUserId": 12345, "createDate": "2013-08-01T14:14:04-07:00", "id": 101, "lastEditDate": "2013-08-01T14:16:47-07:00", "lastEditType": "AUTO", "modifyDate": "2013-08-01T14:16:47-07:00", "status": { "id": 1002, "name": "Closed" }, "statusId": 1002, "title": "Cloud Instance Cancellation - 08/01/13" }, { "accountId": 1234, "assignedUserId": 12345, "createDate": "2014-03-03T09:44:01-08:00", "id": 102, "lastEditDate": "2013-08-01T14:16:47-07:00", "lastEditType": "AUTO", "modifyDate": "2014-03-03T09:44:03-08:00", "status": { "id": 1001, "name": "Open" }, 'assignedUser': {'firstName': 'John', 'lastName': 'Smith'}, "statusId": 1001, "title": "Cloud Instance Cancellation - 08/01/13" }] getOpenTickets = [ticket for ticket in getTickets if ticket['statusId'] == 1001] getClosedTickets = [ticket for ticket in getTickets if ticket['statusId'] == 1002] getCurrentUser = {'id': 12345, 'apiAuthenticationKeys': [{'authenticationKey': 'A' * 64}]} getCdnAccounts = [ { "cdnAccountName": "1234a", "providerPortalAccessFlag": False, "createDate": "2012-06-25T14:05:28-07:00", "id": 1234, "legacyCdnFlag": False, "dependantServiceFlag": True, "cdnSolutionName": "ORIGIN_PULL", "statusId": 4, "accountId": 1234 }, { "cdnAccountName": "1234a", "providerPortalAccessFlag": False, "createDate": "2012-07-24T13:34:25-07:00", "id": 1234, "legacyCdnFlag": False, "dependantServiceFlag": False, "cdnSolutionName": "POP_PULL", "statusId": 4, "accountId": 1234 } ] getNetworkVlans = [{ 'id': 1, 'networkSpace': 'PRIVATE', 'hardwareCount': 0, 'hardware': [], 'networkComponents': [], 'primaryRouter': { 'datacenter': {'name': 'dal00'} }, 'virtualGuestCount': 0, 'virtualGuests': [], 'dedicatedFirewallFlag': True, 'highAvailabilityFirewallFlag': True, 'networkVlanFirewall': {'id': 1234}, 'totalPrimaryIpAddressCount': 1, 'subnetCount': 0, 'subnets': [], }, { 'id': 2, 'networkSpace': 'PRIVATE', 'totalPrimaryIpAddressCount': 2, 'dedicatedFirewallFlag': False, 'hardwareCount': 0, 'hardware': [], 'networkComponents': [], 'primaryRouter': { 'datacenter': {'name': 'dal00'} }, 'virtualGuestCount': 0, 'virtualGuests': [], 'firewallGuestNetworkComponents': [{ 'id': 1234, 'guestNetworkComponent': {'guest': {'id': 1}}, 'status': 'ok'}], 'firewallNetworkComponents': [{ 'id': 1234, 'networkComponent': {'downlinkComponent': {'hardwareId': 1}}, 'status': 'ok'}], 'subnetCount': 0, 'subnets': [], }, { 'id': 3, 'networkSpace': 'PRIVATE', 'name': 'dal00', 'hardwareCount': 1, 'hardware': [{'id': 1}], 'networkComponents': [{'id': 2}], 'primaryRouter': { 'datacenter': {'name': 'dal00'} }, 'totalPrimaryIpAddressCount': 3, 'subnetCount': 0, 'subnets': [], 'virtualGuestCount': 1, 'virtualGuests': [{'id': 3}] }] getAdcLoadBalancers = [] getNasNetworkStorage = [{ 'id': 1, 'capacityGb': 10, 'serviceResource': {'datacenter': {'name': 'Dallas'}}, 'username': 'user', 'password': 'pass', 'serviceResourceBackendIpAddress': '127.0.0.1', }] getActiveQuotes = [{ 'id': 1234, 'name': 'TestQuote1234', 'quoteKey': '1234test4321', }] getOrders = [{ 'id': 1234, 'resourceType': '1 x 2.0 GHz Core', 'hostName': 'test', 'createDate': '2014-05-01T14:03:04-07:00', 'cost': 0.0 }] getBillingInfo = [{ 'id': 1234, 'accountId': 123, 'resourceType': '1 x 2.0 GHz Core', 'hostName': 'test', 'modifyDate': '2014-05-01T14:03:04-07:00', 'createDate': '2014-05-01T14:03:04-07:00', 'anniversaryDayOfMonth': 2, 'percentDiscountOnetime': 2, 'sparePoolAmount': 0, 'currency': { 'KeyName': 'usd', 'id': 1, 'name': 'dollars' } }] getLatestBillDate = '2014-05-01T14:03:04-07:00' getBalance = 40 getNextInvoiceTotalAmount = 2 getHubNetworkStorage = [{'id': 12345, 'username': 'SLOS12345-1'}, {'id': 12346, 'username': 'SLOS12345-2'}] softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Billing_Item.py000066400000000000000000000001151267703721100255300ustar00rootroot00000000000000cancelService = True cancelServiceOnAnniversaryDate = True cancelItem = True softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Billing_Order_Quote.py000066400000000000000000000005331267703721100270660ustar00rootroot00000000000000getObject = { 'accountId': 1234, 'id': 1234, 'name': 'TestQuote1234', 'quoteKey': '1234test4321', } getRecalculatedOrderContainer = { 'orderContainers': [{ 'presetId': '', 'prices': [{ 'id': 1921 }], 'quantity': 1, 'packageId': 50, 'useHourlyPricing': '', }], } softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Dns_Domain.py000066400000000000000000000011361267703721100252110ustar00rootroot00000000000000createObject = {'name': 'example.com'} deleteObject = True editObject = True getZoneFileContents = 'lots of text' getResourceRecords = [ {'id': 1, 'ttl': 7200, 'data': 'd', 'host': 'a', 'type': 'cname'}, {'id': 2, 'ttl': 900, 'data': '1', 'host': 'b', 'type': 'a'}, {'id': 3, 'ttl': 900, 'data': 'x', 'host': 'c', 'type': 'ptr'}, {'id': 4, 'ttl': 86400, 'data': 'b', 'host': 'd', 'type': 'txt'}, {'id': 5, 'ttl': 86400, 'data': 'b', 'host': 'e', 'type': 'txt'}, {'id': 6, 'ttl': 600, 'data': 'b', 'host': 'f', 'type': 'txt'}, ] getObject = {'id': 98765, 'name': 'test-example.com'} softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Dns_Domain_ResourceRecord.py000066400000000000000000000001151267703721100302130ustar00rootroot00000000000000createObject = {'name': 'example.com'} deleteObject = True editObject = True softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Hardware_Server.py000066400000000000000000000061141267703721100262620ustar00rootroot00000000000000getObject = { 'id': 1000, 'globalIdentifier': '1a2b3c-1701', 'datacenter': {'id': 50, 'name': 'TEST00', 'description': 'Test Data Center'}, 'billingItem': { 'id': 6327, 'recurringFee': 1.54, 'nextInvoiceTotalRecurringAmount': 16.08, 'orderItem': { 'order': { 'userRecord': { 'username': 'chechu', } } } }, 'primaryIpAddress': '172.16.1.100', 'hostname': 'hardware-test1', 'domain': 'test.sftlyr.ws', 'bareMetalInstanceFlag': True, 'fullyQualifiedDomainName': 'hardware-test1.test.sftlyr.ws', 'processorPhysicalCoreAmount': 2, 'memoryCapacity': 2, 'primaryBackendIpAddress': '10.1.0.2', 'networkManagementIpAddress': '10.1.0.3', 'hardwareStatus': {'status': 'ACTIVE'}, 'primaryNetworkComponent': {'maxSpeed': 10, 'speed': 10}, 'provisionDate': '2013-08-01 15:23:45', 'notes': 'These are test notes.', 'operatingSystem': { 'softwareLicense': { 'softwareDescription': { 'referenceCode': 'Ubuntu', 'name': 'Ubuntu 12.04 LTS', } }, 'passwords': [ {'username': 'root', 'password': 'abc123'} ], }, 'remoteManagementAccounts': [ {'username': 'root', 'password': 'abc123'} ], 'networkVlans': [ { 'networkSpace': 'PRIVATE', 'vlanNumber': 1800, 'id': 9653 }, { 'networkSpace': 'PUBLIC', 'vlanNumber': 3672, 'id': 19082 }, ], 'tagReferences': [ {'tag': {'name': 'test_tag'}} ], 'activeTransaction': { 'transactionStatus': { 'name': 'TXN_NAME', 'friendlyName': 'Friendly Transaction Name', 'id': 6660 } } } editObject = True setTags = True setPrivateNetworkInterfaceSpeed = True setPublicNetworkInterfaceSpeed = True powerOff = True powerOn = True powerCycle = True rebootSoft = True rebootDefault = True rebootHard = True createFirmwareUpdateTransaction = True setUserMetadata = ['meta'] reloadOperatingSystem = 'OK' getReverseDomainRecords = [ {'resourceRecords': [{'data': '2.0.1.10.in-addr.arpa'}]}] bootToRescueLayer = True getFrontendNetworkComponents = [ {'maxSpeed': 100}, { 'maxSpeed': 1000, 'networkComponentGroup': { 'groupTypeId': 2, 'networkComponents': [{'maxSpeed': 1000}, {'maxSpeed': 1000}] } }, { 'maxSpeed': 1000, 'networkComponentGroup': { 'groupTypeId': 2, 'networkComponents': [{'maxSpeed': 1000}, {'maxSpeed': 1000}] } }, { 'maxSpeed': 1000, 'networkComponentGroup': { 'groupTypeId': 2, 'networkComponents': [{'maxSpeed': 1000}, {'maxSpeed': 1000}] } }, { 'maxSpeed': 1000, 'networkComponentGroup': { 'groupTypeId': 2, 'networkComponents': [{'maxSpeed': 1000}, {'maxSpeed': 1000}] } } ] softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Location.py000066400000000000000000000003131267703721100247420ustar00rootroot00000000000000getDataCenters = [ { "id": 358694, "longName": "London 2", "name": "lon02" }, { "id": 168642, "longName": "San Jose 1", "name": "sjc01" }] softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Location_Datacenter.py000066400000000000000000000000701267703721100270740ustar00rootroot00000000000000getDatacenters = [{ 'id': 0, 'name': 'dal05' }] SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Health_Check_Type.py000066400000000000000000000005201267703721100411070ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/fixturesgetAllObjects = [ {'id': 21, 'keyname': 'DEFAULT', 'name': 'Default'}, {'id': 3, 'keyname': 'DNS', 'name': 'DNS'}, {'id': 2, 'keyname': 'HTTP', 'name': 'HTTP'}, {'id': 5, 'keyname': 'HTTP-CUSTOM', 'name': 'HTTP-CUSTOM'}, {'id': 4, 'keyname': 'ICMP', 'name': 'Ping'}, {'id': 1, 'keyname': 'TCP', 'name': 'TCP'} ] SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Routing_Method.py000066400000000000000000000031711267703721100405400ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/fixturesgetAllObjects = [{'id': 21, 'keyname': 'CONSISTENT_HASH_IP', 'name': 'Consistent Hash IP'}, {'id': 9, 'keyname': 'INSERT_COOKIE', 'name': 'Insert Cookie'}, {'id': 1, 'keyname': 'LEAST_CONNECTIONS', 'name': 'Least Connections'}, {'id': 7, 'keyname': 'LEAST_CONNECTIONS_INSERT_COOKIE', 'name': 'Least Connections with Inserted Cookie'}, {'id': 4, 'keyname': 'LEAST_CONNECTIONS_PERSISTENT_IP', 'name': 'Least Connections with Persistent IP'}, {'id': 11, 'keyname': 'PERSISTENT_IP', 'name': 'Persistent IP'}, {'id': 10, 'keyname': 'ROUND_ROBIN', 'name': 'Round Robin'}, {'id': 6, 'keyname': 'ROUND_ROBIN_INSERT_COOKIE', 'name': 'Round Robin with Inserted Cookie'}, {'id': 3, 'keyname': 'ROUND_ROBIN_PERSISTENT_IP', 'name': 'Round Robin with Persistent IP'}, {'id': 2, 'keyname': 'SHORTEST_RESPONSE', 'name': 'Shortest Response'}, {'id': 8, 'keyname': 'SHORTEST_RESPONSE_INSERT_COOKIE', 'name': 'Shortest Response with Inserted Cookie'}, {'id': 5, 'keyname': 'SHORTEST_RESPONSE_PERSISTENT_IP', 'name': 'Shortest Response with Persistent IP'}] SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Routing_Type.py000066400000000000000000000005651267703721100402450ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/fixturesgetAllObjects = [{'id': 4, 'keyname': 'DNS', 'name': 'DNS'}, {'id': 5, 'keyname': 'FTP', 'name': 'FTP'}, {'id': 2, 'keyname': 'HTTP', 'name': 'HTTP'}, {'id': 41, 'keyname': 'HTTPS', 'name': 'HTTPS'}, {'id': 3, 'keyname': 'TCP', 'name': 'TCP'}, {'id': 6, 'keyname': 'UDP', 'name': 'UDP'}] SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service.py000066400000000000000000000000501267703721100372020ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/fixturesdeleteObject = True toggleStatus = True SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_Service_Group.py000066400000000000000000000000321267703721100403560ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/fixtureskickAllConnections = True SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualIpAddress.py000066400000000000000000000060531267703721100410400ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/fixturesgetBillingItem = {'id': 21370814} getObject = { 'accountId': 307608, 'connectionLimit': 500, 'connectionLimitUnits': "connections/second", 'dedicatedFlag': False, 'highAvailabilityFlag': False, 'id': 22348, 'ipAddressId': 7303278, 'managedResourceFlag': False, 'sslActiveFlag': False, 'sslEnabledFlag': True, 'virtualServers': [ { 'allocation': 10, 'id': 50718, 'port': 80, "serviceGroups": [ { 'id': 51758, 'routingMethodId': 10, 'routingTypeId': 3, 'services': [ { 'enabled': 1, 'id': 1234, 'healthChecks': [ { 'id': 112112 } ], 'groupReferences': [ { 'serviceGroupId': 51758, 'serviceId': 84986, 'weight': 2 } ], 'ipAddressId': 14288108, 'port': 8080, 'status': "DOWN" } ] } ], "virtualIpAddress": { 'accountId': 307608, 'connectionLimit': 500, 'connectionLimitUnits': "connections/second", 'id': 22348, 'ipAddressId': 7303278, }, 'virtualIpAddressId': 22348 }]} getVirtualServers = [ { "allocation": 10, "id": 50718, "port": 80, "serviceGroups": [ { "id": 51758, "routingMethodId": 10, "routingTypeId": 3, "services": [ { "enabled": 1, "id": 1234, "healthChecks": [ { "id": 112112 } ], "groupReferences": [ { "serviceGroupId": 51758, "serviceId": 84986, "weight": 2 } ], "ipAddressId": 14288108, "port": 8080, "status": "DOWN" } ] } ], "virtualIpAddress": { "accountId": 307608, "connectionLimit": 500, "connectionLimitUnits": "connections/second", "id": 22348, "ipAddressId": 7303278, }, "virtualIpAddressId": 22348 } ] editObject = True SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_VirtualServer.py000066400000000000000000000000241267703721100404200ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/fixturesdeleteObject = True softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Network_Component_Firewall.py000066400000000000000000000063601267703721100305020ustar00rootroot00000000000000createCancelServerTicket = {'id': 1234, 'title': 'Server Cancellation Request'} getObject = { "guestNetworkComponentId": 1705294, "id": 1234, "status": "allow_edit", "billingItem": { "allowCancellationFlag": 1, "associatedBillingItemId": "20952512", "categoryCode": "firewall", "createDate": "2014-03-21T14:07:04-05:00", "cycleStartDate": "2014-03-21T14:07:04-05:00", "description": "10Mbps Hardware Firewall", "id": 21370814, "laborFee": "0", "laborFeeTaxRate": ".066", "lastBillDate": "2014-03-21T14:07:04-05:00", "modifyDate": "2014-03-21T14:07:07-05:00", "nextBillDate": "2014-04-04T00:00:00-05:00", "oneTimeFee": "0", "oneTimeFeeTaxRate": ".066", "orderItemId": 28712824, "parentId": 20952512, "recurringFee": "0", "recurringFeeTaxRate": ".066", "recurringMonths": 1, "serviceProviderId": 1, "setupFee": "0", "setupFeeTaxRate": ".066" }, "guestNetworkComponent": { "createDate": "2014-03-17T13:49:00-05:00", "guestId": 3895386, "id": 1705294, "macAddress": "06:a4:8d:d2:88:34", "maxSpeed": 10, "modifyDate": "2014-03-17T13:49:20-05:00", "name": "eth", "networkId": 1310218, "port": 1, "speed": 10, "status": "ACTIVE", "uuid": "3f1b5e08-a652-fb3b-1baa-8ace70c90fe9", "guest": { "accountId": 307608, "dedicatedAccountHostOnlyFlag": False, "domain": "test.com", "fullyQualifiedDomainName": "test.test.com", "hostname": "firewalltest", "id": 3895386, "maxCpu": 1, "maxCpuUnits": "CORE", "maxMemory": 1024, "modifyDate": "2014-03-21T14:05:51-05:00", "startCpus": 1, "statusId": 1001, "uuid": "29b40ef0-a43a-8cb6-31be-1878cb6853f0", "status": { "keyName": "ACTIVE", "name": "Active" } } } } getRules = [ { 'destinationIpAddress': 'any on server', 'protocol': 'tcp', 'orderValue': 1, 'destinationIpSubnetMask': '255.255.255.255', 'destinationPortRangeStart': 80, 'sourceIpSubnetMask': '0.0.0.0', 'destinationPortRangeEnd': 80, 'version': 4, 'action': 'permit', 'sourceIpAddress': '0.0.0.0' }, { 'destinationIpAddress': 'any on server', 'protocol': 'tcp', 'orderValue': 2, 'destinationIpSubnetMask': '255.255.255.255', 'destinationPortRangeStart': 1, 'sourceIpSubnetMask': '255.255.255.255', 'destinationPortRangeEnd': 65535, 'version': 4, 'action': 'permit', 'sourceIpAddress': '193.212.1.10' }, { 'destinationIpAddress': 'any on server', 'protocol': 'tcp', 'orderValue': 3, 'destinationIpSubnetMask': '255.255.255.255', 'destinationPortRangeStart': 80, 'sourceIpSubnetMask': '0.0.0.0', 'destinationPortRangeEnd': 800, 'version': 4, 'action': 'permit', 'sourceIpAddress': '0.0.0.0' } ] getBillingItem = {"id": 21370814} softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Network_ContentDelivery_Account.py000066400000000000000000000014621267703721100315030ustar00rootroot00000000000000getObject = { "cdnAccountName": "1234a", "providerPortalAccessFlag": False, "createDate": "2012-06-25T14:05:28-07:00", "id": 1234, "legacyCdnFlag": False, "dependantServiceFlag": True, "cdnSolutionName": "ORIGIN_PULL", "statusId": 4, "accountId": 1234, "status": {'name': 'ACTIVE'}, } getOriginPullMappingInformation = [ { "originUrl": "http://ams01.objectstorage.softlayer.net:80", "mediaType": "FLASH", "id": "12345", "isSecureContent": False }, { "originUrl": "http://sng01.objectstorage.softlayer.net:80", "mediaType": "FLASH", "id": "12345", "isSecureContent": False } ] createOriginPullMapping = True deleteOriginPullRule = True loadContent = True purgeContent = True purgeCache = True softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Network_Firewall_Update_Request.py000066400000000000000000000001501267703721100314610ustar00rootroot00000000000000getObject = { "guestNetworkComponentId": 1705294, "id": 1234, } createObject = {} edit = True softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Network_Storage_Iscsi.py000066400000000000000000000036631267703721100274540ustar00rootroot00000000000000getObject = { 'accountId': 1111, 'billingItem': {'id': 600}, 'capacityGb': 20, 'createDate': '2014:50:15-04:00', 'guestId': '', 'hardwareId': '', 'hostId': '', 'id': 100, 'nasType': 'ISCSI', 'notes': """{'status': 'available'}""", 'password': 'abcdef', 'serviceProviderId': 1, 'serviceResource': {'datacenter': {'id': 138124}}, 'serviceResourceBackendIpAddress': '10.0.1.1', 'serviceResourceName': 'storagesng0101', 'username': 'username' } createSnapshot = { 'accountId': 1111, 'capacityGb': 20, 'createDate': '2014:51:11-04:00', 'guestId': '', 'hardwareId': '', 'hostId': '', 'id': 101, 'nasType': 'ISCSI_SNAPSHOT', 'parentVolume': { 'accountId': 1111, 'capacityGb': 20, 'createDate': '2014:38:47-04:00', 'guestId': '', 'hardwareId': '', 'hostId': '', 'id': 100, 'nasType': 'ISCSI', 'password': 'abcdef', 'properties': [ {'createDate': '2014:40:22-04:00', 'modifyDate': '', 'type': { 'description': 'Percent of reserved snapshot space that is available', 'keyname': 'SNAPSHOT_RESERVE_AVAILABLE', 'name': 'Snaphot Reserve Available'}, 'value': '100', 'volumeId': 2233}], 'propertyCount': 0, 'serviceProviderId': 1, 'name': 'storagedal05', 'snapshotCapacityGb': '40', 'username': 'username'}, 'password': 'abcdef', 'serviceProviderId': 1, 'serviceResource': {'backendIpAddress': '10.1.0.1', 'name': 'storagedal05', 'type': {'type': 'ISCSI'}}, 'serviceResourceBackendIpAddress': '10.1.0.1', 'serviceResourceName': 'storagedal05', 'username': 'username'} restoreFromSnapshot = True editObject = True createObject = getObject deleteObject = True softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Network_Subnet.py000066400000000000000000000000661267703721100261500ustar00rootroot00000000000000getObject = {'id': 1234, 'billingItem': {'id': 1056}} softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Network_Subnet_IpAddress.py000066400000000000000000000002751267703721100301100ustar00rootroot00000000000000getByIpAddress = { 'id': 12345, 'ipAddress': '10.0.1.37', 'isBroadcast': False, 'isGateway': False, 'isNetwork': False, 'isReserved': False, 'subnetId': 5678, } softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Network_Subnet_IpAddress_Global.py000066400000000000000000000001221267703721100313570ustar00rootroot00000000000000route = True unroute = True getObject = {'id': 1234, 'billingItem': {'id': 1234}} softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Network_Subnet_Rwhois_Data.py000066400000000000000000000000221267703721100304240ustar00rootroot00000000000000editObject = True softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Network_Vlan.py000066400000000000000000000000741267703721100256070ustar00rootroot00000000000000getObject = {'primaryRouter': {'datacenter': {'id': 1234}}} softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Network_Vlan_Firewall.py000066400000000000000000000046771267703721100274510ustar00rootroot00000000000000createCancelServerTicket = {'id': 1234, 'title': 'Server Cancellation Request'} getObject = { "administrativeBypassFlag": "", "customerManagedFlag": False, "billingItem": { "id": 21370815 }, "id": 3130, "primaryIpAddress": "192.155.239.146", "networkVlan": { "accountId": 307608, "id": 371028, "primarySubnetId": 536252, "vlanNumber": 1489, "firewallInterfaces": [ { "id": 6254, "name": "inside", "firewallContextAccessControlLists": [ { "direction": "out", "firewallContextInterfaceId": 6257, "id": 3143 } ] }, { "id": 6256, "name": "outside", "firewallContextAccessControlLists": [ { "direction": "out", "firewallContextInterfaceId": 6257, "id": 3143 }, { "direction": "in", "firewallContextInterfaceId": 6256, "id": 3142 } ] } ] } } getRules = [ { 'destinationIpAddress': 'any on server', 'protocol': 'tcp', 'orderValue': 1, 'destinationIpSubnetMask': '255.255.255.255', 'destinationPortRangeStart': 80, 'sourceIpSubnetMask': '0.0.0.0', 'destinationPortRangeEnd': 80, 'version': 4, 'action': 'permit', 'sourceIpAddress': '0.0.0.0' }, { 'destinationIpAddress': 'any on server', 'protocol': 'tcp', 'orderValue': 2, 'destinationIpSubnetMask': '255.255.255.255', 'destinationPortRangeStart': 1, 'sourceIpSubnetMask': '255.255.255.255', 'destinationPortRangeEnd': 65535, 'version': 4, 'action': 'permit', 'sourceIpAddress': '193.212.1.10' }, { 'destinationIpAddress': 'any on server', 'protocol': 'tcp', 'orderValue': 3, 'destinationIpSubnetMask': '255.255.255.255', 'destinationPortRangeStart': 80, 'sourceIpSubnetMask': '0.0.0.0', 'destinationPortRangeEnd': 800, 'version': 4, 'action': 'permit', 'sourceIpAddress': '0.0.0.0' } ] softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Product_Order.py000066400000000000000000000006611267703721100257530ustar00rootroot00000000000000verifyOrder = { 'orderId': 1234, 'orderDate': '2013-08-01 15:23:45', 'prices': [{ 'id': 1, 'laborFee': '2', 'oneTimeFee': '2', 'oneTimeFeeTax': '.1', 'quantity': 1, 'recurringFee': '2', 'recurringFeeTax': '.1', 'hourlyRecurringFee': '2', 'setupFee': '1', 'item': {'id': 1, 'description': 'this is a thing'}, }]} placeOrder = verifyOrder softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Product_Package.py000066400000000000000000000310251267703721100262310ustar00rootroot00000000000000HARDWARE_ITEMS = [ {'attributes': [], 'capacity': '999', 'description': 'Unknown', 'itemCategory': {'categoryCode': 'unknown', 'id': 325}, 'keyName': 'UNKNOWN', 'prices': [{'accountRestrictions': [], 'currentPriceFlag': '', 'hourlyRecurringFee': '0', 'id': 1245172, 'itemId': 935954, 'laborFee': '0', 'onSaleFlag': '', 'oneTimeFee': '0', 'quantity': '', 'recurringFee': '0', 'setupFee': '0', 'sort': 0}]}, {'attributes': [], 'capacity': '64', 'description': '1 IPv6 Address', 'itemCategory': {'categoryCode': 'pri_ipv6_addresses', 'id': 325}, 'keyName': '1_IPV6_ADDRESS', 'prices': [{'accountRestrictions': [], 'currentPriceFlag': '', 'hourlyRecurringFee': '0', 'id': 17129, 'itemId': 4097, 'laborFee': '0', 'onSaleFlag': '', 'oneTimeFee': '0', 'quantity': '', 'recurringFee': '0', 'setupFee': '0', 'sort': 0}]}, {'attributes': [], 'capacity': '10', 'description': '10 Mbps Public & Private Network Uplinks', 'itemCategory': {'categoryCode': 'port_speed', 'id': 26}, 'keyName': '10_MBPS_PUBLIC_PRIVATE_NETWORK_UPLINKS', 'prices': [{'accountRestrictions': [], 'currentPriceFlag': '', 'hourlyRecurringFee': '0', 'id': 272, 'itemId': 186, 'laborFee': '0', 'onSaleFlag': '', 'oneTimeFee': '0', 'quantity': '', 'recurringFee': '0', 'setupFee': '0', 'sort': 5}]}, {'attributes': [], 'capacity': '0', 'description': 'Ubuntu Linux 14.04 LTS Trusty Tahr (64 bit)', 'itemCategory': {'categoryCode': 'os', 'id': 12}, 'keyName': 'OS_UBUNTU_14_04_LTS_TRUSTY_TAHR_64_BIT', 'prices': [{'accountRestrictions': [], 'currentPriceFlag': '', 'hourlyRecurringFee': '0', 'id': 37650, 'itemId': 4702, 'laborFee': '0', 'onSaleFlag': '', 'oneTimeFee': '0', 'quantity': '', 'recurringFee': '0', 'setupFee': '0', 'sort': 9}], 'softwareDescription': {'id': 1362, 'longDescription': 'Ubuntu / 14.04-64', 'referenceCode': 'UBUNTU_14_64'}}, {'attributes': [], 'capacity': '1', 'description': '1 IP Address', 'itemCategory': {'categoryCode': 'pri_ip_addresses', 'id': 13}, 'keyName': '1_IP_ADDRESS', 'prices': [{'accountRestrictions': [], 'currentPriceFlag': '', 'hourlyRecurringFee': '0', 'id': 21, 'itemId': 15, 'laborFee': '0', 'onSaleFlag': '', 'oneTimeFee': '0', 'quantity': '', 'recurringFee': '0', 'setupFee': '0', 'sort': 0}]}, {'attributes': [{'attributeTypeKeyName': 'RECLAIM_BYPASS', 'id': 1014}], 'description': 'Unlimited SSL VPN Users', 'itemCategory': {'categoryCode': 'vpn_management', 'id': 31}, 'keyName': 'SSL_VPN_USERS_1_PPTP_VPN_USER_PER_ACCOUNT', 'prices': [{'accountRestrictions': [], 'currentPriceFlag': '', 'hourlyRecurringFee': '0', 'id': 420, 'itemId': 309, 'laborFee': '0', 'onSaleFlag': '', 'oneTimeFee': '0', 'quantity': '', 'recurringFee': '0', 'setupFee': '0', 'sort': 0}]}, {'attributes': [], 'description': 'Reboot / KVM over IP', 'itemCategory': {'categoryCode': 'remote_management', 'id': 46}, 'keyName': 'REBOOT_KVM_OVER_IP', 'prices': [{'accountRestrictions': [], 'currentPriceFlag': '', 'hourlyRecurringFee': '0', 'id': 906, 'itemId': 504, 'laborFee': '0', 'onSaleFlag': '', 'oneTimeFee': '0', 'quantity': '', 'recurringFee': '0', 'setupFee': '0', 'sort': 0}]}, {'attributes': [], 'capacity': '0', 'description': '0 GB Bandwidth', 'itemCategory': {'categoryCode': 'bandwidth', 'id': 10}, 'keyName': 'BANDWIDTH_0_GB', 'prices': [{'accountRestrictions': [], 'currentPriceFlag': '', 'id': 22505, 'itemId': 4481, 'laborFee': '0', 'onSaleFlag': '', 'oneTimeFee': '0', 'quantity': '', 'recurringFee': '0', 'setupFee': '0', 'sort': 98}]}, {'attributes': [], 'capacity': '0', 'description': '0 GB Bandwidth', 'itemCategory': {'categoryCode': 'bandwidth', 'id': 10}, 'keyName': 'BANDWIDTH_0_GB_2', 'prices': [{'accountRestrictions': [], 'currentPriceFlag': '', 'hourlyRecurringFee': '0', 'id': 1800, 'itemId': 439, 'laborFee': '0', 'onSaleFlag': '', 'oneTimeFee': '0', 'quantity': '', 'setupFee': '0', 'sort': 99}]}] getAllObjects = [{ 'activePresets': [{ 'description': 'Single Xeon 1270, 8GB Ram, 2x1TB SATA disks, Non-RAID', 'id': 64, 'isActive': '1', 'keyName': 'S1270_8GB_2X1TBSATA_NORAID', 'name': 'S1270 8GB 2X1TBSATA NORAID', 'packageId': 200 }], 'description': 'Bare Metal Server', 'firstOrderStepId': 1, 'id': 200, 'isActive': 1, 'items': HARDWARE_ITEMS, 'name': 'Bare Metal Server', 'regions': [{'description': 'WDC01 - Washington, DC - East Coast U.S.', 'keyname': 'WASHINGTON_DC', 'location': {'location': {'id': 37473, 'longName': 'Washington 1', 'name': 'wdc01'}}, 'sortOrder': 10}], 'subDescription': 'Bare Metal Server', 'unitSize': 1, }] getItems = [ { 'id': 1234, 'capacity': '1000', 'description': 'Public & Private Networks', 'itemCategory': {'categoryCode': 'Uplink Port Speeds'}, 'prices': [{'id': 1122, 'categories': [{'id': 26, 'name': 'Uplink Port Speeds', 'categoryCode': 'port_speed'}]}], }, { 'id': 2233, 'capacity': '1000', 'description': 'Public & Private Networks', 'itemCategory': {'categoryCode': 'Uplink Port Speeds'}, 'prices': [{'id': 4477, 'categories': [{'id': 26, 'name': 'Uplink Port Speeds', 'categoryCode': 'port_speed'}]}], }, { 'id': 1239, 'capacity': '2', 'description': 'RAM', 'itemCategory': {'categoryCode': 'RAM'}, 'prices': [{'id': 1133, 'categories': [{'id': 3, 'name': 'RAM', 'categoryCode': 'ram'}]}], }, { 'id': 1240, 'capacity': '4', 'description': 'Private Computing Instance', 'itemCategory': {'categoryCode': 'Computing Instance'}, 'prices': [{'id': 1007, 'categories': [{'id': 80, 'name': 'Computing Instance', 'categoryCode': 'guest_core'}]}], }, { 'id': 1250, 'capacity': '4', 'description': 'Computing Instance', 'itemCategory': {'categoryCode': 'Computing Instance'}, 'prices': [{'id': 1144, 'locationGroupId': None, 'categories': [{'id': 80, 'name': 'Computing Instance', 'categoryCode': 'guest_core'}]}], }, { 'id': 112233, 'capacity': '55', 'description': 'Computing Instance', 'itemCategory': {'categoryCode': 'Computing Instance'}, 'prices': [{'id': 332211, 'locationGroupId': 1, 'categories': [{'id': 80, 'name': 'Computing Instance', 'categoryCode': 'guest_core'}]}], }, { 'id': 4439, 'capacity': '1', 'description': '1 GB iSCSI Storage', 'itemCategory': {'categoryCode': 'iscsi'}, 'prices': [{'id': 2222}], }, { 'id': 1121, 'capacity': '20', 'description': '20 GB iSCSI snapshot', 'itemCategory': {'categoryCode': 'iscsi_snapshot_space'}, 'prices': [{'id': 2014}], }, { 'id': 4440, 'capacity': '4', 'description': '4 Portable Public IP Addresses', 'itemCategory': {'categoryCode': 'sov_sec_ip_addresses_pub'}, 'prices': [{'id': 4444}], }, { 'id': 8880, 'capacity': '8', 'description': '8 Portable Public IP Addresses', 'itemCategory': {'categoryCode': 'sov_sec_ip_addresses_pub'}, 'prices': [{'id': 8888}], }, { 'id': 44400, 'capacity': '4', 'description': '4 Portable Private IP Addresses', 'itemCategory': {'categoryCode': 'sov_sec_ip_addresses_priv'}, 'prices': [{'id': 44441}], }, { 'id': 88800, 'capacity': '8', 'description': '8 Portable Private IP Addresses', 'itemCategory': {'categoryCode': 'sov_sec_ip_addresses_priv'}, 'prices': [{'id': 88881}], }, { 'id': 10, 'capacity': '0', 'description': 'Global IPv4', 'itemCategory': {'categoryCode': 'global_ipv4'}, 'prices': [{'id': 11}], }, { 'id': 66464, 'capacity': '64', 'description': '/64 Block Portable Public IPv6 Addresses', 'itemCategory': {'categoryCode': 'static_ipv6_addresses'}, 'prices': [{'id': 664641}], }, { 'id': 610, 'capacity': '0', 'description': 'Global IPv6', 'itemCategory': {'categoryCode': 'global_ipv6'}, 'prices': [{'id': 611}], }] getItemPrices = [ { 'currentPriceFlag': '', 'id': 2152, 'item': { 'capacity': '1', 'description': '1 GB iSCSI SAN Storage', 'id': 1111, 'softwareDescriptionId': '', 'units': 'GB', 'upgradeItemId': 547}, 'itemId': 1111, 'laborFee': '0', 'onSaleFlag': '', 'oneTimeFee': '0', 'packageReferences': [{'id': 46626, 'itemPriceId': 2152, 'packageId': 0}], 'quantity': '', 'recurringFee': '.35', 'setupFee': '0', 'sort': 0 }, { 'currentPriceFlag': '', 'id': 22501, 'item': {'capacity': '1', 'description': '1 GB iSCSI SAN Storage', 'id': 1111, 'softwareDescriptionId': '', 'units': 'GB', 'upgradeItemId': 547}, 'itemId': 1111, 'laborFee': '0', 'onSaleFlag': '', 'oneTimeFee': '0', 'packageReferences': [{ 'id': 252983, 'itemPriceId': 22501, 'packageId': 0 }], 'quantity': '', 'recurringFee': '0', 'setupFee': '0', 'sort': 0 }, { 'currentPriceFlag': '', 'id': 22441, 'item': { 'capacity': '1', 'description': '1 GB iSCSI SAN Storage', 'id': 1111, 'softwareDescriptionId': '', 'units': 'GB', 'upgradeItemId': 547 }, 'itemId': 1111, 'laborFee': '0', 'onSaleFlag': '', 'oneTimeFee': '0', 'packageReferences': [{'id': 250326, 'itemPriceId': 22441, 'packageId': 0}], 'quantity': '', 'recurringFee': '15', 'setupFee': '0', 'sort': 0 }] softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Resource_Metadata.py000066400000000000000000000003721267703721100265660ustar00rootroot00000000000000FrontendMacAddresses = ['06-00-00-00-00-00'] BackendMacAddresses = ['07-00-00-00-00-00'] FrontendMacAddresses = ['06-00-00-00-00-00'] Router = 'brc01' Vlans = [10, 124] VlanIds = [8384, 12446] Datacenter = 'dal01' UserMetadata = 'User-supplied data' softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Security_Certificate.py000066400000000000000000000001071267703721100273040ustar00rootroot00000000000000getObject = {} createObject = {} editObject = True deleteObject = True softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Security_Ssh_Key.py000066400000000000000000000004001267703721100264230ustar00rootroot00000000000000deleteObject = True editObject = True getObject = {'id': 1234, 'fingerprint': 'aa:bb:cc:dd', 'label': 'label', 'notes': 'notes', 'key': 'ssh-rsa AAAAB3N...pa67 user@example.com'} createObject = getObject softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Ticket.py000066400000000000000000000017031267703721100244210ustar00rootroot00000000000000createCancelServerTicket = {'id': 1234, 'title': 'Server Cancellation Request'} getObject = { "accountId": 1234, "assignedUserId": 12345, "createDate": "2013-08-01T14:14:04-07:00", "id": 100, "lastEditDate": "2013-08-01T14:16:47-07:00", "lastEditType": "AUTO", "modifyDate": "2013-08-01T14:16:47-07:00", "status": { "id": 1002, "name": "Closed" }, "statusId": 1002, "title": "Cloud Instance Cancellation - 08/01/13", 'updateCount': 3, 'updates': [ {'entry': 'a bot says something'}, {'entry': 'user says something', 'editor': {'firstName': 'John', 'lastName': 'Smith'}}, {'entry': 'employee says something', 'editor': {'displayName': 'emp1'}}, ] } createStandardTicket = { "assignedUserId": 12345, "id": 100, "contents": "body", "subjectId": 1004, "title": "Cloud Instance Cancellation - 08/01/13" } edit = True addUpdate = {} softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Ticket_Subject.py000066400000000000000000000005511267703721100261000ustar00rootroot00000000000000getAllObjects = [ { "id": 1001, "name": "Accounting Request" }, { "id": 1002, "name": "Sales Request" }, { "id": 1003, "name": "Reboots and Console Access" }, { "id": 1004, "name": "DNS Request" }, { "id": 1005, "name": "Hardware Issue" } ] softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_User_Customer.py000066400000000000000000000000431267703721100257710ustar00rootroot00000000000000addApiAuthenticationKey = "A" * 64 softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Virtual_Guest.py000066400000000000000000000163761267703721100260070ustar00rootroot00000000000000getObject = { 'id': 100, 'hostname': 'vs-test1', 'domain': 'test.sftlyr.ws', 'fullyQualifiedDomainName': 'vs-test1.test.sftlyr.ws', 'status': {'keyName': 'ACTIVE', 'name': 'Active'}, 'billingItem': { 'id': 6327, 'recurringFee': 1.54, 'orderItem': { 'order': { 'userRecord': { 'username': 'chechu', } } } }, 'datacenter': {'id': 50, 'name': 'TEST00', 'description': 'Test Data Center'}, 'powerState': {'keyName': 'RUNNING', 'name': 'Running'}, 'maxCpu': 2, 'maxMemory': 1024, 'primaryIpAddress': '172.16.240.2', 'globalIdentifier': '1a2b3c-1701', 'primaryBackendIpAddress': '10.45.19.37', "primaryNetworkComponent": {"speed": 10, "maxSpeed": 100}, 'hourlyBillingFlag': False, 'createDate': '2013-08-01 15:23:45', 'blockDevices': [{"device": 0, 'mountType': 'Disk', "uuid": 1}, {"device": 1, 'mountType': 'Disk'}, {"device": 2, 'mountType': 'CD'}, {"device": 3, 'mountType': 'Disk', "uuid": 3}], 'notes': 'notes', 'networkVlans': [{'networkSpace': 'PUBLIC', 'vlanNumber': 23, 'id': 1}], 'operatingSystem': { 'passwords': [{'username': 'user', 'password': 'pass'}], 'softwareLicense': { 'softwareDescription': {'version': '12.04-64 Minimal for VSI', 'name': 'Ubuntu'}} }, 'tagReferences': [{'tag': {'name': 'production'}}], } getCreateObjectOptions = { 'processors': [ { 'itemPrice': { 'item': {'description': '1 x 2.0 GHz Core'}, 'hourlyRecurringFee': '.07', 'recurringFee': '29' }, 'template': {'startCpus': 1} }, { 'itemPrice': { 'item': {'description': '2 x 2.0 GHz Cores'}, 'hourlyRecurringFee': '.14', 'recurringFee': '78' }, 'template': {'startCpus': 2} }, { 'itemPrice': { 'item': {'description': '3 x 2.0 GHz Cores'}, 'hourlyRecurringFee': '.205', 'recurringFee': '123.5' }, 'template': {'startCpus': 3} }, { 'itemPrice': { 'item': {'description': '4 x 2.0 GHz Cores'}, 'hourlyRecurringFee': '.265', 'recurringFee': '165.5' }, 'template': {'startCpus': 4} }, ], 'memory': [ { 'itemPrice': { 'item': {'description': '1 GB'}, 'hourlyRecurringFee': '.03', 'recurringFee': '21' }, 'template': {'maxMemory': 1024} }, { 'itemPrice': { 'item': {'description': '2 GB'}, 'hourlyRecurringFee': '.06', 'recurringFee': '42' }, 'template': {'maxMemory': 2048} }, { 'itemPrice': { 'item': {'description': '3 GB'}, 'hourlyRecurringFee': '.085', 'recurringFee': '59.5'}, 'template': {'maxMemory': 3072} }, { 'itemPrice': { 'item': {'description': '4 GB'}, 'hourlyRecurringFee': '.11', 'recurringFee': '77' }, 'template': {'maxMemory': 4096} }, ], 'blockDevices': [ { 'itemPrice': { 'item': {'description': '25 GB (LOCAL)'}, 'hourlyRecurringFee': '0', 'recurringFee': '0'}, 'template': { 'blockDevices': [ {'device': '0', 'diskImage': {'capacity': 25}} ], 'localDiskFlag': True } }, { 'itemPrice': { 'item': {'description': '100 GB (LOCAL)'}, 'hourlyRecurringFee': '.01', 'recurringFee': '7' }, 'template': { 'blockDevices': [ {'device': '0', 'diskImage': {'capacity': 100}} ], 'localDiskFlag': True } }, ], 'operatingSystems': [ { 'itemPrice': { 'item': { 'description': 'CentOS 6.0 - Minimal Install (64 bit)' }, 'hourlyRecurringFee': '0', 'recurringFee': '0' }, 'template': { 'operatingSystemReferenceCode': 'CENTOS_6_64' } }, { 'itemPrice': { 'item': { 'description': 'Debian GNU/Linux 7.0 Wheezy/Stable -' ' Minimal Install (64 bit)' }, 'hourlyRecurringFee': '0', 'recurringFee': '0' }, 'template': { 'operatingSystemReferenceCode': 'DEBIAN_7_64' } }, { 'itemPrice': { 'item': { 'description': 'Ubuntu Linux 12.04 LTS Precise' ' Pangolin - Minimal Install (64 bit)' }, 'hourlyRecurringFee': '0', 'recurringFee': '0' }, 'template': { 'operatingSystemReferenceCode': 'UBUNTU_12_64' } }, ], 'networkComponents': [ { 'itemPrice': { 'item': { 'description': '10 Mbps Public & Private Networks' }, 'hourlyRecurringFee': '0', 'recurringFee': '0'}, 'template': { 'networkComponents': [{'maxSpeed': 10}] } }, { 'itemPrice': { 'item': {'description': '100 Mbps Private Network'}, 'hourlyRecurringFee': '0', 'recurringFee': '0'}, 'template': { 'networkComponents': [{'maxSpeed': 100}] } }, { 'itemPrice': { 'item': {'description': '1 Gbps Private Network'}, 'hourlyRecurringFee': '.02', 'recurringFee': '10' }, 'template': { 'networkComponents': [{'maxSpeed': 1000}] } } ], 'datacenters': [ {'template': {'datacenter': {'name': 'ams01'}}}, {'template': {'datacenter': {'name': 'dal05'}}}, ], } getReverseDomainRecords = [{ 'networkAddress': '12.34.56.78', 'name': '12.34.56.78.in-addr.arpa', 'resourceRecords': [{'data': 'test.softlayer.com.', 'id': 987654}], 'updateDate': '2013-09-11T14:36:57-07:00', 'serial': 1234665663, 'id': 123456, }] editObject = True deleteObject = True setPrivateNetworkInterfaceSpeed = True setPublicNetworkInterfaceSpeed = True createObject = getObject createObjects = [getObject] generateOrderTemplate = {} setUserMetadata = ['meta'] reloadOperatingSystem = 'OK' setTags = True createArchiveTransaction = {} executeRescueLayer = True softlayer-python-5.0.1/SoftLayer/fixtures/SoftLayer_Virtual_Guest_Block_Device_Template_Group.py000066400000000000000000000014021267703721100333670ustar00rootroot00000000000000IMAGES = [{ 'accountId': 1234, 'blockDevices': [], 'createDate': '2013-12-05T21:53:03-06:00', 'globalIdentifier': '0B5DEAF4-643D-46CA-A695-CECBE8832C9D', 'id': 100, 'name': 'test_image', 'parentId': '' }, { 'accountId': 1234, 'blockDevices': [], 'createDate': '2013-12-05T21:53:03-06:00', 'globalIdentifier': 'EB38414C-2AB3-47F3-BBBD-56A5F689620B', 'id': 101, 'name': 'test_image2', 'parentId': '' }] getObject = IMAGES[0] getPublicImages = IMAGES deleteObject = {} editObject = True setTags = True createFromExternalSource = [{ 'createDate': '2013-12-05T21:53:03-06:00', 'globalIdentifier': '0B5DEAF4-643D-46CA-A695-CECBE8832C9D', 'id': 100, 'name': 'test_image', }] copyToExternalSource = True softlayer-python-5.0.1/SoftLayer/fixtures/__init__.py000066400000000000000000000000001267703721100227320ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/fixtures/empty.conf000066400000000000000000000000001267703721100226260ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/fixtures/full.conf000066400000000000000000000001151267703721100224410ustar00rootroot00000000000000[softlayer] username=myusername api_key=myapi_key endpoint_url=myendpoint_urlsoftlayer-python-5.0.1/SoftLayer/fixtures/id_rsa.pub000066400000000000000000000000471267703721100226050ustar00rootroot00000000000000ssh-rsa AAAAB3N...pa67 user@example.comsoftlayer-python-5.0.1/SoftLayer/fixtures/no_options.conf000066400000000000000000000000131267703721100236630ustar00rootroot00000000000000[softlayer]softlayer-python-5.0.1/SoftLayer/fixtures/realtest.com000066400000000000000000000015261267703721100231620ustar00rootroot00000000000000$ORIGIN realtest.com. $TTL 86400 @ IN SOA ns1.softlayer.com. support.softlayer.com. ( 2014052300 ; Serial 7200 ; Refresh 600 ; Retry 1728000 ; Expire 43200) ; Minimum @ 86400 IN NS ns1.softlayer.com. @ 86400 IN NS ns2.softlayer.com. IN MX 10 test.realtest.com. testing 86400 IN A 127.0.0.1 testing1 86400 IN A 12.12.0.1 server2 IN A 1.0.3.4 ftp IN CNAME server2 dev.realtest.com IN TXT "This is just a test of the txt record" IN AAAA 2001:db8:10::1 spf IN TXT "v=spf1 ip4:192.0.2.0/24 ip4:198.51.100.123 a -all" softlayer-python-5.0.1/SoftLayer/fixtures/sample_vs_template.conf000066400000000000000000000002271267703721100253670ustar00rootroot00000000000000hostname = myhost domain = example.com datacenter = dal05 cpu = 4 memory = 1024 os = DEBIAN_7_64 network = 100 hourly = true monthly= false disk=50,100softlayer-python-5.0.1/SoftLayer/managers/000077500000000000000000000000001267703721100205575ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/managers/__init__.py000066400000000000000000000027531267703721100226770ustar00rootroot00000000000000""" SoftLayer.managers ~~~~~~~~~~~~~~~~~~ Managers mask out a lot of the complexities of using the API into classes that provide a simpler interface to various services. These are higher-level interfaces to the SoftLayer API. :license: MIT, see LICENSE for more details. """ from SoftLayer.managers.cdn import CDNManager from SoftLayer.managers.dns import DNSManager from SoftLayer.managers.firewall import FirewallManager from SoftLayer.managers.hardware import HardwareManager from SoftLayer.managers.image import ImageManager from SoftLayer.managers.iscsi import ISCSIManager from SoftLayer.managers.load_balancer import LoadBalancerManager from SoftLayer.managers.messaging import MessagingManager from SoftLayer.managers.metadata import MetadataManager from SoftLayer.managers.network import NetworkManager from SoftLayer.managers.object_storage import ObjectStorageManager from SoftLayer.managers.ordering import OrderingManager from SoftLayer.managers.sshkey import SshKeyManager from SoftLayer.managers.ssl import SSLManager from SoftLayer.managers.ticket import TicketManager from SoftLayer.managers.vs import VSManager __all__ = [ 'CDNManager', 'DNSManager', 'FirewallManager', 'HardwareManager', 'ImageManager', 'ISCSIManager', 'LoadBalancerManager', 'MessagingManager', 'MetadataManager', 'NetworkManager', 'ObjectStorageManager', 'OrderingManager', 'SshKeyManager', 'SSLManager', 'TicketManager', 'VSManager', ] softlayer-python-5.0.1/SoftLayer/managers/cdn.py000066400000000000000000000123011267703721100216720ustar00rootroot00000000000000""" SoftLayer.cdn ~~~~~~~~~~~~~ CDN Manager/helpers :license: MIT, see LICENSE for more details. """ import six from SoftLayer import utils MAX_URLS_PER_LOAD = 5 MAX_URLS_PER_PURGE = 5 class CDNManager(utils.IdentifierMixin, object): """Manage CDN accounts.""" def __init__(self, client): self.client = client self.account = self.client['Network_ContentDelivery_Account'] def list_accounts(self): """Lists CDN accounts for the active user.""" account = self.client['Account'] mask = 'cdnAccounts[%s]' % ', '.join(['id', 'createDate', 'cdnAccountName', 'cdnSolutionName', 'cdnAccountNote', 'status']) return account.getObject(mask=mask).get('cdnAccounts', []) def get_account(self, account_id, **kwargs): """Retrieves a CDN account with the specified account ID. :param account_id int: the numeric ID associated with the CDN account. :param dict \\*\\*kwargs: additional arguments to include in the object mask. """ if 'mask' not in kwargs: kwargs['mask'] = 'status' return self.account.getObject(id=account_id, **kwargs) def get_origins(self, account_id, **kwargs): """Retrieves list of origin pull mappings for a specified CDN account. :param account_id int: the numeric ID associated with the CDN account. :param dict \\*\\*kwargs: additional arguments to include in the object mask. """ return self.account.getOriginPullMappingInformation(id=account_id, **kwargs) def add_origin(self, account_id, media_type, origin_url, cname=None, secure=False): """Adds an original pull mapping to an origin-pull. :param int account_id: the numeric ID associated with the CDN account. :param string media_type: the media type/protocol associated with this origin pull mapping; valid values are HTTP, FLASH, and WM. :param string origin_url: the base URL from which content should be pulled. :param string cname: an optional CNAME that should be associated with this origin pull rule; only the hostname should be included (i.e., no 'http://', directories, etc.). :param boolean secure: specifies whether this is an SSL origin pull rule, if SSL is enabled on your account (defaults to false). """ config = {'mediaType': media_type, 'originUrl': origin_url, 'isSecureContent': secure} if cname: config['cname'] = cname return self.account.createOriginPullMapping(config, id=account_id) def remove_origin(self, account_id, origin_id): """Removes an origin pull mapping with the given origin pull ID. :param int account_id: the CDN account ID from which the mapping should be deleted. :param int origin_id: the origin pull mapping ID to delete. """ return self.account.deleteOriginPullRule(origin_id, id=account_id) def load_content(self, account_id, urls): """Prefetches one or more URLs to the CDN edge nodes. :param int account_id: the CDN account ID into which content should be preloaded. :param urls: a string or a list of strings representing the CDN URLs that should be pre-loaded. :returns: true if all load requests were successfully submitted; otherwise, returns the first error encountered. """ if isinstance(urls, six.string_types): urls = [urls] for i in range(0, len(urls), MAX_URLS_PER_LOAD): result = self.account.loadContent(urls[i:i + MAX_URLS_PER_LOAD], id=account_id) if not result: return result return True def purge_content(self, account_id, urls): """Purges one or more URLs from the CDN edge nodes. :param int account_id: the CDN account ID from which content should be purged. :param urls: a string or a list of strings representing the CDN URLs that should be purged. :returns: true if all purge requests were successfully submitted; otherwise, returns the first error encountered. """ if isinstance(urls, six.string_types): urls = [urls] for i in range(0, len(urls), MAX_URLS_PER_PURGE): result = self.account.purgeCache(urls[i:i + MAX_URLS_PER_PURGE], id=account_id) if not result: return result return True softlayer-python-5.0.1/SoftLayer/managers/dns.py000066400000000000000000000120501267703721100217130ustar00rootroot00000000000000""" SoftLayer.dns ~~~~~~~~~~~~~ DNS Manager/helpers :license: MIT, see LICENSE for more details. """ import time from SoftLayer import utils class DNSManager(utils.IdentifierMixin, object): """Domain Name System manager. :param SoftLayer.API.Client client: the client instance """ def __init__(self, client): self.client = client self.service = self.client['Dns_Domain'] self.record = self.client['Dns_Domain_ResourceRecord'] self.resolvers = [self._get_zone_id_from_name] def _get_zone_id_from_name(self, name): """Return zone ID based on a zone.""" results = self.client['Account'].getDomains( filter={"domains": {"name": utils.query_filter(name)}}) return [x['id'] for x in results] def list_zones(self, **kwargs): """Retrieve a list of all DNS zones. :param dict \\*\\*kwargs: response-level options (mask, limit, etc.) :returns: A list of dictionaries representing the matching zones. """ return self.client['Account'].getDomains(**kwargs) def get_zone(self, zone_id, records=True): """Get a zone and its records. :param zone: the zone name :returns: A dictionary containing a large amount of information about the specified zone. """ mask = None if records: mask = 'resourceRecords' return self.service.getObject(id=zone_id, mask=mask) def create_zone(self, zone, serial=None): """Create a zone for the specified zone. :param zone: the zone name to create :param serial: serial value on the zone (default: strftime(%Y%m%d01)) """ return self.service.createObject({ 'name': zone, 'serial': serial or time.strftime('%Y%m%d01'), "resourceRecords": {}}) def delete_zone(self, zone_id): """Delete a zone by its ID. :param integer zone_id: the zone ID to delete """ return self.service.deleteObject(id=zone_id) def edit_zone(self, zone): """Update an existing zone with the options provided. The provided dict must include an 'id' key and value corresponding to the zone that should be updated. :param dict zone: the zone to update """ self.service.editObject(zone) def create_record(self, zone_id, record, record_type, data, ttl=60): """Create a resource record on a domain. :param integer id: the zone's ID :param record: the name of the record to add :param record_type: the type of record (A, AAAA, CNAME, MX, TXT, etc.) :param data: the record's value :param integer ttl: the TTL or time-to-live value (default: 60) """ return self.record.createObject({ 'domainId': zone_id, 'ttl': ttl, 'host': record, 'type': record_type, 'data': data}) def delete_record(self, record_id): """Delete a resource record by its ID. :param integer id: the record's ID """ self.record.deleteObject(id=record_id) def get_record(self, record_id): """Get a DNS record. :param integer id: the record's ID """ return self.record.getObject(id=record_id) def get_records(self, zone_id, ttl=None, data=None, host=None, record_type=None): """List, and optionally filter, records within a zone. :param zone: the zone name in which to search. :param int ttl: time in seconds :param str data: the records data :param str host: record's host :param str record_type: the type of record :returns: A list of dictionaries representing the matching records within the specified zone. """ _filter = utils.NestedDict() if ttl: _filter['resourceRecords']['ttl'] = utils.query_filter(ttl) if host: _filter['resourceRecords']['host'] = utils.query_filter(host) if data: _filter['resourceRecords']['data'] = utils.query_filter(data) if record_type: _filter['resourceRecords']['type'] = utils.query_filter( record_type.lower()) results = self.service.getResourceRecords( id=zone_id, mask='id,expire,domainId,host,minimum,refresh,retry,' 'mxPriority,ttl,type,data,responsiblePerson', filter=_filter.to_dict(), ) return results def edit_record(self, record): """Update an existing record with the options provided. The provided dict must include an 'id' key and value corresponding to the record that should be updated. :param dict record: the record to update """ self.record.editObject(record, id=record['id']) def dump_zone(self, zone_id): """Retrieve a zone dump in BIND format. :param integer id: The zone ID to dump """ return self.service.getZoneFileContents(id=zone_id) softlayer-python-5.0.1/SoftLayer/managers/firewall.py000066400000000000000000000253231267703721100227430ustar00rootroot00000000000000""" SoftLayer.firewall ~~~~~~~~~~~~~~~~~~ Firewall Manager/helpers :license: MIT, see LICENSE for more details. """ from SoftLayer import utils RULE_MASK = ('mask[orderValue,action,destinationIpAddress,' 'destinationIpSubnetMask,protocol,destinationPortRangeStart,' 'destinationPortRangeEnd,sourceIpAddress,sourceIpSubnetMask,' 'version]') def has_firewall(vlan): """Helper to determine whether or not a VLAN has a firewall. :param dict vlan: A dictionary representing a VLAN :returns: True if the VLAN has a firewall, false if it doesn't. """ return bool( vlan.get('dedicatedFirewallFlag', None) or vlan.get('highAvailabilityFirewallFlag', None) or vlan.get('firewallInterfaces', None) or vlan.get('firewallNetworkComponents', None) or vlan.get('firewallGuestNetworkComponents', None) ) class FirewallManager(utils.IdentifierMixin, object): """Manages firewalls. :param SoftLayer.API.Client client: the API client instance """ def __init__(self, client): self.client = client self.account = self.client['Account'] self.prod_pkg = self.client['Product_Package'] def get_standard_package(self, server_id, is_virt=True): """Retrieves the standard firewall package for the virtual server. :param int server_id: The ID of the server to create the firewall for :param bool is_virt: True if the ID provided is for a virtual server, False for a server :returns: A dictionary containing the standard virtual server firewall package """ firewall_port_speed = self._get_fwl_port_speed(server_id, is_virt) _value = "%s%s" % (firewall_port_speed, "Mbps Hardware Firewall") _filter = {'items': {'description': utils.query_filter(_value)}} return self.prod_pkg.getItems(id=0, filter=_filter) def get_dedicated_package(self, ha_enabled=False): """Retrieves the dedicated firewall package. :param bool ha_enabled: True if HA is to be enabled on the firewall False for No HA :returns: A dictionary containing the dedicated virtual server firewall package """ fwl_filter = 'Hardware Firewall (Dedicated)' ha_fwl_filter = 'Hardware Firewall (High Availability)' _filter = utils.NestedDict({}) if ha_enabled: _filter['items']['description'] = utils.query_filter(ha_fwl_filter) else: _filter['items']['description'] = utils.query_filter(fwl_filter) return self.prod_pkg.getItems(id=0, filter=_filter.to_dict()) def cancel_firewall(self, firewall_id, dedicated=False): """Cancels the specified firewall. :param int firewall_id: Firewall ID to be cancelled. :param bool dedicated: If true, the firewall instance is dedicated, otherwise, the firewall instance is shared. """ fwl_billing = self._get_fwl_billing_item(firewall_id, dedicated) billing_id = fwl_billing['billingItem']['id'] billing_item = self.client['Billing_Item'] return billing_item.cancelService(id=billing_id) def add_standard_firewall(self, server_id, is_virt=True): """Creates a firewall for the specified virtual/hardware server. :param int server_id: The ID of the server to create the firewall for :param bool is_virt: If true, will create the firewall for a virtual server, otherwise for a hardware server. :returns: A dictionary containing the standard virtual server firewall order """ package = self.get_standard_package(server_id, is_virt) if is_virt: product_order = { 'complexType': 'SoftLayer_Container_Product_Order_Network_' 'Protection_Firewall', 'quantity': 1, 'packageId': 0, 'virtualGuests': [{'id': server_id}], 'prices': [{'id': package[0]['prices'][0]['id']}] } else: product_order = { 'complexType': 'SoftLayer_Container_Product_Order_Network_' 'Protection_Firewall', 'quantity': 1, 'packageId': 0, 'hardware': [{'id': server_id}], 'prices': [{'id': package[0]['prices'][0]['id']}] } return self.client['Product_Order'].placeOrder(product_order) def add_vlan_firewall(self, vlan_id, ha_enabled=False): """Creates a firewall for the specified vlan. :param int vlan_id: The ID of the vlan to create the firewall for :param bool ha_enabled: If True, an HA firewall will be created :returns: A dictionary containing the VLAN firewall order """ package = self.get_dedicated_package(ha_enabled) product_order = { 'complexType': 'SoftLayer_Container_Product_Order_Network_' 'Protection_Firewall_Dedicated', 'quantity': 1, 'packageId': 0, 'vlanId': vlan_id, 'prices': [{'id': package[0]['prices'][0]['id']}] } return self.client['Product_Order'].placeOrder(product_order) def _get_fwl_billing_item(self, firewall_id, dedicated=False): """Retrieves the billing item of the firewall. :param int firewall_id: Firewall ID to get the billing item for :param bool dedicated: whether the firewall is dedicated or standard :returns: A dictionary of the firewall billing item. """ mask = ('mask[id,billingItem[id]]') if dedicated: fwl_svc = self.client['Network_Vlan_Firewall'] else: fwl_svc = self.client['Network_Component_Firewall'] return fwl_svc.getObject(id=firewall_id, mask=mask) def _get_fwl_port_speed(self, server_id, is_virt=True): """Determines the appropriate speed for a firewall. :param int server_id: The ID of server the firewall is for :param bool is_virt: True if the server_id is for a virtual server :returns: a integer representing the Mbps speed of a firewall """ fwl_port_speed = 0 if is_virt: mask = ('primaryNetworkComponent[maxSpeed]') svc = self.client['Virtual_Guest'] primary = svc.getObject(mask=mask, id=server_id) fwl_port_speed = primary['primaryNetworkComponent']['maxSpeed'] else: mask = ('id,maxSpeed,networkComponentGroup.networkComponents') svc = self.client['Hardware_Server'] network_components = svc.getFrontendNetworkComponents( mask=mask, id=server_id) grouped = [interface['networkComponentGroup']['networkComponents'] for interface in network_components if 'networkComponentGroup' in interface] ungrouped = [interface for interface in network_components if 'networkComponentGroup' not in interface] # For each group, sum the maxSpeeds of each compoment in the # group. Put the sum for each in a new list group_speeds = [] for group in grouped: group_speed = 0 for interface in group: group_speed += interface['maxSpeed'] group_speeds.append(group_speed) # The max speed of all groups is the max of the list max_grouped_speed = max(group_speeds) max_ungrouped = 0 for interface in ungrouped: max_ungrouped = max(max_ungrouped, interface['maxSpeed']) fwl_port_speed = max(max_grouped_speed, max_ungrouped) return fwl_port_speed def get_firewalls(self): """Returns a list of all firewalls on the account. :returns: A list of firewalls on the current account. """ mask = ('firewallNetworkComponents,' 'networkVlanFirewall,' 'dedicatedFirewallFlag,' 'firewallGuestNetworkComponents,' 'firewallInterfaces,' 'firewallRules,' 'highAvailabilityFirewallFlag') return [firewall for firewall in self.account.getNetworkVlans(mask=mask) if has_firewall(firewall)] def get_standard_fwl_rules(self, firewall_id): """Get the rules of a standard firewall. :param integer firewall_id: the instance ID of the standard firewall :returns: A list of the rules. """ svc = self.client['Network_Component_Firewall'] return svc.getRules(id=firewall_id, mask=RULE_MASK) def get_dedicated_fwl_rules(self, firewall_id): """Get the rules of a dedicated firewall. :param integer firewall_id: the instance ID of the dedicated firewall :returns: A list of the rules. """ svc = self.client['Network_Vlan_Firewall'] return svc.getRules(id=firewall_id, mask=RULE_MASK) def edit_dedicated_fwl_rules(self, firewall_id, rules): """Edit the rules for dedicated firewall. :param integer firewall_id: the instance ID of the dedicated firewall :param list rules: the rules to be pushed on the firewall as defined by SoftLayer_Network_Firewall_Update_Request_Rule """ mask = ('mask[networkVlan[firewallInterfaces' '[firewallContextAccessControlLists]]]') svc = self.client['Network_Vlan_Firewall'] fwl = svc.getObject(id=firewall_id, mask=mask) network_vlan = fwl['networkVlan'] for fwl1 in network_vlan['firewallInterfaces']: if fwl1['name'] == 'inside': continue for control_list in fwl1['firewallContextAccessControlLists']: if control_list['direction'] == 'out': continue fwl_ctx_acl_id = control_list['id'] template = {'firewallContextAccessControlListId': fwl_ctx_acl_id, 'rules': rules} svc = self.client['Network_Firewall_Update_Request'] return svc.createObject(template) def edit_standard_fwl_rules(self, firewall_id, rules): """Edit the rules for standard firewall. :param integer firewall_id: the instance ID of the standard firewall :param dict rules: the rules to be pushed on the firewall """ rule_svc = self.client['Network_Firewall_Update_Request'] template = {'networkComponentFirewallId': firewall_id, 'rules': rules} return rule_svc.createObject(template) softlayer-python-5.0.1/SoftLayer/managers/hardware.py000066400000000000000000000654451267703721100227440ustar00rootroot00000000000000""" SoftLayer.hardware ~~~~~~~~~~~~~~~~~~ Hardware Manager/helpers :license: MIT, see LICENSE for more details. """ import socket import SoftLayer from SoftLayer.managers import ordering from SoftLayer import utils # Invalid names are ignored due to long method names and short argument names # pylint: disable=invalid-name, no-self-use EXTRA_CATEGORIES = ['pri_ipv6_addresses', 'static_ipv6_addresses', 'sec_ip_addresses'] class HardwareManager(utils.IdentifierMixin, object): """Manage hardware devices. Example:: # Initialize the Manager. # env variables. These can also be specified in ~/.softlayer, # or passed directly to SoftLayer.Client() # SL_USERNAME = YOUR_USERNAME # SL_API_KEY = YOUR_API_KEY import SoftLayer client = SoftLayer.Client() mgr = SoftLayer.HardwareManager(client) :param SoftLayer.API.Client client: an API client instance :param SoftLayer.managers.OrderingManager ordering_manager: an optional manager to handle ordering. If none is provided, one will be auto initialized. """ def __init__(self, client, ordering_manager=None): self.client = client self.hardware = self.client['Hardware_Server'] self.account = self.client['Account'] self.resolvers = [self._get_ids_from_ip, self._get_ids_from_hostname] if ordering_manager is None: self.ordering_manager = ordering.OrderingManager(client) else: self.ordering_manager = ordering_manager 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 cancelled. :param string reason: The reason code for the cancellation. This should come from :func:`get_cancellation_reasons`. :param string comment: An optional comment to include with the cancellation. """ # Get cancel reason reasons = self.get_cancellation_reasons() cancel_reason = reasons.get(reason, reasons['unneeded']) hw_billing = self.get_hardware(hardware_id, mask='mask[id, billingItem.id]') if 'billingItem' not in hw_billing: raise SoftLayer.SoftLayerError( "No billing item found for hardware") billing_id = hw_billing['billingItem']['id'] return self.client.call('Billing_Item', 'cancelItem', immediate, False, cancel_reason, comment, id=billing_id) 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 based on tags :param integer cpus: filter based on number of CPUS :param integer memory: filter based on amount of memory in gigabytes :param string hostname: filter based on hostname :param string domain: filter based on domain :param string datacenter: filter based on datacenter :param integer nic_speed: filter based on network speed (in MBPS) :param string public_ip: filter based on public ip address :param string private_ip: filter based on private ip address :param dict \\*\\*kwargs: response-level options (mask, limit, etc.) :returns: Returns a list of dictionaries representing the matching hardware. This list will contain both dedicated servers and bare metal computing instances Example:: # Using a custom object-mask. Will get ONLY what is specified # These will stem from the SoftLayer_Hardware_Server datatype object_mask = "mask[hostname,monitoringRobot[robotStatus]]" result = mgr.list_hardware(mask=object_mask) """ if 'mask' not in kwargs: hw_items = [ 'id', 'hostname', 'domain', 'hardwareStatusId', 'globalIdentifier', 'fullyQualifiedDomainName', 'processorPhysicalCoreAmount', 'memoryCapacity', 'primaryBackendIpAddress', 'primaryIpAddress', 'datacenter', ] server_items = [ 'activeTransaction[id, transactionStatus[friendlyName,name]]', ] kwargs['mask'] = ('[mask[%s],' ' mask(SoftLayer_Hardware_Server)[%s]]' % (','.join(hw_items), ','.join(server_items))) _filter = utils.NestedDict(kwargs.get('filter') or {}) if tags: _filter['hardware']['tagReferences']['tag']['name'] = { 'operation': 'in', 'options': [{'name': 'data', 'value': tags}], } if cpus: _filter['hardware']['processorPhysicalCoreAmount'] = ( utils.query_filter(cpus)) if memory: _filter['hardware']['memoryCapacity'] = utils.query_filter(memory) if hostname: _filter['hardware']['hostname'] = utils.query_filter(hostname) if domain: _filter['hardware']['domain'] = utils.query_filter(domain) if datacenter: _filter['hardware']['datacenter']['name'] = ( utils.query_filter(datacenter)) if nic_speed: _filter['hardware']['networkComponents']['maxSpeed'] = ( utils.query_filter(nic_speed)) if public_ip: _filter['hardware']['primaryIpAddress'] = ( utils.query_filter(public_ip)) if private_ip: _filter['hardware']['primaryBackendIpAddress'] = ( utils.query_filter(private_ip)) kwargs['filter'] = _filter.to_dict() return self.account.getHardware(**kwargs) 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,networkVlans[vlanNumber]]" # Object masks are optional result = mgr.get_hardware(hardware_id=1234,mask=object_mask) """ if 'mask' not in kwargs: items = [ 'id', 'globalIdentifier', 'fullyQualifiedDomainName', 'hostname', 'domain', 'provisionDate', 'hardwareStatus', 'processorPhysicalCoreAmount', 'memoryCapacity', 'notes', 'privateNetworkOnlyFlag', 'primaryBackendIpAddress', 'primaryIpAddress', 'networkManagementIpAddress', 'userData', 'datacenter', '''networkComponents[id, status, speed, maxSpeed, name, ipmiMacAddress, ipmiIpAddress, macAddress, primaryIpAddress, port, primarySubnet[id, netmask, broadcastAddress, networkIdentifier, gateway]]''', 'hardwareChassis[id,name]', 'activeTransaction[id, transactionStatus[friendlyName,name]]', '''operatingSystem[ softwareLicense[softwareDescription[manufacturer, name, version, referenceCode]], passwords[username,password]]''', 'billingItem.nextInvoiceTotalRecurringAmount', 'hourlyBillingFlag', 'tagReferences[id,tag[name,id]]', 'networkVlans[id,vlanNumber,networkSpace]', 'billingItem.orderItem.order.userRecord[username]', 'remoteManagementAccounts[username,password]', ] kwargs['mask'] = "mask[%s]" % ','.join(items) return self.hardware.getObject(id=hardware_id, **kwargs) 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_url: The URI of the post-install script to run after reload :param list ssh_keys: The SSH keys to add to the root user """ config = {} if post_uri: config['customProvisionScriptUri'] = post_uri if ssh_keys: config['sshKeyIds'] = [key_id for key_id in ssh_keys] return self.hardware.reloadOperatingSystem('FORCE', config, id=hardware_id) def rescue(self, hardware_id): """Reboot a server into the a recsue kernel. :param integer instance_id: the server ID to rescue Example:: result = mgr.rescue(1234) """ return self.hardware.bootToRescueLayer(id=hardware_id) 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. False indicates the private interface. :param int speed: The port speed to set. .. warning:: A port speed of 0 will disable the interface. Example:: #change the Public interface to 10Mbps on instance 12345 result = mgr.change_port_speed(hardware_id=12345, public=True, speed=10) # result will be True or an Exception """ if public: return self.client.call('Hardware_Server', 'setPublicNetworkInterfaceSpeed', speed, id=hardware_id) else: return self.client.call('Hardware_Server', 'setPrivateNetworkInterfaceSpeed', speed, id=hardware_id) 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 :param string hostname: server hostname :param string domain: server domain name :param string location: location (datacenter) name :param string os: operating system name :param int port_speed: Port speed in Mbps :param list ssh_keys: list of ssh key ids :param string post_uri: The URI of the post-install script to run after reload :param boolean hourly: True if using hourly pricing (default). False for monthly. :param boolean no_public: True if this server should only have private interfaces :param list extras: List of extra feature names """ create_options = self._generate_create_dict(**kwargs) return self.client['Product_Order'].placeOrder(create_options) 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_cancellation_reasons(self): """Returns a dictionary of valid cancellation reasons. These can be used when cancelling a dedicated server via :func:`cancel_hardware`. """ return { 'unneeded': 'No longer needed', 'closing': 'Business closing down', 'cost': 'Server / Upgrade Costs', 'migrate_larger': 'Migrating to larger server', 'migrate_smaller': 'Migrating to smaller server', 'datacenter': 'Migrating to a different SoftLayer datacenter', 'performance': 'Network performance / latency', 'support': 'Support response / timing', 'sales': 'Sales process / upgrades', 'moving': 'Moving to competitor', } 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'], 'key': region['location']['location']['name'], }) # Sizes sizes = [] for preset in package['activePresets']: sizes.append({ 'name': preset['description'], 'key': preset['keyName'] }) # Operating systems operating_systems = [] for item in package['items']: if item['itemCategory']['categoryCode'] == 'os': operating_systems.append({ 'name': item['softwareDescription']['longDescription'], 'key': item['softwareDescription']['referenceCode'], }) # Port speeds port_speeds = [] for item in package['items']: if all([item['itemCategory']['categoryCode'] == 'port_speed', # Hide private options not _is_private_port_speed_item(item), # Hide unbonded options _is_bonded(item)]): port_speeds.append({ 'name': item['description'], 'key': item['capacity'], }) # Extras extras = [] for item in package['items']: if item['itemCategory']['categoryCode'] in EXTRA_CATEGORIES: extras.append({ 'name': item['description'], 'key': item['keyName'] }) return { 'locations': locations, 'sizes': sizes, 'operating_systems': operating_systems, 'port_speeds': port_speeds, 'extras': extras, } def _get_package(self): """Get the package related to simple hardware ordering.""" mask = ''' items[ keyName, capacity, description, attributes[id,attributeTypeKeyName], itemCategory[id,categoryCode], softwareDescription[id,referenceCode,longDescription], prices ], activePresets, regions[location[location[priceGroups]]] ''' package_type = 'BARE_METAL_CPU_FAST_PROVISION' packages = self.ordering_manager.get_packages_of_type([package_type], mask=mask) if len(packages) != 1: raise SoftLayer.SoftLayerError("Ordering package not found") return packages[0] def _generate_create_dict(self, size=None, hostname=None, domain=None, location=None, os=None, port_speed=None, ssh_keys=None, post_uri=None, hourly=True, no_public=False, extras=None): """Translates arguments into a dictionary for creating a server.""" extras = extras or [] package = self._get_package() location = _get_location(package, location) prices = [] for category in ['pri_ip_addresses', 'vpn_management', 'remote_management']: prices.append(_get_default_price_id(package['items'], option=category, hourly=hourly, location=location)) prices.append(_get_os_price_id(package['items'], os, location=location)) prices.append(_get_bandwidth_price_id(package['items'], hourly=hourly, no_public=no_public, location=location)) prices.append(_get_port_speed_price_id(package['items'], port_speed, no_public, location=location)) for extra in extras: prices.append(_get_extra_price_id(package['items'], extra, hourly, location=location)) hardware = { 'hostname': hostname, 'domain': domain, } order = { 'hardware': [hardware], 'location': location['keyname'], 'prices': [{'id': price} for price in prices], 'packageId': package['id'], 'presetId': _get_preset_id(package, size), 'useHourlyPricing': hourly, } if post_uri: order['provisionScripts'] = [post_uri] if ssh_keys: order['sshKeys'] = [{'sshKeyIds': ssh_keys}] return order 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): """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 the server via ip address. First try public ip, then private results = self.list_hardware(public_ip=ip, mask="id") if results: return [result['id'] for result in results] results = self.list_hardware(private_ip=ip, mask="id") if results: return [result['id'] for result in results] 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 edit :param string userdata: user data on the hardware to edit. If none exist it will be created :param string hostname: valid hostname :param string domain: valid domain name :param string notes: notes about this particular hardware :param string tags: tags to set on the hardware as a comma separated list. Use the empty string to remove all tags. Example:: # Change the hostname on instance 12345 to 'something' result = mgr.edit(hardware_id=12345 , hostname="something") #result will be True or an Exception """ obj = {} if userdata: self.hardware.setUserMetadata([userdata], id=hardware_id) if tags is not None: self.hardware.setTags(tags, id=hardware_id) if hostname: obj['hostname'] = hostname if domain: obj['domain'] = domain if notes: obj['notes'] = notes if not obj: return True return self.hardware.editObject(obj, id=hardware_id) 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 minutes. :param int hardware_id: The ID of the hardware to have its firmware updated. :param bool ipmi: Update the ipmi firmware. :param bool raid_controller: Update the raid controller firmware. :param bool bios: Update the bios firmware. :param bool hard_drive: Update the hard drive firmware. Example:: # Check the servers active transactions to see progress result = mgr.update_firmware(hardware_id=1234) """ return self.hardware.createFirmwareUpdateTransaction( bool(ipmi), bool(raid_controller), bool(bios), bool(hard_drive), id=hardware_id) 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): continue if not _matches_location(price, location): continue return price['id'] raise SoftLayer.SoftLayerError( "Could not find valid price for extra option, '%s'" % key_name) 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('hourlyRecurringFee', 0)) == 0.0, float(price.get('recurringFee', 0)) == 0.0, _matches_billing(price, hourly), _matches_location(price, location)]): return price['id'] raise SoftLayer.SoftLayerError( "Could not find valid price for '%s' option" % option) 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.get('capacity', 0)) # Hourly and private only do pay-as-you-go bandwidth if any([utils.lookup(item, 'itemCategory', 'categoryCode') != 'bandwidth', (hourly or no_public) and capacity != 0.0, not (hourly or no_public) and capacity == 0.0]): continue for price in item['prices']: if not _matches_billing(price, hourly): continue if not _matches_location(price, location): continue return price['id'] raise SoftLayer.SoftLayerError( "Could not find valid price for bandwidth option") 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, 'softwareDescription', 'referenceCode') != os]): continue for price in item['prices']: if not _matches_location(price, location): continue return price['id'] raise SoftLayer.SoftLayerError("Could not find valid price for os: '%s'" % os) 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 capacity and if the item matches private only if any([int(utils.lookup(item, 'capacity')) != port_speed, _is_private_port_speed_item(item) != no_public, not _is_bonded(item)]): continue for price in item['prices']: if not _matches_location(price, location): continue return price['id'] raise SoftLayer.SoftLayerError( "Could not find valid price for port speed: '%s'" % port_speed) 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 group in location['location']['location']['priceGroups']: if group['id'] == price['locationGroupId']: return True return False def _is_private_port_speed_item(item): """Determine if the port speed item is private network only.""" for attribute in item['attributes']: if attribute['attributeTypeKeyName'] == 'IS_PRIVATE_NETWORK_ONLY': return True return False def _is_bonded(item): """Determine if the item refers to a bonded port.""" for attribute in item['attributes']: if attribute['attributeTypeKeyName'] == 'NON_LACP': return False return True 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']: if preset['keyName'] == size: return preset['id'] raise SoftLayer.SoftLayerError("Could not find valid size for: '%s'" % size) softlayer-python-5.0.1/SoftLayer/managers/image.py000066400000000000000000000114321267703721100222140ustar00rootroot00000000000000""" SoftLayer.image ~~~~~~~~~~~~~~~ Image Manager/helpers :license: MIT, see LICENSE for more details. """ from SoftLayer import utils IMAGE_MASK = ('id,accountId,name,globalIdentifier,blockDevices,parentId,' 'createDate,transaction') class ImageManager(utils.IdentifierMixin, object): """Manages server images. :param SoftLayer.API.Client client: an API client instance """ def __init__(self, client): self.client = client self.vgbdtg = self.client['Virtual_Guest_Block_Device_Template_Group'] self.resolvers = [self._get_ids_from_name_public, self._get_ids_from_name_private] 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.getObject(id=image_id, **kwargs) def delete_image(self, image_id): """Deletes the specified image. :param int image_id: The ID of the image. """ self.vgbdtg.deleteObject(id=image_id) 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: kwargs['mask'] = IMAGE_MASK _filter = utils.NestedDict(kwargs.get('filter') or {}) if name: _filter['privateBlockDeviceTemplateGroups']['name'] = ( utils.query_filter(name)) if guid: _filter['privateBlockDeviceTemplateGroups']['globalIdentifier'] = ( utils.query_filter(guid)) kwargs['filter'] = _filter.to_dict() account = self.client['Account'] return account.getPrivateBlockDeviceTemplateGroups(**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: kwargs['mask'] = IMAGE_MASK _filter = utils.NestedDict(kwargs.get('filter') or {}) if name: _filter['name'] = utils.query_filter(name) if guid: _filter['globalIdentifier'] = utils.query_filter(guid) kwargs['filter'] = _filter.to_dict() return self.vgbdtg.getPublicImages(**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. """ obj = {} if name: obj['name'] = name if note: obj['note'] = note if obj: self.vgbdtg.editObject(obj, id=image_id) if tag: self.vgbdtg.setTags(str(tag), id=image_id) return bool(name or note or tag) def import_image_from_uri(self, name, uri, os_code=None, note=None): """Import a new image from object storage. :param string name: Name of the new image :param string uri: The URI for an object storage object (.vhd/.iso file) of the format: swift://@// :param string os_code: The reference code of the operating system :param string note: Note to add to the image """ return self.vgbdtg.createFromExternalSource({ 'name': name, 'note': note, 'operatingSystemReferenceCode': os_code, 'uri': uri, }) def export_image_to_uri(self, image_id, uri): """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://@// """ return self.vgbdtg.copyToExternalSource({'uri': uri}, id=image_id) softlayer-python-5.0.1/SoftLayer/managers/iscsi.py000066400000000000000000000132551267703721100222510ustar00rootroot00000000000000""" SoftLayer.iscsi ~~~~~~~~~~~~~~~ ISCSI Manager/helpers :license: MIT, see LICENSE for more details. """ from SoftLayer import exceptions from SoftLayer import utils class ISCSIManager(utils.IdentifierMixin, object): """Manages iSCSI storages.""" def __init__(self, client): self.configuration = {} self.client = client self.iscsi_svc = self.client['Network_Storage_Iscsi'] self.product_order = self.client['Product_Order'] def _find_item_prices(self, size, categorycode=''): """Retrieves the Item Price IDs.""" item_prices = self.client['Product_Package'].getItems( id=0, mask='id,capacity,prices[id]', filter={ 'items': { 'capacity': {'operation': int(size)}, 'categories': { 'categoryCode': {'operation': categorycode} }}}) for item_price in item_prices: for price in item_price['prices']: return price['id'] raise exceptions.SoftLayerError( "Could not find a valid price with for the given size") def _build_order(self, item_price, location): """Returns a dict appropriate for Product_Order::placeOrder().""" location_id = self._get_location_id(location) order = { 'complexType': 'SoftLayer_Container_Product_Order_Network_Storage_Iscsi', 'location': location_id, 'packageId': 0, # storage package 'prices': [{'id': item_price}], 'quantity': 1 } return order def _get_location_id(self, location): """Returns location id of datacenter for ProductOrder::placeOrder().""" loc_svc = self.client['Location_Datacenter'] datacenters = loc_svc.getDatacenters(mask='mask[longName,id,name]') for datacenter in datacenters: if datacenter['name'] == location: location = datacenter['id'] return location raise ValueError('Invalid datacenter name specified.') def create_iscsi(self, size=None, location=None): """Places an order for iSCSI volume. :param integer size: size of iSCSI volume to create :param string location: datacenter to use to create volume in """ item_price = self._find_item_prices(int(size), categorycode='iscsi') iscsi_order = self._build_order(item_price, location) return self.product_order.placeOrder(iscsi_order) def list_iscsi(self): """List iSCSI volume.""" account = self.client['Account'] iscsi_list = account.getIscsiNetworkStorage( mask='eventCount,serviceResource[datacenter.name]') return iscsi_list def get_iscsi(self, volume_id, **kwargs): """Get details about a iSCSI storage. :param integer volume_id: the volume ID :returns: A dictionary containing a large amount of information about the specified storage. """ if 'mask' not in kwargs: items = [ 'id', 'serviceResourceName', 'createDate', 'nasType', 'capacityGb', 'snapshotCapacityGb', 'mountableFlag', 'serviceResourceBackendIpAddress', 'billingItem', 'notes', 'username', 'password' ] kwargs['mask'] = "mask[%s]" % ','.join(items) return self.iscsi_svc.getObject(id=volume_id, **kwargs) def cancel_iscsi(self, volume_id, reason='unNeeded', immediate=False): """Cancels the given iSCSI volume. :param integer volume_id: the volume ID """ iscsi = self.get_iscsi( volume_id, mask='mask[id,capacityGb,username,password,billingItem[id]]') billingitemid = iscsi['billingItem']['id'] self.client['Billing_Item'].cancelItem( immediate, True, reason, id=billingitemid) def create_snapshot(self, volume_id, notes='No longer needed'): """Orders a snapshot for given volume. :param integer volume_id: the volume ID """ self.iscsi_svc.createSnapshot(notes, id=volume_id) def create_snapshot_space(self, volume_id, capacity): """Orders a snapshot space for given volume. :param integer volume_id: the volume ID :param integer capacity: capacity in ~GB """ item_price = self._find_item_prices( int(capacity), categorycode='iscsi_snapshot_space') result = self.get_iscsi( volume_id, mask='mask[id,capacityGb,serviceResource[datacenter]]') snapshotspaceorder = { 'complexType': 'SoftLayer_Container_Product_Order_\ Network_Storage_Iscsi_SnapshotSpace', 'location': result['serviceResource']['datacenter']['id'], 'packageId': 0, 'prices': [{'id': item_price}], 'quantity': 1, 'volumeId': volume_id} self.product_order.placeOrder(snapshotspaceorder) def delete_snapshot(self, snapshot_id): """Deletes the given snapshot. :params: integer snapshot_id: the snapshot ID """ self.iscsi_svc.deleteObject(id=snapshot_id) def restore_from_snapshot(self, volume_id, snapshot_id): """Restore the volume to snapshot's contents. :params: imteger volume_id: the volume ID :params: integer snapshot_id: the snapshot ID """ self.iscsi_svc.restoreFromSnapshot(snapshot_id, id=volume_id) softlayer-python-5.0.1/SoftLayer/managers/load_balancer.py000066400000000000000000000311251267703721100237010ustar00rootroot00000000000000""" SoftLayer.load_balancer ~~~~~~~~~~~~~~~~~~~~~~~ Load Balancer Manager/helpers :license: MIT, see LICENSE for more details. """ from SoftLayer import utils class LoadBalancerManager(utils.IdentifierMixin, object): """Manages load balancers. :param SoftLayer.API.Client client: the API client instance """ def __init__(self, client): self.client = client self.account = self.client['Account'] self.prod_pkg = self.client['Product_Package'] self.lb_svc = self.client['Network_Application_Delivery_Controller_' 'LoadBalancer_VirtualIpAddress'] def get_lb_pkgs(self): """Retrieves the local load balancer packages. :returns: A dictionary containing the load balancer packages """ _filter = {'items': {'description': utils.query_filter('*Load Balancer*')}} packages = self.prod_pkg.getItems(id=0, filter=_filter) pkgs = [] for package in packages: if not package['description'].startswith('Global'): pkgs.append(package) return pkgs def get_hc_types(self): """Retrieves the health check type values. :returns: A dictionary containing the health check types """ svc = self.client['Network_Application_Delivery_Controller_' 'LoadBalancer_Health_Check_Type'] return svc.getAllObjects() def get_routing_methods(self): """Retrieves the load balancer routing methods. :returns: A dictionary containing the load balancer routing methods """ svc = self.client['Network_Application_Delivery_Controller_' 'LoadBalancer_Routing_Method'] return svc.getAllObjects() def get_routing_types(self): """Retrieves the load balancer routing types. :returns: A dictionary containing the load balancer routing types """ svc = self.client['Network_Application_Delivery_Controller_' 'LoadBalancer_Routing_Type'] return svc.getAllObjects() def _get_location(self, datacenter_name): """Returns the location of the specified datacenter. :param string datacenter_name: The datacenter to create the loadbalancer in :returns: the location id of the given datacenter """ datacenters = self.client['Location'].getDataCenters() for datacenter in datacenters: if datacenter['name'] == datacenter_name: return datacenter['id'] return 'FIRST_AVAILABLE' def cancel_lb(self, loadbal_id): """Cancels the specified load balancer. :param int loadbal_id: Load Balancer ID to be cancelled. """ lb_billing = self.lb_svc.getBillingItem(id=loadbal_id) billing_id = lb_billing['id'] billing_item = self.client['Billing_Item'] return billing_item.cancelService(id=billing_id) def add_local_lb(self, price_item_id, datacenter): """Creates a local load balancer in the specified data center. :param int price_item_id: The price item ID for the load balancer :param string datacenter: The datacenter to create the loadbalancer in :returns: A dictionary containing the product order """ product_order = { 'complexType': 'SoftLayer_Container_Product_Order_Network_' 'LoadBalancer', 'quantity': 1, 'packageId': 0, "location": self._get_location(datacenter), 'prices': [{'id': price_item_id}] } return self.client['Product_Order'].placeOrder(product_order) def get_local_lbs(self): """Returns a list of all local load balancers on the account. :returns: A list of all local load balancers on the current account. """ mask = 'loadBalancerHardware[datacenter],ipAddress' return self.account.getAdcLoadBalancers(mask=mask) def get_local_lb(self, loadbal_id, **kwargs): """Returns a specified local load balancer given the id. :param int loadbal_id: The id of the load balancer to retrieve :returns: A dictionary containing the details of the load balancer """ if 'mask' not in kwargs: kwargs['mask'] = ('loadBalancerHardware[datacenter], ' 'ipAddress, virtualServers[serviceGroups' '[routingMethod,routingType,services' '[healthChecks[type], groupReferences,' ' ipAddress]]]') return self.lb_svc.getObject(id=loadbal_id, **kwargs) def delete_service(self, service_id): """Deletes a service from the loadbal_id. :param int service_id: The id of the service to delete """ svc = self.client['Network_Application_Delivery_Controller_' 'LoadBalancer_Service'] return svc.deleteObject(id=service_id) def delete_service_group(self, group_id): """Deletes a service group from the loadbal_id. :param int group_id: The id of the service group to delete """ svc = self.client['Network_Application_Delivery_Controller_' 'LoadBalancer_VirtualServer'] return svc.deleteObject(id=group_id) def toggle_service_status(self, service_id): """Toggles the service status. :param int service_id: The id of the service to delete """ svc = self.client['Network_Application_Delivery_Controller_' 'LoadBalancer_Service'] return svc.toggleStatus(id=service_id) def edit_service(self, loadbal_id, service_id, ip_address_id=None, port=None, enabled=None, hc_type=None, weight=None): """Edits an existing service properties. :param int loadbal_id: The id of the loadbal where the service resides :param int service_id: The id of the service to edit :param string ip_address: The ip address of the service :param int port: the port of the service :param bool enabled: enable or disable the search :param int hc_type: The health check type :param int weight: the weight to give to the service """ _filter = { 'virtualServers': { 'serviceGroups': { 'services': {'id': utils.query_filter(service_id)}}}} mask = 'serviceGroups[services[groupReferences,healthChecks]]' virtual_servers = self.lb_svc.getVirtualServers(id=loadbal_id, filter=_filter, mask=mask) for service in virtual_servers[0]['serviceGroups'][0]['services']: if service['id'] == service_id: if enabled is not None: service['enabled'] = int(enabled) if port is not None: service['port'] = port if weight is not None: service['groupReferences'][0]['weight'] = weight if hc_type is not None: service['healthChecks'][0]['healthCheckTypeId'] = hc_type if ip_address_id is not None: service['ipAddressId'] = ip_address_id template = {'virtualServers': list(virtual_servers)} load_balancer = self.lb_svc.editObject(template, id=loadbal_id) return load_balancer def add_service(self, loadbal_id, service_group_id, ip_address_id, port=80, enabled=True, hc_type=21, weight=1): """Adds a new service to the service group. :param int loadbal_id: The id of the loadbal where the service resides :param int service_group_id: The group to add the service to :param int ip_address id: The ip address ID of the service :param int port: the port of the service :param bool enabled: Enable or disable the service :param int hc_type: The health check type :param int weight: the weight to give to the service """ kwargs = utils.NestedDict({}) kwargs['mask'] = ('virtualServers[' 'serviceGroups[services[groupReferences]]]') load_balancer = self.lb_svc.getObject(id=loadbal_id, **kwargs) virtual_servers = load_balancer['virtualServers'] for virtual_server in virtual_servers: if virtual_server['id'] == service_group_id: service_template = { 'enabled': int(enabled), 'port': port, 'ipAddressId': ip_address_id, 'healthChecks': [ { 'healthCheckTypeId': hc_type } ], 'groupReferences': [ { 'weight': weight } ] } services = virtual_server['serviceGroups'][0]['services'] services.append(service_template) return self.lb_svc.editObject(load_balancer, id=loadbal_id) def add_service_group(self, lb_id, allocation=100, port=80, routing_type=2, routing_method=10): """Adds a new service group to the load balancer. :param int loadbal_id: The id of the loadbal where the service resides :param int allocation: percent of connections to allocate toward the group :param int port: the port of the service group :param int routing_type: the routing type to set on the service group :param int routing_method: The routing method to set on the group """ mask = 'virtualServers[serviceGroups[services[groupReferences]]]' load_balancer = self.lb_svc.getObject(id=lb_id, mask=mask) service_template = { 'port': port, 'allocation': allocation, 'serviceGroups': [ { 'routingTypeId': routing_type, 'routingMethodId': routing_method } ] } load_balancer['virtualServers'].append(service_template) return self.lb_svc.editObject(load_balancer, id=lb_id) def edit_service_group(self, loadbal_id, group_id, allocation=None, port=None, routing_type=None, routing_method=None): """Edit an existing service group. :param int loadbal_id: The id of the loadbal where the service resides :param int group_id: The id of the service group :param int allocation: the % of connections to allocate to the group :param int port: the port of the service group :param int routing_type: the routing type to set on the service group :param int routing_method: The routing method to set on the group """ mask = 'virtualServers[serviceGroups[services[groupReferences]]]' load_balancer = self.lb_svc.getObject(id=loadbal_id, mask=mask) virtual_servers = load_balancer['virtualServers'] for virtual_server in virtual_servers: if virtual_server['id'] == group_id: service_group = virtual_server['serviceGroups'][0] if allocation is not None: virtual_server['allocation'] = allocation if port is not None: virtual_server['port'] = port if routing_type is not None: service_group['routingTypeId'] = routing_type if routing_method is not None: service_group['routingMethodId'] = routing_method break return self.lb_svc.editObject(load_balancer, id=loadbal_id) def reset_service_group(self, loadbal_id, group_id): """Resets all the connections on the service group. :param int loadbal_id: The id of the loadbal :param int group_id: The id of the service group to reset """ _filter = {'virtualServers': {'id': utils.query_filter(group_id)}} virtual_servers = self.lb_svc.getVirtualServers(id=loadbal_id, filter=_filter, mask='serviceGroups') actual_id = virtual_servers[0]['serviceGroups'][0]['id'] svc = self.client['Network_Application_Delivery_Controller' '_LoadBalancer_Service_Group'] return svc.kickAllConnections(id=actual_id) softlayer-python-5.0.1/SoftLayer/managers/messaging.py000066400000000000000000000305751267703721100231200ustar00rootroot00000000000000""" SoftLayer.messaging ~~~~~~~~~~~~~~~~~~~ Manager for the SoftLayer Message Queue service :license: MIT, see LICENSE for more details. """ import json import requests.auth from SoftLayer import consts from SoftLayer import exceptions # pylint: disable=no-self-use ENDPOINTS = { "dal05": { "public": "dal05.mq.softlayer.net", "private": "dal05.mq.service.networklayer.com" } } class QueueAuth(requests.auth.AuthBase): """Message Queue authentication for requests. :param endpoint: endpoint URL :param username: SoftLayer username :param api_key: SoftLayer API Key :param auth_token: (optional) Starting auth token """ def __init__(self, endpoint, username, api_key, auth_token=None): self.endpoint = endpoint self.username = username self.api_key = api_key self.auth_token = auth_token def auth(self): """Authenticate.""" headers = { 'X-Auth-User': self.username, 'X-Auth-Key': self.api_key } resp = requests.post(self.endpoint, headers=headers) if resp.ok: self.auth_token = resp.headers['X-Auth-Token'] else: raise exceptions.Unauthenticated("Error while authenticating: %s" % resp.status_code) def handle_error(self, resp, **_): """Handle errors.""" resp.request.deregister_hook('response', self.handle_error) if resp.status_code == 503: resp.connection.send(resp.request) elif resp.status_code == 401: self.auth() resp.request.headers['X-Auth-Token'] = self.auth_token resp.connection.send(resp.request) def __call__(self, resp): """Attach auth token to the request. Do authentication if an auth token isn't available """ if not self.auth_token: self.auth() resp.register_hook('response', self.handle_error) resp.headers['X-Auth-Token'] = self.auth_token return resp class MessagingManager(object): """Manage SoftLayer Message Queue.""" def __init__(self, client): self.client = client def list_accounts(self, **kwargs): """List message queue accounts. :param dict \\*\\*kwargs: response-level options (mask, limit, etc.) """ if 'mask' not in kwargs: items = [ 'id', 'name', 'status', 'nodes', ] kwargs['mask'] = "mask[%s]" % ','.join(items) return self.client['Account'].getMessageQueueAccounts(**kwargs) def get_endpoint(self, datacenter=None, network=None): """Get a message queue endpoint based on datacenter/network type. :param datacenter: datacenter code :param network: network ('public' or 'private') """ if datacenter is None: datacenter = 'dal05' if network is None: network = 'public' try: host = ENDPOINTS[datacenter][network] return "https://%s" % host except KeyError: raise TypeError('Invalid endpoint %s/%s' % (datacenter, network)) def get_endpoints(self): """Get all known message queue endpoints.""" return ENDPOINTS def get_connection(self, account_id, datacenter=None, network=None): """Get connection to Message Queue Service. :param account_id: Message Queue Account id :param datacenter: Datacenter code :param network: network ('public' or 'private') """ if any([not self.client.auth, not getattr(self.client.auth, 'username', None), not getattr(self.client.auth, 'api_key', None)]): raise exceptions.SoftLayerError( 'Client instance auth must be BasicAuthentication.') client = MessagingConnection( account_id, endpoint=self.get_endpoint(datacenter, network)) client.authenticate(self.client.auth.username, self.client.auth.api_key) return client def ping(self, datacenter=None, network=None): """Ping a message queue endpoint.""" resp = requests.get('%s/v1/ping' % self.get_endpoint(datacenter, network)) resp.raise_for_status() return True class MessagingConnection(object): """Message Queue Service Connection. :param account_id: Message Queue Account id :param endpoint: Endpoint URL """ def __init__(self, account_id, endpoint=None): self.account_id = account_id self.endpoint = endpoint self.auth = None def _make_request(self, method, path, **kwargs): """Make request. Generally not called directly. :param method: HTTP Method :param path: resource Path :param dict \\*\\*kwargs: extra request arguments """ headers = { 'Content-Type': 'application/json', 'User-Agent': consts.USER_AGENT, } headers.update(kwargs.get('headers', {})) kwargs['headers'] = headers kwargs['auth'] = self.auth url = '/'.join((self.endpoint, 'v1', self.account_id, path)) resp = requests.request(method, url, **kwargs) try: resp.raise_for_status() except requests.HTTPError as ex: content = json.loads(ex.response.content) raise exceptions.SoftLayerAPIError(ex.response.status_code, content['message']) return resp def authenticate(self, username, api_key, auth_token=None): """Authenticate this connection using the given credentials. :param username: SoftLayer username :param api_key: SoftLayer API Key :param auth_token: (optional) Starting auth token """ auth_endpoint = '/'.join((self.endpoint, 'v1', self.account_id, 'auth')) auth = QueueAuth(auth_endpoint, username, api_key, auth_token=auth_token) auth.auth() self.auth = auth def stats(self, period='hour'): """Get account stats. :param period: 'hour', 'day', 'week', 'month' """ resp = self._make_request('get', 'stats/%s' % period) return resp.json() # QUEUE METHODS def get_queues(self, tags=None): """Get listing of queues. :param list tags: (optional) list of tags to filter by """ params = {} if tags: params['tags'] = ','.join(tags) resp = self._make_request('get', 'queues', params=params) return resp.json() def create_queue(self, queue_name, **kwargs): """Create Queue. :param queue_name: Queue Name :param dict \\*\\*kwargs: queue options """ queue = {} queue.update(kwargs) data = json.dumps(queue) resp = self._make_request('put', 'queues/%s' % queue_name, data=data) return resp.json() def modify_queue(self, queue_name, **kwargs): """Modify Queue. :param queue_name: Queue Name :param dict \\*\\*kwargs: queue options """ return self.create_queue(queue_name, **kwargs) def get_queue(self, queue_name): """Get queue details. :param queue_name: Queue Name """ resp = self._make_request('get', 'queues/%s' % queue_name) return resp.json() def delete_queue(self, queue_name, force=False): """Delete Queue. :param queue_name: Queue Name :param force: (optional) Force queue to be deleted even if there are pending messages """ params = {} if force: params['force'] = 1 self._make_request('delete', 'queues/%s' % queue_name, params=params) return True def push_queue_message(self, queue_name, body, **kwargs): """Create Queue Message. :param queue_name: Queue Name :param body: Message body :param dict \\*\\*kwargs: Message options """ message = {'body': body} message.update(kwargs) resp = self._make_request('post', 'queues/%s/messages' % queue_name, data=json.dumps(message)) return resp.json() def pop_messages(self, queue_name, count=1): """Pop messages from a queue. :param queue_name: Queue Name :param count: (optional) number of messages to retrieve """ resp = self._make_request('get', 'queues/%s/messages' % queue_name, params={'batch': count}) return resp.json() def pop_message(self, queue_name): """Pop a single message from a queue. If no messages are returned this returns None :param queue_name: Queue Name """ messages = self.pop_messages(queue_name, count=1) if messages['item_count'] > 0: return messages['items'][0] else: return None def delete_message(self, queue_name, message_id): """Delete a message. :param queue_name: Queue Name :param message_id: Message id """ self._make_request('delete', 'queues/%s/messages/%s' % (queue_name, message_id)) return True # TOPIC METHODS def get_topics(self, tags=None): """Get listing of topics. :param list tags: (optional) list of tags to filter by """ params = {} if tags: params['tags'] = ','.join(tags) resp = self._make_request('get', 'topics', params=params) return resp.json() def create_topic(self, topic_name, **kwargs): """Create Topic. :param topic_name: Topic Name :param dict \\*\\*kwargs: Topic options """ data = json.dumps(kwargs) resp = self._make_request('put', 'topics/%s' % topic_name, data=data) return resp.json() def modify_topic(self, topic_name, **kwargs): """Modify Topic. :param topic_name: Topic Name :param dict \\*\\*kwargs: Topic options """ return self.create_topic(topic_name, **kwargs) def get_topic(self, topic_name): """Get topic details. :param topic_name: Topic Name """ resp = self._make_request('get', 'topics/%s' % topic_name) return resp.json() def delete_topic(self, topic_name, force=False): """Delete Topic. :param topic_name: Topic Name :param force: (optional) Force topic to be deleted even if there are attached subscribers """ params = {} if force: params['force'] = 1 self._make_request('delete', 'topics/%s' % topic_name, params=params) return True def push_topic_message(self, topic_name, body, **kwargs): """Create Topic Message. :param topic_name: Topic Name :param body: Message body :param dict \\*\\*kwargs: Topic message options """ message = {'body': body} message.update(kwargs) resp = self._make_request('post', 'topics/%s/messages' % topic_name, data=json.dumps(message)) return resp.json() def get_subscriptions(self, topic_name): """Listing of subscriptions on a topic. :param topic_name: Topic Name """ resp = self._make_request('get', 'topics/%s/subscriptions' % topic_name) return resp.json() def create_subscription(self, topic_name, subscription_type, **kwargs): """Create Subscription. :param topic_name: Topic Name :param subscription_type: type ('queue' or 'http') :param dict \\*\\*kwargs: Subscription options """ resp = self._make_request( 'post', 'topics/%s/subscriptions' % topic_name, data=json.dumps({ 'endpoint_type': subscription_type, 'endpoint': kwargs})) return resp.json() def delete_subscription(self, topic_name, subscription_id): """Delete a subscription. :param topic_name: Topic Name :param subscription_id: Subscription id """ self._make_request('delete', 'topics/%s/subscriptions/%s' % (topic_name, subscription_id)) return True softlayer-python-5.0.1/SoftLayer/managers/metadata.py000066400000000000000000000107321267703721100227140ustar00rootroot00000000000000""" SoftLayer.metadata ~~~~~~~~~~~~~~~~~~ Metadata Manager/helpers :license: MIT, see LICENSE for more details. """ import SoftLayer from SoftLayer import consts from SoftLayer import exceptions from SoftLayer import transports METADATA_MAPPING = { 'backend_mac': {'call': 'BackendMacAddresses'}, 'datacenter': {'call': 'Datacenter'}, 'datacenter_id': {'call': 'DatacenterId'}, 'domain': {'call': 'Domain'}, 'frontend_mac': {'call': 'FrontendMacAddresses'}, 'fqdn': {'call': 'FullyQualifiedDomainName'}, 'hostname': {'call': 'Hostname'}, 'id': {'call': 'Id'}, 'primary_backend_ip': {'call': 'PrimaryBackendIpAddress'}, 'primary_ip': {'call': 'PrimaryIpAddress'}, 'primary_frontend_ip': {'call': 'PrimaryIpAddress'}, 'provision_state': {'call': 'ProvisionState'}, 'router': {'call': 'Router', 'param_req': True}, 'tags': {'call': 'Tags'}, 'user_data': {'call': 'UserMetadata'}, 'user_metadata': {'call': 'UserMetadata'}, 'vlan_ids': {'call': 'VlanIds', 'param_req': True}, 'vlans': {'call': 'Vlans', 'param_req': True}, } METADATA_ATTRIBUTES = METADATA_MAPPING.keys() class MetadataManager(object): """Provides an interface for the metadata service. This provides metadata about the resourse it is called from. See `METADATA_ATTRIBUTES` for full list of attributes. Usage: >>> import SoftLayer >>> client = SoftLayer.create_client_from_env() >>> from SoftLayer import MetadataManager >>> meta = MetadataManager(client) >>> meta.get('datacenter') 'dal05' >>> meta.get('fqdn') 'test.example.com' """ attribs = METADATA_MAPPING def __init__(self, client=None, timeout=5): if client is None: transport = transports.RestTransport( timeout=timeout, endpoint_url=consts.API_PRIVATE_ENDPOINT_REST, ) client = SoftLayer.BaseClient(transport=transport) self.client = client def get(self, name, param=None): """Retreive a metadata attribute. :param string name: name of the attribute to retrieve. See `attribs` :param param: Required parameter for some attributes """ if name not in self.attribs: raise exceptions.SoftLayerError('Unknown metadata attribute.') call_details = self.attribs[name] if call_details.get('param_req'): if not param: raise exceptions.SoftLayerError( 'Parameter required to get this attribute.') params = tuple() if param is not None: params = (param,) try: return self.client.call('Resource_Metadata', self.attribs[name]['call'], *params) except exceptions.SoftLayerAPIError as ex: if ex.faultCode == 404: return None raise ex def _get_network(self, kind, router=True, vlans=True, vlan_ids=True): """Wrapper for getting details about networks. :param string kind: network kind. Typically 'public' or 'private' :param boolean router: flag to include router information :param boolean vlans: flag to include vlan information :param boolean vlan_ids: flag to include vlan_ids """ network = {} macs = self.get('%s_mac' % kind) network['mac_addresses'] = macs if len(macs) == 0: return network if router: network['router'] = self.get('router', macs[0]) if vlans: network['vlans'] = self.get('vlans', macs[0]) if vlan_ids: network['vlan_ids'] = self.get('vlan_ids', macs[0]) return network def public_network(self, **kwargs): """Returns details about the public network. :param boolean router: True to return router details :param boolean vlans: True to return vlan details :param boolean vlan_ids: True to return vlan_ids """ return self._get_network('frontend', **kwargs) def private_network(self, **kwargs): """Returns details about the private network. :param boolean router: True to return router details :param boolean vlans: True to return vlan details :param boolean vlan_ids: True to return vlan_ids """ return self._get_network('backend', **kwargs) softlayer-python-5.0.1/SoftLayer/managers/network.py000066400000000000000000000374611267703721100226350ustar00rootroot00000000000000""" SoftLayer.network ~~~~~~~~~~~~~~~~~ Network Manager/helpers :license: MIT, see LICENSE for more details. """ import collections from SoftLayer import exceptions from SoftLayer import utils DEFAULT_SUBNET_MASK = ','.join(['hardware', 'datacenter', 'ipAddressCount', 'virtualGuests']) DEFAULT_VLAN_MASK = ','.join([ 'firewallInterfaces', 'hardwareCount', 'primaryRouter[id, fullyQualifiedDomainName, datacenter]', 'subnetCount', 'totalPrimaryIpAddressCount', 'virtualGuestCount', 'networkSpace', ]) class NetworkManager(object): """Manage Networks.""" def __init__(self, client): self.client = client self.account = client['Account'] self.vlan = client['Network_Vlan'] self.subnet = client['Network_Subnet'] self.network_storage = self.client['Network_Storage'] def add_global_ip(self, version=4, test_order=False): """Adds a global IP address to the account. :param int version: Specifies whether this is IPv4 or IPv6 :param bool test_order: If true, this will only verify the order. """ # This method is here to improve the public interface from a user's # perspective since ordering a single global IP through the subnet # interface is not intuitive. return self.add_subnet('global', version=version, test_order=test_order) def add_subnet(self, subnet_type, quantity=None, vlan_id=None, version=4, test_order=False): """Orders a new subnet :param str subnet_type: Type of subnet to add: private, public, global :param int quantity: Number of IPs in the subnet :param int vlan_id: VLAN id for the subnet to be placed into :param int version: 4 for IPv4, 6 for IPv6 :param bool test_order: If true, this will only verify the order. """ package = self.client['Product_Package'] category = 'sov_sec_ip_addresses_priv' desc = '' if version == 4: if subnet_type == 'global': quantity = 0 category = 'global_ipv4' elif subnet_type == 'public': category = 'sov_sec_ip_addresses_pub' else: category = 'static_ipv6_addresses' if subnet_type == 'global': quantity = 0 category = 'global_ipv6' desc = 'Global' elif subnet_type == 'public': desc = 'Portable' # In the API, every non-server item is contained within package ID 0. # This means that we need to get all of the items and loop through them # looking for the items we need based upon the category, quantity, and # item description. price_id = None quantity_str = str(quantity) for item in package.getItems(id=0, mask='itemCategory'): category_code = utils.lookup(item, 'itemCategory', 'categoryCode') if all([category_code == category, item.get('capacity') == quantity_str, version == 4 or (version == 6 and desc in item['description'])]): price_id = item['prices'][0]['id'] break if not price_id: raise TypeError('Invalid combination specified for ordering a' ' subnet.') order = { 'packageId': 0, 'prices': [{'id': price_id}], 'quantity': 1, # This is necessary in order for the XML-RPC endpoint to select the # correct order container 'complexType': 'SoftLayer_Container_Product_Order_Network_Subnet', } if subnet_type != 'global': order['endPointVlanId'] = vlan_id if test_order: return self.client['Product_Order'].verifyOrder(order) else: return self.client['Product_Order'].placeOrder(order) def assign_global_ip(self, global_ip_id, target): """Assigns a global IP address to a specified target. :param int global_ip_id: The ID of the global IP being assigned :param string target: The IP address to assign """ return self.client['Network_Subnet_IpAddress_Global'].route( target, id=global_ip_id) def cancel_global_ip(self, global_ip_id): """Cancels the specified global IP address. :param int id: The ID of the global IP to be cancelled. """ service = self.client['Network_Subnet_IpAddress_Global'] ip_address = service.getObject(id=global_ip_id, mask='billingItem') billing_id = ip_address['billingItem']['id'] return self.client['Billing_Item'].cancelService(id=billing_id) def cancel_subnet(self, subnet_id): """Cancels the specified subnet. :param int subnet_id: The ID of the subnet to be cancelled. """ subnet = self.get_subnet(subnet_id, mask='id, billingItem.id') if "billingItem" not in subnet: raise exceptions.SoftLayerError("subnet %s can not be cancelled" " " % subnet_id) billing_id = subnet['billingItem']['id'] return self.client['Billing_Item'].cancelService(id=billing_id) def edit_rwhois(self, abuse_email=None, address1=None, address2=None, city=None, company_name=None, country=None, first_name=None, last_name=None, postal_code=None, private_residence=None, state=None): """Edit rwhois record.""" update = {} for key, value in [('abuseEmail', abuse_email), ('address1', address1), ('address2', address2), ('city', city), ('companyName', company_name), ('country', country), ('firstName', first_name), ('lastName', last_name), ('privateResidenceFlag', private_residence), ('state', state), ('postalCode', postal_code)]: if value is not None: update[key] = value # If there's anything to update, update it if update: rwhois = self.get_rwhois() return self.client['Network_Subnet_Rwhois_Data'].editObject( update, id=rwhois['id']) return True def ip_lookup(self, ip_address): """Looks up an IP address and returns network information about it. :param string ip_address: An IP address. Can be IPv4 or IPv6 :returns: A dictionary of information about the IP """ obj = self.client['Network_Subnet_IpAddress'] return obj.getByIpAddress(ip_address, mask='hardware, virtualGuest') def get_rwhois(self): """Returns the RWhois information about the current account. :returns: A dictionary containing the account's RWhois information. """ return self.account.getRwhoisData() def get_subnet(self, subnet_id, **kwargs): """Returns information about a single subnet. :param string id: Either the ID for the subnet or its network identifier :returns: A dictionary of information about the subnet """ if 'mask' not in kwargs: kwargs['mask'] = DEFAULT_SUBNET_MASK return self.subnet.getObject(id=subnet_id, **kwargs) def get_vlan(self, vlan_id): """Returns information about a single VLAN. :param int id: The unique identifier for the VLAN :returns: A dictionary containing a large amount of information about the specified VLAN. """ return self.vlan.getObject(id=vlan_id, mask=DEFAULT_VLAN_MASK) def list_global_ips(self, version=None, identifier=None, **kwargs): """Returns a list of all global IP address records on the account. :param int version: Only returns IPs of this version (4 or 6) :param string identifier: If specified, the list will only contain the global ips matching this network identifier. """ if 'mask' not in kwargs: mask = ['destinationIpAddress[hardware, virtualGuest]', 'ipAddress'] kwargs['mask'] = ','.join(mask) _filter = utils.NestedDict({}) if version: ver = utils.query_filter(version) _filter['globalIpRecords']['ipAddress']['subnet']['version'] = ver if identifier: subnet_filter = _filter['globalIpRecords']['ipAddress']['subnet'] subnet_filter['networkIdentifier'] = utils.query_filter(identifier) kwargs['filter'] = _filter.to_dict() return self.account.getGlobalIpRecords(**kwargs) def list_subnets(self, identifier=None, datacenter=None, version=0, subnet_type=None, **kwargs): """Display a list of all subnets on the account. This provides a quick overview of all subnets including information about data center residence and the number of devices attached. :param string identifier: If specified, the list will only contain the subnet matching this network identifier. :param string datacenter: If specified, the list will only contain subnets in the specified data center. :param int version: Only returns subnets of this version (4 or 6). :param string subnet_type: If specified, it will only returns subnets of this type. :param dict \\*\\*kwargs: response-level options (mask, limit, etc.) """ if 'mask' not in kwargs: kwargs['mask'] = DEFAULT_SUBNET_MASK _filter = utils.NestedDict(kwargs.get('filter') or {}) if identifier: _filter['subnets']['networkIdentifier'] = ( utils.query_filter(identifier)) if datacenter: _filter['subnets']['datacenter']['name'] = ( utils.query_filter(datacenter)) if version: _filter['subnets']['version'] = utils.query_filter(version) if subnet_type: _filter['subnets']['subnetType'] = utils.query_filter(subnet_type) else: # This filters out global IPs from the subnet listing. _filter['subnets']['subnetType'] = {'operation': '!= GLOBAL_IP'} kwargs['filter'] = _filter.to_dict() return self.account.getSubnets(**kwargs) def list_vlans(self, datacenter=None, vlan_number=None, name=None, **kwargs): """Display a list of all VLANs on the account. This provides a quick overview of all VLANs including information about data center residence and the number of devices attached. :param string datacenter: If specified, the list will only contain VLANs in the specified data center. :param int vlan_number: If specified, the list will only contain the VLAN matching this VLAN number. :param int name: If specified, the list will only contain the VLAN matching this VLAN name. :param dict \\*\\*kwargs: response-level options (mask, limit, etc.) """ _filter = utils.NestedDict(kwargs.get('filter') or {}) if vlan_number: _filter['networkVlans']['vlanNumber'] = ( utils.query_filter(vlan_number)) if name: _filter['networkVlans']['name'] = utils.query_filter(name) if datacenter: _filter['networkVlans']['primaryRouter']['datacenter']['name'] = ( utils.query_filter(datacenter)) kwargs['filter'] = _filter.to_dict() if 'mask' not in kwargs: kwargs['mask'] = DEFAULT_VLAN_MASK return self.account.getNetworkVlans(**kwargs) def resolve_global_ip_ids(self, identifier): """Resolve global ip ids.""" return utils.resolve_ids(identifier, [self._list_global_ips_by_identifier]) def resolve_subnet_ids(self, identifier): """Resolve subnet ids.""" return utils.resolve_ids(identifier, [self._list_subnets_by_identifier]) def resolve_vlan_ids(self, identifier): """Resolve VLAN ids.""" return utils.resolve_ids(identifier, [self._list_vlans_by_name]) def summary_by_datacenter(self): """Summary of the networks on the account, grouped by data center. The resultant dictionary is primarily useful for statistical purposes. It contains count information rather than raw data. If you want raw information, see the :func:`list_vlans` method instead. :returns: A dictionary keyed by data center with the data containing a set of counts for subnets, hardware, virtual servers, and other objects residing within that data center. """ datacenters = collections.defaultdict(lambda: { 'hardware_count': 0, 'public_ip_count': 0, 'subnet_count': 0, 'virtual_guest_count': 0, 'vlan_count': 0, }) for vlan in self.list_vlans(): name = utils.lookup(vlan, 'primaryRouter', 'datacenter', 'name') datacenters[name]['vlan_count'] += 1 datacenters[name]['public_ip_count'] += ( vlan['totalPrimaryIpAddressCount']) datacenters[name]['subnet_count'] += vlan['subnetCount'] # NOTE(kmcdonald): Only count hardware/guests once if vlan.get('networkSpace') == 'PRIVATE': datacenters[name]['hardware_count'] += ( vlan['hardwareCount']) datacenters[name]['virtual_guest_count'] += ( vlan['virtualGuestCount']) return dict(datacenters) def unassign_global_ip(self, global_ip_id): """Unassigns a global IP address from a target. :param int id: The ID of the global IP being unassigned """ return self.client['Network_Subnet_IpAddress_Global'].unroute( id=global_ip_id) def _list_global_ips_by_identifier(self, identifier): """Returns a list of IDs of the global IP matching the identifier. :param string identifier: The identifier to look up :returns: List of matching IDs """ results = self.list_global_ips(identifier=identifier, mask='id') return [result['id'] for result in results] def _list_subnets_by_identifier(self, identifier): """Returns a list of IDs of the subnet matching the identifier. :param string identifier: The identifier to look up :returns: List of matching IDs """ identifier = identifier.split('/', 1)[0] results = self.list_subnets(identifier=identifier, mask='id') return [result['id'] for result in results] def _list_vlans_by_name(self, name): """Returns a list of IDs of VLANs which match the given VLAN name. :param string name: a VLAN name :returns: List of matching IDs """ results = self.list_vlans(name=name, mask='id') return [result['id'] for result in results] def get_nas_credentials(self, identifier, **kwargs): """Returns a list of IDs of VLANs which match the given VLAN name. :param integer instance_id: the instance ID :returns: A dictionary containing a large amount of information about the specified instance. """ result = self.network_storage.getObject(id=identifier, **kwargs) return result softlayer-python-5.0.1/SoftLayer/managers/object_storage.py000066400000000000000000000030331267703721100241220ustar00rootroot00000000000000""" SoftLayer.object_storage ~~~~~~~~~~~~~~~~~~~~~~~~ Object Storage Manager/helpers :license: MIT, see LICENSE for more details. """ LIST_ACCOUNTS_MASK = '''mask(SoftLayer_Network_Storage_Hub_Swift)[ id,username,notes ]''' ENDPOINT_MASK = '''mask(SoftLayer_Network_Storage_Hub_Swift)[ id,storageNodes[id,backendIpAddress,frontendIpAddress,datacenter] ]''' class ObjectStorageManager(object): """Manager for Object Storage.""" def __init__(self, client): self.client = client def list_accounts(self): """Lists your object storage accounts.""" _filter = { 'hubNetworkStorage': {'vendorName': {'operation': 'Swift'}}, } return self.client.call('Account', 'getHubNetworkStorage', mask=LIST_ACCOUNTS_MASK, filter=_filter) def list_endpoints(self): """Lists the known object storage endpoints.""" _filter = { 'hubNetworkStorage': {'vendorName': {'operation': 'Swift'}}, } endpoints = [] for node in self.client.call('Account', 'getHubNetworkStorage', mask=ENDPOINT_MASK, limit=1, filter=_filter)['storageNodes']: endpoints.append({ 'datacenter': node['datacenter'], 'public': node['frontendIpAddress'], 'private': node['backendIpAddress'], }) return endpoints softlayer-python-5.0.1/SoftLayer/managers/ordering.py000066400000000000000000000154031267703721100227450ustar00rootroot00000000000000""" SoftLayer.ordering ~~~~~~~~~~~~~~~~~~ Ordering Manager :license: MIT, see LICENSE for more details. """ class OrderingManager(object): """Manages hardware devices. :param SoftLayer.API.Client client: an API client instance """ def __init__(self, client): self.client = client def get_packages_of_type(self, package_types, mask=None): """Get packages that match a certain type. Each ordering package has a type, so return all packages that match the types we are looking for :param list package_types: List of strings representing the package type keynames we are interested in. :param string mask: Mask to specify the properties we want to retrieve """ package_service = self.client['Product_Package'] _filter = { 'type': { 'keyName': { 'operation': 'in', 'options': [ {'name': 'data', 'value': package_types} ], }, }, } packages = package_service.getAllObjects(mask=mask, filter=_filter) packages = self.filter_outlet_packages(packages) return packages @staticmethod def filter_outlet_packages(packages): """Remove packages designated as OUTLET. Those type of packages must be handled in a different way, and they are not supported at the moment. :param packages: Dictionary of packages. Name and description keys must be present in each of them. """ non_outlet_packages = [] for package in packages: if all(['OUTLET' not in package.get('description', '').upper(), 'OUTLET' not in package.get('name', '').upper()]): non_outlet_packages.append(package) return non_outlet_packages @staticmethod def get_only_active_packages(packages): """Return only active packages. If a package is active, it is eligible for ordering This will inspect the 'isActive' property on the provided packages :param packages Dictionary of packages, isActive key must be present """ active_packages = [] for package in packages: if package['isActive']: active_packages.append(package) return active_packages def get_package_by_type(self, package_type, mask=None): """Get a single package of a given type. Syntactic sugar to retrieve a single package of a given type. If multiple packages share the given type, this will return the first one returned by the API. If no packages are found, returns None :param package_type string representing the package type key name we are interested in """ packages = self.get_packages_of_type([package_type], mask) if len(packages) == 0: return None else: return packages.pop() def get_package_id_by_type(self, package_type): """Return the package ID of a Product Package with a given type. :param package_type string representing the package type key name we are interested in :raises ValueError when no package of the given type is found """ mask = "mask[id, name, description, isActive, type[keyName]]" package = self.get_package_by_type(package_type, mask) if package: return package['id'] else: raise ValueError("No package found for type: " + package_type) def get_quotes(self): """Retrieve a list of quotes. :return a list of SoftLayer_Billing_Order_Quote """ quotes = self.client['Account'].getActiveQuotes() return quotes def get_quote_details(self, quote_id): """Retrieve quote details. :param quote_id ID number of target quote """ quote = self.client['Billing_Order_Quote'].getObject(id=quote_id) return quote def get_order_container(self, quote_id): """Generate an order container from a quote object. :param quote_id ID number of target quote """ quote = self.client['Billing_Order_Quote'] container = quote.getRecalculatedOrderContainer(id=quote_id) return container['orderContainers'][0] def generate_order_template(self, quote_id, extra, quantity=1): """Generate a complete order template. :param int quote_id: ID of target quote :param list extra: List of dictionaries that have extra details about the order such as hostname or domain names for virtual servers or hardware nodes :param int quantity: Number of ~things~ to order """ container = self.get_order_container(quote_id) container['quantity'] = quantity # NOTE(kmcdonald): This will only work with virtualGuests and hardware. # There has to be a better way, since this is based on # an existing quote that supposedly knows about this # detail if container['packageId'] == 46: product_type = 'virtualGuests' else: product_type = 'hardware' if len(extra) != quantity: raise ValueError("You must specify extra for each server in the " "quote") container[product_type] = [] for extra_details in extra: container[product_type].append(extra_details) container['presetId'] = None return container def verify_quote(self, quote_id, extra, quantity=1): """Verifies that a quote order is valid. :param int quote_id: ID for the target quote :param list hostnames: hostnames of the servers :param string domain: domain of the new servers :param int quantity: Quantity to override default """ container = self.generate_order_template(quote_id, extra, quantity=quantity) return self.client['Product_Order'].verifyOrder(container) def order_quote(self, quote_id, extra, quantity=1): """Places an order using a quote :param int quote_id: ID for the target quote :param list hostnames: hostnames of the servers :param string domain: domain of the new server :param int quantity: Quantity to override default """ container = self.generate_order_template(quote_id, extra, quantity=quantity) return self.client['Product_Order'].placeOrder(container) softlayer-python-5.0.1/SoftLayer/managers/sshkey.py000066400000000000000000000051071267703721100224420ustar00rootroot00000000000000""" SoftLayer.sshkey ~~~~~~~~~~~~~~~~ SSH Key Manager/helpers :license: MIT, see LICENSE for more details. """ from SoftLayer import utils class SshKeyManager(utils.IdentifierMixin, object): """Manages account SSH keys. :param SoftLayer.API.Client client: an API client instance """ def __init__(self, client): self.client = client self.sshkey = client['Security_Ssh_Key'] self.resolvers = [self._get_ids_from_label] def add_key(self, key, label, notes=None): """Adds a new SSH key to the account. :param string key: The SSH key to add :param string label: The label for the key :returns: A dictionary of the new key's information. """ order = { 'key': key, 'label': label, 'notes': notes, } return self.sshkey.createObject(order) def delete_key(self, key_id): """Permanently deletes an SSH key from the account. :param int key_id: The ID of the key to delete """ return self.sshkey.deleteObject(id=key_id) def edit_key(self, key_id, label=None, notes=None): """Edits information about an SSH key. :param int key_id: The ID of the key to edit :param string label: The new label for the key :param string notes: Notes to set or change on the key :returns: A Boolean indicating success or failure """ data = {} if label: data['label'] = label if notes: data['notes'] = notes return self.sshkey.editObject(data, id=key_id) def get_key(self, key_id): """Returns full information about a single SSH key. :param int key_id: The ID of the key to retrieve :returns: A dictionary of information about the key """ return self.sshkey.getObject(id=key_id) def list_keys(self, label=None): """Lists all SSH keys on the account. :param string label: Filter list based on SSH key label :returns: A list of dictionaries with information about each key """ _filter = utils.NestedDict({}) if label: _filter['sshKeys']['label'] = utils.query_filter(label) return self.client['Account'].getSshKeys(filter=_filter.to_dict()) def _get_ids_from_label(self, label): """Return sshkey IDs which match the given label.""" keys = self.list_keys() results = [] for key in keys: if key['label'] == label: results.append(key['id']) return results softlayer-python-5.0.1/SoftLayer/managers/ssl.py000066400000000000000000000061261267703721100217370ustar00rootroot00000000000000""" SoftLayer.ssl ~~~~~~~~~~~~~ SSL Manager/helpers :license: MIT, see LICENSE for more details. """ class SSLManager(object): """Manages SSL certificates. :param SoftLayer.API.Client client: an API client instance Example:: # Initialize the Manager. # env variables. These can also be specified in ~/.softlayer, # or passed directly to SoftLayer.Client() # SL_USERNAME = YOUR_USERNAME # SL_API_KEY = YOUR_API_KEY import SoftLayer client = SoftLayer.Client() mgr = SoftLayer.SSLManager(client) """ def __init__(self, client): self.client = client self.ssl = self.client['Security_Certificate'] def list_certs(self, method='all'): """List all certificates. :param string method: The type of certificates to list. Options are 'all', 'expired', and 'valid'. :returns: A list of dictionaries representing the requested SSL certs. Example:: # Get all valid SSL certs certs = mgr.list_certs(method='valid') print certs """ ssl = self.client['Account'] methods = { 'all': 'getSecurityCertificates', 'expired': 'getExpiredSecurityCertificates', 'valid': 'getValidSecurityCertificates' } mask = "mask[id, commonName, validityDays, notes]" func = getattr(ssl, methods[method]) return func(mask=mask) def add_certificate(self, certificate): """Creates a new certificate. :param dict certificate: A dictionary representing the parts of the certificate. See developer.softlayer.com for more info. Example:: cert = ?? result = mgr.add_certificate(certificate=cert) """ return self.ssl.createObject(certificate) def remove_certificate(self, cert_id): """Removes a certificate. :param integer cert_id: a certificate ID to remove Example:: # Removes certificate with id 1234 result = mgr.remove_certificate(cert_id = 1234) """ return self.ssl.deleteObject(id=cert_id) def edit_certificate(self, certificate): """Updates a certificate with the included options. The provided dict must include an 'id' key and value corresponding to the certificate ID that should be updated. :param dict certificate: the certificate to update. Example:: # Updates the cert id 1234 cert['id'] = 1234 cert['certificate'] = ?? result = mgr.edit_certificate(certificate=cert) """ return self.ssl.editObject(certificate, id=certificate['id']) def get_certificate(self, cert_id): """Gets a certificate with the ID specified. :param integer cert_id: the certificate ID to retrieve Example:: cert = mgr.get_certificate(cert_id=1234) print(cert) """ return self.ssl.getObject(id=cert_id) softlayer-python-5.0.1/SoftLayer/managers/ticket.py000066400000000000000000000050531267703721100224170ustar00rootroot00000000000000""" SoftLayer.ticket ~~~~~~~~~~~~~~~~ Ticket Manager/helpers :license: MIT, see LICENSE for more details. """ from SoftLayer import utils class TicketManager(utils.IdentifierMixin, object): """Manages support Tickets. :param SoftLayer.API.Client client: an API client instance """ def __init__(self, client): self.client = client self.account = self.client['Account'] self.ticket = self.client['Ticket'] def list_tickets(self, open_status=True, closed_status=True): """List all tickets. :param boolean open_status: include open tickets :param boolean closed_status: include closed tickets """ mask = ('id, title, assignedUser[firstName, lastName],' 'createDate,lastEditDate,accountId,status') call = 'getTickets' if not all([open_status, closed_status]): if open_status: call = 'getOpenTickets' elif closed_status: call = 'getClosedTickets' return self.client.call('Account', call, mask=mask) def list_subjects(self): """List all tickets.""" return self.client['Ticket_Subject'].getAllObjects() def get_ticket(self, ticket_id): """Get details about a ticket. :param integer id: the ticket ID :returns: A dictionary containing a large amount of information about the specified ticket. """ mask = ('id, title, assignedUser[firstName, lastName],status,' 'createDate,lastEditDate,updates[entry,editor],updateCount') return self.ticket.getObject(id=ticket_id, mask=mask) def create_ticket(self, title=None, body=None, subject=None): """Create a new ticket. :param string title: title for the new ticket :param string body: body for the new ticket :param integer subject: id of the subject to be assigned to the ticket """ current_user = self.account.getCurrentUser() new_ticket = { 'subjectId': subject, 'contents': body, 'assignedUserId': current_user['id'], 'title': title, } created_ticket = self.ticket.createStandardTicket(new_ticket, body) return created_ticket def update_ticket(self, ticket_id=None, body=None): """Update a ticket. :param integer ticket_id: the id of the ticket to update :param string body: entry to update in the ticket """ return self.ticket.addUpdate({'entry': body}, id=ticket_id) softlayer-python-5.0.1/SoftLayer/managers/vs.py000066400000000000000000000761371267703721100215770ustar00rootroot00000000000000""" SoftLayer.vs ~~~~~~~~~~~~ VS Manager/helpers :license: MIT, see LICENSE for more details. """ import datetime import itertools import socket import time from SoftLayer import exceptions from SoftLayer.managers import ordering from SoftLayer import utils # pylint: disable=no-self-use class VSManager(utils.IdentifierMixin, object): """Manages Virtual Servers. :param SoftLayer.API.Client client: an API client instance :param SoftLayer.managers.OrderingManager ordering_manager: an optional manager to handle ordering. If none is provided, one will be auto initialized. Example:: # Initialize the VSManager. # env variables. These can also be specified in ~/.softlayer, # or passed directly to SoftLayer.Client() # SL_USERNAME = YOUR_USERNAME # SL_API_KEY = YOUR_API_KEY import SoftLayer client = SoftLayer.Client() mgr = SoftLayer.VSManager(client) """ def __init__(self, client, ordering_manager=None): self.client = client self.account = client['Account'] self.guest = client['Virtual_Guest'] self.resolvers = [self._get_ids_from_ip, self._get_ids_from_hostname] if ordering_manager is None: self.ordering_manager = ordering.OrderingManager(client) else: self.ordering_manager = ordering_manager def list_instances(self, hourly=True, monthly=True, tags=None, cpus=None, memory=None, hostname=None, domain=None, local_disk=None, datacenter=None, nic_speed=None, public_ip=None, private_ip=None, **kwargs): """Retrieve a list of all virtual servers on the account. Example:: # Print out a list of hourly instances in the DAL05 data center. for vsi in mgr.list_instances(hourly=True, datacenter='dal05'): print vsi['fullyQualifiedDomainName'], vsi['primaryIpAddress'] # Using a custom object-mask. Will get ONLY what is specified object_mask = "mask[hostname,monitoringRobot[robotStatus]]" for vsi in mgr.list_instances(mask=object_mask,hourly=True): print vsi :param boolean hourly: include hourly instances :param boolean monthly: include monthly instances :param list tags: filter based on list of tags :param integer cpus: filter based on number of CPUS :param integer memory: filter based on amount of memory :param string hostname: filter based on hostname :param string domain: filter based on domain :param string local_disk: filter based on local_disk :param string datacenter: filter based on datacenter :param integer nic_speed: filter based on network speed (in MBPS) :param string public_ip: filter based on public ip address :param string private_ip: filter based on private ip address :param dict \\*\\*kwargs: response-level options (mask, limit, etc.) :returns: Returns a list of dictionaries representing the matching virtual servers """ if 'mask' not in kwargs: items = [ 'id', 'globalIdentifier', 'hostname', 'domain', 'fullyQualifiedDomainName', 'primaryBackendIpAddress', 'primaryIpAddress', 'lastKnownPowerState.name', 'powerState', 'maxCpu', 'maxMemory', 'datacenter', 'activeTransaction.transactionStatus[friendlyName,name]', 'status', ] kwargs['mask'] = "mask[%s]" % ','.join(items) call = 'getVirtualGuests' if not all([hourly, monthly]): if hourly: call = 'getHourlyVirtualGuests' elif monthly: call = 'getMonthlyVirtualGuests' _filter = utils.NestedDict(kwargs.get('filter') or {}) if tags: _filter['virtualGuests']['tagReferences']['tag']['name'] = { 'operation': 'in', 'options': [{'name': 'data', 'value': tags}], } if cpus: _filter['virtualGuests']['maxCpu'] = utils.query_filter(cpus) if memory: _filter['virtualGuests']['maxMemory'] = utils.query_filter(memory) if hostname: _filter['virtualGuests']['hostname'] = utils.query_filter(hostname) if domain: _filter['virtualGuests']['domain'] = utils.query_filter(domain) if local_disk is not None: _filter['virtualGuests']['localDiskFlag'] = ( utils.query_filter(bool(local_disk))) if datacenter: _filter['virtualGuests']['datacenter']['name'] = ( utils.query_filter(datacenter)) if nic_speed: _filter['virtualGuests']['networkComponents']['maxSpeed'] = ( utils.query_filter(nic_speed)) if public_ip: _filter['virtualGuests']['primaryIpAddress'] = ( utils.query_filter(public_ip)) if private_ip: _filter['virtualGuests']['primaryBackendIpAddress'] = ( utils.query_filter(private_ip)) kwargs['filter'] = _filter.to_dict() func = getattr(self.account, call) return func(**kwargs) def get_instance(self, instance_id, **kwargs): """Get details about a virtual server instance. :param integer instance_id: the instance ID :returns: A dictionary containing a large amount of information about the specified instance. Example:: # Print out instance ID 12345. vsi = mgr.get_instance(12345) print vsi # Print out only FQDN and primaryIP for instance 12345 object_mask = "mask[fullyQualifiedDomainName,primaryIpAddress]" vsi = mgr.get_instance(12345, mask=mask) print vsi """ if 'mask' not in kwargs: items = [ 'id', 'globalIdentifier', 'fullyQualifiedDomainName', 'hostname', 'domain', 'createDate', 'modifyDate', 'provisionDate', 'notes', 'dedicatedAccountHostOnlyFlag', 'privateNetworkOnlyFlag', 'primaryBackendIpAddress', 'primaryIpAddress', '''networkComponents[id, status, speed, maxSpeed, name, macAddress, primaryIpAddress, port, primarySubnet]''', 'lastKnownPowerState.name', 'powerState', 'status', 'maxCpu', 'maxMemory', 'datacenter', 'activeTransaction[id, transactionStatus[friendlyName,name]]', 'lastOperatingSystemReload.id', 'blockDevices', 'blockDeviceTemplateGroup[id, name, globalIdentifier]', 'postInstallScriptUri', '''operatingSystem[passwords[username,password], softwareLicense.softwareDescription[ manufacturer,name,version, referenceCode]]''', 'hourlyBillingFlag', 'userData', 'billingItem.recurringFee', 'tagReferences[id,tag[name,id]]', 'networkVlans[id,vlanNumber,networkSpace]', 'billingItem.orderItem.order.userRecord[username]' ] kwargs['mask'] = "mask[%s]" % ','.join(items) return self.guest.getObject(id=instance_id, **kwargs) def get_create_options(self): """Retrieves the available options for creating a VS. :returns: A dictionary of creation options. Example:: # Prints out the create option dictionary options = mgr.get_create_options() print(options) """ return self.guest.getCreateObjectOptions() def cancel_instance(self, instance_id): """Cancel an instance immediately, deleting all its data. :param integer instance_id: the instance ID to cancel Example:: # Cancels instance 12345 mgr.cancel_instance(12345) """ return self.guest.deleteObject(id=instance_id) def reload_instance(self, instance_id, post_uri=None, ssh_keys=None, image_id=None): """Perform an OS reload of an instance. :param integer instance_id: the instance ID to reload :param string post_url: The URI of the post-install script to run after reload :param list ssh_keys: The SSH keys to add to the root user :param int image_id: The ID of the image to load onto the server .. warning:: This will reformat the primary drive. Post-provision script MUST be HTTPS for it to be executed. Example:: # Reload instance ID 12345 then run a custom post-provision script. # Post-provision script MUST be HTTPS for it to be executed. post_uri = 'https://somehost.com/bootstrap.sh' vsi = mgr.reload_instance(12345, post_uri=post_url) """ config = {} if post_uri: config['customProvisionScriptUri'] = post_uri if ssh_keys: config['sshKeyIds'] = [key_id for key_id in ssh_keys] if image_id: config['imageTemplateId'] = image_id return self.client.call('Virtual_Guest', 'reloadOperatingSystem', 'FORCE', config, id=instance_id) def _generate_create_dict( self, cpus=None, memory=None, hourly=True, hostname=None, domain=None, local_disk=True, datacenter=None, os_code=None, image_id=None, dedicated=False, public_vlan=None, private_vlan=None, userdata=None, nic_speed=None, disks=None, post_uri=None, private=False, ssh_keys=None): """Returns a dict appropriate to pass into Virtual_Guest::createObject See :func:`create_instance` for a list of available options. """ required = [cpus, memory, hostname, domain] mutually_exclusive = [ {'os_code': os_code, "image_id": image_id}, ] if not all(required): raise ValueError("cpu, memory, hostname, and domain are required") for mu_ex in mutually_exclusive: if all(mu_ex.values()): raise ValueError( 'Can only specify one of: %s' % (','.join(mu_ex.keys()))) data = { "startCpus": int(cpus), "maxMemory": int(memory), "hostname": hostname, "domain": domain, "localDiskFlag": local_disk, } data["hourlyBillingFlag"] = hourly if dedicated: data["dedicatedAccountHostOnlyFlag"] = dedicated if private: data['privateNetworkOnlyFlag'] = private if image_id: data["blockDeviceTemplateGroup"] = {"globalIdentifier": image_id} elif os_code: data["operatingSystemReferenceCode"] = os_code if datacenter: data["datacenter"] = {"name": datacenter} if public_vlan: data.update({ 'primaryNetworkComponent': { "networkVlan": {"id": int(public_vlan)}}}) if private_vlan: data.update({ "primaryBackendNetworkComponent": { "networkVlan": {"id": int(private_vlan)}}}) if userdata: data['userData'] = [{'value': userdata}] if nic_speed: data['networkComponents'] = [{'maxSpeed': nic_speed}] if disks: data['blockDevices'] = [ {"device": "0", "diskImage": {"capacity": disks[0]}} ] for dev_id, disk in enumerate(disks[1:], start=2): data['blockDevices'].append( { "device": str(dev_id), "diskImage": {"capacity": disk} } ) if post_uri: data['postInstallScriptUri'] = post_uri if ssh_keys: data['sshKeys'] = [{'id': key_id} for key_id in ssh_keys] return data def wait_for_transaction(self, instance_id, limit, delay=1): """Waits on a VS transaction for the specified amount of time. This is really just a wrapper for wait_for_ready(pending=True). Provided for backwards compatibility. :param int instance_id: The instance ID with the pending transaction :param int limit: The maximum amount of time to wait. :param int delay: The number of seconds to sleep before checks. Defaults to 1. """ return self.wait_for_ready(instance_id, limit, delay=delay, pending=True) def wait_for_ready(self, instance_id, limit, delay=1, pending=False): """Determine if a VS is ready and available. In some cases though, that can mean that no transactions are running. The default arguments imply a VS is operational and ready for use by having network connectivity and remote access is available. Setting ``pending=True`` will ensure future API calls against this instance will not error due to pending transactions such as OS Reloads and cancellations. :param int instance_id: The instance ID with the pending transaction :param int limit: The maximum amount of time to wait. :param int delay: The number of seconds to sleep before checks. Defaults to 1. :param bool pending: Wait for pending transactions not related to provisioning or reloads such as monitoring. Example:: # Will return once vsi 12345 is ready, or after 10 checks ready = mgr.wait_for_ready(12345, 10) """ until = time.time() + limit for new_instance in itertools.repeat(instance_id): mask = """id, lastOperatingSystemReload.id, activeTransaction.id,provisionDate""" instance = self.get_instance(new_instance, mask=mask) last_reload = utils.lookup(instance, 'lastOperatingSystemReload', 'id') active_transaction = utils.lookup(instance, 'activeTransaction', 'id') reloading = all(( active_transaction, last_reload, last_reload == active_transaction, )) # only check for outstanding transactions if requested outstanding = False if pending: outstanding = active_transaction # return True if the instance has only if the instance has # finished provisioning and isn't currently reloading the OS. if all([instance.get('provisionDate'), not reloading, not outstanding]): return True now = time.time() if now >= until: return False time.sleep(min(delay, until - now)) def verify_create_instance(self, **kwargs): """Verifies an instance creation command. Without actually placing an order. See :func:`create_instance` for a list of available options. Example:: new_vsi = { 'domain': u'test01.labs.sftlyr.ws', 'hostname': u'minion05', 'datacenter': u'hkg02', 'dedicated': False, 'private': False, 'cpus': 1, 'os_code' : u'UBUNTU_LATEST', 'hourly': True, 'ssh_keys': [1234], 'disks': ('100','25'), 'local_disk': True, 'memory': 1024 } vsi = mgr.verify_create_instance(**new_vsi) # vsi will be a SoftLayer_Container_Product_Order_Virtual_Guest # if your order is correct. Otherwise you will get an exception print vsi """ kwargs.pop('tags', None) create_options = self._generate_create_dict(**kwargs) return self.guest.generateOrderTemplate(create_options) def create_instance(self, **kwargs): """Creates a new virtual server instance. .. warning:: This will add charges to your account Example:: new_vsi = { 'domain': u'test01.labs.sftlyr.ws', 'hostname': u'minion05', 'datacenter': u'hkg02', 'dedicated': False, 'private': False, 'cpus': 1, 'os_code' : u'UBUNTU_LATEST', 'hourly': True, 'ssh_keys': [1234], 'disks': ('100','25'), 'local_disk': True, 'memory': 1024, 'tags': 'test, pleaseCancel' } vsi = mgr.create_instance(**new_vsi) # vsi will have the newly created vsi details if done properly. print vsi :param int cpus: The number of virtual CPUs to include in the instance. :param int memory: The amount of RAM to order. :param bool hourly: Flag to indicate if this server should be billed hourly (default) or monthly. :param string hostname: The hostname to use for the new server. :param string domain: The domain to use for the new server. :param bool local_disk: Flag to indicate if this should be a local disk (default) or a SAN disk. :param string datacenter: The short name of the data center in which the VS should reside. :param string os_code: The operating system to use. Cannot be specified if image_id is specified. :param int image_id: The ID of the image to load onto the server. Cannot be specified if os_code is specified. :param bool dedicated: Flag to indicate if this should be housed on a dedicated or shared host (default). This will incur a fee on your account. :param int public_vlan: The ID of the public VLAN on which you want this VS placed. :param int private_vlan: The ID of the private VLAN on which you want this VS placed. :param list disks: A list of disk capacities for this server. :param string post_uri: The URI of the post-install script to run after reload :param bool private: If true, the VS will be provisioned only with access to the private network. Defaults to false :param list ssh_keys: The SSH keys to add to the root user :param int nic_speed: The port speed to set :param string tags: tags to set on the VS as a comma separated list """ tags = kwargs.pop('tags', None) inst = self.guest.createObject(self._generate_create_dict(**kwargs)) if tags is not None: self.guest.setTags(tags, id=inst['id']) return inst def create_instances(self, config_list): """Creates multiple virtual server instances. This takes a list of dictionaries using the same arguments as create_instance(). .. warning:: This will add charges to your account Example:: # Define the instance we want to create. new_vsi = { 'domain': u'test01.labs.sftlyr.ws', 'hostname': u'multi-test', 'datacenter': u'hkg02', 'dedicated': False, 'private': False, 'cpus': 1, 'os_code' : u'UBUNTU_LATEST', 'hourly': True, 'ssh_keys': [87634], 'disks': ('100','25'), 'local_disk': True, 'memory': 1024, 'tags': 'test, pleaseCancel' } # using .copy() so we can make changes to individual nodes instances = [new_vsi.copy(), new_vsi.copy(), new_vsi.copy()] # give each its own hostname, not required. instances[0]['hostname'] = "multi-test01" instances[1]['hostname'] = "multi-test02" instances[2]['hostname'] = "multi-test03" vsi = mgr.create_instances(config_list=instances) #vsi will be a dictionary of all the new virtual servers print vsi """ tags = [conf.pop('tags', None) for conf in config_list] resp = self.guest.createObjects([self._generate_create_dict(**kwargs) for kwargs in config_list]) for instance, tag in zip(resp, tags): if tag is not None: self.guest.setTags(tag, id=instance['id']) return resp def change_port_speed(self, instance_id, public, speed): """Allows you to change the port speed of a virtual server's NICs. Example:: #change the Public interface to 10Mbps on instance 12345 result = mgr.change_port_speed(instance_id=12345, public=True, speed=10) # result will be True or an Exception :param int instance_id: The ID of the VS :param bool public: Flag to indicate which interface to change. True (default) means the public interface. False indicates the private interface. :param int speed: The port speed to set. .. warning:: A port speed of 0 will disable the interface. """ if public: return self.client.call('Virtual_Guest', 'setPublicNetworkInterfaceSpeed', speed, id=instance_id) else: return self.client.call('Virtual_Guest', 'setPrivateNetworkInterfaceSpeed', speed, id=instance_id) def _get_ids_from_hostname(self, hostname): """List VS ids which match the given hostname.""" results = self.list_instances(hostname=hostname, mask="id") return [result['id'] for result in results] def _get_ids_from_ip(self, ip_address): """List VS ids which match the given ip address.""" try: # Does it look like an ip address? socket.inet_aton(ip_address) except socket.error: return [] # Find the VS via ip address. First try public ip, then private results = self.list_instances(public_ip=ip_address, mask="id") if results: return [result['id'] for result in results] results = self.list_instances(private_ip=ip_address, mask="id") if results: return [result['id'] for result in results] def edit(self, instance_id, userdata=None, hostname=None, domain=None, notes=None, tags=None): """Edit hostname, domain name, notes, and/or the user data of a VS. Parameters set to None will be ignored and not attempted to be updated. :param integer instance_id: the instance ID to edit :param string userdata: user data on VS to edit. If none exist it will be created :param string hostname: valid hostname :param string domain: valid domain namem :param string notes: notes about this particular VS :param string tags: tags to set on the VS as a comma separated list. Use the empty string to remove all tags. :returns: bool -- True or an Exception Example:: # Change the hostname on instance 12345 to 'something' result = mgr.edit(instance_id=12345 , hostname="something") #result will be True or an Exception """ obj = {} if userdata: self.guest.setUserMetadata([userdata], id=instance_id) if tags is not None: self.guest.setTags(tags, id=instance_id) if hostname: obj['hostname'] = hostname if domain: obj['domain'] = domain if notes: obj['notes'] = notes if not obj: return True return self.guest.editObject(obj, id=instance_id) def rescue(self, instance_id): """Reboot a VSI into the Xen recsue kernel. :param integer instance_id: the instance ID to rescue :returns: bool -- True or an Exception Example:: # Puts instance 12345 into rescue mode result = mgr.rescue(instance_id=12345) """ return self.guest.executeRescueLayer(id=instance_id) def capture(self, instance_id, name, additional_disks=False, notes=None): """Capture one or all disks from a VS to a SoftLayer image. Parameters set to None will be ignored and not attempted to be updated. :param integer instance_id: the instance ID to edit :param string name: name assigned to the image :param bool additional_disks: set to true to include all additional attached storage devices :param string notes: notes about this particular image :returns: dictionary -- information about the capture transaction. Example:: name = "Testing Images" notes = "Some notes about this image" result = mgr.capture(instance_id=12345, name=name, notes=notes) """ vsi = self.get_instance(instance_id) disk_filter = lambda x: x['device'] == '0' # Skip disk 1 (swap partition) and CD mounts if additional_disks: disk_filter = lambda x: (str(x['device']) != '1' and x['mountType'] != 'CD') disks = [block_device for block_device in vsi['blockDevices'] if disk_filter(block_device)] return self.guest.createArchiveTransaction( name, disks, notes, id=instance_id) def upgrade(self, instance_id, cpus=None, memory=None, nic_speed=None, public=True): """Upgrades a VS instance. Example:: # Upgrade instance 12345 to 4 CPUs and 4 GB of memory import SoftLayer client = SoftLayer.create_client_from_env() mgr = SoftLayer.VSManager(client) mgr.upgrade(12345, cpus=4, memory=4) :param int instance_id: Instance id of the VS to be upgraded :param int cpus: The number of virtual CPUs to upgrade to of a VS instance. :param bool public: CPU will be in Private/Public Node. :param int memory: RAM of the VS to be upgraded to. :param int nic_speed: The port speed to set :returns: bool """ package_items = self._get_package_items() prices = [] for option, value in {'cpus': cpus, 'memory': memory, 'nic_speed': nic_speed}.items(): if not value: continue price_id = self._get_price_id_for_upgrade(package_items, option, value, public) if not price_id: # Every option provided is expected to have a price raise exceptions.SoftLayerError( "Unable to find %s option with value %s" % (option, value)) prices.append({'id': price_id}) maintenance_window = datetime.datetime.now(utils.UTC()) order = { 'complexType': 'SoftLayer_Container_Product_Order_Virtual_Guest_' 'Upgrade', 'prices': prices, 'properties': [{ 'name': 'MAINTENANCE_WINDOW', 'value': maintenance_window.strftime("%Y-%m-%d %H:%M:%S%z") }], 'virtualGuests': [{'id': int(instance_id)}], } if prices: self.client['Product_Order'].placeOrder(order) return True return False def _get_package_items(self): """Following Method gets all the item ids related to VS.""" mask = [ 'description', 'capacity', 'prices[id,locationGroupId,categories[name,id,categoryCode]]' ] mask = "mask[%s]" % ','.join(mask) package_type = "VIRTUAL_SERVER_INSTANCE" package_id = self.ordering_manager.get_package_id_by_type(package_type) package_service = self.client['Product_Package'] return package_service.getItems(id=package_id, mask=mask) def _get_price_id_for_upgrade(self, package_items, option, value, public=True): """Find the price id for the option and value to upgrade. :param list package_items: Contains all the items related to an VS :param string option: Describes type of parameter to be upgraded :param int value: The value of the parameter to be upgraded :param bool public: CPU will be in Private/Public Node. """ option_category = { 'memory': 'ram', 'cpus': 'guest_core', 'nic_speed': 'port_speed' } category_code = option_category[option] for item in package_items: is_private = str(item['description']).startswith('Private') for price in item['prices']: if 'locationGroupId' in price and price['locationGroupId']: # Skip location based prices continue if 'categories' not in price: continue categories = price['categories'] for category in categories: if not (category['categoryCode'] == category_code and str(item['capacity']) == str(value)): continue if option == 'cpus': if public and not is_private: return price['id'] elif not public and is_private: return price['id'] elif option == 'nic_speed': if 'Public' in item['description']: return price['id'] else: return price['id'] softlayer-python-5.0.1/SoftLayer/shell/000077500000000000000000000000001267703721100200715ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/shell/__init__.py000066400000000000000000000000001267703721100221700ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/shell/cmd_env.py000066400000000000000000000007151267703721100220610ustar00rootroot00000000000000"""Print environment variables.""" # :license: MIT, see LICENSE for more details. import click from SoftLayer.CLI import environment from SoftLayer.CLI import formatting @click.command() @environment.pass_env def cli(env): """Print environment variables.""" filtered_vars = dict([(k, v) for k, v in env.vars.items() if not k.startswith('_')]) env.fout(formatting.iter_to_table(filtered_vars)) softlayer-python-5.0.1/SoftLayer/shell/cmd_exit.py000066400000000000000000000003101267703721100222310ustar00rootroot00000000000000"""Exit the shell.""" # :license: MIT, see LICENSE for more details. import click from SoftLayer.shell import core @click.command() def cli(): """Exit the shell.""" raise core.ShellExit() softlayer-python-5.0.1/SoftLayer/shell/cmd_help.py000066400000000000000000000017721267703721100222250ustar00rootroot00000000000000"""Print help text.""" # :license: MIT, see LICENSE for more details. import click from click import formatting from SoftLayer.CLI import core as cli_core from SoftLayer.CLI import environment from SoftLayer.shell import routes @click.command() @environment.pass_env @click.pass_context 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) details = (name, command.short_help) if name in dict(routes.ALL_ROUTES): shell_commands.append(details) else: commands.append(details) with formatter.section('Shell Commands'): formatter.write_dl(shell_commands) with formatter.section('Commands'): formatter.write_dl(commands) for line in formatter.buffer: env.out(line, newline=False) softlayer-python-5.0.1/SoftLayer/shell/completer.py000066400000000000000000000045671267703721100224510ustar00rootroot00000000000000""" SoftLayer.CLI.shell.completer ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Click completer for prompt_toolkit :license: MIT, see LICENSE for more details. """ import itertools import shlex import click from prompt_toolkit import completion as completion class ShellCompleter(completion.Completer): """Completer for the shell.""" def __init__(self, click_root): self.root = click_root def get_completions(self, document, complete_event): """Returns an iterator of completions for the shell.""" return _click_autocomplete(self.root, document.text_before_cursor) def _click_autocomplete(root, text): """Completer generator for click applications.""" try: parts = shlex.split(text) except ValueError: raise StopIteration location, incomplete = _click_resolve_command(root, parts) if not text.endswith(' ') and not incomplete and text: raise StopIteration if incomplete and not incomplete[0:2].isalnum(): for param in location.params: if not isinstance(param, click.Option): continue for opt in itertools.chain(param.opts, param.secondary_opts): if opt.startswith(incomplete): yield completion.Completion(opt, -len(incomplete), display_meta=param.help) elif isinstance(location, (click.MultiCommand, click.core.Group)): ctx = click.Context(location) commands = location.list_commands(ctx) for command in commands: if command.startswith(incomplete): cmd = location.get_command(ctx, command) yield completion.Completion(command, -len(incomplete), display_meta=cmd.short_help) def _click_resolve_command(root, parts): """Return the click command and the left over text given some vargs.""" location = root incomplete = '' for part in parts: incomplete = part if not part[0:2].isalnum(): continue try: next_location = location.get_command(click.Context(location), part) if next_location is not None: location = next_location incomplete = '' except AttributeError: break return location, incomplete softlayer-python-5.0.1/SoftLayer/shell/core.py000066400000000000000000000071311267703721100213750ustar00rootroot00000000000000""" SoftLayer.CLI.shell.core ~~~~~~~~~~~~~~~~~~~~~~~~ An interactive shell which exposes the CLI :license: MIT, see LICENSE for more details. """ from __future__ import print_function import copy import os import shlex import sys import traceback import click from prompt_toolkit import auto_suggest as p_auto_suggest from prompt_toolkit import history as p_history from prompt_toolkit import shortcuts as p_shortcuts from pygments import token from SoftLayer.CLI import core from SoftLayer.CLI import environment from SoftLayer.shell import completer from SoftLayer.shell import routes # pylint: disable=broad-except class ShellExit(Exception): """Exception raised to quit the shell.""" pass @click.command() @environment.pass_env @click.pass_context 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'] = 0 # Set up prompt_toolkit settings app_path = click.get_app_dir('softlayer_shell') if not os.path.exists(app_path): os.makedirs(app_path) history = p_history.FileHistory(os.path.join(app_path, 'history')) complete = completer.ShellCompleter(core.cli) while True: def get_prompt_tokens(_): """Returns tokens for the command prompt""" tokens = [] try: tokens.append((token.Token.Username, env.client.auth.username)) tokens.append((token.Token.At, "@")) except AttributeError: pass tokens.append((token.Token.Host, "slcli-shell")) if env.vars['last_exit_code']: tokens.append((token.Token.ErrorPrompt, '> ')) else: tokens.append((token.Token.Prompt, '> ')) return tokens try: line = p_shortcuts.prompt( completer=complete, history=history, auto_suggest=p_auto_suggest.AutoSuggestFromHistory(), get_prompt_tokens=get_prompt_tokens, ) # Parse arguments try: args = shlex.split(line) except ValueError as ex: print("Invalid Command: %s" % ex) continue if not args: continue # Run Command try: # Reset client so that the client gets refreshed env.client = None core.main(args=list(get_env_args(env)) + args, obj=env, prog_name="", reraise_exceptions=True) except SystemExit as ex: env.vars['last_exit_code'] = ex.code except EOFError: return except ShellExit: return except Exception as ex: env.vars['last_exit_code'] = 1 traceback.print_exc(file=sys.stderr) except KeyboardInterrupt: env.vars['last_exit_code'] = 130 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 elif val is None: continue else: yield '--%s=%s' % (arg, val) softlayer-python-5.0.1/SoftLayer/shell/routes.py000066400000000000000000000006121267703721100217630ustar00rootroot00000000000000""" SoftLayer.CLI.routes ~~~~~~~~~~~~~~~~~~~ Routes for shell-specific commands :license: MIT, see LICENSE for more details. """ ALL_ROUTES = [ ('exit', 'SoftLayer.shell.cmd_exit:cli'), ('shell-help', 'SoftLayer.shell.cmd_help:cli'), ('env', 'SoftLayer.shell.cmd_env:cli'), ] ALL_ALIASES = { '?': 'shell-help', 'help': 'shell-help', 'quit': 'exit', } softlayer-python-5.0.1/SoftLayer/testing/000077500000000000000000000000001267703721100204375ustar00rootroot00000000000000softlayer-python-5.0.1/SoftLayer/testing/__init__.py000066400000000000000000000125311267703721100225520ustar00rootroot00000000000000""" SoftLayer.testing ~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ # Disable pylint import error and too many methods error # pylint: disable=invalid-name import logging import os.path from click import testing import mock import testtools import SoftLayer from SoftLayer.CLI import core from SoftLayer.CLI import environment from SoftLayer.testing import xmlrpc FIXTURE_PATH = os.path.abspath(os.path.join(__file__, '..', '..', 'fixtures')) class MockableTransport(object): """Transport which is able to mock out specific API calls.""" def __init__(self, transport): self.calls = [] self.mocked = {} self.transport = transport def __call__(self, call): self._record_call(call) key = _mock_key(call.service, call.method) if key in self.mocked: return self.mocked[key](call) # Fall back to another transport (usually with fixtures) return self.transport(call) def set_mock(self, service, method): """Create a mock and return the mock object for the specific API call. :param service: API service to mock :param method: API method to mock """ _mock = mock.MagicMock() self.mocked[_mock_key(service, method)] = _mock return _mock def clear(self): """Clear out mocks and call history.""" self.calls = [] self.mocked = {} def _record_call(self, call): """Record and log the API call (for later assertions).""" self.calls.append(call) details = [] for prop in ['identifier', 'args', 'mask', 'filter', 'limit', 'offset']: details.append('%s=%r' % (prop, getattr(call, prop))) logging.info('%s::%s called; %s', call.service, call.method, '; '.join(details)) def _mock_key(service, method): """Key to address a mock object in MockableTransport.""" return '%s::%s' % (service, method) class TestCase(testtools.TestCase): """Testcase class with PEP-8 compatable method names.""" @classmethod def setUpClass(cls): """Stand up fixtured/mockable XML-RPC server.""" cls.mocks = MockableTransport(SoftLayer.FixtureTransport()) cls.server = xmlrpc.create_test_server(cls.mocks) host, port = cls.server.socket.getsockname()[:2] cls.endpoint_url = "http://%s:%s" % (host, port) @classmethod def tearDownClass(cls): """Clean up the http server.""" cls.server.shutdown() def set_up(self): """Aliased from setUp.""" pass def tear_down(self): """Aliased from tearDown.""" pass def setUp(self): # NOQA testtools.TestCase.setUp(self) self.mocks.clear() transport = SoftLayer.XmlRpcTransport(endpoint_url=self.endpoint_url) wrapped_transport = SoftLayer.TimingTransport(transport) self.client = SoftLayer.BaseClient(transport=wrapped_transport) self.env = environment.Environment() self.env.client = self.client self.set_up() def tearDown(self): # NOQA testtools.TestCase.tearDown(self) self.tear_down() self.mocks.clear() def calls(self, service=None, method=None): """Return all API calls made during the current test.""" conditions = [] if service is not None: conditions.append(lambda call: call.service == service) if method is not None: conditions.append(lambda call: call.method == method) return [call for call in self.mocks.calls if all(cond(call) for cond in conditions)] def assert_called_with(self, service, method, **props): """Used to assert that API calls were called with given properties. Props are properties of the given transport.Request object. """ for call in self.calls(service, method): if call_has_props(call, props): return raise AssertionError('%s::%s was not called with given properties: %s' % (service, method, props)) def set_mock(self, service, method): """Set and return mock on the current client.""" return self.mocks.set_mock(service, method) def run_command(self, args=None, env=None, fixtures=True, fmt='json'): """A helper that runs a SoftLayer CLI command. This returns a click.testing.Result object. """ args = args or [] if fixtures is True: args.insert(0, '--demo') args.insert(0, '--format=%s' % fmt) runner = testing.CliRunner() return runner.invoke(core.cli, args=args, obj=env or self.env) def call_has_props(call, props): """Check if a call has matching properties of a given props dictionary.""" for prop, expected_value in props.items(): actual_value = getattr(call, prop) if actual_value != expected_value: logging.info( '%s::%s property mismatch, %s: expected=%r; actual=%r', call.service, call.method, prop, expected_value, actual_value) return False return True softlayer-python-5.0.1/SoftLayer/testing/xmlrpc.py000066400000000000000000000070571267703721100223270ustar00rootroot00000000000000""" SoftLayer.testing.xmlrpc ~~~~~~~~~~~~~~~~~~~~~~~~ XMP-RPC server which can use a transport to proxy requests for testing. :license: MIT, see LICENSE for more details. """ import logging import threading import six import SoftLayer from SoftLayer import transports from SoftLayer import utils # pylint: disable=invalid-name, broad-except class TestServer(six.moves.BaseHTTPServer.HTTPServer): """Test HTTP server which holds a given transport.""" def __init__(self, transport, *args, **kw): six.moves.BaseHTTPServer.HTTPServer.__init__(self, *args, **kw) self.transport = transport class TestHandler(six.moves.BaseHTTPServer.BaseHTTPRequestHandler): """Test XML-RPC Handler which converts XML-RPC to transport requests.""" def do_POST(self): """Handle XML-RPC POSTs.""" try: length = int(self.headers['Content-Length']) data = self.rfile.read(length).decode('utf-8') args, method = utils.xmlrpc_client.loads(data) headers = args[0].get('headers', {}) # Form Request for the transport req = transports.Request() req.service = self.path.lstrip('/') req.method = method req.limit = utils.lookup(headers, 'resultLimit', 'limit') req.offset = utils.lookup(headers, 'resultLimit', 'offset') req.args = args[1:] req.filter = _item_by_key_postfix(headers, 'ObjectFilter') or None req.mask = _item_by_key_postfix(headers, 'ObjectMask').get('mask') req.identifier = _item_by_key_postfix(headers, 'InitParameters').get('id') req.transport_headers = dict(((k.lower(), v) for k, v in self.headers.items())) req.headers = headers # Get response response = self.server.transport(req) response_body = utils.xmlrpc_client.dumps((response,), allow_none=True, methodresponse=True) self.send_response(200) self.send_header("Content-type", "application/xml") self.end_headers() self.wfile.write(response_body.encode('utf-8')) except SoftLayer.SoftLayerAPIError as ex: self.send_response(200) self.end_headers() response = utils.xmlrpc_client.Fault(ex.faultCode, str(ex.reason)) response_body = utils.xmlrpc_client.dumps(response, allow_none=True, methodresponse=True) self.wfile.write(response_body.encode('utf-8')) except Exception as ex: self.send_response(500) logging.exception("Error while handling request") def log_message(self, fmt, *args): """Override log_message.""" pass def _item_by_key_postfix(dictionary, key_prefix): """Get item from a dictionary which begins with the given prefix.""" for key, value in dictionary.items(): if key.endswith(key_prefix): return value return {} def create_test_server(transport, host='localhost', port=0): """Create a test XML-RPC server in a new thread.""" server = TestServer(transport, (host, port), TestHandler) thread = threading.Thread(target=server.serve_forever, kwargs={'poll_interval': 0.01}) thread.start() return server softlayer-python-5.0.1/SoftLayer/transports.py000066400000000000000000000306371267703721100215640ustar00rootroot00000000000000""" SoftLayer.transports ~~~~~~~~~~~~~~~~~~~~ XML-RPC transport layer that uses the requests library. :license: MIT, see LICENSE for more details. """ import importlib import json import logging import time import requests from SoftLayer import consts from SoftLayer import exceptions from SoftLayer import utils LOGGER = logging.getLogger(__name__) # transports.Request does have a lot of instance attributes. :( # pylint: disable=too-many-instance-attributes __all__ = [ 'Request', 'XmlRpcTransport', 'RestTransport', 'TimingTransport', 'FixtureTransport', 'SoftLayerListResult', ] REST_SPECIAL_METHODS = { 'deleteObject': 'DELETE', 'createObject': 'POST', 'createObjects': 'POST', 'editObject': 'PUT', 'editObjects': 'PUT', } class Request(object): """Transport request object.""" def __init__(self): #: API service name. E.G. SoftLayer_Account self.service = None #: API method name. E.G. getObject self.method = None #: API Parameters. self.args = tuple() #: API headers, used for authentication, masks, limits, offsets, etc. self.headers = {} #: Transport user. self.transport_user = None #: Transport password. self.transport_password = None #: Transport headers. self.transport_headers = {} #: Boolean specifying if the server certificate should be verified. self.verify = True #: Client certificate file path. self.cert = None #: InitParameter/identifier of an object. self.identifier = None #: SoftLayer mask (dict or string). self.mask = None #: SoftLayer Filter (dict). self.filter = None #: Integer result limit. self.limit = None #: Integer result offset. self.offset = None class SoftLayerListResult(list): """A SoftLayer API list result.""" def __init__(self, items, total_count): #: total count of items that exist on the server. This is useful when #: paginating through a large list of objects. self.total_count = total_count super(SoftLayerListResult, self).__init__(items) class XmlRpcTransport(object): """XML-RPC transport.""" def __init__(self, endpoint_url=None, timeout=None, proxy=None, user_agent=None): self.endpoint_url = (endpoint_url or consts.API_PUBLIC_ENDPOINT).rstrip('/') self.timeout = timeout or None self.proxy = proxy self.user_agent = user_agent or consts.USER_AGENT def __call__(self, request): """Makes a SoftLayer API call against the XML-RPC endpoint. :param request request: Request object """ largs = list(request.args) headers = request.headers if request.identifier is not None: header_name = request.service + 'InitParameters' headers[header_name] = {'id': request.identifier} if request.mask is not None: headers.update(_format_object_mask_xmlrpc(request.mask, request.service)) if request.filter is not None: headers['%sObjectFilter' % request.service] = request.filter if request.limit: headers['resultLimit'] = { 'limit': request.limit, 'offset': request.offset or 0, } largs.insert(0, {'headers': headers}) request.transport_headers.setdefault('Content-Type', 'application/xml') request.transport_headers.setdefault('User-Agent', self.user_agent) url = '/'.join([self.endpoint_url, request.service]) payload = utils.xmlrpc_client.dumps(tuple(largs), methodname=request.method, allow_none=True) LOGGER.debug("=== REQUEST ===") LOGGER.info('POST %s', url) LOGGER.debug(request.transport_headers) LOGGER.debug(payload) try: resp = requests.request('POST', url, data=payload, headers=request.transport_headers, timeout=self.timeout, verify=request.verify, cert=request.cert, proxies=_proxies_dict(self.proxy)) LOGGER.debug("=== RESPONSE ===") LOGGER.debug(resp.headers) LOGGER.debug(resp.content) resp.raise_for_status() result = utils.xmlrpc_client.loads(resp.content)[0][0] if isinstance(result, list): return SoftLayerListResult( result, int(resp.headers.get('softlayer-total-items', 0))) else: return result except utils.xmlrpc_client.Fault as ex: # These exceptions are formed from the XML-RPC spec # http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php error_mapping = { '-32700': exceptions.NotWellFormed, '-32701': exceptions.UnsupportedEncoding, '-32702': exceptions.InvalidCharacter, '-32600': exceptions.SpecViolation, '-32601': exceptions.MethodNotFound, '-32602': exceptions.InvalidMethodParameters, '-32603': exceptions.InternalError, '-32500': exceptions.ApplicationError, '-32400': exceptions.RemoteSystemError, '-32300': exceptions.TransportError, } _ex = error_mapping.get(ex.faultCode, exceptions.SoftLayerAPIError) raise _ex(ex.faultCode, ex.faultString) except requests.HTTPError as ex: raise exceptions.TransportError(ex.response.status_code, str(ex)) except requests.RequestException as ex: raise exceptions.TransportError(0, str(ex)) class RestTransport(object): """REST transport. Currently only supports GET requests (no POST, PUT, DELETE) and lacks support for masks, filters, limits and offsets. """ def __init__(self, endpoint_url=None, timeout=None, proxy=None, user_agent=None): self.endpoint_url = (endpoint_url or consts.API_PUBLIC_ENDPOINT_REST).rstrip('/') self.timeout = timeout or None self.proxy = proxy self.user_agent = user_agent or consts.USER_AGENT def __call__(self, request): """Makes a SoftLayer API call against the REST endpoint. This currently only works with GET requests :param request request: Request object """ request.transport_headers.setdefault('Content-Type', 'application/json') request.transport_headers.setdefault('User-Agent', self.user_agent) params = request.headers.copy() if request.mask: params['objectMask'] = _format_object_mask(request.mask) if request.limit: params['limit'] = request.limit if request.offset: params['offset'] = request.offset if request.filter: params['objectFilter'] = json.dumps(request.filter) auth = None if request.transport_user: auth = requests.auth.HTTPBasicAuth( request.transport_user, request.transport_password, ) method = REST_SPECIAL_METHODS.get(request.method) is_special_method = True if method is None: is_special_method = False method = 'GET' body = {} if request.args: # NOTE(kmcdonald): force POST when there are arguments because # the request body is ignored otherwise. method = 'POST' body['parameters'] = request.args raw_body = None if body: raw_body = json.dumps(body) url_parts = [self.endpoint_url, request.service] if request.identifier is not None: url_parts.append(str(request.identifier)) # Special methods (createObject, editObject, etc) use the HTTP verb # to determine the action on the resource if request.method is not None and not is_special_method: url_parts.append(request.method) url = '%s.%s' % ('/'.join(url_parts), 'json') LOGGER.debug("=== REQUEST ===") LOGGER.info(url) LOGGER.debug(request.transport_headers) LOGGER.debug(raw_body) try: resp = requests.request(method, url, auth=auth, headers=request.transport_headers, params=params, data=raw_body, timeout=self.timeout, verify=request.verify, cert=request.cert, proxies=_proxies_dict(self.proxy)) LOGGER.debug("=== RESPONSE ===") LOGGER.debug(resp.headers) LOGGER.debug(resp.content) resp.raise_for_status() result = json.loads(resp.content) if isinstance(result, list): return SoftLayerListResult( result, int(resp.headers.get('softlayer-total-items', 0))) else: return result except requests.HTTPError as ex: content = json.loads(ex.response.content) raise exceptions.SoftLayerAPIError(ex.response.status_code, content['error']) except requests.RequestException as ex: raise exceptions.TransportError(0, str(ex)) class TimingTransport(object): """Transport that records API call timings.""" def __init__(self, transport): self.transport = transport self.last_calls = [] def __call__(self, call): """See Client.call for documentation.""" start_time = time.time() result = self.transport(call) end_time = time.time() self.last_calls.append((call, start_time, end_time - start_time)) return result def get_last_calls(self): """Retrieves the last_calls property. This property will contain a list of tuples in the form (Request, initiated_utc_timestamp, execution_time) """ last_calls = self.last_calls self.last_calls = [] return last_calls class FixtureTransport(object): """Implements a transport which returns fixtures.""" def __call__(self, call): """Load fixture from the default fixture path.""" try: module_path = 'SoftLayer.fixtures.%s' % call.service module = importlib.import_module(module_path) except ImportError: raise NotImplementedError('%s fixture is not implemented' % call.service) try: return getattr(module, call.method) except AttributeError: raise NotImplementedError('%s::%s fixture is not implemented' % (call.service, call.method)) def _proxies_dict(proxy): """Makes a proxy dict appropriate to pass to requests.""" if not proxy: return None return {'http': proxy, 'https': proxy} def _format_object_mask_xmlrpc(objectmask, service): """Format new and old style object masks into proper headers. :param objectmask: a string- or dict-based object mask :param service: a SoftLayer API service name """ if isinstance(objectmask, dict): mheader = '%sObjectMask' % service else: mheader = 'SoftLayer_ObjectMask' objectmask = _format_object_mask(objectmask) return {mheader: {'mask': objectmask}} def _format_object_mask(objectmask): """Format the new style object mask. This wraps the user mask with mask[USER_MASK] if it does not already have one. This makes it slightly easier for users. :param objectmask: a string-based object mask """ objectmask = objectmask.strip() if (not objectmask.startswith('mask') and not objectmask.startswith('[')): objectmask = "mask[%s]" % objectmask return objectmask softlayer-python-5.0.1/SoftLayer/utils.py000066400000000000000000000116301267703721100204750ustar00rootroot00000000000000""" SoftLayer.utils ~~~~~~~~~~~~~~~ Utility function/classes. :license: MIT, see LICENSE for more details. """ import datetime import re import six # pylint: disable=no-member, invalid-name UUID_RE = re.compile(r'^[0-9a-f\-]{36}$', re.I) KNOWN_OPERATIONS = ['<=', '>=', '<', '>', '~', '!~', '*=', '^=', '$=', '_='] configparser = six.moves.configparser string_types = six.string_types StringIO = six.StringIO xmlrpc_client = six.moves.xmlrpc_client 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({}, 'this', 'is') None """ if keys: return lookup(dic.get(key, {}), keys[0], *keys[1:]) return dic.get(key) class NestedDict(dict): """This helps with accessing a heavily nested dictionary. Dictionary where accessing keys that don't exist will return another NestedDict object. """ def __getitem__(self, key): if key in self: return self.get(key) return self.setdefault(key, NestedDict()) def to_dict(self): """Converts a NestedDict instance into a real dictionary. This is needed for places where strict type checking is done. """ new_dict = {} for key, val in self.items(): if isinstance(val, NestedDict): new_dict[key] = val.to_dict() else: new_dict[key] = val return new_dict 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 value Case Sensitive '~ value' Contains '!~ value' Does not contain '> value' Greater than value '< value' Less than value '>= value' Greater than or equal to value '<= value' Less than or equal to value :param string query: query string """ try: return {'operation': int(query)} except ValueError: pass if isinstance(query, string_types): query = query.strip() for operation in KNOWN_OPERATIONS: if query.startswith(operation): query = "%s %s" % (operation, query[len(operation):].strip()) return {'operation': query} if query.startswith('*') and query.endswith('*'): query = "*= %s" % query.strip('*') elif query.startswith('*'): query = "$= %s" % query.strip('*') elif query.endswith('*'): query = "^= %s" % query.strip('*') else: query = "_= %s" % query return {'operation': query} 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) enddate = "%s/%s/%s" % (edate.month, edate.day, edate.year) return { 'operation': 'betweenDate', 'options': [ {'name': 'startDate', 'value': [startdate+' 0:0:0']}, {'name': 'endDate', 'value': [enddate+' 0:0:0']} ] } class IdentifierMixin(object): """Mixin used to resolve ids from other names of objects. This mixin provides an interface to provide multiple methods for converting an 'indentifier' to an id """ resolvers = [] def resolve_ids(self, identifier): """Takes a string and tries to resolve to a list of matching ids. What exactly 'identifier' can be depends on the resolvers :param string identifier: identifying string :returns list: """ return resolve_ids(identifier, self.resolvers) 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)] except ValueError: pass # It was worth a shot # This looks like a globalIdentifier (UUID) if len(identifier) == 36 and UUID_RE.match(identifier): return [identifier] for resolver in resolvers: ids = resolver(identifier) if ids: return ids return [] class UTC(datetime.tzinfo): """UTC timezone.""" def utcoffset(self, _): return datetime.timedelta(0) def tzname(self, _): return "UTC" def dst(self, _): return datetime.timedelta(0) softlayer-python-5.0.1/docs/000077500000000000000000000000001267703721100160025ustar00rootroot00000000000000softlayer-python-5.0.1/docs/Makefile000066400000000000000000000130041267703721100174400ustar00rootroot00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: -rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/SoftLayerAPIPythonClient.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/SoftLayerAPIPythonClient.qhc" devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/SoftLayerAPIPythonClient" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/SoftLayerAPIPythonClient" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." softlayer-python-5.0.1/docs/_static/000077500000000000000000000000001267703721100174305ustar00rootroot00000000000000softlayer-python-5.0.1/docs/_static/style.css000066400000000000000000000001731267703721100213030ustar00rootroot00000000000000@import url("nature.css"); p.deprecated { background-color: #ffe4e4; border: 1px solid #f66; padding: 0.2em; }softlayer-python-5.0.1/docs/api/000077500000000000000000000000001267703721100165535ustar00rootroot00000000000000softlayer-python-5.0.1/docs/api/client.rst000066400000000000000000000125761267703721100205760ustar00rootroot00000000000000.. _client: API Documentation ================= This is the primary API client to make API calls. It deals with constructing and executing XML-RPC calls against the SoftLayer API. Below are some links that will help to use the SoftLayer API. * `SoftLayer API Documentation `_ * `Source on GitHub `_ :: >>> import SoftLayer >>> client = SoftLayer.create_client_from_env(username="username", api_key="api_key") >>> resp = client.call('Account', 'getObject') >>> resp['companyName'] 'Your Company' Getting Started --------------- You can pass in your username and api_key when creating a SoftLayer client instance. However, you can also set these in the environmental variables 'SL_USERNAME' and 'SL_API_KEY'. Creating a client instance by passing in the username/api_key: :: import SoftLayer client = SoftLayer.create_client_from_env(username='YOUR_USERNAME', api_key='YOUR_API_KEY') Creating a client instance with environmental variables set: :: $ export SL_USERNAME=YOUR_USERNAME $ export SL_API_KEY=YOUR_API_KEY $ python >>> import SoftLayer >>> client = SoftLayer.create_client_from_env() Below is an example of creating a client instance with more options. This will create a client with the private API endpoint (only accessible from the SoftLayer private network) and a timeout of 4 minutes. :: client = SoftLayer.create_client_from_env(username='YOUR_USERNAME', api_key='YOUR_API_KEY' endpoint_url=SoftLayer.API_PRIVATE_ENDPOINT, timeout=240) Managers -------- For day-to-day operation, most users will find the managers to be the most convenient means for interacting with the API. Managers abstract a lot of the complexities of using the API into classes that provide a simpler interface to various services. These are higher-level interfaces to the SoftLayer API. :: from SoftLayer import VSManager, Client client = Client(...) vs = VSManager(client) vs.list_instances() [...] **Available managers**: .. toctree:: :maxdepth: 1 :glob: managers/* If you need more power or functionality than the managers provide, you can make direct API calls as well. Making API Calls ---------------- For full control over your account and services, you can directly call the SoftLayer API. The SoftLayer API client for python leverages SoftLayer's XML-RPC API. It supports authentication, object masks, object filters, limits, offsets, and retrieving objects by id. The following section assumes you have an initialized client named 'client'. The best way to test our setup is to call the `getObject `_ method on the `SoftLayer_Account `_ service. :: client.call('Account', 'getObject') For a more complex example we'll retrieve a support ticket with id 123456 along with the ticket's updates, the user it's assigned to, the servers attached to it, and the datacenter those servers are in. To retrieve our extra information using an `object mask `_. Retrieve a ticket using object masks. :: ticket = client.call('Ticket', 'getObject', id=123456, mask="updates, assignedUser, attachedHardware.datacenter") Now add an update to the ticket with `Ticket.addUpdate `_. This uses a parameter, which translate to positional arguments in the order that they appear in the API docs. :: update = client.call('Ticket', 'addUpdate', {'entry' : 'Hello!'}, id=123456) Let's get a listing of virtual guests using the domain example.com :: client.call('Account', 'getVirtualGuests', filter={'virtualGuests': {'domain': {'operation': 'example.com'}}}) This call gets tickets created between the beginning of March 1, 2013 and March 15, 2013. :: client.call('Account', 'getTickets', filter={ 'tickets': { 'createDate': { 'operation': 'betweenDate', 'options': [ {'name': 'startDate', 'value': ['03/01/2013 0:0:0']}, {'name': 'endDate', 'value': ['03/15/2013 23:59:59']} ] } } } ) SoftLayer's XML-RPC API also allows for pagination. :: client.call('Account', 'getVirtualGuests', limit=10, offset=0) # Page 1 client.call('Account', 'getVirtualGuests', limit=10, offset=10) # Page 2 Here's how to create a new Cloud Compute Instance using `SoftLayer_Virtual_Guest.createObject `_. Be warned, this call actually creates an hourly virtual server so this will have billing implications. :: client.call('Virtual_Guest', 'createObject', { 'hostname': 'myhostname', 'domain': 'example.com', 'startCpus': 1, 'maxMemory': 1024, 'hourlyBillingFlag': 'true', 'operatingSystemReferenceCode': 'UBUNTU_LATEST', 'localDiskFlag': 'false' }) API Reference ------------- .. automodule:: SoftLayer :members: softlayer-python-5.0.1/docs/api/managers/000077500000000000000000000000001267703721100203505ustar00rootroot00000000000000softlayer-python-5.0.1/docs/api/managers/cdn.rst000066400000000000000000000001251267703721100216440ustar00rootroot00000000000000.. _cdn: .. automodule:: SoftLayer.managers.cdn :members: :inherited-members: softlayer-python-5.0.1/docs/api/managers/dns.rst000066400000000000000000000001251267703721100216640ustar00rootroot00000000000000.. _dns: .. automodule:: SoftLayer.managers.dns :members: :inherited-members: softlayer-python-5.0.1/docs/api/managers/firewall.rst000066400000000000000000000001371267703721100227100ustar00rootroot00000000000000.. _firewall: .. automodule:: SoftLayer.managers.firewall :members: :inherited-members: softlayer-python-5.0.1/docs/api/managers/hardware.rst000066400000000000000000000001361267703721100226770ustar00rootroot00000000000000.. _hardware: .. automodule:: SoftLayer.managers.hardware :members: :inherited-members:softlayer-python-5.0.1/docs/api/managers/image.rst000066400000000000000000000001311267703721100221570ustar00rootroot00000000000000.. _image: .. automodule:: SoftLayer.managers.image :members: :inherited-members: softlayer-python-5.0.1/docs/api/managers/iscsi.rst000066400000000000000000000001311267703721100222070ustar00rootroot00000000000000.. _iscsi: .. automodule:: SoftLayer.managers.iscsi :members: :inherited-members: softlayer-python-5.0.1/docs/api/managers/load_balancer.rst000066400000000000000000000001511267703721100236450ustar00rootroot00000000000000.. _load_balancer: .. automodule:: SoftLayer.managers.load_balancer :members: :inherited-members: softlayer-python-5.0.1/docs/api/managers/messaging.rst000066400000000000000000000001411267703721100230530ustar00rootroot00000000000000.. _messaging: .. automodule:: SoftLayer.managers.messaging :members: :inherited-members: softlayer-python-5.0.1/docs/api/managers/metadata.rst000066400000000000000000000002421267703721100226600ustar00rootroot00000000000000.. _metadata: .. automodule:: SoftLayer.managers.metadata :members: :inherited-members: .. autoattribute:: SoftLayer.managers.metadata.METADATA_ATTRIBUTESsoftlayer-python-5.0.1/docs/api/managers/network.rst000066400000000000000000000001351267703721100225720ustar00rootroot00000000000000.. _network: .. automodule:: SoftLayer.managers.network :members: :inherited-members: softlayer-python-5.0.1/docs/api/managers/sshkey.rst000066400000000000000000000001331267703721100224050ustar00rootroot00000000000000.. _sshkey: .. automodule:: SoftLayer.managers.sshkey :members: :inherited-members: softlayer-python-5.0.1/docs/api/managers/ssl.rst000066400000000000000000000001251267703721100217010ustar00rootroot00000000000000.. _ssl: .. automodule:: SoftLayer.managers.ssl :members: :inherited-members: softlayer-python-5.0.1/docs/api/managers/ticket.rst000066400000000000000000000001331267703721100223620ustar00rootroot00000000000000.. _ticket: .. automodule:: SoftLayer.managers.ticket :members: :inherited-members: softlayer-python-5.0.1/docs/api/managers/vs.rst000066400000000000000000000001231267703721100215260ustar00rootroot00000000000000.. _vs: .. automodule:: SoftLayer.managers.vs :members: :inherited-members: softlayer-python-5.0.1/docs/cla-corporate.md000066400000000000000000000154551267703721100210710ustar00rootroot00000000000000#### International Business Machines, Inc. ##### Software Grant and Corporate Contributor License Agreement ("Agreement") https://github.com/softlayer/softlayer-python/ Thank you for your interest in IBM’s softlayer-python project (“the Project"). In order to clarify the intellectual property license granted with Contributions from any person or entity, IBM must have a Contributor License Agreement (CLA) on file that has been signed by each Contributor, indicating agreement to the license terms below. This license is for your protection as a Contributor as well as the protection of IBM and its users; it does not change your rights to use your own Contributions for any other purpose. This version of the Agreement allows an entity (the "Corporation") to submit Contributions to the Project, to authorize Contributions submitted by its designated employees to the Project, and to grant copyright and patent licenses thereto. If you have not already done so, please complete and sign, then scan and email a PDF file of this Agreement to pjackson@softlayer.com. Please read this document carefully before signing and keep a copy for your records. Corporation name: ________________________________________________ Corporation address: ________________________________________________ Point of Contact: ________________________________________________ E-Mail: ________________________________________________ Telephone: _____________________ You accept and agree to the following terms and conditions for Your present and future Contributions submitted to the Project. Except for the license granted herein to IBM and recipients of software distributed by IBM, You reserve all right, title, and interest in and to Your Contributions. 1. Definitions. "You" (or "Your") shall mean the copyright owner or legal entity authorized by the copyright owner that is making this Agreement with IBM. For legal entities, the entity making a Contribution and all other entities that control, are controlled by, or are under common control with that entity are considered to be a single Contributor. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "Contribution" shall mean the code, documentation or other original works of authorship expressly identified in Schedule B, as well as any original work of authorship, including any modifications or additions to an existing work, that is intentionally submitted by You to IBM for inclusion in, or documentation of, the Project managed by IBM (the "Work"). For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to IBM or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, IBM for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by You as "Not a Contribution." 2. Grant of Copyright License. Subject to the terms and conditions of this Agreement, You hereby grant to IBM and to recipients of software distributed by IBM a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute Your Contributions and such derivative works. 3. Grant of Patent License. Subject to the terms and conditions of this Agreement, You hereby grant to IBM and to recipients of software distributed by IBM a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by You that are necessarily infringed by Your Contribution(s) alone or by combination of Your Contribution(s) with the Work to which such Contribution(s) were submitted. If any entity institutes patent litigation against You or any other entity (including a cross-claim or counterclaim in a lawsuit) alleging that your Contribution, or the Work to which you have contributed, constitutes direct or contributory patent infringement, then any patent licenses granted to that entity under this Agreement for that Contribution or Work shall terminate as of the date such litigation is filed. 4. You represent that You are legally entitled to grant the above license. You represent further that each employee of the Corporation designated on Schedule A below (or in a subsequent written modification to that Schedule) is authorized to submit Contributions on behalf of the Corporation. 5. You represent that each of Your Contributions is Your original creation (see section 7 for submissions on behalf of others). 6. You are not expected to provide support for Your Contributions, except to the extent You desire to provide support. You may provide support for free, for a fee, or not at all. Unless required by applicable law or agreed to in writing, You provide Your Contributions on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. 7. Should You wish to submit work that is not Your original creation, You may submit it to IBM separately from any Contribution, identifying the complete details of its source and of any license or other restriction (including, but not limited to, related patents, trademarks, and license agreements) of which you are personally aware, and conspicuously marking the work as "Submitted on behalf of a third-party: [named here]". 8. It is your responsibility to notify IBM when any change is required to the list of designated employees authorized to submit Contributions on behalf of the Corporation, or to the Corporation's Point of Contact with IBM. Please sign: __________________________________ Date: _______________ Title: __________________________________ Corporation: __________________________________ Schedule A [Initial list of designated employees. NB: authorization is not tied to particular Contributions.] Schedule B [Identification of optional concurrent software grant. Would be left blank or omitted if there is no concurrent software grant.] softlayer-python-5.0.1/docs/cla-individual.md000066400000000000000000000151021267703721100212100ustar00rootroot00000000000000#### International Business Machines, Inc. (IBM) ##### Individual Contributor License Agreement ("Agreement") https://github.com/softlayer/softlayer-python Thank you for your interest in the softlayer-python project ("the Project"). In order to clarify the intellectual property license granted with Contributions from any person or entity, IBM must have a Contributor License Agreement ("CLA") on file that has been signed by each Contributor, indicating agreement to the license terms below. This license is for your protection as a Contributor as well as the protection of IBM and its customers; it does not change your rights to use your own Contributions for any other purpose. If you have not already done so, please complete and sign, then scan and email a PDF file of this Agreement to pjackson@softlayer.com. Please read this document carefully before signing and keep a copy for your records. Full name: ______________________________________________________ (optional) Public name: _________________________________________ Mailing Address: ________________________________________________ Country: ______________________________________________________ Telephone: ______________________________________________________ E-Mail: ______________________________________________________ You accept and agree to the following terms and conditions for Your present and future Contributions submitted to the Project. Except for the license granted herein to IBM and recipients of software distributed by IBM, You reserve all right, title, and interest in and to Your Contributions. 1. Definitions. "You" (or "Your") shall mean the copyright owner or legal entity authorized by the copyright owner that is making this Agreement with IBM. For legal entities, the entity making a Contribution and all other entities that control, are controlled by, or are under common control with that entity are considered to be a single Contributor. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "Contribution" shall mean any original work of authorship, including any modifications or additions to an existing work, that is intentionally submitted by You to the Project for inclusion in, or documentation of, the Project (”the Work”). For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Project or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Project for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by You as "Not a Contribution." 2. Grant of Copyright License. Subject to the terms and conditions of this Agreement, You hereby grant to IBM and to recipients of software distributed by IBM a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute Your Contributions and such derivative works. 3. Grant of Patent License. Subject to the terms and conditions of this Agreement, You hereby grant to IBM and to recipients of software distributed by IBM a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work to which Your Contribution(s) were submitted, where such license applies only to those patent claims licensable by You that are necessarily infringed by Your Contribution(s) alone or by combination of Your Contribution(s) with the Work to which such Contribution(s) was submitted. If any entity institutes patent litigation against You or any other entity (including a cross-claim or counterclaim in a lawsuit) alleging that your Contribution, or the Work to which you have contributed, constitutes direct or contributory patent infringement, then any patent licenses granted to that entity under this Agreement for that Contribution or Work shall terminate as of the date such litigation is filed. 4. You represent that you are legally entitled to grant the above license. If your employer(s) has rights to intellectual property that you create that includes your Contributions, you represent that you have received permission to make Contributions on behalf of that employer, that your employer has waived such rights for your Contributions to the Project, or that your employer has executed a separate Corporate CLA with IBM. 5. You represent that each of Your Contributions is Your original creation (see section 7 for submissions on behalf of others). You represent that Your Contribution submissions include complete details of any third-party license or other restriction (including, but not limited to, related patents and trademarks) of which you are personally aware and which are associated with any part of Your Contributions. 6. You are not expected to provide support for Your Contributions, except to the extent You desire to provide support. You may provide support for free, for a fee, or not at all. Unless required by applicable law or agreed to in writing, You provide Your Contributions on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON- INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. 7. Should You wish to submit work that is not Your original creation, You may submit it to the Project separately from any Contribution, identifying the complete details of its source and of any license or other restriction (including, but not limited to, related patents, trademarks, and license agreements) of which you are personally aware, and conspicuously marking the work as "Submitted on behalf of a third-party: [named here]". 8. You agree to notify IBM of any facts or circumstances of which you become aware that would make these representations inaccurate in any respect. Please sign: __________________________________ Date: ________________ softlayer-python-5.0.1/docs/cli.rst000066400000000000000000000150321267703721100173040ustar00rootroot00000000000000.. _cli: Command-line Interface ====================== The SoftLayer command line interface is available via the `sl` command available in your `PATH`. The `sl` command is a reference implementation of SoftLayer API bindings for python and how to efficiently make API calls. See the :ref:`usage-examples` section to see how to discover all of the functionality not fully documented here. .. toctree:: :maxdepth: 2 cli/vs .. _config_setup: Configuration Setup ------------------- To update the configuration, you can use `slcli setup`. :: $ slcli setup Username []: username API Key or Password []: Endpoint (public|private|custom): public :..............:..................................................................: : Name : Value : :..............:..................................................................: : Username : username : : API Key : oyVmeipYQCNrjVS4rF9bHWV7D75S6pa1fghFl384v7mwRCbHTfuJ8qRORIqoVnha : : Endpoint URL : https://api.softlayer.com/xmlrpc/v3/ : :..............:..................................................................: Are you sure you want to write settings to "/home/me/.softlayer"? [y/N]: y To check the configuration, you can use `slcli config show`. :: $ slcli config show :..............:..................................................................: : Name : Value : :..............:..................................................................: : Username : username : : API Key : oyVmeipYQCNrjVS4rF9bHWV7D75S6pa1fghFl384v7mwRCbHTfuJ8qRORIqoVnha : : Endpoint URL : https://api.softlayer.com/xmlrpc/v3/ : :..............:..................................................................: To see more about the config file format, see :ref:`config_file`. .. _usage-examples: Usage Examples -------------- To discover the available commands, simply type `sl`. :: $ sl Usage: slcli [OPTIONS] COMMAND [ARGS]... SoftLayer Command-line Client Options: --format [table|raw|json] Output format -C, --config PATH Config file location --debug [0|1|2|3] Sets the debug noise level -v, --verbose Sets the debug noise level --timings Time each API call and display after results --proxy TEXT HTTP[S] proxy to be use to make API calls -y, --really Confirm all prompt actions --fixtures Use fixtures instead of actually making API calls --version Show the version and exit. --help Show this message and exit. Commands: call-api Call arbitrary API endpoints. cdn Content Delivery Network. config CLI configuration. dns Domain Name System. firewall Firewalls. globalip Global IP addresses. image Compute images. iscsi iSCSI storage. loadbal Load balancers. messaging Message queue service. metadata Find details about this machine. nas Network Attached Storage. rwhois Referral Whois. server Hardware servers. snapshot Snapshots. sshkey SSH Keys. ssl SSL Certificates. subnet Network subnets. summary Account summary. ticket Support tickets. vlan Network VLANs. vs Virtual Servers. To use most commands your SoftLayer username and api_key need to be configured. The easiest way to do that is to use: 'slcli setup' As you can see, there are a number of commands/sections. To look at the list of subcommands for virtual servers type `slcli vs`. For example: :: $ slcli vs Usage: slcli vs [OPTIONS] COMMAND [ARGS]... Virtual Servers. Options: --help Show this message and exit. Commands: cancel Cancel virtual servers. capture Capture SoftLayer image. create Order/create virtual servers. create-options Virtual server order options. credentials List virtual server credentials. detail Get details for a virtual server. dns-sync Sync DNS records. edit Edit a virtual server's details. list List virtual servers. network Manage network settings. pause Pauses an active virtual server. power_off Power off an active virtual server. power_on Power on a virtual server. ready Check if a virtual server is ready. reboot Reboot an active virtual server. reload Reload operating system on a virtual server. rescue Reboot into a rescue image. resume Resumes a paused virtual server. upgrade Upgrade a virtual server. Finally, we can make an actual call. Let's list out the virtual servers on our account by using `slcli vs list`. :: $ slcli vs list :.........:............:....................:.......:........:................:..............:....................: : id : datacenter : host : cores : memory : primary_ip : backend_ip : active_transaction : :.........:............:....................:.......:........:................:..............:....................: : 1234567 : sjc01 : test.example.com : 4 : 4G : 12.34.56 : 65.43.21 : - : :.........:............:....................:.......:........:................:..............:....................: Most commands will take in additional options/arguments. To see all available actions, use `--help`. :: $ slcli vs list --help Usage: slcli vs list [OPTIONS] List virtual servers. Options: --sortby [guid|hostname|primary_ip|backend_ip|datacenter] Column to sort by -c, --cpu INTEGER Number of CPU cores -D, --domain TEXT Domain portion of the FQDN -d, --datacenter TEXT Datacenter shortname -H, --hostname TEXT Host portion of the FQDN -m, --memory INTEGER Memory in mebibytes -n, --network TEXT Network port speed in Mbps --hourly Show only hourly instances --monthly Show only monthly instances --tags TEXT Show instances that have one of these comma- separated tags --help Show this message and exit. softlayer-python-5.0.1/docs/cli/000077500000000000000000000000001267703721100165515ustar00rootroot00000000000000softlayer-python-5.0.1/docs/cli/vs.rst000066400000000000000000000347151267703721100177450ustar00rootroot00000000000000.. _vs_user_docs: Working with Virtual Servers ============================ Using the SoftLayer portal to order virtual servers is fine, but for a number of reasons it's often more convenient to use the command line. For this, you can use SoftLayer's command-line client to make administrative tasks quicker and easier. This page gives an intro to working with SoftLayer virtual servers using SoftLayer's command-line client. .. note:: The following assumes that the client is already :ref:`configured with valid SoftLayer credentials`. First, let's list the current virtual servers with `slcli vs list`. :: $ slcli vs list :.....:............:.........................:.......:........:..............:.............:....................:........: : id : datacenter : host : cores : memory : primary_ip : backend_ip : active_transaction : owner : :.....:............:.........................:.......:........:..............:.............:....................:........: :.....:............:.........................:.......:........:..............:.............:....................:........: We don't have any virtual servers yet! Let's fix that. Before we can create a virtual server (VS), we need to know what options are available to us: RAM, CPU, operating systems, disk sizes, disk types, datacenters, and so on. Luckily, there's a simple command to show all options: `slcli vs create-options`. :: $ slcli vs create-options :.................:...........................................................................................: : Name : Value : :.................:...........................................................................................: : datacenter : ams01,dal01,dal05,dal06,dal09,hkg02,hou02,lon02,mel01,par01,sea01,sjc01,sng01,tor01,wdc01 : : cpus (private) : 1,2,4,8 : : cpus (standard) : 1,2,4,8,12,16 : : memory : 1024,2048,4096,6144,8192,12288,16384,32768,49152,65536 : : os (CENTOS) : CENTOS_5_32 : : : CENTOS_5_64 : : : CENTOS_6_32 : : : CENTOS_6_64 : : : CENTOS_7_64 : : : CENTOS_LATEST : : : CENTOS_LATEST_32 : : : CENTOS_LATEST_64 : : os (CLOUDLINUX) : CLOUDLINUX_5_32 : : : CLOUDLINUX_5_64 : : : CLOUDLINUX_6_32 : : : CLOUDLINUX_6_64 : : : CLOUDLINUX_LATEST : : : CLOUDLINUX_LATEST_32 : : : CLOUDLINUX_LATEST_64 : : os (DEBIAN) : DEBIAN_6_32 : : : DEBIAN_6_64 : : : DEBIAN_7_32 : : : DEBIAN_7_64 : : : DEBIAN_LATEST : : : DEBIAN_LATEST_32 : : : DEBIAN_LATEST_64 : : os (REDHAT) : REDHAT_5_32 : : : REDHAT_5_64 : : : REDHAT_6_32 : : : REDHAT_6_64 : : : REDHAT_LATEST : : : REDHAT_LATEST_32 : : : REDHAT_LATEST_64 : : os (UBUNTU) : UBUNTU_10_32 : : : UBUNTU_10_64 : : : UBUNTU_12_32 : : : UBUNTU_12_64 : : : UBUNTU_14_32 : : : UBUNTU_14_64 : : : UBUNTU_LATEST : : : UBUNTU_LATEST_32 : : : UBUNTU_LATEST_64 : : os (VYATTACE) : VYATTACE_6.5_64 : : : VYATTACE_6.6_64 : : : VYATTACE_LATEST : : : VYATTACE_LATEST_64 : : os (WIN) : WIN_2003-DC-SP2-1_32 : : : WIN_2003-DC-SP2-1_64 : : : WIN_2003-ENT-SP2-5_32 : : : WIN_2003-ENT-SP2-5_64 : : : WIN_2003-STD-SP2-5_32 : : : WIN_2003-STD-SP2-5_64 : : : WIN_2008-DC-R2_64 : : : WIN_2008-DC-SP2_64 : : : WIN_2008-ENT-R2_64 : : : WIN_2008-ENT-SP2_32 : : : WIN_2008-ENT-SP2_64 : : : WIN_2008-STD-R2-SP1_64 : : : WIN_2008-STD-R2_64 : : : WIN_2008-STD-SP2_32 : : : WIN_2008-STD-SP2_64 : : : WIN_2012-DC_64 : : : WIN_2012-STD_64 : : : WIN_LATEST : : : WIN_LATEST_32 : : : WIN_LATEST_64 : : local disk(0) : 25,100 : : local disk(2) : 25,100,150,200,300 : : san disk(0) : 25,100 : : san disk(2) : 10,20,25,30,40,50,75,100,125,150,175,200,250,300,350,400,500,750,1000,1500,2000 : : san disk(3) : 10,20,25,30,40,50,75,100,125,150,175,200,250,300,350,400,500,750,1000,1500,2000 : : san disk(4) : 10,20,25,30,40,50,75,100,125,150,175,200,250,300,350,400,500,750,1000,1500,2000 : : san disk(5) : 10,20,25,30,40,50,75,100,125,150,175,200,250,300,350,400,500,750,1000,1500,2000 : : nic : 10,100,1000 : :.................:...........................................................................................: Here's the command to create a 2-core virtual server with 1GiB memory, running Ubuntu 14.04 LTS, and that is billed on an hourly basis in the San Jose 1 datacenter using the command `slcli vs create`. :: $ slcli vs create --hostname=example --domain=softlayer.com --cpu 2 --memory 1024 -o UBUNTU_14_64 --datacenter=sjc01 --billing=hourly This action will incur charges on your account. Continue? [y/N]: y :.........:......................................: : name : value : :.........:......................................: : id : 1234567 : : created : 2013-06-13T08:29:44-06:00 : : guid : 6e013cde-a863-46ee-8s9a-f806dba97c89 : :.........:......................................: After the last command, the virtual server is now being built. It should instantly appear in your virtual server list now. :: $ slcli vs list :.........:............:.......................:.......:........:................:..............:....................: : id : datacenter : host : cores : memory : primary_ip : backend_ip : active_transaction : :.........:............:.......................:.......:........:................:..............:....................: : 1234567 : sjc01 : example.softlayer.com : 2 : 1G : 108.168.200.11 : 10.54.80.200 : Assign Host : :.........:............:.......................:.......:........:................:..............:....................: Cool. You may ask, "It's creating... but how do I know when it's done?" Well, here's how: :: $ slcli vs ready 'example' --wait=600 READY When the previous command returns, you'll know that the virtual server has finished the provisioning process and is ready to use. This is *very* useful for chaining commands together. Now that you have your virtual server, let's get access to it. To do that, use the `slcli vs detail` command. From the example below, you can see that the username is 'root' and password is 'ABCDEFGH'. .. warning:: Be careful when using the `--passwords` flag. This will print the virtual server's password on the screen. Make sure no one is looking over your shoulder. It's also advisable to change your root password soon after creating your virtual server, or to create a user with sudo access and disable SSH-based login directly to the root account. :: $ slcli vs detail example --passwords :..............:...........................: : Name : Value : :..............:...........................: : id : 1234567 : : hostname : example.softlayer.com : : status : Active : : state : Running : : datacenter : sjc01 : : cores : 2 : : memory : 1G : : public_ip : 108.168.200.11 : : private_ip : 10.54.80.200 : : os : Ubuntu : : private_only : False : : private_cpu : False : : created : 2013-06-13T08:29:44-06:00 : : modified : 2013-06-13T08:31:57-06:00 : : users : root ABCDEFGH : :..............:...........................: There are many other commands to help manage virtual servers. To see them all, use `slcli help vs`. :: $ slcli vs Usage: slcli vs [OPTIONS] COMMAND [ARGS]... Virtual Servers. Options: --help Show this message and exit. Commands: cancel Cancel virtual servers. capture Capture SoftLayer image. create Order/create virtual servers. create-options Virtual server order options. credentials List virtual server credentials. detail Get details for a virtual server. dns-sync Sync DNS records. edit Edit a virtual server's details. list List virtual servers. network Manage network settings. pause Pauses an active virtual server. power_off Power off an active virtual server. power_on Power on a virtual server. ready Check if a virtual server is ready. reboot Reboot an active virtual server. reload Reload operating system on a virtual server. rescue Reboot into a rescue image. resume Resumes a paused virtual server. upgrade Upgrade a virtual server. softlayer-python-5.0.1/docs/conf.py000066400000000000000000000204401267703721100173010ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # SoftLayer API Python Client documentation build configuration file, created # by sphinx-quickstart on Fri Mar 22 11:08:48 2013. # # This file is execfile()d with the current directory set to its containing # dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys import os # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # sys.path.insert(0, os.path.abspath('.')) sys.path.insert(0, os.path.abspath('..')) # -- General configuration ---------------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. # needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['sphinx.ext.autodoc', 'sphinx.ext.coverage', 'sphinx.ext.viewcode'] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. # source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = u'SoftLayer API Python Client' # Hack to avoid the "Redefining built-in 'copyright'" error from static # analysis tools globals()['copyright'] = u'2016, SoftLayer Technologies, Inc.' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = '5.0.1' # The full version, including alpha/beta/rc tags. release = '5.0.1' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: # today = '' # Else, today_fmt is used as the format for a strftime call. # today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['_build'] # The reST default role (used for this markup: `text`) to use for all # documents. # default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. # add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). # add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. # show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'friendly' # A list of ignored prefixes for module index sorting. # modindex_common_prefix = [] # -- Options for HTML output -------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. on_rtd = os.environ.get('READTHEDOCS', None) == 'True' if on_rtd: html_theme = 'default' else: html_theme = 'nature' html_style = "style.css" # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. # html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. # html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". # html_title = None # A shorter title for the navigation bar. Default is the same as html_title. # html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. # html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. # html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. # html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. # html_use_smartypants = True # Custom sidebar templates, maps document names to template names. # html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. # html_additional_pages = {} # If false, no module index is generated. # html_domain_indices = True # If false, no index is generated. # html_use_index = True # If true, the index is split into individual pages for each letter. # html_split_index = False # If true, links to the reST sources are added to the pages. # html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. # html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. # html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. # html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). # html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'SoftLayerAPIPythonClientdoc' # -- Options for LaTeX output ------------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). # 'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). # 'pointsize': '10pt', # Additional stuff for the LaTeX preamble. # 'preamble': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, # documentclass [howto/manual]). latex_documents = [ ('index', 'SoftLayerAPIPythonClient.tex', u'SoftLayer API Python Client Documentation', u'SoftLayer Technologies, Inc.', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. # latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. # latex_use_parts = False # If true, show page references after internal links. # latex_show_pagerefs = False # If true, show URL addresses after external links. # latex_show_urls = False # Documents to append as an appendix to all manuals. # latex_appendices = [] # If false, no module index is generated. # latex_domain_indices = True # -- Options for manual page output ------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ('index', 'softlayerapipythonclient', u'SoftLayer API Python Client Documentation', [u'SoftLayer Technologies, Inc.'], 1) ] # If true, show URL addresses after external links. # man_show_urls = False # -- Options for Texinfo output ----------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ('index', 'SoftLayerAPIPythonClient', u'SoftLayer API Python Client Documentation', u'SoftLayer Technologies, Inc.', 'SoftLayerAPIPythonClient', 'One line description of project.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. # texinfo_appendices = [] # If false, no module index is generated. # texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. # texinfo_show_urls = 'footnote' softlayer-python-5.0.1/docs/config_file.rst000066400000000000000000000015671267703721100210110ustar00rootroot00000000000000.. _config_file: Configuration File ================== The SoftLayer API bindings load your settings from a number of different locations. * Input directly into SoftLayer.create_client_from_env(...) * Enviorment variables (`SL_USERNAME`, `SL_API_KEY`) * Config file locations (`~/.softlayer`, `/etc/softlayer.conf`) * Or argument (`-C/path/to/config` or `--config=/path/to/config`) The configuration file is INI-based and requires the `softlayer` section to be present. The only required fields are `username` and `api_key`. You can optionally supply the `endpoint_url` as well. This file is created automatically by the `slcli setup` command detailed here: :ref:`config_setup`. *Config Example* :: [softlayer] username = username api_key = oyVmeipYQCNrjVS4rF9bHWV7D75S6pa1fghFl384v7mwRCbHTfuJ8qRORIqoVnha endpoint_url = https://api.softlayer.com/xmlrpc/v3/ timeout = 40 softlayer-python-5.0.1/docs/dev/000077500000000000000000000000001267703721100165605ustar00rootroot00000000000000softlayer-python-5.0.1/docs/dev/cli.rst000066400000000000000000000104201267703721100200560ustar00rootroot00000000000000.. _cli_dev: Command-Line Interface Developer Guide ====================================== The SoftLayer CLI can be used to manage many different SoftLayer services directly from the command line. The command line parsing is currently based on `click `_, which is a command parsing library along with some additions to dynamically load modules from a routes-like file and from `entry points `_. First Example ------------- For the first example, we can create `slcli table-example` by creating the following file at SoftLayer/CLI/table_example.py: :: from SoftLayer.CLI import formatting import click @click.command() def cli(): """This returns an table that highlights how tables are output""" # create a table with two columns: col1, col2 t = formatting.Table(['col1', 'col2']) # align the data facing each other # valid values are r, c, l for right, center, left # note, these are suggestions based on the format chosen by the user t.align['col1'] = 'r' t.align['col2'] = 'l' # add rows t.add_row(['test', 'test']) t.add_row(['test2', 'test2']) return t Then we need to register it so that `slcli table-example` will know to route to this new module. We do that by adding ALL_ROUTES in SoftLayer/CLI/routes.py to include the following: :: ... ('table-example', 'SoftLayer.CLI.table_example:cli'), ... Which gives us :: $ slcli table-example :.......:.......: : col1 : col2 : :.......:.......: : test : test : : test2 : test2 : :.......:.......: $ slcli --format=raw table-example test test test2 test2 Formatting of the data represented in the table is actually controlled upstream from the CLIRunnable's making supporting more data formats in the future easier. Arguments --------- A command usually isn't very useful without context or arguments of some kind. With click, you have a large array of argument and option types at your disposal. Additionally, with the SoftLayer CLI, we have global options and context which is stored in `SoftLayer.CLI.environment.Environment` and is attainable through a decorator located at `SoftLayer.CLI.environment.pass_env`. An example of options and the environment is shown below. It also shows how output should be done using `env.out` instead of printing. This is used for testing and to have a consistent way to print things onto the screen. :: from SoftLayer.CLI import environment import click @click.command() @click.option("--number", required=True, type=click.INT, help="print different output") @click.option("--choice", type=click.Choice(['this', 'that']), help="print different output") @click.option("--test", help="print different output") @environment.pass_env def cli(env, number, choice, test): """Argument parsing example""" if test: env.out("Just testing, move along...") else: env.out("This is fo'realz!") if choice == 'this': env.out("Selected this") elif choice == 'that': env.out("Selected that") env.out("This is a number: %d" % number) Refer to the click library documentation for more options. Accessing the API ----------------- A SoftLayer client is stood up for every command and is available through `SoftLayer.CLI.environment.Environment.client`. The example below shows how to make a simple API call to the SoftLayer_Account::getObject. :: from SoftLayer.CLI import environment import click @click.command() @environment.pass_env def cli(env): """Using the SoftLayer API client""" account = env.client['Account'].getObject() return account['companyName'] Aborting execution ------------------ When a confirmation fails, you probably want to stop execution and give a non-zero exit code. To do that, raise a `SoftLayer.CLI.exceptions.CLIAbort` exception with the message for the user as the first parameter. This will prevent any further execution and properly return the right error code. :: raise CLIAbort("Aborting. Failed confirmation") softlayer-python-5.0.1/docs/dev/example_module.rst000066400000000000000000000040271267703721100223150ustar00rootroot00000000000000.. _example_module: :orphan: Example CLI Module ================== :: """ usage: slcli example [] [...] [options] Example implementation of a CLI module Available commands are: parse parsing args example pretty formatted print example print print example """ from SoftLayer.CLI import ( CLIRunnable, Table, no_going_back, confirm) class ExampleAction(CLIRunnable): """ usage: slcli example print [options] Print example """ action = 'print' def execute(self, args): print "EXAMPLE!" class ExamplePretty(CLIRunnable): """ usage: slcli example pretty [options] Pretty output example """ action = 'pretty' def execute(self, args): # create a table with two columns: col1, col2 t = Table(['col1', 'col2']) # align the data facing each other # valid values are r, c, l for right, center, left # note, these are suggestions based on the format chosen by the user t.align['col1'] = 'r' t.align['col2'] = 'l' # add rows t.add_row(['test', 'test']) t.add_row(['test2', 'test2']) return t class ExampleArgs(CLIRunnable): """ usage: slcli example parse [--test] [--this=THIS|--that=THAT] (--one|--two) [options] Argument parsing example Options: --test Print different output """ action = 'parse' options = ['confirm'] def execute(self, args): if args.get('--test'): print "Just testing, move along..." else: print "This is fo'realz!" if args['--one']: print 1 elif args['--two']: print 2 if args.get('--this'): print "I gots", args['--this'] if args.get('--that'): print "you dont have", args['--that'] softlayer-python-5.0.1/docs/dev/index.rst000066400000000000000000000112311267703721100204170ustar00rootroot00000000000000.. _api_dev: Contribution Guide ================== This page explains how to get started contributing code to the SoftLayer API Python Bindings project. Code Organization ----------------- * **docs** - Where The source to this documentation lives. * **SoftLayer** - All the source lives under here. * **API** - Primary API client. * **CLI** - Code for the command-line interface. * **managers** - API Managers. Abstractions to help use the API. Setting Up A Dev Environment ---------------------------- Before working with the SoftLayer Python API client source, we strongly recommend that you know how to use Python's virtualization environment, `virtualenv `_. Virtualenv allows you to create isolated Python environments that are individually tailored to particular development projects. Each environment can have its own set of libraries and even its own Python interpreter. This keeps them fully isolated, reducing the possibility of library conflicts between different projects. After you have virtualenv, you should set up a virtual environment and activate it whenever you are working on softlayer-python. The commands needed to setup an environment and activate it might look something like this: :: virtualenv --no-site-packages softlayer_env source softlayer_env/bin/activate Please refer to the virtualenv documentation for more information about creating, and working with virtual environments. Once you have an appropriate environment, you will then download the SoftLayer API Python Bindings source code by following the :ref:`installation instructions `. Change into softlayer-python source directory and run the following to install the pre-requisites that you'll need in order to run the test suites: :: pip install -r tools/test-requirements.txt Testing ------- The project has a mix of functional and unit tests. Before submitting changes to be integrated into the project, you should validate your code using `tox `_. Simply issue the tox command from the root of the source tree: :: tox In addition to testing different versions of Python, tox checks for common mistakes in the code using `Flake8 `_. You should eliminate the simple errors reported by Flake8 before submitting your code. The project's configuration instructs tox to test against many different versions of Python. A tox test will use as many of those as it can find on your local computer. Rather than installing all those versions, we recommend that you point the `Travis `_ continuous integration tool at your GitHub fork. Travis will run the test against the full suite of Python versions every time you push new code. Using tox to running the tests in multiple environments can be very time consuming. If you wish to quickly run the tests in your own environment, you may do so using `py.test `_. The command to do that is: :: py.test tests Documentation ------------- The project is documented in `reStructuredText `_ and built using `Sphinx `_. If you have `fabric `_ installed, you simply need to run the following to build the docs: :: fab make_html The documentation will be built in `docs/_build/html`. If you don't have fabric, use the following commands. :: cd docs make html The primary docs are built at `Read the Docs `_. Style ----- This project follows :pep:`8` and most of the style suggestions that pyflakes recommends. Run `Flake8 `_ regularly. Flake8, with project-specific exceptions, can be run by using tox: :: tox -e analysis Contributing ------------ Contributing to the Python API bindings follows the fork-pull-request model on `GitHub `_. The project uses GitHub's `issue tracker `_ and `pull requests `_ to manage source control, bug fixes and new feature development regarding the API bindings and the CLI. Developer Resources ------------------- .. toctree:: SoftLayer API Documentation Source on GitHub Issues Pull Requests PyPI Twitter #softlayer on freenode softlayer-python-5.0.1/docs/index.rst000066400000000000000000000026621267703721100176510ustar00rootroot00000000000000.. SoftLayer API Python Client documentation SoftLayer API Python Client |version| ======================================== `API Docs `_ ``|`` `GitHub `_ ``|`` `Issues `_ ``|`` `Pull Requests `_ ``|`` `PyPI `_ ``|`` `Twitter `_ ``|`` `#softlayer on freenode `_ This is the documentation to SoftLayer's Python API Bindings. These bindings use SoftLayer's `XML-RPC interface `_ in order to manage SoftLayer services. .. toctree:: :maxdepth: 3 :glob: install config_file api/* cli Contributing ------------ .. toctree:: :maxdepth: 1 :glob: dev/index dev/cli External Links -------------- * `SoftLayer API Documentation `_ * `Source on GitHub `_ * `Issues `_ * `Pull Requests `_ * `PyPI `_ * `Twitter `_ * `#softlayer on freenode `_ softlayer-python-5.0.1/docs/install.rst000066400000000000000000000033001267703721100201760ustar00rootroot00000000000000.. _install: Installation ============ What's Included --------------- When you install softlayer-python you you will get the following: * a python package called 'SoftLayer' (casing is important) available in your python path. * a command-line client placed in your system path named 'slcli'. Using Pip --------- Install via pip: :: $ pip install softlayer Debian/Ubuntu ------------- For Debian "jessie" (currently testing) and Ubuntu 14.04, official system packages are available. **These are typically a couple versions behind so it is recommended to install from pypi if problems are encountered.** :: $ sudo apt-get install python-softlayer .. _install_from_source: From Source ----------- The project is developed on GitHub, at `https://github.com/softlayer/softlayer-python `_. Install from source via pip (requires `git `_): :: $ pip install git+git://github.com/softlayer/softlayer-python.git You can clone the public repository:: $ git clone git@github.com:softlayer/softlayer-python.git Or, Download the `tarball `_: :: $ curl -OL https://github.com/softlayer/softlayer-python/tarball/master Or, download the `zipball `_: :: $ curl -OL https://github.com/softlayer/softlayer-python/zipball/master Once you have a copy of the source you can install it with one of the following commands: :: $ python setup.py install Or: :: $ pip install . For more information about working with the source, or contributing to the project, please see the :ref:`Contribution Guide `. softlayer-python-5.0.1/fabfile.py000066400000000000000000000021461267703721100170170ustar00rootroot00000000000000import os.path import shutil from fabric.api import local, lcd, puts, abort def make_html(): "Build HTML docs" with lcd('docs'): local('make html') def upload(): "Upload distribution to PyPi" local('python setup.py sdist upload') local('python setup.py bdist_wheel upload') def clean(): puts("* Cleaning Repo") directories = ['.tox', 'SoftLayer.egg-info', 'build', 'dist'] for directory in directories: if os.path.exists(directory) and os.path.isdir(directory): shutil.rmtree(directory) def release(version, force=False): """Perform a release. Example: $ fab release:3.0.0 """ if version.startswith("v"): abort("Version should not start with 'v'") version_str = "v%s" % version clean() puts(" * Tagging Version %s" % version_str) force_option = 'f' if force else '' local("git tag -%sam \"%s\" %s" % (force_option, version_str, version_str)) local("pip install wheel") puts(" * Uploading to PyPI") upload() puts(" * Pushing Tag to upstream") local("git push upstream %s" % version_str) softlayer-python-5.0.1/pkg/000077500000000000000000000000001267703721100156335ustar00rootroot00000000000000softlayer-python-5.0.1/pkg/softlayer-python.spec000066400000000000000000000030571267703721100220430ustar00rootroot00000000000000# sitelib for noarch packages, sitearch for others (remove the unneeded one) %{!?python_sitelib: %global python_sitelib %(%{__python} -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())")} %{!?python_sitearch: %global python_sitearch %(%{__python} -c "from distutils.sysconfig import get_python_lib; print(get_python_lib(1))")} %global commit master %global shortcommit %(c=%{commit}; echo ${c:0:7}) Name: softlayer-python Version: %{commit} Release: 1%{?dist} Summary: softlayer python interface License: MIT URL: https://github.com/softlayer/softlayer-python Source: https://github.com/softlayer/softlayer-python/archive/%{commit}/softlayer-python-%{commit}.tar.gz #BuildArch: BuildRequires: python-devel, python-setuptools Requires: python-requests, python-click, python-prettytable >= 0.7.0 Requires: python-importlib, python-six >= 1.6.1 %description %prep %setup -q %build # Remove CFLAGS=... for noarch packages (unneeded) CFLAGS="$RPM_OPT_FLAGS" %{__python} setup.py build %install rm -rf $RPM_BUILD_ROOT %{__python} setup.py install -O1 --skip-build --root $RPM_BUILD_ROOT %files %doc /usr/bin/sl # For noarch packages: sitelib %{python_sitelib}/* # For arch-specific packages: sitearch #%{python_sitearch}/* %changelog * Thu Oct 23 2014 Christopher Gallo - master-2 - Changed Source to a proper github url, added python-setuptool build requirement * Wed Mar 19 2014 Andy Bakun 773ab17-1 - initial packaging softlayer-python-5.0.1/setup.cfg000066400000000000000000000000701267703721100166700ustar00rootroot00000000000000[pytest] python_files = *_tests.py [wheel] universal=1 softlayer-python-5.0.1/setup.py000066400000000000000000000034671267703721100165760ustar00rootroot00000000000000from __future__ import print_function import sys from codecs import open import os from setuptools import setup, find_packages DESCRIPTION = "A library for SoftLayer's API" if os.path.exists('README.rst'): with open('README.rst', 'r', 'utf-8') as readme_file: LONG_DESCRIPTION = readme_file.read() else: LONG_DESCRIPTION = DESCRIPTION setup( name='SoftLayer', version='5.0.1', description=DESCRIPTION, long_description=LONG_DESCRIPTION, author='SoftLayer Technologies, Inc.', author_email='sldn@softlayer.com', packages=find_packages(exclude=['tests']), license='MIT', zip_safe=False, url='http://github.com/softlayer/softlayer-python', entry_points={ 'console_scripts': [ 'slcli = SoftLayer.CLI.core:main', 'sl = SoftLayer.CLI.deprecated:main', ], }, install_requires=[ 'six >= 1.7.0', 'prettytable >= 0.7.0', 'click >= 5', 'requests >= 2.7.0', 'prompt_toolkit >= 0.53', 'pygments >= 2.0.0', ], keywords=['softlayer', 'cloud'], classifiers=[ 'Environment :: Console', 'Environment :: Web Environment', 'Intended Audience :: Developers', 'Intended Audience :: System Administrators', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Topic :: Software Development :: Libraries :: Python Modules', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: Implementation :: CPython', 'Programming Language :: Python :: Implementation :: PyPy', ], ) softlayer-python-5.0.1/tests/000077500000000000000000000000001267703721100162145ustar00rootroot00000000000000softlayer-python-5.0.1/tests/CLI/000077500000000000000000000000001267703721100166235ustar00rootroot00000000000000softlayer-python-5.0.1/tests/CLI/__init__.py000066400000000000000000000000001267703721100207220ustar00rootroot00000000000000softlayer-python-5.0.1/tests/CLI/core_tests.py000066400000000000000000000100011267703721100213370ustar00rootroot00000000000000""" SoftLayer.tests.CLI.core_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import logging import SoftLayer from SoftLayer.CLI import core from SoftLayer.CLI import environment from SoftLayer import testing from SoftLayer import utils import click import mock class CoreTests(testing.TestCase): def test_load_all(self): for path, cmd in recursive_subcommand_loader(core.cli, current_path='root'): try: cmd.main(args=['--help']) except SystemExit as ex: if ex.code != 0: self.fail("Non-zero exit code for command: %s" % path) def test_verbose_max(self): with mock.patch('logging.getLogger') as log_mock: result = self.run_command(['-vvv', 'vs', 'list']) self.assertEqual(result.exit_code, 0) log_mock().addHandler.assert_called_with(mock.ANY) log_mock().setLevel.assert_called_with(logging.DEBUG) def test_build_client(self): env = environment.Environment() result = self.run_command(['vs', 'list'], env=env) self.assertEqual(result.exit_code, 0) self.assertIsNotNone(env.client) def test_diagnostics(self): result = self.run_command(['-v', 'vs', 'list']) self.assertEqual(result.exit_code, 0) self.assertIn('SoftLayer_Account::getVirtualGuests', result.output) self.assertIn('"execution_time"', result.output) self.assertIn('"api_calls"', result.output) self.assertIn('"version"', result.output) self.assertIn('"python_version"', result.output) self.assertIn('"library_location"', result.output) class CoreMainTests(testing.TestCase): @mock.patch('SoftLayer.CLI.core.cli.main') @mock.patch('sys.stdout', new_callable=utils.StringIO) def test_unexpected_error(self, stdoutmock, climock): climock.side_effect = AttributeError('Attribute foo does not exist') self.assertRaises(SystemExit, core.main) self.assertIn("Feel free to report this error as it is likely a bug", stdoutmock.getvalue()) self.assertIn("Traceback (most recent call last)", stdoutmock.getvalue()) self.assertIn("AttributeError: Attribute foo does not exist", stdoutmock.getvalue()) @mock.patch('SoftLayer.CLI.core.cli.main') @mock.patch('sys.stdout', new_callable=utils.StringIO) def test_sl_error(self, stdoutmock, climock): ex = SoftLayer.SoftLayerAPIError('SoftLayer_Exception', 'Not found') climock.side_effect = ex self.assertRaises(SystemExit, core.main) self.assertIn("SoftLayerAPIError(SoftLayer_Exception): Not found", stdoutmock.getvalue()) @mock.patch('SoftLayer.CLI.core.cli.main') @mock.patch('sys.stdout', new_callable=utils.StringIO) def test_auth_error(self, stdoutmock, climock): ex = SoftLayer.SoftLayerAPIError('SoftLayer_Exception', 'Invalid API token.') climock.side_effect = ex self.assertRaises(SystemExit, core.main) self.assertIn("Authentication Failed:", stdoutmock.getvalue()) self.assertIn("use 'slcli config setup'", stdoutmock.getvalue()) def recursive_subcommand_loader(root, current_path=''): """Recursively load and list every command.""" if getattr(root, 'list_commands', None) is None: return ctx = click.Context(root) for command in root.list_commands(ctx): new_path = '%s:%s' % (current_path, command) logging.info("loading %s", new_path) new_root = root.get_command(ctx, command) if new_root is None: raise Exception('Could not load command: %s' % command) for path, cmd in recursive_subcommand_loader(new_root, current_path=new_path): yield path, cmd yield current_path, new_root softlayer-python-5.0.1/tests/CLI/deprecated_tests.py000066400000000000000000000020131267703721100225130ustar00rootroot00000000000000""" SoftLayer.tests.CLI.deprecated_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import mock from SoftLayer.CLI import deprecated from SoftLayer import testing from SoftLayer import utils class EnvironmentTests(testing.TestCase): def test_main(self): with mock.patch('sys.stderr', new=utils.StringIO()) as fake_out: ex = self.assertRaises(SystemExit, deprecated.main) self.assertEqual(ex.code, -1) self.assertIn("ERROR: Use the 'slcli' command instead.", fake_out.getvalue()) def test_with_args(self): with mock.patch('sys.stderr', new=utils.StringIO()) as fake_out: with mock.patch('sys.argv', new=['sl', 'module', 'subcommand']): ex = self.assertRaises(SystemExit, deprecated.main) self.assertEqual(ex.code, -1) self.assertIn("ERROR: Use the 'slcli' command instead.", fake_out.getvalue()) softlayer-python-5.0.1/tests/CLI/environment_tests.py000066400000000000000000000035071267703721100227700ustar00rootroot00000000000000""" SoftLayer.tests.CLI.environment_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import click import mock from SoftLayer.CLI import environment from SoftLayer import testing @click.command() def fixture_command(): pass class EnvironmentTests(testing.TestCase): def set_up(self): self.env = environment.Environment() def test_list_commands(self): self.env.load() actions = self.env.list_commands() self.assertIn('virtual', actions) self.assertIn('dns', actions) def test_get_command_invalid(self): cmd = self.env.get_command('invalid', 'command') self.assertEqual(cmd, None) def test_get_command(self): fixture_loader = environment.ModuleLoader( 'tests.CLI.environment_tests', 'fixture_command', ) self.env.commands = {'fixture:run': fixture_loader} command = self.env.get_command('fixture', 'run') self.assertIsInstance(command, click.Command) @mock.patch('click.prompt') def test_input(self, prompt_mock): r = self.env.input('input') prompt_mock.assert_called_with('input', default=None, show_default=True) self.assertEqual(prompt_mock(), r) @mock.patch('click.prompt') def test_getpass(self, prompt_mock): r = self.env.getpass('input') prompt_mock.assert_called_with('input', default=None, hide_input=True) self.assertEqual(prompt_mock(), r) def test_resolve_alias(self): self.env.aliases = {'aliasname': 'realname'} r = self.env.resolve_alias('aliasname') self.assertEqual(r, 'realname') r = self.env.resolve_alias('realname') self.assertEqual(r, 'realname') softlayer-python-5.0.1/tests/CLI/helper_tests.py000066400000000000000000000344521267703721100217060ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ SoftLayer.tests.CLI.helper_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import json import os import tempfile import click import mock from SoftLayer.CLI import core from SoftLayer.CLI import exceptions from SoftLayer.CLI import formatting from SoftLayer.CLI import helpers from SoftLayer.CLI import template from SoftLayer import testing class CLIJSONEncoderTest(testing.TestCase): def test_default(self): out = json.dumps({ 'formattedItem': formatting.FormattedItem('normal', 'formatted') }, cls=formatting.CLIJSONEncoder) self.assertEqual(out, '{"formattedItem": "normal"}') out = json.dumps({'normal': 'string'}, cls=formatting.CLIJSONEncoder) self.assertEqual(out, '{"normal": "string"}') def test_fail(self): self.assertRaises( TypeError, json.dumps, {'test': object()}, cls=formatting.CLIJSONEncoder) class PromptTests(testing.TestCase): @mock.patch('click.prompt') def test_do_or_die(self, prompt_mock): confirmed = '37347373737' prompt_mock.return_value = confirmed result = formatting.no_going_back(confirmed) self.assertTrue(result) # no_going_back should cast int's to str() confirmed = '4712309182309' prompt_mock.return_value = confirmed result = formatting.no_going_back(int(confirmed)) self.assertTrue(result) confirmed = None prompt_mock.return_value = '' result = formatting.no_going_back(confirmed) self.assertFalse(result) @mock.patch('click.prompt') def test_confirmation(self, prompt_mock): prompt_mock.return_value = 'Y' res = formatting.confirm('Confirm?', default=False) self.assertTrue(res) prompt_mock.return_value = 'N' res = formatting.confirm('Confirm?', default=False) self.assertFalse(res) prompt_mock.return_value = 'Y' res = formatting.confirm('Confirm?', default=True) self.assertTrue(res) prompt_mock.assert_called_with('Confirm? [Y/n]', default='y', show_default=False) prompt_mock.return_value = 'N' res = formatting.confirm('Confirm?', default=False) self.assertFalse(res) prompt_mock.assert_called_with('Confirm? [y/N]', default='n', show_default=False) class FormattedItemTests(testing.TestCase): def test_init(self): item = formatting.FormattedItem('test', 'test_formatted') self.assertEqual('test', item.original) self.assertEqual('test_formatted', item.formatted) self.assertEqual('test', str(item)) item = formatting.FormattedItem('test') self.assertEqual('test', item.original) self.assertEqual('test', item.formatted) self.assertEqual('test', str(item)) def test_mb_to_gb(self): item = formatting.mb_to_gb(1024) self.assertEqual(1024, item.original) self.assertEqual('1G', item.formatted) item = formatting.mb_to_gb('1024') self.assertEqual('1024', item.original) self.assertEqual('1G', item.formatted) item = formatting.mb_to_gb('1025.0') self.assertEqual('1025.0', item.original) self.assertEqual('1G', item.formatted) self.assertRaises(ValueError, formatting.mb_to_gb, '1024string') def test_gb(self): item = formatting.gb(2) self.assertEqual(2048, item.original) self.assertEqual('2G', item.formatted) item = formatting.gb('2') self.assertEqual(2048, item.original) self.assertEqual('2G', item.formatted) item = formatting.gb('2.0') self.assertEqual(2048, item.original) self.assertEqual('2G', item.formatted) def test_blank(self): item = formatting.blank() self.assertEqual(None, item.original) self.assertEqual('-', item.formatted) self.assertEqual('NULL', str(item)) def test_sort_mixed(self): blank = formatting.blank() items = [10, blank] sorted_items = sorted(items) self.assertEqual(sorted_items, [blank, 10]) items = [blank, 10] sorted_items = sorted(items) self.assertEqual(sorted_items, [blank, 10]) items = [blank, "10"] sorted_items = sorted(items) self.assertEqual(sorted_items, [blank, "10"]) def test_sort(self): items = [10, formatting.FormattedItem(20), formatting.FormattedItem(5)] sorted_items = sorted(items) self.assertEqual(sorted_items, [formatting.FormattedItem(5), 10, formatting.FormattedItem(20)]) class FormattedListTests(testing.TestCase): def test_init(self): l = formatting.listing([1, 'two'], separator=':') self.assertEqual([1, 'two'], list(l)) self.assertEqual(':', l.separator) l = formatting.listing([]) self.assertEqual(',', l.separator) def test_to_python(self): l = formatting.listing([1, 'two']) result = l.to_python() self.assertEqual([1, 'two'], result) l = formatting.listing(x for x in [1, 'two']) result = l.to_python() self.assertEqual([1, 'two'], result) def test_str(self): l = formatting.listing([1, 'two']) result = str(l) self.assertEqual('1,two', result) l = formatting.listing((x for x in [1, 'two']), separator=':') result = str(l) self.assertEqual('1:two', result) class FormattedTxnTests(testing.TestCase): def test_active_txn_empty(self): result = formatting.active_txn({}) self.assertEqual(str(result), 'NULL') 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_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_transaction_status(self): result = formatting.transaction_status({ 'transactionStatus': { 'name': 'a', 'friendlyName': 'b' } }) self.assertEqual(result.original, 'a') self.assertEqual(result.formatted, 'b') self.assertIsInstance(result, formatting.FormattedItem) def test_transaction_status_missing(self): b = formatting.blank() result = formatting.transaction_status({ 'transactionStatus': {} }) self.assertIsInstance(result, formatting.FormattedItem) self.assertEqual(result.original, b.original) class CLIAbortTests(testing.TestCase): def test_init(self): e = exceptions.CLIAbort("something") self.assertEqual(2, e.code) self.assertEqual("something", e.message) self.assertIsInstance(e, exceptions.CLIHalt) class ResolveIdTests(testing.TestCase): def test_resolve_id_one(self): resolver = lambda r: [12345] id = helpers.resolve_id(resolver, 'test') self.assertEqual(id, 12345) def test_resolve_id_none(self): resolver = lambda r: [] self.assertRaises( exceptions.CLIAbort, helpers.resolve_id, resolver, 'test') def test_resolve_id_multiple(self): resolver = lambda r: [12345, 54321] self.assertRaises( exceptions.CLIAbort, helpers.resolve_id, resolver, 'test') class TestFormatOutput(testing.TestCase): def test_format_output_string(self): t = formatting.format_output('just a string', 'raw') self.assertEqual('just a string', t) t = formatting.format_output(b'just a string', 'raw') self.assertEqual(b'just a string', t) def test_format_output_raw(self): t = formatting.Table(['nothing']) t.align['nothing'] = 'c' t.add_row(['testdata']) t.sortby = 'nothing' ret = formatting.format_output(t, 'raw') self.assertNotIn('nothing', str(ret)) self.assertIn('testdata', str(ret)) def test_format_output_json(self): t = formatting.Table(['nothing']) t.align['nothing'] = 'c' t.add_row(['testdata']) t.add_row([formatting.blank()]) t.sortby = 'nothing' ret = formatting.format_output(t, 'json') # This uses json.dumps due to slight changes in the output between # py3.3 and py3.4 expected = json.dumps([{'nothing': 'testdata'}, {'nothing': None}], indent=4) self.assertEqual(expected, ret) ret = formatting.format_output('test', 'json') self.assertEqual('"test"', ret) def test_format_output_json_keyvaluetable(self): t = formatting.KeyValueTable(['key', 'value']) t.add_row(['nothing', formatting.blank()]) t.sortby = 'nothing' ret = formatting.format_output(t, 'json') self.assertEqual('''{ "nothing": null }''', ret) def test_format_output_formatted_item(self): item = formatting.FormattedItem('test', 'test_formatted') ret = formatting.format_output(item, 'table') self.assertEqual('test_formatted', ret) def test_format_output_list(self): item = ['this', 'is', 'a', 'list'] ret = formatting.format_output(item, 'table') self.assertEqual(os.linesep.join(item), ret) def test_format_output_table(self): t = formatting.Table(['nothing']) t.align['nothing'] = 'c' t.add_row(['testdata']) t.sortby = 'nothing' ret = formatting.format_output(t, 'table') self.assertIn('nothing', str(ret)) self.assertIn('testdata', str(ret)) def test_unknown(self): t = formatting.format_output({}, 'raw') self.assertEqual({}, t) def test_sequentialoutput(self): t = formatting.SequentialOutput() self.assertTrue(hasattr(t, 'append')) t.append('This is a test') t.append('') t.append('More tests') output = formatting.format_output(t) self.assertEqual("This is a test\nMore tests", output) t.separator = ',' output = formatting.format_output(t) self.assertEqual("This is a test,More tests", output) def test_format_output_python(self): t = formatting.format_output('just a string', 'python') self.assertEqual('just a string', t) t = formatting.format_output(['just a string'], 'python') self.assertEqual(['just a string'], t) t = formatting.format_output({'test_key': 'test_value'}, 'python') self.assertEqual({'test_key': 'test_value'}, t) def test_format_output_python_keyvaluetable(self): t = formatting.KeyValueTable(['key', 'value']) t.add_row(['nothing', formatting.blank()]) t.sortby = 'nothing' ret = formatting.format_output(t, 'python') self.assertEqual({'nothing': None}, ret) def test_format_output_unicode(self): t = formatting.format_output('☃', 'raw') self.assertEqual('☃', t) item = formatting.FormattedItem('raw ☃', '☃') t = formatting.format_output(item) self.assertEqual('☃', t) t = formatting.format_output(item, 'raw') self.assertEqual('raw ☃', t) class TestTemplateArgs(testing.TestCase): def test_no_template_option(self): ctx = click.Context(core.cli) template.TemplateCallback()(ctx, None, None) self.assertIsNone(ctx.default_map) def test_template_options(self): ctx = click.Context(core.cli) path = os.path.join(testing.FIXTURE_PATH, 'sample_vs_template.conf') template.TemplateCallback(list_args=['disk'])(ctx, None, path) self.assertEqual(ctx.default_map, { 'cpu': '4', 'datacenter': 'dal05', 'domain': 'example.com', 'hostname': 'myhost', 'hourly': 'true', 'memory': '1024', 'monthly': 'false', 'network': '100', 'os': 'DEBIAN_7_64', 'disk': ['50', '100'], }) class TestExportToTemplate(testing.TestCase): def test_export_to_template(self): with tempfile.NamedTemporaryFile() as tmp: template.export_to_template(tmp.name, { 'os': None, 'datacenter': 'ams01', 'disk': ('disk1', 'disk2'), # The following should get stripped out 'config': 'no', 'really': 'no', 'format': 'no', 'debug': 'no', # exclude list 'test': 'test', }, exclude=['test']) with open(tmp.name) as f: data = f.read() self.assertEqual(len(data.splitlines()), 2) self.assertIn('datacenter=ams01\n', data) self.assertIn('disk=disk1,disk2\n', data) class IterToTableTests(testing.TestCase): def test_format_api_dict(self): result = formatting._format_dict({'key': 'value'}) self.assertIsInstance(result, formatting.Table) self.assertEqual(result.columns, ['name', 'value']) self.assertEqual(result.rows, [['key', 'value']]) def test_format_api_list(self): result = formatting._format_list([{'key': 'value'}]) self.assertIsInstance(result, formatting.Table) self.assertEqual(result.columns, ['key']) self.assertEqual(result.rows, [['value']]) def test_format_api_list_non_objects(self): result = formatting._format_list(['a', 'b', 'c']) self.assertIsInstance(result, formatting.Table) self.assertEqual(result.columns, ['value']) self.assertEqual(result.rows, [['a'], ['b'], ['c']]) softlayer-python-5.0.1/tests/CLI/modules/000077500000000000000000000000001267703721100202735ustar00rootroot00000000000000softlayer-python-5.0.1/tests/CLI/modules/__init__.py000066400000000000000000000000001267703721100223720ustar00rootroot00000000000000softlayer-python-5.0.1/tests/CLI/modules/call_api_tests.py000066400000000000000000000160011267703721100236310ustar00rootroot00000000000000""" SoftLayer.tests.CLI.modules.call_api_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import json from SoftLayer.CLI import call_api from SoftLayer import testing class BuildFilterTests(testing.TestCase): def test_empty(self): assert call_api._build_filters([]) == {} def test_basic(self): result = call_api._build_filters(['property=value']) assert result == {'property': {'operation': '_= value'}} def test_nested(self): result = call_api._build_filters(['nested.property=value']) assert result == {'nested': {'property': {'operation': '_= value'}}} def test_multi(self): result = call_api._build_filters(['prop1=value1', 'prop2=prop2']) assert result == { 'prop1': {'operation': '_= value1'}, 'prop2': {'operation': '_= prop2'}, } class CallCliTests(testing.TestCase): def test_python_output(self): result = self.run_command(['call-api', 'Service', 'method', '--mask=some.mask', '--limit=20', '--offset=40', '--id=100', '-f nested.property=5432', '--output-python']) self.assertEqual(result.exit_code, 0) # NOTE(kmcdonald): Python 3 no longer inserts 'u' before unicode # string literals but python 2 does. These are stripped out to make # this test pass on both python versions. stripped_output = result.output.replace("u'", "'") self.assertIsNotNone(stripped_output, """import SoftLayer client = SoftLayer.create_client_from_env() result = client.call(u'Service', u'method', filter={u'nested': {u'property': {'operation': 5432}}}, id=u'100', limit=20, mask=u'some.mask', offset=40) """) self.assertEqual(self.calls(), [], "no API calls were made") def test_options(self): mock = self.set_mock('SoftLayer_Service', 'method') mock.return_value = 'test' result = self.run_command(['call-api', 'Service', 'method', '--mask=some.mask', '--limit=20', '--offset=40', '--id=100', '-f property=1234', '-f nested.property=5432']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), 'test') self.assert_called_with('SoftLayer_Service', 'method', mask='mask[some.mask]', limit=20, offset=40, identifier='100', filter={ 'property': {'operation': 1234}, 'nested': {'property': {'operation': 5432}} }) def test_object(self): mock = self.set_mock('SoftLayer_Service', 'method') mock.return_value = {'string': 'string', 'int': 10, 'float': 1.0, 'None': None, 'Bool': True} result = self.run_command(['call-api', 'Service', 'method']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), {'string': 'string', 'int': 10, 'float': 1.0, 'None': None, 'Bool': True}) def test_object_table(self): mock = self.set_mock('SoftLayer_Service', 'method') mock.return_value = {'string': 'string', 'int': 10, 'float': 1.0, 'None': None, 'Bool': True} result = self.run_command(['call-api', 'Service', 'method'], fmt='table') self.assertEqual(result.exit_code, 0) # NOTE(kmcdonald): Order is not guaranteed self.assertIn(":........:........:", result.output) self.assertIn(": name : value :", result.output) self.assertIn(": int : 10 :", result.output) self.assertIn(": None : None :", result.output) self.assertIn(": float : 1.0 :", result.output) self.assertIn(": Bool : True :", result.output) self.assertIn(": string : string :", result.output) self.assertIn(":........:........:", result.output) def test_object_nested(self): mock = self.set_mock('SoftLayer_Service', 'method') mock.return_value = {'this': {'is': [{'pretty': 'nested'}]}} result = self.run_command(['call-api', 'Service', 'method']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), {'this': {'is': [{'pretty': 'nested'}]}}) def test_list(self): mock = self.set_mock('SoftLayer_Service', 'method') mock.return_value = [{'string': 'string', 'int': 10, 'float': 1.0, 'None': None, 'Bool': True}] result = self.run_command(['call-api', 'Service', 'method']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), [{'string': 'string', 'int': 10, 'float': 1.0, 'None': None, 'Bool': True}]) def test_list_table(self): mock = self.set_mock('SoftLayer_Service', 'method') mock.return_value = [{'string': 'string', 'int': 10, 'float': 1.0, 'None': None, 'Bool': True}] result = self.run_command(['call-api', 'Service', 'method'], fmt='table') self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, """:......:......:.......:.....:........: : Bool : None : float : int : string : :......:......:.......:.....:........: : True : None : 1.0 : 10 : string : :......:......:.......:.....:........: """) def test_parameters(self): mock = self.set_mock('SoftLayer_Service', 'method') mock.return_value = {} result = self.run_command(['call-api', 'Service', 'method', 'arg1', '1234']) self.assertEqual(result.exit_code, 0) self.assert_called_with('SoftLayer_Service', 'method', args=('arg1', '1234')) softlayer-python-5.0.1/tests/CLI/modules/cdn_tests.py000066400000000000000000000055371267703721100226450ustar00rootroot00000000000000""" SoftLayer.tests.CLI.modules.cdn_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ from SoftLayer import testing import json class CdnTests(testing.TestCase): def test_list_accounts(self): result = self.run_command(['cdn', 'list']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), [{'notes': None, 'created': '2012-06-25T14:05:28-07:00', 'type': 'ORIGIN_PULL', 'id': 1234, 'account_name': '1234a'}, {'notes': None, 'created': '2012-07-24T13:34:25-07:00', 'type': 'POP_PULL', 'id': 1234, 'account_name': '1234a'}]) def test_detail_account(self): result = self.run_command(['cdn', 'detail', '1245']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), {'notes': None, 'created': '2012-06-25T14:05:28-07:00', 'type': 'ORIGIN_PULL', 'status': 'ACTIVE', 'id': 1234, 'account_name': '1234a'}) def test_load_content(self): result = self.run_command(['cdn', 'load', '1234', 'http://example.com']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") def test_purge_content(self): result = self.run_command(['cdn', 'purge', '1234', 'http://example.com']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") def test_list_origins(self): result = self.run_command(['cdn', 'origin-list', '1234']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), [ {'media_type': 'FLASH', 'origin_url': 'http://ams01.objectstorage.softlayer.net:80', 'cname': None, 'id': '12345'}, {'media_type': 'FLASH', 'origin_url': 'http://sng01.objectstorage.softlayer.net:80', 'cname': None, 'id': '12345'}]) def test_add_origin(self): result = self.run_command(['cdn', 'origin-add', '1234', 'http://example.com']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") def test_remove_origin(self): result = self.run_command(['cdn', 'origin-remove', '1234', 'http://example.com']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") softlayer-python-5.0.1/tests/CLI/modules/config_tests.py000066400000000000000000000112771267703721100233440ustar00rootroot00000000000000""" SoftLayer.tests.CLI.modules.config_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import json import tempfile import mock import SoftLayer from SoftLayer import auth from SoftLayer.CLI.config import setup as config from SoftLayer.CLI import exceptions from SoftLayer import consts from SoftLayer import testing from SoftLayer import transports class TestHelpShow(testing.TestCase): def set_up(self): transport = transports.XmlRpcTransport( endpoint_url='http://endpoint-url', ) self.env.client = SoftLayer.BaseClient( transport=transport, auth=auth.BasicAuthentication('username', 'api-key')) def test_show(self): result = self.run_command(['config', 'show']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), {'Username': 'username', 'API Key': 'api-key', 'Endpoint URL': 'http://endpoint-url', 'Timeout': 'not set'}) class TestHelpSetup(testing.TestCase): def set_up(self): super(TestHelpSetup, self).set_up() # NOTE(kmcdonald): since the endpoint_url is changed with the client # in these commands, we need to ensure that a fixtured transport is # used. transport = testing.MockableTransport(SoftLayer.FixtureTransport()) self.env.client = SoftLayer.BaseClient(transport=transport) @mock.patch('SoftLayer.CLI.formatting.confirm') @mock.patch('SoftLayer.CLI.environment.Environment.getpass') @mock.patch('SoftLayer.CLI.environment.Environment.input') def test_setup(self, input, getpass, confirm_mock): with tempfile.NamedTemporaryFile() as config_file: confirm_mock.return_value = True getpass.return_value = 'A' * 64 input.side_effect = ['user', 'public', 0] result = self.run_command(['--config=%s' % config_file.name, 'config', 'setup']) self.assertEqual(result.exit_code, 0) self.assertTrue('Configuration Updated Successfully' in result.output) contents = config_file.read().decode("utf-8") self.assertTrue('[softlayer]' in contents) self.assertTrue('username = user' in contents) self.assertTrue('api_key = AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAA' in contents) self.assertTrue('endpoint_url = %s' % consts.API_PUBLIC_ENDPOINT in contents) @mock.patch('SoftLayer.CLI.formatting.confirm') @mock.patch('SoftLayer.CLI.environment.Environment.getpass') @mock.patch('SoftLayer.CLI.environment.Environment.input') def test_setup_cancel(self, input, getpass, confirm_mock): with tempfile.NamedTemporaryFile() as config_file: confirm_mock.return_value = False getpass.return_value = 'A' * 64 input.side_effect = ['user', 'public', 0] result = self.run_command(['--config=%s' % config_file.name, 'config', 'setup']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) @mock.patch('SoftLayer.CLI.environment.Environment.getpass') @mock.patch('SoftLayer.CLI.environment.Environment.input') def test_get_user_input_private(self, input, getpass): getpass.return_value = 'A' * 64 input.side_effect = ['user', 'private', 0] username, secret, endpoint_url, timeout = ( config.get_user_input(self.env)) self.assertEqual(username, 'user') self.assertEqual(secret, 'A' * 64) self.assertEqual(endpoint_url, consts.API_PRIVATE_ENDPOINT) @mock.patch('SoftLayer.CLI.environment.Environment.getpass') @mock.patch('SoftLayer.CLI.environment.Environment.input') def test_get_user_input_custom(self, input, getpass): getpass.return_value = 'A' * 64 input.side_effect = ['user', 'custom', 'custom-endpoint', 0] _, _, endpoint_url, _ = config.get_user_input(self.env) self.assertEqual(endpoint_url, 'custom-endpoint') @mock.patch('SoftLayer.CLI.environment.Environment.getpass') @mock.patch('SoftLayer.CLI.environment.Environment.input') def test_get_user_input_default(self, input, getpass): self.env.getpass.return_value = 'A' * 64 self.env.input.side_effect = ['user', 'public', 0] _, _, endpoint_url, _ = config.get_user_input(self.env) self.assertEqual(endpoint_url, consts.API_PUBLIC_ENDPOINT) softlayer-python-5.0.1/tests/CLI/modules/dns_tests.py000066400000000000000000000210621267703721100226540ustar00rootroot00000000000000""" SoftLayer.tests.CLI.modules.dns_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import json import os.path import mock from SoftLayer.CLI.dns import zone_import from SoftLayer.CLI import exceptions from SoftLayer import testing class DnsTests(testing.TestCase): def test_zone_print(self): result = self.run_command(['dns', 'zone-print', '1234']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), "lots of text") def test_create_zone(self): result = self.run_command(['dns', 'zone-create', 'example.com']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") @mock.patch('SoftLayer.CLI.formatting.no_going_back') def test_delete_zone(self, no_going_back_mock): no_going_back_mock.return_value = True result = self.run_command(['dns', 'zone-delete', '1234']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") no_going_back_mock.return_value = False result = self.run_command(['--really', 'dns', 'zone-delete', '1234']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") @mock.patch('SoftLayer.CLI.formatting.no_going_back') def test_delete_zone_abort(self, no_going_back_mock): no_going_back_mock.return_value = False result = self.run_command(['dns', 'zone-delete', '1234']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) def test_list_zones(self): result = self.run_command(['dns', 'zone-list']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), [{'serial': 2014030728, 'updated': '2014-03-07T13:52:31-06:00', 'id': 12345, 'zone': 'example.com'}]) def test_list_records(self): result = self.run_command(['dns', 'record-list', '1234']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output)[0], {'record': 'a', 'type': 'CNAME', 'id': 1, 'data': 'd', 'ttl': 7200}) def test_add_record(self): result = self.run_command(['dns', 'record-add', '1234', 'hostname', 'A', 'd', '--ttl=100']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") @mock.patch('SoftLayer.CLI.formatting.no_going_back') def test_delete_record(self, no_going_back_mock): no_going_back_mock.return_value = True result = self.run_command(['dns', 'record-remove', '1234']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") @mock.patch('SoftLayer.CLI.formatting.no_going_back') def test_delete_record_abort(self, no_going_back_mock): no_going_back_mock.return_value = False result = self.run_command(['dns', 'record-remove', '1234']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) def test_parse_zone_file(self): zone_file = """$ORIGIN realtest.com. $TTL 86400 @ IN SOA ns1.softlayer.com. support.softlayer.com. ( 2014052300 ; Serial 7200 ; Refresh 600 ; Retry 1728000 ; Expire 43200) ; Minimum @ 86400 IN NS ns1.softlayer.com. @ 86400 IN NS ns2.softlayer.com. IN MX 10 test.realtest.com. testing 86400 IN A 127.0.0.1 testing1 86400 IN A 12.12.0.1 server2 IN A 1.0.3.4 ftp IN CNAME server2 dev.realtest.com IN TXT "This is just a test of the txt record" IN AAAA 2001:db8:10::1 spf IN TXT "v=spf1 ip4:192.0.2.0/24 ip4:198.51.100.123 a" """ expected = [{'data': 'ns1.softlayer.com.', 'record': '@', 'type': 'NS', 'ttl': '86400'}, {'data': 'ns2.softlayer.com.', 'record': '@', 'type': 'NS', 'ttl': '86400'}, {'data': '127.0.0.1', 'record': 'testing', 'type': 'A', 'ttl': '86400'}, {'data': '12.12.0.1', 'record': 'testing1', 'type': 'A', 'ttl': '86400'}, {'data': '1.0.3.4', 'record': 'server2', 'type': 'A', 'ttl': None}, {'data': 'server2', 'record': 'ftp', 'type': 'CNAME', 'ttl': None}, {'data': '"This is just a test of the txt record"', 'record': 'dev.realtest.com', 'type': 'TXT', 'ttl': None}, {'data': '"v=spf1 ip4:192.0.2.0/24 ip4:198.51.100.123 a"', 'record': 'spf', 'type': 'TXT', 'ttl': None}] zone, records, bad_lines = zone_import.parse_zone_details(zone_file) self.assertEqual(zone, 'realtest.com') self.assertEqual(records, expected) self.assertEqual(len(bad_lines), 13) def test_import_zone_dry_run(self): path = os.path.join(testing.FIXTURE_PATH, 'realtest.com') result = self.run_command(['dns', 'import', path, '--dry-run']) self.assertIn("Parsed: zone=realtest.com", result.output) self.assertIn( "Parsed: type=NS, record=@, data=ns1.softlayer.com., ttl=86400", result.output) self.assertIn("Unparsed: $TTL 86400", result.output) def test_import_zone(self): path = os.path.join(testing.FIXTURE_PATH, 'realtest.com') result = self.run_command(['dns', 'import', path]) self.assertEqual(self.calls('SoftLayer_Dns_Domain', 'createObject'), []) calls = self.calls('SoftLayer_Dns_Domain_ResourceRecord', 'createObject') expected_calls = [{'data': 'ns1.softlayer.com.', 'host': '@', 'domainId': 12345, 'type': 'NS', 'ttl': '86400'}, {'data': 'ns2.softlayer.com.', 'host': '@', 'domainId': 12345, 'type': 'NS', 'ttl': '86400'}, {'data': '127.0.0.1', 'host': 'testing', 'domainId': 12345, 'type': 'A', 'ttl': '86400'}, {'data': '12.12.0.1', 'host': 'testing1', 'domainId': 12345, 'type': 'A', 'ttl': '86400'}, {'data': '1.0.3.4', 'host': 'server2', 'domainId': 12345, 'type': 'A', 'ttl': None}, {'data': 'server2', 'host': 'ftp', 'domainId': 12345, 'type': 'CNAME', 'ttl': None}, {'data': '"This is just a test of the txt record"', 'host': 'dev.realtest.com', 'domainId': 12345, 'type': 'TXT', 'ttl': None}, {'data': '"v=spf1 ip4:192.0.2.0/24 ' 'ip4:198.51.100.123 a -all"', 'host': 'spf', 'domainId': 12345, 'type': 'TXT', 'ttl': None}] self.assertEqual(len(calls), len(expected_calls)) for call, expected_call in zip(calls, expected_calls): self.assertEqual(call.args[0], expected_call) self.assertIn("Finished", result.output) softlayer-python-5.0.1/tests/CLI/modules/firewall_tests.py000066400000000000000000000020321267703721100236710ustar00rootroot00000000000000""" SoftLayer.tests.CLI.modules.firewall_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import json from SoftLayer import testing class FirewallTests(testing.TestCase): def test_list_firewalls(self): result = self.run_command(['firewall', 'list']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), [{'type': 'VLAN - dedicated', 'server/vlan id': 1, 'features': ['HA'], 'firewall id': 'vlan:1234'}, {'features': '-', 'firewall id': 'vs:1234', 'server/vlan id': 1, 'type': 'Virtual Server - standard'}, {'features': '-', 'firewall id': 'server:1234', 'server/vlan id': 1, 'type': 'Server - standard'}]) softlayer-python-5.0.1/tests/CLI/modules/globalip_tests.py000066400000000000000000000046001267703721100236600ustar00rootroot00000000000000""" SoftLayer.tests.CLI.modules.globalip_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import mock from SoftLayer.CLI import exceptions from SoftLayer import testing import json class DnsTests(testing.TestCase): def test_ip_assign(self): result = self.run_command(['globalip', 'assign', '1', '127.0.0.1']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") @mock.patch('SoftLayer.CLI.formatting.no_going_back') def test_ip_cancel(self, no_going_back_mock): # Test using --really flag result = self.run_command(['--really', 'globalip', 'cancel', '1']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") # Test with confirmation no_going_back_mock.return_value = True result = self.run_command(['globalip', 'cancel', '1']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") # Test with confirmation and responding negatively no_going_back_mock.return_value = False result = self.run_command(['globalip', 'cancel', '1']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) def test_ip_list(self): result = self.run_command(['globalip', 'list', '--ip-version=v4']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), [{'assigned': 'Yes', 'id': '200', 'ip': '127.0.0.1', 'target': '127.0.0.1 (example.com)'}, {'assigned': 'Yes', 'id': '201', 'ip': '127.0.0.1', 'target': '127.0.0.1 (example.com)'}]) result = self.run_command(['globalip', 'list', '--ip-version=v6']) self.assertEqual(json.loads(result.output), [{'assigned': 'Yes', 'id': '200', 'ip': '127.0.0.1', 'target': '127.0.0.1 (example.com)'}, {'assigned': 'Yes', 'id': '201', 'ip': '127.0.0.1', 'target': '127.0.0.1 (example.com)'}]) softlayer-python-5.0.1/tests/CLI/modules/nas_tests.py000066400000000000000000000011051267703721100226450ustar00rootroot00000000000000""" SoftLayer.tests.CLI.modules.nas_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ from SoftLayer import testing import json class RWhoisTests(testing.TestCase): def test_list_nas(self): result = self.run_command(['nas', 'list']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), [{'datacenter': 'Dallas', 'server': '127.0.0.1', 'id': 1, 'size': 10}]) softlayer-python-5.0.1/tests/CLI/modules/object_storage_tests.py000066400000000000000000000024421267703721100250630ustar00rootroot00000000000000""" SoftLayer.tests.CLI.modules.object_storage_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import json from SoftLayer import testing class ObjectStorageTests(testing.TestCase): def test_list_accounts(self): result = self.run_command(['object-storage', 'accounts']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), [{'id': 12345, 'name': 'SLOS12345-1'}, {'id': 12346, 'name': 'SLOS12345-2'}]) def test_list_endpoints(self): accounts = self.set_mock('SoftLayer_Account', 'getHubNetworkStorage') accounts.return_value = { 'storageNodes': [{ 'datacenter': {'name': 'dal05'}, 'frontendIpAddress': 'https://dal05/auth/v1.0/', 'backendIpAddress': 'https://dal05/auth/v1.0/'} ], } result = self.run_command(['object-storage', 'endpoints']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), [{'datacenter': 'dal05', 'private': 'https://dal05/auth/v1.0/', 'public': 'https://dal05/auth/v1.0/'}]) softlayer-python-5.0.1/tests/CLI/modules/rwhois_tests.py000066400000000000000000000063301267703721100234040ustar00rootroot00000000000000""" SoftLayer.tests.CLI.modules.rwhois_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ from SoftLayer.CLI import exceptions from SoftLayer import testing import json class RWhoisTests(testing.TestCase): def test_edit_nothing(self): result = self.run_command(['rwhois', 'edit']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) def test_edit(self): result = self.run_command(['rwhois', 'edit', '--abuse=abuse@site.com', '--address1=address line 1', '--address2=address line 2', '--company=Company, Inc', '--city=Dallas', '--country=United States', '--firstname=John', '--lastname=Smith', '--postal=12345', '--state=TX', '--state=TX', '--private']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") self.assert_called_with('SoftLayer_Network_Subnet_Rwhois_Data', 'editObject', args=({'city': 'Dallas', 'firstName': 'John', 'companyName': 'Company, Inc', 'address1': 'address line 1', 'address2': 'address line 2', 'lastName': 'Smith', 'abuseEmail': 'abuse@site.com', 'state': 'TX', 'country': 'United States', 'postalCode': '12345', 'privateResidenceFlag': True},), identifier='id') def test_edit_public(self): result = self.run_command(['rwhois', 'edit', '--public']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") self.assert_called_with('SoftLayer_Network_Subnet_Rwhois_Data', 'editObject', args=({'privateResidenceFlag': False},), identifier='id') def test_show(self): self.maxDiff = 100000 result = self.run_command(['rwhois', 'show']) expected = {'Abuse Email': 'abuseEmail', 'Address 1': 'address1', 'Address 2': 'address2', 'City': 'city', 'Company': 'companyName', 'Country': 'country', 'Name': 'firstName lastName', 'Postal Code': 'postalCode', 'State': '-', 'Private Residence': True} self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), expected) softlayer-python-5.0.1/tests/CLI/modules/server_tests.py000066400000000000000000000431441267703721100234030ustar00rootroot00000000000000""" SoftLayer.tests.CLI.modules.server_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ This is a series of integration tests designed to test the complete command line interface. :license: MIT, see LICENSE for more details. """ import mock from SoftLayer.CLI import exceptions from SoftLayer import testing import json import tempfile class ServerCLITests(testing.TestCase): def test_server_cancel_reasons(self): result = self.run_command(['server', 'cancel-reasons']) output = json.loads(result.output) self.assertEqual(result.exit_code, 0) self.assertEqual(len(output), 10) def test_server_details(self): result = self.run_command(['server', 'detail', '1234', '--passwords', '--price']) expected = { 'cores': 2, 'created': '2013-08-01 15:23:45', 'datacenter': 'TEST00', 'guid': '1a2b3c-1701', 'domain': 'test.sftlyr.ws', 'hostname': 'hardware-test1', 'fqdn': 'hardware-test1.test.sftlyr.ws', 'id': 1000, 'ipmi_ip': '10.1.0.3', 'memory': 2048, 'notes': 'These are test notes.', 'os': 'Ubuntu', 'owner': 'chechu', 'price rate': 16.08, 'private_ip': '10.1.0.2', 'ptr': '2.0.1.10.in-addr.arpa', 'public_ip': '172.16.1.100', 'remote users': [{'password': 'abc123', 'ipmi_username': 'root'}], 'status': 'ACTIVE', 'tags': ['test_tag'], 'users': [{'password': 'abc123', 'username': 'root'}], 'vlans': [{'id': 9653, 'number': 1800, 'type': 'PRIVATE'}, {'id': 19082, 'number': 3672, 'type': 'PUBLIC'}] } self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), expected) def test_detail_vs_empty_tag(self): mock = self.set_mock('SoftLayer_Hardware_Server', 'getObject') mock.return_value = { 'id': 100, 'processorPhysicalCoreAmount': 2, 'memoryCapacity': 2, 'tagReferences': [ {'tag': {'name': 'example-tag'}}, {}, ], } result = self.run_command(['server', 'detail', '100']) self.assertEqual(result.exit_code, 0) self.assertEqual( json.loads(result.output)['tags'], ['example-tag'], ) def test_list_servers(self): result = self.run_command(['server', 'list', '--tag=openstack']) expected = [ { 'datacenter': 'TEST00', 'primary_ip': '172.16.1.100', 'hostname': 'hardware-test1', 'id': 1000, 'backend_ip': '10.1.0.2', 'action': 'TXN_NAME', }, { 'datacenter': 'TEST00', 'primary_ip': '172.16.4.94', 'hostname': 'hardware-test2', 'id': 1001, 'backend_ip': '10.1.0.3', 'action': None, }, { 'datacenter': 'TEST00', 'primary_ip': '172.16.4.95', 'hostname': 'hardware-bad-memory', 'id': 1002, 'backend_ip': '10.1.0.4', 'action': None, }, { 'action': None, 'backend_ip': None, 'datacenter': None, 'hostname': None, 'id': 1003, 'primary_ip': None, }, ] self.assertEqual(result.exit_code, 0) self.assertEqual(expected, json.loads(result.output)) @mock.patch('SoftLayer.CLI.formatting.no_going_back') @mock.patch('SoftLayer.HardwareManager.reload') def test_server_reload(self, reload_mock, ngb_mock): ngb_mock.return_value = False # Check the positive case result = self.run_command(['--really', 'server', 'reload', '12345', '--key=4567']) self.assertEqual(result.exit_code, 0) reload_mock.assert_called_with(12345, None, [4567]) # Now check to make sure we properly call CLIAbort in the negative case result = self.run_command(['server', 'reload', '12345']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) @mock.patch('SoftLayer.CLI.formatting.no_going_back') @mock.patch('SoftLayer.HardwareManager.cancel_hardware') def test_cancel_server(self, cancel_mock, ngb_mock): ngb_mock.return_value = False # Check the positive case result = self.run_command(['--really', 'server', 'cancel', '12345', '--reason=Test', '--comment=Test']) self.assertEqual(result.exit_code, 0) cancel_mock.assert_called_with(12345, "Test", "Test", False) # Test result = self.run_command(['server', 'cancel', '12345', '--reason=Test', '--comment=Test']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) @mock.patch('SoftLayer.CLI.formatting.confirm') def test_server_power_off(self, confirm_mock): # Check the positive case result = self.run_command(['--really', 'server', 'power-off', '12345']) self.assert_called_with('SoftLayer_Hardware_Server', 'powerOff', identifier=12345) # Now check to make sure we properly call CLIAbort in the negative case confirm_mock.return_value = False result = self.run_command(['server', 'power-off', '12345']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) def test_server_reboot_default(self): result = self.run_command(['--really', 'server', 'reboot', '12345']) self.assertEqual(result.exit_code, 0) self.assert_called_with('SoftLayer_Hardware_Server', 'rebootDefault', identifier=12345) def test_server_reboot_soft(self): result = self.run_command(['--really', 'server', 'reboot', '12345', '--soft']) self.assertEqual(result.exit_code, 0) self.assert_called_with('SoftLayer_Hardware_Server', 'rebootSoft', identifier=12345) def test_server_reboot_hard(self): result = self.run_command(['--really', 'server', 'reboot', '12345', '--hard']) self.assertEqual(result.exit_code, 0) self.assert_called_with('SoftLayer_Hardware_Server', 'rebootHard', identifier=12345) @mock.patch('SoftLayer.CLI.formatting.confirm') def test_server_reboot_negative(self, confirm_mock): confirm_mock.return_value = False result = self.run_command(['server', 'reboot', '12345']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) def test_server_power_on(self): result = self.run_command(['--really', 'server', 'power-on', '12345']) self.assertEqual(result.exit_code, 0) self.assert_called_with('SoftLayer_Hardware_Server', 'powerOn', identifier=12345) def test_server_power_cycle(self): result = self.run_command(['--really', 'server', 'power-cycle', '12345']) self.assertEqual(result.exit_code, 0) self.assert_called_with('SoftLayer_Hardware_Server', 'powerCycle', identifier=12345) @mock.patch('SoftLayer.CLI.formatting.confirm') def test_server_power_cycle_negative(self, confirm_mock): confirm_mock.return_value = False result = self.run_command(['server', 'power-cycle', '12345']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) @mock.patch('SoftLayer.HardwareManager.verify_order') def test_create_server_test_flag(self, verify_mock): verify_mock.return_value = { 'prices': [ { 'recurringFee': 0.0, 'setupFee': 0.0, 'item': {'description': 'First Item'}, }, { 'recurringFee': 25.0, 'setupFee': 0.0, 'item': {'description': 'Second Item'}, } ] } result = self.run_command(['--really', 'server', 'create', '--size=S1270_8GB_2X1TBSATA_NORAID', '--hostname=test', '--domain=example.com', '--datacenter=TEST00', '--port-speed=100', '--os=UBUNTU_12_64', '--test'], fmt='raw') self.assertEqual(result.exit_code, 0) self.assertIn("First Item", result.output) self.assertIn("Second Item", result.output) self.assertIn("Total monthly cost", result.output) def test_create_options(self): result = self.run_command(['server', 'create-options']) self.assertEqual(result.exit_code, 0) expected = [ [{'datacenter': 'Washington 1', 'value': 'wdc01'}], [{'size': 'Single Xeon 1270, 8GB Ram, 2x1TB SATA disks, Non-RAID', 'value': 'S1270_8GB_2X1TBSATA_NORAID'}], [{'operating_system': 'Ubuntu / 14.04-64', 'value': 'UBUNTU_14_64'}], [{'port_speed': '10 Mbps Public & Private Network Uplinks', 'value': '10'}], [{'extras': '1 IPv6 Address', 'value': '1_IPV6_ADDRESS'}]] self.assertEqual(json.loads(result.output), expected) @mock.patch('SoftLayer.HardwareManager.place_order') def test_create_server(self, order_mock): order_mock.return_value = { 'orderId': 98765, 'orderDate': '2013-08-02 15:23:47' } result = self.run_command(['--really', 'server', 'create', '--size=S1270_8GB_2X1TBSATA_NORAID', '--hostname=test', '--domain=example.com', '--datacenter=TEST00', '--port-speed=100', '--os=UBUNTU_12_64', '--no-public', '--key=10', ]) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), {'id': 98765, 'created': '2013-08-02 15:23:47'}) def test_create_server_missing_required(self): # This is missing a required argument result = self.run_command(['server', 'create', # Note: no chassis id '--hostname=test', '--domain=example.com', '--datacenter=TEST00', '--network=100', '--os=UBUNTU_12_64_MINIMAL', ]) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, SystemExit) @mock.patch('SoftLayer.CLI.template.export_to_template') def test_create_server_with_export(self, export_mock): result = self.run_command(['--really', 'server', 'create', '--size=S1270_8GB_2X1TBSATA_NORAID', '--hostname=test', '--domain=example.com', '--datacenter=TEST00', '--port-speed=100', '--os=UBUNTU_12_64', '--no-public', '--export=/path/to/test_file.txt'], fmt='raw') self.assertEqual(result.exit_code, 0) self.assertIn("Successfully exported options to a template file.", result.output) export_mock.assert_called_with('/path/to/test_file.txt', {'billing': 'hourly', 'datacenter': 'TEST00', 'domain': 'example.com', 'extra': (), 'hostname': 'test', 'key': (), 'os': 'UBUNTU_12_64', 'port_speed': 100, 'postinstall': None, 'size': 'S1270_8GB_2X1TBSATA_NORAID', 'test': False, 'no_public': True, 'wait': None, 'template': None}, exclude=['wait', 'test']) def test_edit_server_userdata_and_file(self): # Test both userdata and userfile at once with tempfile.NamedTemporaryFile() as userfile: result = self.run_command(['server', 'edit', '1000', '--hostname=hardware-test1', '--domain=test.sftlyr.ws', '--userdata=My data', '--userfile=%s' % userfile.name]) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.ArgumentError) def test_edit_server_userdata(self): result = self.run_command(['server', 'edit', '1000', '--hostname=hardware-test1', '--domain=test.sftlyr.ws', '--userdata=My data']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") self.assert_called_with('SoftLayer_Hardware_Server', 'editObject', args=({'domain': 'test.sftlyr.ws', 'hostname': 'hardware-test1'},), identifier=1000) @mock.patch('SoftLayer.HardwareManager.edit') def test_edit_server_failed(self, edit_mock): edit_mock.return_value = False result = self.run_command(['server', 'edit', '1000', '--hostname=hardware-test1', '--domain=test.sftlyr.ws', '--userdata=My data']) self.assertEqual(result.exit_code, 2) self.assertEqual(result.output, "") edit_mock.assert_called_with(1000, userdata='My data', domain='test.sftlyr.ws', hostname='hardware-test1') def test_edit_server_userfile(self): with tempfile.NamedTemporaryFile() as userfile: userfile.write(b"some data") userfile.flush() result = self.run_command(['server', 'edit', '1000', '--userfile=%s' % userfile.name]) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") self.assert_called_with('SoftLayer_Hardware_Server', 'setUserMetadata', args=(['some data'],), identifier=1000) @mock.patch('SoftLayer.CLI.formatting.confirm') def test_update_firmware(self, confirm_mock): confirm_mock.return_value = True result = self.run_command(['server', 'update-firmware', '1000']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, "") self.assert_called_with('SoftLayer_Hardware_Server', 'createFirmwareUpdateTransaction', args=((1, 1, 1, 1)), identifier=1000) def test_edit(self): result = self.run_command(['server', 'edit', '--domain=example.com', '--hostname=host', '--userdata="testdata"', '--tag=dev', '--tag=green', '--public-speed=10', '--private-speed=100', '100']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, '') self.assert_called_with( 'SoftLayer_Hardware_Server', 'editObject', args=({'domain': 'example.com', 'hostname': 'host'},), identifier=100, ) self.assert_called_with( 'SoftLayer_Hardware_Server', 'setUserMetadata', args=(['"testdata"'],), identifier=100, ) self.assert_called_with( 'SoftLayer_Hardware_Server', 'setPublicNetworkInterfaceSpeed', args=(10,), identifier=100, ) self.assert_called_with( 'SoftLayer_Hardware_Server', 'setPrivateNetworkInterfaceSpeed', args=(100,), identifier=100, ) softlayer-python-5.0.1/tests/CLI/modules/sshkey_tests.py000066400000000000000000000102741267703721100234010ustar00rootroot00000000000000""" SoftLayer.tests.CLI.modules.sshkey_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import json import os.path import tempfile import mock from SoftLayer import testing class SshKeyTests(testing.TestCase): def test_add_by_option(self): service = self.client['Security_Ssh_Key'] mock_key = service.getObject()['key'] result = self.run_command(['sshkey', 'add', 'key1', '--key=%s' % mock_key, '--note=my key']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), "SSH key added: aa:bb:cc:dd") self.assert_called_with('SoftLayer_Security_Ssh_Key', 'createObject', args=({'notes': 'my key', 'key': mock_key, 'label': 'key1'},)) def test_add_by_file(self): path = os.path.join(testing.FIXTURE_PATH, 'id_rsa.pub') result = self.run_command(['sshkey', 'add', 'key1', '--in-file=%s' % path]) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), "SSH key added: aa:bb:cc:dd") service = self.client['Security_Ssh_Key'] mock_key = service.getObject()['key'] self.assert_called_with('SoftLayer_Security_Ssh_Key', 'createObject', args=({'notes': None, 'key': mock_key, 'label': 'key1'},)) def test_remove_key(self): result = self.run_command(['--really', 'sshkey', 'remove', '1234']) self.assertEqual(result.exit_code, 0) self.assert_called_with('SoftLayer_Security_Ssh_Key', 'deleteObject', identifier=1234) @mock.patch('SoftLayer.CLI.formatting.no_going_back') def test_remove_key_fail(self, ngb_mock): ngb_mock.return_value = False result = self.run_command(['sshkey', 'remove', '1234']) self.assertEqual(result.exit_code, 2) def test_edit_key(self): result = self.run_command(['sshkey', 'edit', '1234', '--label=key1', '--note=my key']) self.assertEqual(result.exit_code, 0) self.assert_called_with('SoftLayer_Security_Ssh_Key', 'editObject', args=({'notes': 'my key', 'label': 'key1'},), identifier=1234) def test_edit_key_fail(self): fixture = self.set_mock('SoftLayer_Security_Ssh_Key', 'editObject') fixture.return_value = False result = self.run_command(['sshkey', 'edit', '1234', '--label=key1', '--note=my key']) self.assertEqual(result.exit_code, 2) def test_list_keys(self): result = self.run_command(['sshkey', 'list']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), [{'notes': '-', 'fingerprint': None, 'id': '100', 'label': 'Test 1'}, {'notes': 'my key', 'fingerprint': None, 'id': '101', 'label': 'Test 2'}]) def test_print_key(self): result = self.run_command(['sshkey', 'print', '1234']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), {'id': 1234, 'label': 'label', 'notes': 'notes'}) def test_print_key_file(self): with tempfile.NamedTemporaryFile() as sshkey_file: service = self.client['Security_Ssh_Key'] mock_key = service.getObject()['key'] result = self.run_command(['sshkey', 'print', '1234', '--out-file=%s' % sshkey_file.name]) self.assertEqual(result.exit_code, 0) self.assertEqual(mock_key, sshkey_file.read().decode("utf-8")) softlayer-python-5.0.1/tests/CLI/modules/summary_tests.py000066400000000000000000000012441267703721100235650ustar00rootroot00000000000000""" SoftLayer.tests.CLI.modules.summary_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ from SoftLayer import testing import json class SummaryTests(testing.TestCase): def test_summary(self): result = self.run_command(['summary']) expected = [ { 'datacenter': 'dal00', 'subnets': 0, 'hardware': 1, 'public_ips': 6, 'virtual_servers': 1, 'vlans': 3 } ] self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), expected) softlayer-python-5.0.1/tests/CLI/modules/ticket_tests.py000066400000000000000000000024101267703721100233470ustar00rootroot00000000000000""" SoftLayer.tests.CLI.modules.ticket_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ from SoftLayer import testing import json class TicketTests(testing.TestCase): def test_list(self): result = self.run_command(['ticket', 'list']) expected = [{ 'assigned_user': 'John Smith', 'id': 102, 'last_edited': '2013-08-01T14:16:47-07:00', 'status': 'Open', 'title': 'Cloud Instance Cancellation - 08/01/13'}] self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), expected) def test_detail(self): result = self.run_command(['ticket', 'detail', '1']) expected = { 'created': '2013-08-01T14:14:04-07:00', 'edited': '2013-08-01T14:16:47-07:00', 'id': 100, 'status': 'Closed', 'title': 'Cloud Instance Cancellation - 08/01/13', 'update 1': 'a bot says something', 'update 2': 'By John Smith\nuser says something', 'update 3': 'By emp1 (Employee)\nemployee says something', } self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), expected) softlayer-python-5.0.1/tests/CLI/modules/vs_tests.py000066400000000000000000000430561267703721100225270ustar00rootroot00000000000000""" SoftLayer.tests.CLI.modules.vs_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import json import mock from SoftLayer.CLI import exceptions from SoftLayer import testing class VirtTests(testing.TestCase): def test_list_vs(self): result = self.run_command(['vs', 'list', '--tag=tag']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), [{'datacenter': 'TEST00', 'primary_ip': '172.16.240.2', 'hostname': 'vs-test1', 'action': None, 'id': 100, 'backend_ip': '10.45.19.37'}, {'datacenter': 'TEST00', 'primary_ip': '172.16.240.7', 'hostname': 'vs-test2', 'action': None, 'id': 104, 'backend_ip': '10.45.19.35'}]) def test_detail_vs(self): result = self.run_command(['vs', 'detail', '100', '--passwords', '--price']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), {'active_transaction': None, 'cores': 2, 'created': '2013-08-01 15:23:45', 'datacenter': 'TEST00', 'hostname': 'vs-test1', 'domain': 'test.sftlyr.ws', 'fqdn': 'vs-test1.test.sftlyr.ws', 'id': 100, 'guid': '1a2b3c-1701', 'memory': 1024, 'modified': {}, 'os': '12.04-64 Minimal for VSI', 'os_version': '12.04-64 Minimal for VSI', 'notes': 'notes', 'price rate': 1.54, 'tags': ['production'], 'private_cpu': {}, 'private_ip': '10.45.19.37', 'private_only': {}, 'ptr': 'test.softlayer.com.', 'public_ip': '172.16.240.2', 'state': 'RUNNING', 'status': 'ACTIVE', 'users': [{'password': 'pass', 'username': 'user'}], 'vlans': [{'type': 'PUBLIC', 'number': 23, 'id': 1}], 'owner': 'chechu'}) def test_detail_vs_empty_tag(self): mock = self.set_mock('SoftLayer_Virtual_Guest', 'getObject') mock.return_value = { 'id': 100, 'maxCpu': 2, 'maxMemory': 1024, 'tagReferences': [ {'tag': {'name': 'example-tag'}}, {}, ], } result = self.run_command(['vs', 'detail', '100']) self.assertEqual(result.exit_code, 0) self.assertEqual( json.loads(result.output)['tags'], ['example-tag'], ) def test_create_options(self): result = self.run_command(['vs', 'create-options']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), {'cpus (private)': [], 'cpus (standard)': ['1', '2', '3', '4'], 'datacenter': ['ams01', 'dal05'], 'local disk(0)': ['25', '100'], 'memory': ['1024', '2048', '3072', '4096'], 'nic': ['10', '100', '1000'], 'os (CENTOS)': 'CENTOS_6_64', 'os (DEBIAN)': 'DEBIAN_7_64', 'os (UBUNTU)': 'UBUNTU_12_64'}) @mock.patch('SoftLayer.CLI.formatting.confirm') def test_create(self, confirm_mock): confirm_mock.return_value = True result = self.run_command(['vs', 'create', '--cpu=2', '--domain=example.com', '--hostname=host', '--os=UBUNTU_LATEST', '--memory=1', '--network=100', '--billing=hourly', '--datacenter=dal05', '--tag=dev', '--tag=green']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), {'guid': '1a2b3c-1701', 'id': 100, 'created': '2013-08-01 15:23:45'}) args = ({'datacenter': {'name': 'dal05'}, 'domain': 'example.com', 'hourlyBillingFlag': True, 'localDiskFlag': True, 'maxMemory': 1024, 'hostname': 'host', 'startCpus': 2, 'operatingSystemReferenceCode': 'UBUNTU_LATEST', 'networkComponents': [{'maxSpeed': '100'}]},) self.assert_called_with('SoftLayer_Virtual_Guest', 'createObject', args=args) @mock.patch('SoftLayer.CLI.formatting.confirm') def test_create_with_integer_image_id(self, confirm_mock): confirm_mock.return_value = True result = self.run_command(['vs', 'create', '--cpu=2', '--domain=example.com', '--hostname=host', '--image=12345', '--memory=1', '--network=100', '--billing=hourly', '--datacenter=dal05']) self.assertEqual(result.exit_code, 0) self.assertEqual(json.loads(result.output), {'guid': '1a2b3c-1701', 'id': 100, 'created': '2013-08-01 15:23:45'}) args = ({ 'datacenter': {'name': 'dal05'}, 'domain': 'example.com', 'hourlyBillingFlag': True, 'localDiskFlag': True, 'maxMemory': 1024, 'hostname': 'host', 'startCpus': 2, 'blockDeviceTemplateGroup': { 'globalIdentifier': '0B5DEAF4-643D-46CA-A695-CECBE8832C9D', }, 'networkComponents': [{'maxSpeed': '100'}] },) self.assert_called_with('SoftLayer_Virtual_Guest', 'createObject', args=args) @mock.patch('SoftLayer.CLI.formatting.confirm') def test_dns_sync_both(self, confirm_mock): confirm_mock.return_value = True getReverseDomainRecords = self.set_mock('SoftLayer_Virtual_Guest', 'getReverseDomainRecords') getReverseDomainRecords.return_value = [{ 'networkAddress': '172.16.240.2', 'name': '2.240.16.172.in-addr.arpa', 'resourceRecords': [{'data': 'test.softlayer.com.', 'id': 100, 'host': '12'}], 'updateDate': '2013-09-11T14:36:57-07:00', 'serial': 1234665663, 'id': 123456, }] getResourceRecords = self.set_mock('SoftLayer_Dns_Domain', 'getResourceRecords') getResourceRecords.return_value = [] createAargs = ({ 'type': 'a', 'host': 'vs-test1', 'domainId': 98765, 'data': '172.16.240.2', 'ttl': 7200 },) createPTRargs = ({ 'type': 'ptr', 'host': '2', 'domainId': 123456, 'data': 'vs-test1.test.sftlyr.ws', 'ttl': 7200 },) result = self.run_command(['vs', 'dns-sync', '100']) self.assertEqual(result.exit_code, 0) self.assert_called_with('SoftLayer_Dns_Domain', 'getResourceRecords') self.assert_called_with('SoftLayer_Virtual_Guest', 'getReverseDomainRecords') self.assert_called_with('SoftLayer_Dns_Domain_ResourceRecord', 'createObject', args=createAargs) self.assert_called_with('SoftLayer_Dns_Domain_ResourceRecord', 'createObject', args=createPTRargs) @mock.patch('SoftLayer.CLI.formatting.confirm') def test_dns_sync_v6(self, confirm_mock): confirm_mock.return_value = True getResourceRecords = self.set_mock('SoftLayer_Dns_Domain', 'getResourceRecords') getResourceRecords.return_value = [] guest = self.set_mock('SoftLayer_Virtual_Guest', 'getObject') test_guest = { 'id': 100, 'hostname': 'vs-test1', 'domain': 'sftlyr.ws', 'primaryIpAddress': '172.16.240.2', 'fullyQualifiedDomainName': 'vs-test1.sftlyr.ws', "primaryNetworkComponent": {} } guest.return_value = test_guest result = self.run_command(['vs', 'dns-sync', '--aaaa-record', '100']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) test_guest['primaryNetworkComponent'] = { 'primaryVersion6IpAddressRecord': { 'ipAddress': '2607:f0d0:1b01:0023:0000:0000:0000:0004' } } createV6args = ({ 'type': 'aaaa', 'host': 'vs-test1', 'domainId': 98765, 'data': '2607:f0d0:1b01:0023:0000:0000:0000:0004', 'ttl': 7200 },) guest.return_value = test_guest result = self.run_command(['vs', 'dns-sync', '--aaaa-record', '100']) self.assertEqual(result.exit_code, 0) self.assert_called_with('SoftLayer_Dns_Domain_ResourceRecord', 'createObject', args=createV6args) v6Record = { 'id': 1, 'ttl': 7200, 'data': '2607:f0d0:1b01:0023:0000:0000:0000:0004', 'host': 'vs-test1', 'type': 'aaaa' } getResourceRecords = self.set_mock('SoftLayer_Dns_Domain', 'getResourceRecords') getResourceRecords.return_value = [v6Record] editArgs = (v6Record,) result = self.run_command(['vs', 'dns-sync', '--aaaa-record', '100']) self.assertEqual(result.exit_code, 0) self.assert_called_with('SoftLayer_Dns_Domain_ResourceRecord', 'editObject', args=editArgs) getResourceRecords = self.set_mock('SoftLayer_Dns_Domain', 'getResourceRecords') getResourceRecords.return_value = [v6Record, v6Record] result = self.run_command(['vs', 'dns-sync', '--aaaa-record', '100']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) @mock.patch('SoftLayer.CLI.formatting.confirm') def test_dns_sync_edit_a(self, confirm_mock): confirm_mock.return_value = True getResourceRecords = self.set_mock('SoftLayer_Dns_Domain', 'getResourceRecords') getResourceRecords.return_value = [ {'id': 1, 'ttl': 7200, 'data': '1.1.1.1', 'host': 'vs-test1', 'type': 'a'} ] editArgs = ( {'type': 'a', 'host': 'vs-test1', 'data': '172.16.240.2', 'id': 1, 'ttl': 7200}, ) result = self.run_command(['vs', 'dns-sync', '-a', '100']) self.assertEqual(result.exit_code, 0) self.assert_called_with('SoftLayer_Dns_Domain_ResourceRecord', 'editObject', args=editArgs) getResourceRecords = self.set_mock('SoftLayer_Dns_Domain', 'getResourceRecords') getResourceRecords.return_value = [ {'id': 1, 'ttl': 7200, 'data': '1.1.1.1', 'host': 'vs-test1', 'type': 'a'}, {'id': 2, 'ttl': 7200, 'data': '1.1.1.1', 'host': 'vs-test1', 'type': 'a'} ] result = self.run_command(['vs', 'dns-sync', '-a', '100']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) @mock.patch('SoftLayer.CLI.formatting.confirm') def test_dns_sync_edit_ptr(self, confirm_mock): confirm_mock.return_value = True getReverseDomainRecords = self.set_mock('SoftLayer_Virtual_Guest', 'getReverseDomainRecords') getReverseDomainRecords.return_value = [{ 'networkAddress': '172.16.240.2', 'name': '2.240.16.172.in-addr.arpa', 'resourceRecords': [{'data': 'test.softlayer.com.', 'id': 100, 'host': '2'}], 'updateDate': '2013-09-11T14:36:57-07:00', 'serial': 1234665663, 'id': 123456, }] editArgs = ({'host': '2', 'data': 'vs-test1.test.sftlyr.ws', 'id': 100, 'ttl': 7200},) result = self.run_command(['vs', 'dns-sync', '--ptr', '100']) self.assertEqual(result.exit_code, 0) self.assert_called_with('SoftLayer_Dns_Domain_ResourceRecord', 'editObject', args=editArgs) @mock.patch('SoftLayer.CLI.formatting.confirm') def test_dns_sync_misc_exception(self, confirm_mock): confirm_mock.return_value = False result = self.run_command(['vs', 'dns-sync', '-a', '100']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) guest = self.set_mock('SoftLayer_Virtual_Guest', 'getObject') test_guest = { 'id': 100, 'primaryIpAddress': '', 'hostname': 'vs-test1', 'domain': 'sftlyr.ws', 'fullyQualifiedDomainName': 'vs-test1.sftlyr.ws', "primaryNetworkComponent": {} } guest.return_value = test_guest result = self.run_command(['vs', 'dns-sync', '-a', '100']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) def test_upgrade_no_options(self, ): result = self.run_command(['vs', 'upgrade', '100']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.ArgumentError) def test_upgrade_private_no_cpu(self): result = self.run_command(['vs', 'upgrade', '100', '--private', '--memory=1024']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.ArgumentError) @mock.patch('SoftLayer.CLI.formatting.confirm') def test_upgrade_aborted(self, confirm_mock): confirm_mock.return_value = False result = self.run_command(['vs', 'upgrade', '100', '--cpu=1']) self.assertEqual(result.exit_code, 2) self.assertIsInstance(result.exception, exceptions.CLIAbort) @mock.patch('SoftLayer.CLI.formatting.confirm') def test_upgrade(self, confirm_mock): confirm_mock.return_value = True result = self.run_command(['vs', 'upgrade', '100', '--cpu=4', '--memory=2048', '--network=1000']) self.assertEqual(result.exit_code, 0) self.assert_called_with('SoftLayer_Product_Order', 'placeOrder') call = self.calls('SoftLayer_Product_Order', 'placeOrder')[0] order_container = call.args[0] self.assertIn({'id': 1144}, order_container['prices']) self.assertIn({'id': 1133}, order_container['prices']) self.assertIn({'id': 1122}, order_container['prices']) self.assertEqual(order_container['virtualGuests'], [{'id': 100}]) def test_edit(self): result = self.run_command(['vs', 'edit', '--domain=example.com', '--hostname=host', '--userdata="testdata"', '--tag=dev', '--tag=green', '--public-speed=10', '--private-speed=100', '100']) self.assertEqual(result.exit_code, 0) self.assertEqual(result.output, '') self.assert_called_with( 'SoftLayer_Virtual_Guest', 'editObject', args=({'domain': 'example.com', 'hostname': 'host'},), identifier=100, ) self.assert_called_with( 'SoftLayer_Virtual_Guest', 'setUserMetadata', args=(['"testdata"'],), identifier=100, ) self.assert_called_with( 'SoftLayer_Virtual_Guest', 'setPublicNetworkInterfaceSpeed', args=(10,), identifier=100, ) self.assert_called_with( 'SoftLayer_Virtual_Guest', 'setPrivateNetworkInterfaceSpeed', args=(100,), identifier=100, ) softlayer-python-5.0.1/tests/__init__.py000066400000000000000000000000001267703721100203130ustar00rootroot00000000000000softlayer-python-5.0.1/tests/api_tests.py000066400000000000000000000237051267703721100205700ustar00rootroot00000000000000""" SoftLayer.tests.api_tests ~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import mock import SoftLayer import SoftLayer.API from SoftLayer import testing from SoftLayer import transports class Inititialization(testing.TestCase): def test_init(self): client = SoftLayer.Client(username='doesnotexist', api_key='issurelywrong', timeout=10) self.assertIsInstance(client.auth, SoftLayer.BasicAuthentication) self.assertEqual(client.auth.username, 'doesnotexist') self.assertEqual(client.auth.api_key, 'issurelywrong') self.assertIsNotNone(client.transport) self.assertIsInstance(client.transport, transports.XmlRpcTransport) self.assertEqual(client.transport.timeout, 10) @mock.patch('SoftLayer.config.get_client_settings') def test_env(self, get_client_settings): auth = mock.Mock() get_client_settings.return_value = { 'timeout': 10, 'endpoint_url': 'http://endpoint_url/', } client = SoftLayer.Client(auth=auth) self.assertEqual(client.auth.get_headers(), auth.get_headers()) self.assertEqual(client.transport.timeout, 10) self.assertEqual(client.transport.endpoint_url, 'http://endpoint_url') class ClientMethods(testing.TestCase): def test_repr(self): client = SoftLayer.Client( username='doesnotexist', api_key='issurelywrong' ) self.assertIn("Client", repr(client)) def test_service_repr(self): client = SoftLayer.Client( username='doesnotexist', api_key='issurelywrong' ) self.assertIn("Service", repr(client['SERVICE'])) def test_len(self): client = SoftLayer.Client( username='doesnotexist', api_key='issurelywrong' ) self.assertEqual(len(client), 0) class APIClient(testing.TestCase): def test_simple_call(self): mock = self.set_mock('SoftLayer_SERVICE', 'METHOD') mock.return_value = {"test": "result"} resp = self.client['SERVICE'].METHOD() self.assertEqual(resp, {"test": "result"}) self.assert_called_with('SoftLayer_SERVICE', 'METHOD', mask=None, filter=None, identifier=None, args=tuple(), limit=None, offset=None, ) def test_complex(self): mock = self.set_mock('SoftLayer_SERVICE', 'METHOD') mock.return_value = {"test": "result"} _filter = {'TYPE': {'attribute': {'operation': '^= prefix'}}} resp = self.client['SERVICE'].METHOD( 1234, id=5678, mask={'object': {'attribute': ''}}, headers={'header': 'value'}, raw_headers={'RAW': 'HEADER'}, filter=_filter, limit=9, offset=10) self.assertEqual(resp, {"test": "result"}) self.assert_called_with('SoftLayer_SERVICE', 'METHOD', mask={'object': {'attribute': ''}}, filter=_filter, identifier=5678, args=(1234,), limit=9, offset=10, ) calls = self.calls('SoftLayer_SERVICE', 'METHOD') self.assertEqual(len(calls), 1) self.assertIn('header', calls[0].headers) self.assertEqual(calls[0].headers['header'], 'value') @mock.patch('SoftLayer.API.BaseClient.iter_call') def test_iterate(self, _iter_call): self.client['SERVICE'].METHOD(iter=True) _iter_call.assert_called_with('SERVICE', 'METHOD') @mock.patch('SoftLayer.API.BaseClient.iter_call') def test_service_iter_call(self, _iter_call): self.client['SERVICE'].iter_call('METHOD', 'ARG') _iter_call.assert_called_with('SERVICE', 'METHOD', 'ARG') @mock.patch('SoftLayer.API.BaseClient.iter_call') def test_service_iter_call_with_chunk(self, _iter_call): self.client['SERVICE'].iter_call('METHOD', 'ARG', chunk=2) _iter_call.assert_called_with('SERVICE', 'METHOD', 'ARG', chunk=2) @mock.patch('SoftLayer.API.BaseClient.call') def test_iter_call(self, _call): # chunk=100, no limit _call.side_effect = [list(range(100)), list(range(100, 125))] result = list(self.client.iter_call('SERVICE', 'METHOD', iter=True)) self.assertEqual(list(range(125)), result) _call.assert_has_calls([ mock.call('SERVICE', 'METHOD', limit=100, iter=False, offset=0), mock.call('SERVICE', 'METHOD', limit=100, iter=False, offset=100), ]) _call.reset_mock() # chunk=100, no limit. Requires one extra request. _call.side_effect = [list(range(100)), list(range(100, 200)), []] result = list(self.client.iter_call('SERVICE', 'METHOD', iter=True)) self.assertEqual(list(range(200)), result) _call.assert_has_calls([ mock.call('SERVICE', 'METHOD', limit=100, iter=False, offset=0), mock.call('SERVICE', 'METHOD', limit=100, iter=False, offset=100), mock.call('SERVICE', 'METHOD', limit=100, iter=False, offset=200), ]) _call.reset_mock() # chunk=25, limit=30 _call.side_effect = [list(range(0, 25)), list(range(25, 30))] result = list(self.client.iter_call( 'SERVICE', 'METHOD', iter=True, limit=30, chunk=25)) self.assertEqual(list(range(30)), result) _call.assert_has_calls([ mock.call('SERVICE', 'METHOD', iter=False, limit=25, offset=0), mock.call('SERVICE', 'METHOD', iter=False, limit=5, offset=25), ]) _call.reset_mock() # A non-list was returned _call.side_effect = ["test"] result = list(self.client.iter_call('SERVICE', 'METHOD', iter=True)) self.assertEqual(["test"], result) _call.assert_has_calls([ mock.call('SERVICE', 'METHOD', iter=False, limit=100, offset=0), ]) _call.reset_mock() # chunk=25, limit=30, offset=12 _call.side_effect = [list(range(0, 25)), list(range(25, 30))] result = list(self.client.iter_call('SERVICE', 'METHOD', 'ARG', iter=True, limit=30, chunk=25, offset=12)) self.assertEqual(list(range(30)), result) _call.assert_has_calls([ mock.call('SERVICE', 'METHOD', 'ARG', iter=False, limit=25, offset=12), mock.call('SERVICE', 'METHOD', 'ARG', iter=False, limit=5, offset=37), ]) # Chunk size of 0 is invalid self.assertRaises( AttributeError, lambda: list(self.client.iter_call('SERVICE', 'METHOD', iter=True, chunk=0))) def test_call_invalid_arguments(self): self.assertRaises( TypeError, self.client.call, 'SERVICE', 'METHOD', invalid_kwarg='invalid') def test_call_compression_disabled(self): mocked = self.set_mock('SoftLayer_SERVICE', 'METHOD') mocked.return_value = {} self.client['SERVICE'].METHOD(compress=False) calls = self.calls('SoftLayer_SERVICE', 'METHOD') self.assertEqual(len(calls), 1) headers = calls[0].transport_headers self.assertEqual(headers.get('accept-encoding'), 'identity') def test_call_compression_enabled(self): mocked = self.set_mock('SoftLayer_SERVICE', 'METHOD') mocked.return_value = {} self.client['SERVICE'].METHOD(compress=True) calls = self.calls('SoftLayer_SERVICE', 'METHOD') self.assertEqual(len(calls), 1) headers = calls[0].transport_headers self.assertEqual(headers.get('accept-encoding'), 'gzip, deflate, compress') def test_call_compression_override(self): # raw_headers should override compress=False mocked = self.set_mock('SoftLayer_SERVICE', 'METHOD') mocked.return_value = {} self.client['SERVICE'].METHOD( compress=False, raw_headers={'Accept-Encoding': 'gzip'}) calls = self.calls('SoftLayer_SERVICE', 'METHOD') self.assertEqual(len(calls), 1) headers = calls[0].transport_headers self.assertEqual(headers.get('accept-encoding'), 'gzip') class UnauthenticatedAPIClient(testing.TestCase): def set_up(self): self.client = SoftLayer.Client(endpoint_url="ENDPOINT") @mock.patch('SoftLayer.config.get_client_settings') def test_init(self, get_client_settings): get_client_settings.return_value = {} client = SoftLayer.Client() self.assertIsNone(client.auth) @mock.patch('SoftLayer.config.get_client_settings') def test_init_with_proxy(self, get_client_settings): get_client_settings.return_value = {'proxy': 'http://localhost:3128'} client = SoftLayer.Client() self.assertEqual(client.transport.proxy, 'http://localhost:3128') @mock.patch('SoftLayer.API.BaseClient.call') def test_authenticate_with_password(self, _call): _call.return_value = { 'userId': 12345, 'hash': 'TOKEN', } self.client.authenticate_with_password('USERNAME', 'PASSWORD') _call.assert_called_with( 'User_Customer', 'getPortalLoginToken', 'USERNAME', 'PASSWORD', None, None) self.assertIsNotNone(self.client.auth) self.assertEqual(self.client.auth.user_id, 12345) self.assertEqual(self.client.auth.auth_token, 'TOKEN') softlayer-python-5.0.1/tests/auth_tests.py000066400000000000000000000050301267703721100207470ustar00rootroot00000000000000""" SoftLayer.tests.auth_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ from SoftLayer import auth from SoftLayer import testing from SoftLayer import transports class TestAuthenticationBase(testing.TestCase): def test_get_request(self): auth_base = auth.AuthenticationBase() self.assertEqual(auth_base.get_request({}), {}) self.assertEqual(auth_base.get_headers(), {}) class TestBasicAuthentication(testing.TestCase): def set_up(self): self.auth = auth.BasicAuthentication('USERNAME', 'APIKEY') def test_attribs(self): self.assertEqual(self.auth.username, 'USERNAME') self.assertEqual(self.auth.api_key, 'APIKEY') def test_get_request(self): req = transports.Request() authed_req = self.auth.get_request(req) self.assertEqual(authed_req.headers, { 'authenticate': { 'username': 'USERNAME', 'apiKey': 'APIKEY', } }) def test_repr(self): s = repr(self.auth) self.assertIn('BasicAuthentication', s) self.assertIn('USERNAME', s) class TestTokenAuthentication(testing.TestCase): def set_up(self): self.auth = auth.TokenAuthentication(12345, 'TOKEN') def test_attribs(self): self.assertEqual(self.auth.user_id, 12345) self.assertEqual(self.auth.auth_token, 'TOKEN') def test_get_request(self): req = transports.Request() authed_req = self.auth.get_request(req) self.assertEqual(authed_req.headers, { 'authenticate': { 'complexType': 'PortalLoginToken', 'userId': 12345, 'authToken': 'TOKEN', } }) def test_repr(self): s = repr(self.auth) self.assertIn('TokenAuthentication', s) self.assertIn('12345', s) class TestBasicHTTPAuthentication(testing.TestCase): def set_up(self): self.auth = auth.BasicHTTPAuthentication('USERNAME', 'APIKEY') def test_attribs(self): self.assertEqual(self.auth.username, 'USERNAME') self.assertEqual(self.auth.api_key, 'APIKEY') def test_get_request(self): req = transports.Request() authed_req = self.auth.get_request(req) self.assertEqual(authed_req.transport_user, 'USERNAME') self.assertEqual(authed_req.transport_password, 'APIKEY') def test_repr(self): s = repr(self.auth) self.assertIn('BasicHTTPAuthentication', s) self.assertIn('USERNAME', s) softlayer-python-5.0.1/tests/basic_tests.py000066400000000000000000000117601267703721100210760ustar00rootroot00000000000000""" SoftLayer.tests.basic_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Tests shared code :license: MIT, see LICENSE for more details. """ import SoftLayer from SoftLayer import testing class TestExceptions(testing.TestCase): def test_softlayer_api_error(self): e = SoftLayer.SoftLayerAPIError('fault code', 'fault string') self.assertEqual(e.faultCode, 'fault code') self.assertEqual(e.faultString, 'fault string') self.assertEqual(e.reason, 'fault string') self.assertEqual( repr(e), "") self.assertEqual( str(e), "SoftLayerAPIError(fault code): fault string") def test_parse_error(self): e = SoftLayer.ParseError('fault code', 'fault string') self.assertEqual(e.faultCode, 'fault code') self.assertEqual(e.faultString, 'fault string') self.assertEqual(e.reason, 'fault string') self.assertEqual( repr(e), "") self.assertEqual( str(e), "ParseError(fault code): fault string") class TestUtils(testing.TestCase): def test_query_filter(self): result = SoftLayer.utils.query_filter('test') self.assertEqual({'operation': '_= test'}, result) result = SoftLayer.utils.query_filter('~ test') self.assertEqual({'operation': '~ test'}, result) result = SoftLayer.utils.query_filter('*test') self.assertEqual({'operation': '$= test'}, result) result = SoftLayer.utils.query_filter('test*') self.assertEqual({'operation': '^= test'}, result) result = SoftLayer.utils.query_filter('*test*') self.assertEqual({'operation': '*= test'}, result) result = SoftLayer.utils.query_filter('> 10') self.assertEqual({'operation': '> 10'}, result) result = SoftLayer.utils.query_filter('>10') self.assertEqual({'operation': '> 10'}, result) result = SoftLayer.utils.query_filter(10) self.assertEqual({'operation': 10}, result) class TestNestedDict(testing.TestCase): def test_basic(self): n = SoftLayer.utils.NestedDict() self.assertEqual(n['test'], SoftLayer.utils.NestedDict()) n['test_set'] = 1 self.assertEqual(n['test_set'], 1) d = { 'test': { 'nested': 1 }} n = SoftLayer.utils.NestedDict(d) self.assertEqual(d, n) self.assertEqual(n['test']['nested'], 1) # new default top level elements should return a new NestedDict() self.assertEqual(n['not']['nested'], SoftLayer.utils.NestedDict()) # NestedDict doesn't convert dict children, just the top level dict # so you can't assume the same behavior with children self.assertRaises(KeyError, lambda: n['test']['not']['nested']) def test_to_dict(self): n = SoftLayer.utils.NestedDict() n['test']['test1']['test2']['test3'] = {} d = n.to_dict() self.assertEqual({ 'test': {'test1': {'test2': {'test3': {}}}} }, d) self.assertEqual(dict, type(d)) self.assertEqual(dict, type(d['test'])) self.assertEqual(dict, type(d['test']['test1'])) self.assertEqual(dict, type(d['test']['test1']['test2'])) self.assertEqual(dict, type(d['test']['test1']['test2']['test3'])) class TestLookup(testing.TestCase): def test_lookup(self): d = {'test': {'nested': 1}} val = SoftLayer.utils.lookup(d, 'test') self.assertEqual(val, {'nested': 1}) val = SoftLayer.utils.lookup(d, 'test', 'nested') self.assertEqual(val, 1) val = SoftLayer.utils.lookup(d, 'test1') self.assertEqual(val, None) val = SoftLayer.utils.lookup(d, 'test1', 'nested1') self.assertEqual(val, None) def is_a(string): if string == 'a': return ['this', 'is', 'a'] def is_b(string): if string == 'b': return ['this', 'is', 'b'] class IdentifierFixture(SoftLayer.utils.IdentifierMixin): resolvers = [is_a, is_b] class TestIdentifierMixin(testing.TestCase): def set_up(self): self.fixture = IdentifierFixture() def test_integer(self): ids = self.fixture.resolve_ids(1234) self.assertEqual(ids, [1234]) def test_a(self): ids = self.fixture.resolve_ids('a') self.assertEqual(ids, ['this', 'is', 'a']) def test_b(self): ids = self.fixture.resolve_ids('b') self.assertEqual(ids, ['this', 'is', 'b']) def test_not_found(self): ids = self.fixture.resolve_ids('something') self.assertEqual(ids, []) def test_globalidentifier(self): ids = self.fixture.resolve_ids('9d888bc2-7c9a-4dba-bbd8-6bd688687bae') self.assertEqual(ids, ['9d888bc2-7c9a-4dba-bbd8-6bd688687bae']) def test_globalidentifier_upper(self): ids = self.fixture.resolve_ids('B534EF96-55C4-4891-B51A-63866411B58E') self.assertEqual(ids, ['B534EF96-55C4-4891-B51A-63866411B58E']) softlayer-python-5.0.1/tests/config_tests.py000066400000000000000000000071661267703721100212670ustar00rootroot00000000000000""" SoftLayer.tests.config_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import mock from SoftLayer import config from SoftLayer import testing class TestGetClientSettings(testing.TestCase): @mock.patch('SoftLayer.config.SETTING_RESOLVERS', []) def test_no_resolvers(self): result = config.get_client_settings() self.assertEqual(result, {}) def test_resolve_one(self): resolvers = [mock.Mock() for i in range(1)] resolvers[0].return_value = {'auth': 'AUTH HANDLER'} with mock.patch('SoftLayer.config.SETTING_RESOLVERS', resolvers): result = config.get_client_settings() self.assertEqual(result, {'auth': 'AUTH HANDLER'}) def test_inherit(self): # This tests the inheritting properties of the list of resolvers. # Values should be preferred on earlier resolvers except where their # value is false-ish resolvers = [mock.Mock() for i in range(4)] resolvers[0].return_value = {'timeout': 20} resolvers[1].return_value = {'timeout': 10, 'auth': None} resolvers[2].return_value = None resolvers[3].return_value = {'auth': 'AUTH HANDLER'} with mock.patch('SoftLayer.config.SETTING_RESOLVERS', resolvers): result = config.get_client_settings() self.assertEqual(result, {'auth': 'AUTH HANDLER', 'timeout': 20}) class TestGetClientSettingsArgs(testing.TestCase): def test_username_api_key(self): result = config.get_client_settings_args( username='username', api_key='api_key', endpoint_url='http://endpoint/', timeout=10, proxy='https://localhost:3128') self.assertEqual(result['endpoint_url'], 'http://endpoint/') self.assertEqual(result['timeout'], 10) self.assertEqual(result['username'], 'username') self.assertEqual(result['api_key'], 'api_key') self.assertEqual(result['proxy'], 'https://localhost:3128') class TestGetClientSettingsEnv(testing.TestCase): @mock.patch.dict('os.environ', {'SL_USERNAME': 'username', 'SL_API_KEY': 'api_key', 'https_proxy': 'https://localhost:3128'}) def test_username_api_key(self): result = config.get_client_settings_env() self.assertEqual(result['username'], 'username') self.assertEqual(result['api_key'], 'api_key') class TestGetClientSettingsConfigFile(testing.TestCase): @mock.patch('six.moves.configparser.RawConfigParser') def test_username_api_key(self, config_parser): result = config.get_client_settings_config_file() self.assertEqual(result['endpoint_url'], config_parser().get()) self.assertEqual(result['timeout'], config_parser().getfloat()) self.assertEqual(result['proxy'], config_parser().get()) self.assertEqual(result['username'], config_parser().get()) self.assertEqual(result['api_key'], config_parser().get()) @mock.patch('six.moves.configparser.RawConfigParser') def test_no_section(self, config_parser): config_parser().has_section.return_value = False result = config.get_client_settings_config_file() self.assertIsNone(result) @mock.patch('six.moves.configparser.RawConfigParser') def test_config_file(self, config_parser): config.get_client_settings_config_file(config_file='path/to/config') config_parser().read.assert_called_with([mock.ANY, mock.ANY, 'path/to/config']) softlayer-python-5.0.1/tests/conftest.py000066400000000000000000000000711267703721100204110ustar00rootroot00000000000000import logging logging.basicConfig(level=logging.DEBUG) softlayer-python-5.0.1/tests/functional_tests.py000066400000000000000000000066101267703721100221550ustar00rootroot00000000000000""" SoftLayer.tests.functional_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import os import SoftLayer from SoftLayer import testing from SoftLayer import transports class FunctionalTest(testing.TestCase): def _get_creds(self): for key in 'SL_USERNAME SL_API_KEY'.split(): if key not in os.environ: raise self.skipTest('SL_USERNAME and SL_API_KEY environmental ' 'variables not set') return { 'endpoint': (os.environ.get('SL_API_ENDPOINT') or SoftLayer.API_PUBLIC_ENDPOINT), 'username': os.environ['SL_USERNAME'], 'api_key': os.environ['SL_API_KEY'] } class UnauthedUser(FunctionalTest): def test_failed_auth(self): client = SoftLayer.Client( username='doesnotexist', api_key='issurelywrong', timeout=20) self.assertRaises( SoftLayer.SoftLayerAPIError, client['SoftLayer_User_Customer'].getPortalLoginToken) def test_no_hostname(self): try: request = transports.Request() request.service = 'SoftLayer_Account' request.method = 'getObject' request.id = 1234 # This test will fail if 'notvalidsoftlayer.com' becomes a thing transport = transports.XmlRpcTransport( endpoint_url='http://notvalidsoftlayer.com', ) transport(request) except SoftLayer.TransportError as ex: self.assertEqual(ex.faultCode, 0) else: self.fail('Transport Error Exception Not Raised') class AuthedUser(FunctionalTest): def test_service_does_not_exist(self): creds = self._get_creds() client = SoftLayer.Client( username=creds['username'], api_key=creds['api_key'], endpoint_url=creds['endpoint'], timeout=20) try: client["SoftLayer_DOESNOTEXIST"].getObject() except SoftLayer.SoftLayerAPIError as e: self.assertEqual(e.faultCode, '-32601') self.assertEqual(e.faultString, 'Service does not exist') self.assertEqual(e.reason, 'Service does not exist') else: self.fail('No Exception Raised') def test_get_users(self): creds = self._get_creds() client = SoftLayer.Client( username=creds['username'], api_key=creds['api_key'], endpoint_url=creds['endpoint'], timeout=20) found = False results = client["Account"].getUsers() for user in results: if user.get('username') == creds['username']: found = True self.assertTrue(found) def test_result_types(self): creds = self._get_creds() client = SoftLayer.Client( username=creds['username'], api_key=creds['api_key'], endpoint_url=creds['endpoint'], timeout=20) result = client['SoftLayer_User_Security_Question'].getAllObjects() self.assertIsInstance(result, list) self.assertIsInstance(result[0], dict) self.assertIsInstance(result[0]['viewable'], int) self.assertIsInstance(result[0]['question'], str) self.assertIsInstance(result[0]['id'], int) self.assertIsInstance(result[0]['displayOrder'], int) softlayer-python-5.0.1/tests/managers/000077500000000000000000000000001267703721100200115ustar00rootroot00000000000000softlayer-python-5.0.1/tests/managers/__init__.py000066400000000000000000000000001267703721100221100ustar00rootroot00000000000000softlayer-python-5.0.1/tests/managers/cdn_tests.py000066400000000000000000000117011267703721100223510ustar00rootroot00000000000000""" SoftLayer.tests.managers.cdn_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import math from SoftLayer import fixtures from SoftLayer.managers import cdn from SoftLayer import testing class CDNTests(testing.TestCase): def set_up(self): self.cdn_client = cdn.CDNManager(self.client) def test_list_accounts(self): accounts = self.cdn_client.list_accounts() self.assertEqual(accounts, fixtures.SoftLayer_Account.getCdnAccounts) def test_get_account(self): account = self.cdn_client.get_account(12345) self.assertEqual( account, fixtures.SoftLayer_Network_ContentDelivery_Account.getObject) def test_get_origins(self): origins = self.cdn_client.get_origins(12345) self.assertEqual( origins, fixtures.SoftLayer_Network_ContentDelivery_Account. getOriginPullMappingInformation) def test_add_origin(self): self.cdn_client.add_origin(12345, 'http', 'http://localhost/', 'self.local', False) args = ({ 'mediaType': 'http', 'originUrl': 'http://localhost/', 'cname': 'self.local', 'isSecureContent': False },) self.assert_called_with('SoftLayer_Network_ContentDelivery_Account', 'createOriginPullMapping', args=args, identifier=12345) def test_remove_origin(self): self.cdn_client.remove_origin(12345, 12345) self.assert_called_with('SoftLayer_Network_ContentDelivery_Account', 'deleteOriginPullRule', args=(12345,), identifier=12345) def test_load_content(self): urls = ['http://a/img/0x001.png', 'http://b/img/0x002.png', 'http://c/img/0x004.png', 'http://d/img/0x008.png', 'http://e/img/0x010.png', 'http://e/img/0x020.png'] self.cdn_client.load_content(12345, urls) calls = self.calls('SoftLayer_Network_ContentDelivery_Account', 'loadContent') self.assertEqual(len(calls), math.ceil(len(urls) / float(cdn.MAX_URLS_PER_LOAD))) def test_load_content_single(self): url = 'http://geocities.com/Area51/Meteor/12345/under_construction.gif' self.cdn_client.load_content(12345, url) self.assert_called_with('SoftLayer_Network_ContentDelivery_Account', 'loadContent', args=([url],), identifier=12345) def test_load_content_failure(self): urls = ['http://z/img/0x004.png', 'http://y/img/0x002.png', 'http://x/img/0x001.png'] service = self.client['SoftLayer_Network_ContentDelivery_Account'] service.loadContent.return_value = False self.cdn_client.load_content(12345, urls) calls = self.calls('SoftLayer_Network_ContentDelivery_Account', 'loadContent') self.assertEqual(len(calls), math.ceil(len(urls) / float(cdn.MAX_URLS_PER_LOAD))) def test_purge_content(self): urls = ['http://z/img/0x020.png', 'http://y/img/0x010.png', 'http://x/img/0x008.png', 'http://w/img/0x004.png', 'http://v/img/0x002.png', 'http://u/img/0x001.png'] self.cdn_client.purge_content(12345, urls) calls = self.calls('SoftLayer_Network_ContentDelivery_Account', 'purgeCache') self.assertEqual(len(calls), math.ceil(len(urls) / float(cdn.MAX_URLS_PER_PURGE))) def test_purge_content_failure(self): urls = ['http://z/img/0x004.png', 'http://y/img/0x002.png', 'http://x/img/0x001.png'] mock = self.set_mock('SoftLayer_Network_ContentDelivery_Account', 'purgeCache') mock.return_value = False self.cdn_client.purge_content(12345, urls) calls = self.calls('SoftLayer_Network_ContentDelivery_Account', 'purgeCache') self.assertEqual(len(calls), math.ceil(len(urls) / float(cdn.MAX_URLS_PER_PURGE))) def test_purge_content_single(self): url = 'http://geocities.com/Area51/Meteor/12345/under_construction.gif' self.cdn_client.purge_content(12345, url) self.assert_called_with('SoftLayer_Network_ContentDelivery_Account', 'purgeCache', args=([url],), identifier=12345) softlayer-python-5.0.1/tests/managers/dns_tests.py000066400000000000000000000123111267703721100223670ustar00rootroot00000000000000""" SoftLayer.tests.managers.dns_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import SoftLayer from SoftLayer import fixtures from SoftLayer import testing class DNSTests(testing.TestCase): def set_up(self): self.dns_client = SoftLayer.DNSManager(self.client) def test_list_zones(self): zones = self.dns_client.list_zones() self.assertEqual(zones, fixtures.SoftLayer_Account.getDomains) def test_get_zone(self): # match, with defaults res = self.dns_client.get_zone(12345) self.assertEqual(res, fixtures.SoftLayer_Dns_Domain.getObject) self.assert_called_with('SoftLayer_Dns_Domain', 'getObject', identifier=12345, mask='mask[resourceRecords]') def test_get_zone_without_records(self): self.dns_client.get_zone(12345, records=False) self.assert_called_with('SoftLayer_Dns_Domain', 'getObject', identifier=12345, mask=None) def test_resolve_zone_name(self): res = self.dns_client._get_zone_id_from_name('example.com') self.assertEqual([12345], res) _filter = {"domains": {"name": {"operation": "_= example.com"}}} self.assert_called_with('SoftLayer_Account', 'getDomains', filter=_filter) def test_resolve_zone_name_no_matches(self): mock = self.set_mock('SoftLayer_Account', 'getDomains') mock.return_value = [] res = self.dns_client._get_zone_id_from_name('example.com') self.assertEqual([], res) _filter = {"domains": {"name": {"operation": "_= example.com"}}} self.assert_called_with('SoftLayer_Account', 'getDomains', filter=_filter) def test_create_zone(self): res = self.dns_client.create_zone('example.com', serial='2014110201') args = ({'serial': '2014110201', 'name': 'example.com', 'resourceRecords': {}},) self.assert_called_with('SoftLayer_Dns_Domain', 'createObject', args=args) self.assertEqual(res, {'name': 'example.com'}) def test_delete_zone(self): self.dns_client.delete_zone(1) self.assert_called_with('SoftLayer_Dns_Domain', 'deleteObject', identifier=1) def test_edit_zone(self): self.dns_client.edit_zone('example.com') self.assert_called_with('SoftLayer_Dns_Domain', 'editObject', args=('example.com',)) def test_create_record(self): res = self.dns_client.create_record(1, 'test', 'TXT', 'testing', ttl=1200) self.assert_called_with('SoftLayer_Dns_Domain_ResourceRecord', 'createObject', args=({ 'domainId': 1, 'ttl': 1200, 'host': 'test', 'type': 'TXT', 'data': 'testing' },)) self.assertEqual(res, {'name': 'example.com'}) def test_delete_record(self): self.dns_client.delete_record(1) self.assert_called_with('SoftLayer_Dns_Domain_ResourceRecord', 'deleteObject', identifier=1) def test_edit_record(self): self.dns_client.edit_record({'id': 1, 'name': 'test', 'ttl': '1800'}) self.assert_called_with('SoftLayer_Dns_Domain_ResourceRecord', 'editObject', args=({'id': 1, 'name': 'test', 'ttl': '1800'},), identifier=1) def test_dump_zone(self): self.dns_client.dump_zone(1) self.assert_called_with('SoftLayer_Dns_Domain', 'getZoneFileContents', identifier=1) def test_get_record(self): # maybe valid domain, but no records matching mock = self.set_mock('SoftLayer_Dns_Domain', 'getResourceRecords') mock.return_value = [] self.assertEqual(self.dns_client.get_records(12345), []) mock.reset_mock() records = fixtures.SoftLayer_Dns_Domain.getResourceRecords mock.return_value = [records[0]] self.dns_client.get_records(12345, record_type='a', host='hostname', data='a', ttl='86400') _filter = {'resourceRecords': {'type': {'operation': '_= a'}, 'host': {'operation': '_= hostname'}, 'data': {'operation': '_= a'}, 'ttl': {'operation': 86400}}} self.assert_called_with('SoftLayer_Dns_Domain', 'getResourceRecords', identifier=12345, filter=_filter) softlayer-python-5.0.1/tests/managers/firewall_tests.py000066400000000000000000000260401267703721100234140ustar00rootroot00000000000000""" SoftLayer.tests.managers.firewall_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import SoftLayer from SoftLayer import fixtures from SoftLayer import testing class FirewallTests(testing.TestCase): def set_up(self): self.firewall = SoftLayer.FirewallManager(self.client) def test_get_firewalls(self): firewall_vlan = { 'id': 1, 'firewallNetworkComponents': [{'id': 1234}], 'networkVlanFirewall': {'id': 1234}, 'dedicatedFirewallFlag': True, 'firewallGuestNetworkComponents': [{'id': 1234}], 'firewallInterfaces': [{'id': 1234}], 'firewallRules': [{'id': 1234}], 'highAvailabilityFirewallFlag': True, } mock = self.set_mock('SoftLayer_Account', 'getNetworkVlans') mock.return_value = [firewall_vlan] firewalls = self.firewall.get_firewalls() self.assertEqual(firewalls, [firewall_vlan]) self.assert_called_with('SoftLayer_Account', 'getNetworkVlans') def test_get_standard_fwl_rules(self): rules = self.firewall.get_standard_fwl_rules(1234) self.assertEqual( rules, fixtures.SoftLayer_Network_Component_Firewall.getRules) self.assert_called_with('SoftLayer_Network_Component_Firewall', 'getRules', identifier=1234) def test_get_dedicated_fwl_rules(self): rules = self.firewall.get_dedicated_fwl_rules(1234) self.assertEqual(rules, fixtures.SoftLayer_Network_Vlan_Firewall.getRules) self.assert_called_with('SoftLayer_Network_Vlan_Firewall', 'getRules', identifier=1234) def test_get_standard_package_virtual_server(self): # test standard firewalls self.firewall.get_standard_package(server_id=1234, is_virt=True) self.assert_called_with('SoftLayer_Virtual_Guest', 'getObject', identifier=1234, mask='mask[primaryNetworkComponent[maxSpeed]]') _filter = { 'items': { 'description': { 'operation': '_= 100Mbps Hardware Firewall' } } } self.assert_called_with('SoftLayer_Product_Package', 'getItems', identifier=0, filter=_filter) def test_get_standard_package_bare_metal(self): self.firewall.get_standard_package(server_id=1234, is_virt=False) # we should ask for the frontEndNetworkComponents to get # the firewall port speed mask = 'mask[id,maxSpeed,networkComponentGroup.networkComponents]' self.assert_called_with('SoftLayer_Hardware_Server', 'getFrontendNetworkComponents', identifier=1234, mask=mask) # shiould call the product package for a 2000Mbps firwall _filter = { 'items': { 'description': { 'operation': '_= 2000Mbps Hardware Firewall' } } } self.assert_called_with('SoftLayer_Product_Package', 'getItems', identifier=0, filter=_filter) def test_get_dedicated_package_ha(self): # test dedicated HA firewalls self.firewall.get_dedicated_package(ha_enabled=True) _filter = { 'items': { 'description': { 'operation': '_= Hardware Firewall (High Availability)' } } } self.assert_called_with('SoftLayer_Product_Package', 'getItems', identifier=0, filter=_filter) def test_get_dedicated_package_pkg(self): # test dedicated HA firewalls self.firewall.get_dedicated_package(ha_enabled=False) _filter = { 'items': { 'description': { 'operation': '_= Hardware Firewall (Dedicated)' } } } self.assert_called_with('SoftLayer_Product_Package', 'getItems', identifier=0, filter=_filter) def test_cancel_firewall(self): # test standard firewalls result = self.firewall.cancel_firewall(6327, dedicated=False) self.assertEqual(result, fixtures.SoftLayer_Billing_Item.cancelService) self.assert_called_with('SoftLayer_Network_Component_Firewall', 'getObject', identifier=6327, mask='mask[id,billingItem[id]]') self.assert_called_with('SoftLayer_Billing_Item', 'cancelService', identifier=21370814) def test_cancel_dedicated_firewall(self): # test dedicated firewalls result = self.firewall.cancel_firewall(6327, dedicated=True) self.assertEqual(result, fixtures.SoftLayer_Billing_Item.cancelService) self.assert_called_with('SoftLayer_Network_Vlan_Firewall', 'getObject', identifier=6327, mask='mask[id,billingItem[id]]') self.assert_called_with('SoftLayer_Billing_Item', 'cancelService', identifier=21370815) def test_add_standard_firewall_virtual_server(self): # test standard firewalls for virtual servers self.firewall.add_standard_firewall(6327, is_virt=True) self.assert_called_with('SoftLayer_Virtual_Guest', 'getObject', mask='mask[primaryNetworkComponent[maxSpeed]]', identifier=6327) _filter = { 'items': { 'description': { 'operation': '_= 100Mbps Hardware Firewall' } } } self.assert_called_with('SoftLayer_Product_Package', 'getItems', filter=_filter, identifier=0) args = ({'prices': [{'id': 1122}], 'quantity': 1, 'virtualGuests': [{'id': 6327}], 'packageId': 0, 'complexType': 'SoftLayer_Container_Product_Order_Network_' 'Protection_Firewall'},) self.assert_called_with('SoftLayer_Product_Order', 'placeOrder', args=args) def test_add_standard_firewall_server(self): # test dedicated firewall for Servers self.firewall.add_standard_firewall(6327, is_virt=False) # We should query the product package for a 2000Mbps firewall _filter = { 'items': { 'description': { 'operation': '_= 2000Mbps Hardware Firewall' } } } self.assert_called_with('SoftLayer_Product_Package', 'getItems', identifier=0, filter=_filter) # we should ask for the frontEndNetworkComponents to get # the firewall port speed mask = 'mask[id,maxSpeed,networkComponentGroup.networkComponents]' self.assert_called_with('SoftLayer_Hardware_Server', 'getFrontendNetworkComponents', mask=mask, identifier=6327) args = ({'hardware': [{'id': 6327}], 'prices': [{'id': 1122}], 'quantity': 1, 'packageId': 0, 'complexType': 'SoftLayer_Container_Product_Order_Network_' 'Protection_Firewall'},) self.assert_called_with('SoftLayer_Product_Order', 'placeOrder', args=args) def test__get_fwl_port_speed_server(self): # Test the routine that calculates the speed of firewall # required for a server port_speed = self.firewall._get_fwl_port_speed(186908, False) self.assertEqual(port_speed, 2000) def test_add_vlan_firewall(self): # test dedicated firewall for Vlan self.firewall.add_vlan_firewall(6327, ha_enabled=False) _filter = { 'items': { 'description': { 'operation': '_= Hardware Firewall (Dedicated)' } } } self.assert_called_with('SoftLayer_Product_Package', 'getItems', identifier=0, filter=_filter) args = ({'prices': [{'id': 1122}], 'quantity': 1, 'vlanId': 6327, 'packageId': 0, 'complexType': 'SoftLayer_Container_Product_Order_Network_' 'Protection_Firewall_Dedicated'},) self.assert_called_with('SoftLayer_Product_Order', 'placeOrder', args=args) def test_add_vlan_firewall_ha(self): # test dedicated firewall for Vlan self.firewall.add_vlan_firewall(6327, ha_enabled=True) _filter = { 'items': { 'description': { 'operation': '_= Hardware Firewall (High Availability)' } } } self.assert_called_with('SoftLayer_Product_Package', 'getItems', identifier=0, filter=_filter) args = ({'prices': [{'id': 1122}], 'quantity': 1, 'vlanId': 6327, 'packageId': 0, 'complexType': 'SoftLayer_Container_Product_Order_Network_' 'Protection_Firewall_Dedicated'},) self.assert_called_with('SoftLayer_Product_Order', 'placeOrder', args=args) def test_edit_dedicated_fwl_rules(self): # test standard firewalls rules = fixtures.SoftLayer_Network_Vlan_Firewall.getRules self.firewall.edit_dedicated_fwl_rules(firewall_id=1234, rules=rules) args = ({'firewallContextAccessControlListId': 3142, 'rules': rules},) self.assert_called_with('SoftLayer_Network_Firewall_Update_Request', 'createObject', args=args) def test_edit_standard_fwl_rules(self): # test standard firewalls rules = fixtures.SoftLayer_Network_Component_Firewall.getRules self.firewall.edit_standard_fwl_rules(firewall_id=1234, rules=rules) args = ({"networkComponentFirewallId": 1234, "rules": rules},) self.assert_called_with('SoftLayer_Network_Firewall_Update_Request', 'createObject', args=args) softlayer-python-5.0.1/tests/managers/hardware_tests.py000066400000000000000000000376201267703721100234120ustar00rootroot00000000000000""" SoftLayer.tests.managers.hardware_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import copy import mock import SoftLayer from SoftLayer import fixtures from SoftLayer import managers from SoftLayer import testing MINIMAL_TEST_CREATE_ARGS = { 'size': 'S1270_8GB_2X1TBSATA_NORAID', 'hostname': 'unicorn', 'domain': 'giggles.woo', 'location': 'wdc01', 'os': 'UBUNTU_14_64', 'port_speed': 10, } class HardwareTests(testing.TestCase): def set_up(self): self.hardware = SoftLayer.HardwareManager(self.client) def test_init_with_ordering_manager(self): ordering_manager = SoftLayer.OrderingManager(self.client) mgr = SoftLayer.HardwareManager(self.client, ordering_manager) self.assertEqual(mgr.ordering_manager, ordering_manager) def test_list_hardware(self): results = self.hardware.list_hardware() self.assertEqual(results, fixtures.SoftLayer_Account.getHardware) self.assert_called_with('SoftLayer_Account', 'getHardware') def test_list_hardware_with_filters(self): results = self.hardware.list_hardware( tags=['tag1', 'tag2'], cpus=2, memory=1, hostname='hostname', domain='example.com', datacenter='dal05', nic_speed=100, public_ip='1.2.3.4', private_ip='4.3.2.1', ) self.assertEqual(results, fixtures.SoftLayer_Account.getHardware) _filter = { 'hardware': { 'datacenter': {'name': {'operation': '_= dal05'}}, 'domain': {'operation': '_= example.com'}, 'tagReferences': { 'tag': {'name': { 'operation': 'in', 'options': [ {'name': 'data', 'value': ['tag1', 'tag2']}] }} }, 'memoryCapacity': {'operation': 1}, 'processorPhysicalCoreAmount': {'operation': 2}, 'hostname': {'operation': '_= hostname'}, 'primaryIpAddress': {'operation': '_= 1.2.3.4'}, 'networkComponents': {'maxSpeed': {'operation': 100}}, 'primaryBackendIpAddress': {'operation': '_= 4.3.2.1'}} } self.assert_called_with('SoftLayer_Account', 'getHardware', filter=_filter) def test_resolve_ids_ip(self): _id = self.hardware._get_ids_from_ip('172.16.1.100') self.assertEqual(_id, [1000, 1001, 1002, 1003]) _id = self.hardware._get_ids_from_ip('nope') self.assertEqual(_id, []) # Now simulate a private IP test mock = self.set_mock('SoftLayer_Account', 'getHardware') mock.side_effect = [[], [{'id': 99}]] _id = self.hardware._get_ids_from_ip('10.0.1.87') self.assertEqual(_id, [99]) def test_resolve_ids_hostname(self): _id = self.hardware._get_ids_from_hostname('hardware-test1') self.assertEqual(_id, [1000, 1001, 1002, 1003]) def test_get_hardware(self): result = self.hardware.get_hardware(1000) self.assertEqual(fixtures.SoftLayer_Hardware_Server.getObject, result) self.assert_called_with('SoftLayer_Hardware_Server', 'getObject', identifier=1000) def test_reload(self): post_uri = 'http://test.sftlyr.ws/test.sh' result = self.hardware.reload(1, post_uri=post_uri, ssh_keys=[1701]) self.assertEqual(result, 'OK') self.assert_called_with('SoftLayer_Hardware_Server', 'reloadOperatingSystem', args=('FORCE', {'customProvisionScriptUri': post_uri, 'sshKeyIds': [1701]}), identifier=1) def test_get_create_options(self): options = self.hardware.get_create_options() expected = { 'extras': [{'key': '1_IPV6_ADDRESS', 'name': '1 IPv6 Address'}], 'locations': [{'key': 'wdc01', 'name': 'Washington 1'}], 'operating_systems': [{'key': 'UBUNTU_14_64', 'name': 'Ubuntu / 14.04-64'}], 'port_speeds': [{ 'key': '10', 'name': '10 Mbps Public & Private Network Uplinks' }], 'sizes': [{ 'key': 'S1270_8GB_2X1TBSATA_NORAID', 'name': 'Single Xeon 1270, 8GB Ram, 2x1TB SATA disks, Non-RAID' }] } self.assertEqual(options, expected) def test_get_create_options_package_missing(self): packages = self.set_mock('SoftLayer_Product_Package', 'getAllObjects') packages.return_value = [] ex = self.assertRaises(SoftLayer.SoftLayerError, self.hardware.get_create_options) self.assertEqual("Ordering package not found", str(ex)) def test_generate_create_dict_no_items(self): packages = self.set_mock('SoftLayer_Product_Package', 'getAllObjects') packages_copy = copy.deepcopy( fixtures.SoftLayer_Product_Package.getAllObjects) packages_copy[0]['items'] = [] packages.return_value = packages_copy ex = self.assertRaises(SoftLayer.SoftLayerError, self.hardware._generate_create_dict, location="wdc01") self.assertIn("Could not find valid price", str(ex)) def test_generate_create_dict_no_regions(self): packages = self.set_mock('SoftLayer_Product_Package', 'getAllObjects') packages_copy = copy.deepcopy( fixtures.SoftLayer_Product_Package.getAllObjects) packages_copy[0]['regions'] = [] packages.return_value = packages_copy ex = self.assertRaises(SoftLayer.SoftLayerError, self.hardware._generate_create_dict, **MINIMAL_TEST_CREATE_ARGS) self.assertIn("Could not find valid location for: 'wdc01'", str(ex)) def test_generate_create_dict_invalid_size(self): args = { 'size': 'UNKNOWN_SIZE', 'hostname': 'unicorn', 'domain': 'giggles.woo', 'location': 'wdc01', 'os': 'UBUNTU_14_64', 'port_speed': 10, } ex = self.assertRaises(SoftLayer.SoftLayerError, self.hardware._generate_create_dict, **args) self.assertIn("Could not find valid size for: 'UNKNOWN_SIZE'", str(ex)) def test_generate_create_dict(self): args = { 'size': 'S1270_8GB_2X1TBSATA_NORAID', 'hostname': 'unicorn', 'domain': 'giggles.woo', 'location': 'wdc01', 'os': 'UBUNTU_14_64', 'port_speed': 10, 'hourly': True, 'extras': ['1_IPV6_ADDRESS'], 'post_uri': 'http://example.com/script.php', 'ssh_keys': [10], } expected = { 'hardware': [{ 'domain': 'giggles.woo', 'hostname': 'unicorn', }], 'location': 'WASHINGTON_DC', 'packageId': 200, 'presetId': 64, 'prices': [{'id': 21}, {'id': 420}, {'id': 906}, {'id': 37650}, {'id': 1800}, {'id': 272}, {'id': 17129}], 'useHourlyPricing': True, 'provisionScripts': ['http://example.com/script.php'], 'sshKeys': [{'sshKeyIds': [10]}], } data = self.hardware._generate_create_dict(**args) self.assertEqual(expected, data) @mock.patch('SoftLayer.managers.hardware.HardwareManager' '._generate_create_dict') def test_verify_order(self, create_dict): create_dict.return_value = {'test': 1, 'verify': 1} self.hardware.verify_order(test=1, verify=1) create_dict.assert_called_once_with(test=1, verify=1) self.assert_called_with('SoftLayer_Product_Order', 'verifyOrder', args=({'test': 1, 'verify': 1},)) @mock.patch('SoftLayer.managers.hardware.HardwareManager' '._generate_create_dict') def test_place_order(self, create_dict): create_dict.return_value = {'test': 1, 'verify': 1} self.hardware.place_order(test=1, verify=1) create_dict.assert_called_once_with(test=1, verify=1) self.assert_called_with('SoftLayer_Product_Order', 'placeOrder', args=({'test': 1, 'verify': 1},)) def test_cancel_hardware_without_reason(self): mock = self.set_mock('SoftLayer_Hardware_Server', 'getObject') mock.return_value = {'id': 987, 'billingItem': {'id': 1234}} result = self.hardware.cancel_hardware(987) self.assertEqual(result, True) reasons = self.hardware.get_cancellation_reasons() args = (False, False, reasons['unneeded'], '') self.assert_called_with('SoftLayer_Billing_Item', 'cancelItem', identifier=1234, args=args) def test_cancel_hardware_with_reason_and_comment(self): mock = self.set_mock('SoftLayer_Hardware_Server', 'getObject') mock.return_value = {'id': 987, 'billingItem': {'id': 1234}} result = self.hardware.cancel_hardware(6327, reason='sales', comment='Test Comment') self.assertEqual(result, True) reasons = self.hardware.get_cancellation_reasons() args = (False, False, reasons['sales'], 'Test Comment') self.assert_called_with('SoftLayer_Billing_Item', 'cancelItem', identifier=1234, args=args) def test_cancel_hardware(self): result = self.hardware.cancel_hardware(6327) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Billing_Item', 'cancelItem', identifier=6327, args=(False, False, 'No longer needed', '')) def test_cancel_hardware_no_billing_item(self): mock = self.set_mock('SoftLayer_Hardware_Server', 'getObject') mock.return_value = {'id': 987} ex = self.assertRaises(SoftLayer.SoftLayerError, self.hardware.cancel_hardware, 6327) self.assertEqual("No billing item found for hardware", str(ex)) def test_change_port_speed_public(self): self.hardware.change_port_speed(2, True, 100) self.assert_called_with('SoftLayer_Hardware_Server', 'setPublicNetworkInterfaceSpeed', identifier=2, args=(100,)) def test_change_port_speed_private(self): self.hardware.change_port_speed(2, False, 10) self.assert_called_with('SoftLayer_Hardware_Server', 'setPrivateNetworkInterfaceSpeed', identifier=2, args=(10,)) def test_edit_meta(self): # Test editing user data self.hardware.edit(100, userdata='my data') self.assert_called_with('SoftLayer_Hardware_Server', 'setUserMetadata', args=(['my data'],), identifier=100) def test_edit_blank(self): # Now test a blank edit self.assertTrue(self.hardware.edit, 100) self.assertEqual(self.calls(), []) def test_edit(self): # Finally, test a full edit self.hardware.edit(100, hostname='new-host', domain='new.sftlyr.ws', notes='random notes') self.assert_called_with('SoftLayer_Hardware_Server', 'editObject', args=({ 'hostname': 'new-host', 'domain': 'new.sftlyr.ws', 'notes': 'random notes', },), identifier=100) def test_rescue(self): result = self.hardware.rescue(1234) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Hardware_Server', 'bootToRescueLayer', identifier=1234) def test_update_firmware(self): result = self.hardware.update_firmware(100) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Hardware_Server', 'createFirmwareUpdateTransaction', identifier=100, args=(1, 1, 1, 1)) def test_update_firmware_selective(self): result = self.hardware.update_firmware(100, ipmi=False, hard_drive=False) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Hardware_Server', 'createFirmwareUpdateTransaction', identifier=100, args=(0, 1, 1, 0)) class HardwareHelperTests(testing.TestCase): def test_get_extra_price_id_no_items(self): ex = self.assertRaises(SoftLayer.SoftLayerError, managers.hardware._get_extra_price_id, [], 'test', True, None) self.assertEqual("Could not find valid price for extra option, 'test'", str(ex)) def test_get_default_price_id_item_not_first(self): items = [{ 'itemCategory': {'categoryCode': 'unknown', 'id': 325}, 'keyName': 'UNKNOWN', 'prices': [{'accountRestrictions': [], 'currentPriceFlag': '', 'hourlyRecurringFee': '10.0', 'id': 1245172, 'recurringFee': '1.0'}], }] ex = self.assertRaises(SoftLayer.SoftLayerError, managers.hardware._get_default_price_id, items, 'unknown', True, None) self.assertEqual("Could not find valid price for 'unknown' option", str(ex)) def test_get_default_price_id_no_items(self): ex = self.assertRaises(SoftLayer.SoftLayerError, managers.hardware._get_default_price_id, [], 'test', True, None) self.assertEqual("Could not find valid price for 'test' option", str(ex)) def test_get_bandwidth_price_id_no_items(self): ex = self.assertRaises(SoftLayer.SoftLayerError, managers.hardware._get_bandwidth_price_id, [], hourly=True, no_public=False) self.assertEqual("Could not find valid price for bandwidth option", str(ex)) def test_get_os_price_id_no_items(self): ex = self.assertRaises(SoftLayer.SoftLayerError, managers.hardware._get_os_price_id, [], 'UBUNTU_14_64', None) self.assertEqual("Could not find valid price for os: 'UBUNTU_14_64'", str(ex)) def test_get_port_speed_price_id_no_items(self): ex = self.assertRaises(SoftLayer.SoftLayerError, managers.hardware._get_port_speed_price_id, [], 10, True, None) self.assertEqual("Could not find valid price for port speed: '10'", str(ex)) softlayer-python-5.0.1/tests/managers/image_tests.py000066400000000000000000000130111267703721100226630ustar00rootroot00000000000000""" SoftLayer.tests.managers.image_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import SoftLayer from SoftLayer import testing IMAGE_SERVICE = 'SoftLayer_Virtual_Guest_Block_Device_Template_Group' class ImageTests(testing.TestCase): def set_up(self): self.image = SoftLayer.ImageManager(self.client) self.vgbdtg = self.client[''] self.account = self.client['Account'] def test_get_image(self): result = self.image.get_image(100) self.assertEqual(result['id'], 100) self.assertEqual(result['name'], 'test_image') self.assertEqual(result['accountId'], 1234) self.assert_called_with(IMAGE_SERVICE, 'getObject', identifier=100) def test_delete_image(self): self.image.delete_image(100) self.assert_called_with(IMAGE_SERVICE, 'deleteObject', identifier=100) def test_list_private_images(self): results = self.image.list_private_images() self.assertEqual(len(results), 2) self.assert_called_with('SoftLayer_Account', 'getPrivateBlockDeviceTemplateGroups') def test_list_private_images_with_filters(self): results = self.image.list_private_images( guid='0FA9ECBD-CF7E-4A1F-1E36F8D27C2B', name='name') self.assertEqual(len(results), 2) _filter = { 'privateBlockDeviceTemplateGroups': { 'globalIdentifier': { 'operation': '_= 0FA9ECBD-CF7E-4A1F-1E36F8D27C2B'}, 'name': {'operation': '_= name'}} } self.assert_called_with('SoftLayer_Account', 'getPrivateBlockDeviceTemplateGroups', filter=_filter) def test_list_public_images(self): results = self.image.list_public_images() self.assertEqual(len(results), 2) self.assert_called_with(IMAGE_SERVICE, 'getPublicImages') def test_list_public_images_with_filters(self): results = self.image.list_public_images( guid='0FA9ECBD-CF7E-4A1F-1E36F8D27C2B', name='name') _filter = { 'globalIdentifier': { 'operation': '_= 0FA9ECBD-CF7E-4A1F-1E36F8D27C2B'}, 'name': {'operation': '_= name'} } self.assertEqual(len(results), 2) self.assert_called_with(IMAGE_SERVICE, 'getPublicImages', filter=_filter) def test_resolve_ids_guid(self): result = self.image.resolve_ids('3C1F3C68-0B67-4F5E-8907-D0FC84BF3F12') self.assertEqual(['3C1F3C68-0B67-4F5E-8907-D0FC84BF3F12'], result) def test_resolve_ids_name_public(self): public_mock = self.set_mock(IMAGE_SERVICE, 'getPublicImages') public_mock.return_value = [{'id': 100}] private_mock = self.set_mock('SoftLayer_Account', 'getPrivateBlockDeviceTemplateGroups') private_mock.return_value = [] self.account.getPrivateBlockDeviceTemplateGroups.return_value = [] result = self.image.resolve_ids('image_name') self.assertEqual([100], result) def test_resolve_ids_name_private(self): public_mock = self.set_mock(IMAGE_SERVICE, 'getPublicImages') public_mock.return_value = [] private_mock = self.set_mock('SoftLayer_Account', 'getPrivateBlockDeviceTemplateGroups') private_mock.return_value = [{'id': 100}] result = self.image.resolve_ids('private_image_name') self.assertEqual([100], result) def test_resolve_ids_not_found(self): public_mock = self.set_mock(IMAGE_SERVICE, 'getPublicImages') public_mock.return_value = [] private_mock = self.set_mock('SoftLayer_Account', 'getPrivateBlockDeviceTemplateGroups') private_mock.return_value = [] result = self.image.resolve_ids('unknown_name') self.assertEqual([], result) def test_edit_tags(self): # Test updating tags self.image.edit(1, tag="tag1,tag2") self.assert_called_with(IMAGE_SERVICE, 'setTags', identifier=1, args=("tag1,tag2",)) def test_edit_blank(self): # Test a blank edit result = self.image.edit(1) self.assertEqual(result, False) self.assertEqual(self.calls(IMAGE_SERVICE, 'setTags'), []) def test_edit_full(self): # Finally test a full edit self.image.edit(1, name='abc', note='xyz') self.assert_called_with(IMAGE_SERVICE, 'editObject', identifier=1, args=({'name': 'abc', 'note': 'xyz'},)) def test_import_image(self): self.image.import_image_from_uri(name='test_image', note='testimage', uri='someuri', os_code='UBUNTU_LATEST') self.assert_called_with( IMAGE_SERVICE, 'createFromExternalSource', args=({'name': 'test_image', 'note': 'testimage', 'uri': 'someuri', 'operatingSystemReferenceCode': 'UBUNTU_LATEST'},)) def test_export_image(self): self.image.export_image_to_uri(1234, 'someuri') self.assert_called_with( IMAGE_SERVICE, 'copyToExternalSource', args=({'uri': 'someuri'},), identifier=1234) softlayer-python-5.0.1/tests/managers/iscsi_tests.py000066400000000000000000000102161267703721100227170ustar00rootroot00000000000000""" SoftLayer.tests.managers.iscsi_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import SoftLayer from SoftLayer import fixtures from SoftLayer import testing class ISCSITests(testing.TestCase): def set_up(self): self.iscsi = SoftLayer.ISCSIManager(self.client) def test_get_iscsi(self): result = self.iscsi.get_iscsi(100) self.assertEqual(fixtures.SoftLayer_Network_Storage_Iscsi.getObject, result) self.assert_called_with('SoftLayer_Network_Storage_Iscsi', 'getObject', identifier=100) def test_cancel_iscsi_immediately(self): self.iscsi.cancel_iscsi(600, immediate=True) self.assert_called_with('SoftLayer_Billing_Item', 'cancelItem', args=(True, True, 'unNeeded'), identifier=600) def test_cancel_iscsi_without_reason(self): self.iscsi.cancel_iscsi(600) self.assert_called_with('SoftLayer_Billing_Item', 'cancelItem', args=(False, True, 'unNeeded'), identifier=600) def test_cancel_iscsi_with_reason(self): self.iscsi.cancel_iscsi(600, 'Network Performance') self.assert_called_with('SoftLayer_Billing_Item', 'cancelItem', args=(False, True, 'Network Performance'), identifier=600) def test_invalid_datacenter(self): self.assertRaises(ValueError, self.iscsi.create_iscsi, size=10, location='foo') def test_create_iscsi(self): mock = self.set_mock('SoftLayer_Product_Package', 'getItems') mock.return_value = [ { 'id': 4439, 'capacity': '1', 'description': '1 GB iSCSI Storage', 'itemCategory': {'categoryCode': 'iscsi'}, 'prices': [{'id': 2222}] } ] self.iscsi.create_iscsi(size=1, location='dal05') args = ({'prices': [{'id': 2222}], 'quantity': 1, 'location': 0, 'packageId': 0, 'complexType': 'SoftLayer_Container_Product_Order_Network_Storage_Iscsi'},) self.assert_called_with('SoftLayer_Product_Order', 'placeOrder', args=args) def test_delete_snapshot(self): self.iscsi.delete_snapshot(1) self.assert_called_with('SoftLayer_Network_Storage_Iscsi', 'deleteObject', identifier=1) def test_create_snapshot(self): self.iscsi.create_snapshot(100, 'unNeeded') self.assert_called_with('SoftLayer_Network_Storage_Iscsi', 'createSnapshot', identifier=100) def test_create_snapshot_space(self): mock = self.set_mock('SoftLayer_Product_Package', 'getItems') mock.return_value = [ { 'id': 1121, 'capacity': '20', 'description': '20 GB iSCSI snapshot', 'itemCategory': {'categoryCode': 'iscsi_snapshot_space'}, 'prices': [{'id': 2014}] }] self.iscsi.create_snapshot_space(100, 20) args = ( { 'volumeId': 100, 'location': 138124, 'packageId': 0, 'complexType': 'SoftLayer_Container_' 'Product_Order_Network_Storage_Iscsi_SnapshotSpace', 'prices': [{'id': 2014}], 'quantity': 1, }, ) self.assert_called_with('SoftLayer_Product_Order', 'placeOrder', args=args) def test_restore_from_snapshot(self): self.iscsi.restore_from_snapshot(100, 101) self.assert_called_with('SoftLayer_Network_Storage_Iscsi', 'restoreFromSnapshot', args=(101,), identifier=100) softlayer-python-5.0.1/tests/managers/loadbal_tests.py000066400000000000000000000173661267703721100232200ustar00rootroot00000000000000""" SoftLayer.tests.managers.loadbal_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import SoftLayer from SoftLayer import testing VIRT_IP_SERVICE = ('SoftLayer_Network_Application_Delivery_Controller_' 'LoadBalancer_VirtualIpAddress') class LoadBalancerTests(testing.TestCase): def set_up(self): self.lb_mgr = SoftLayer.LoadBalancerManager(self.client) def test_get_lb_pkgs(self): result = self.lb_mgr.get_lb_pkgs() self.assertEqual(len(result), 13) _filter = { 'items': { 'description': { 'operation': '*= Load Balancer' } } } self.assert_called_with('SoftLayer_Product_Package', 'getItems', identifier=0, filter=_filter) def test_get_hc_types(self): result = self.lb_mgr.get_hc_types() self.assertEqual(len(result), 6) service = ('SoftLayer_Network_Application_Delivery_Controller_' 'LoadBalancer_Health_Check_Type') self.assert_called_with(service, 'getAllObjects') def test_get_routing_methods(self): result = self.lb_mgr.get_routing_methods() self.assertEqual(len(result), 12) service = ('SoftLayer_Network_Application_Delivery_Controller_' 'LoadBalancer_Routing_Method') self.assert_called_with(service, 'getAllObjects') def test_get_location(self): id1 = self.lb_mgr._get_location('sjc01') self.assertEqual(id1, 168642) id2 = self.lb_mgr._get_location('dal05') self.assertEqual(id2, 'FIRST_AVAILABLE') def test_get_routing_types(self): result = self.lb_mgr.get_routing_types() self.assertEqual(len(result), 6) service = ('SoftLayer_Network_Application_Delivery_Controller_' 'LoadBalancer_Routing_Type') self.assert_called_with(service, 'getAllObjects') def test_cancel_lb(self): result = self.lb_mgr.cancel_lb(6327) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Billing_Item', 'cancelService', identifier=21370814) def test_add_local_lb(self): self.lb_mgr.add_local_lb(6327, 'sjc01') args = ({ 'complexType': 'SoftLayer_Container_Product_Order_Network_' 'LoadBalancer', 'quantity': 1, 'packageId': 0, "location": 168642, 'prices': [{'id': 6327}] },) self.assert_called_with('SoftLayer_Product_Order', 'placeOrder', args=args) def test_get_local_lbs(self): result = self.lb_mgr.get_local_lbs() self.assertEqual(len(result), 0) mask = 'mask[loadBalancerHardware[datacenter],ipAddress]' self.assert_called_with('SoftLayer_Account', 'getAdcLoadBalancers', mask=mask) def test_get_local_lb(self): result = self.lb_mgr.get_local_lb(22348) self.assertEqual(result['id'], 22348) mask = ('mask[' 'loadBalancerHardware[datacenter], ' 'ipAddress, virtualServers[serviceGroups' '[routingMethod,routingType,services' '[healthChecks[type], groupReferences,' ' ipAddress]]]]') self.assert_called_with(VIRT_IP_SERVICE, 'getObject', identifier=22348, mask=mask) def test_delete_service(self): result = self.lb_mgr.delete_service(1234) self.assertEqual(result, True) service = ('SoftLayer_Network_Application_Delivery_Controller_' 'LoadBalancer_Service') self.assert_called_with(service, 'deleteObject', identifier=1234) def test_delete_service_group(self): result = self.lb_mgr.delete_service_group(1234) self.assertEqual(result, True) service = ('SoftLayer_Network_Application_Delivery_Controller_' 'LoadBalancer_VirtualServer') self.assert_called_with(service, 'deleteObject', identifier=1234) def test_toggle_service_status(self): result = self.lb_mgr.toggle_service_status(1234) self.assertEqual(result, True) service = ('SoftLayer_Network_Application_Delivery_Controller_' 'LoadBalancer_Service') self.assert_called_with(service, 'toggleStatus', identifier=1234) def test_edit_service(self): self.lb_mgr.edit_service(12345, 1234, '9.9.9.9', 80, True, 21, 1) _filter = { 'virtualServers': { 'serviceGroups': { 'services': { 'id': { 'operation': 1234 } } } } } mask = 'mask[serviceGroups[services[groupReferences,healthChecks]]]' self.assert_called_with(VIRT_IP_SERVICE, 'getVirtualServers', identifier=12345, filter=_filter, mask=mask) self.assert_called_with(VIRT_IP_SERVICE, 'editObject') def test_add_service(self): self.lb_mgr.add_service(12345, 50718, 123, 80, True, 21, 1) mask = 'mask[virtualServers[serviceGroups[services[groupReferences]]]]' self.assert_called_with(VIRT_IP_SERVICE, 'getObject', mask=mask, identifier=12345) self.assert_called_with(VIRT_IP_SERVICE, 'editObject', identifier=12345) arg = self.calls(VIRT_IP_SERVICE, 'editObject')[0].args[0] self.assertEqual( len(arg['virtualServers'][0]['serviceGroups'][0]['services']), 2) def test_edit_service_group(self): self.lb_mgr.edit_service_group(12345, group_id=50718, allocation=100, port=80, routing_type=2, routing_method=10) mask = 'mask[virtualServers[serviceGroups[services[groupReferences]]]]' self.assert_called_with(VIRT_IP_SERVICE, 'getObject', identifier=12345, mask=mask) self.assert_called_with(VIRT_IP_SERVICE, 'getObject', identifier=12345) def test_add_service_group(self): self.lb_mgr.add_service_group(12345, 100, 80, 2, 10) mask = 'mask[virtualServers[serviceGroups[services[groupReferences]]]]' self.assert_called_with(VIRT_IP_SERVICE, 'getObject', mask=mask, identifier=12345) self.assert_called_with(VIRT_IP_SERVICE, 'editObject', identifier=12345) arg = self.calls(VIRT_IP_SERVICE, 'editObject')[0].args[0] self.assertEqual(len(arg['virtualServers']), 2) def test_reset_service_group(self): result = self.lb_mgr.reset_service_group(12345, group_id=50718) self.assertEqual(result, True) _filter = {'virtualServers': {'id': {'operation': 50718}}} self.assert_called_with(VIRT_IP_SERVICE, 'getVirtualServers', identifier=12345, filter=_filter, mask='mask[serviceGroups]') service = ('SoftLayer_Network_Application_Delivery_Controller_' 'LoadBalancer_Service_Group') self.assert_called_with(service, 'kickAllConnections', identifier=51758) softlayer-python-5.0.1/tests/managers/metadata_tests.py000066400000000000000000000057751267703721100234030ustar00rootroot00000000000000""" SoftLayer.tests.managers.metadata_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import SoftLayer from SoftLayer import testing class MetadataTests(testing.TestCase): def set_up(self): self.metadata = SoftLayer.MetadataManager(client=self.client) def test_get(self): mock = self.set_mock('SoftLayer_Resource_Metadata', 'Datacenter') mock.return_value = 'dal01' resp = self.metadata.get('datacenter') self.assertEqual('dal01', resp) self.assert_called_with('SoftLayer_Resource_Metadata', 'Datacenter', identifier=None) def test_no_param(self): resp = self.metadata.get('datacenter') self.assertEqual('dal01', resp) self.assert_called_with('SoftLayer_Resource_Metadata', 'Datacenter', identifier=None, args=tuple()) def test_w_param(self): resp = self.metadata.get('vlans', '1:2:3:4:5') self.assertEqual([10, 124], resp) self.assert_called_with('SoftLayer_Resource_Metadata', 'Vlans', args=('1:2:3:4:5',)) def test_user_data(self): resp = self.metadata.get('user_data') self.assertEqual(resp, 'User-supplied data') self.assert_called_with('SoftLayer_Resource_Metadata', 'UserMetadata', identifier=None) def test_return_none(self): mock = self.set_mock('SoftLayer_Resource_Metadata', 'Datacenter') mock.return_value = None resp = self.metadata.get('datacenter') self.assertEqual(None, resp) def test_404(self): mock = self.set_mock('SoftLayer_Resource_Metadata', 'UserMetadata') mock.side_effect = SoftLayer.SoftLayerAPIError(404, 'Not Found') resp = self.metadata.get('user_data') self.assertEqual(None, resp) def test_error(self): exception = SoftLayer.SoftLayerAPIError(500, 'Error') mock = self.set_mock('SoftLayer_Resource_Metadata', 'UserMetadata') mock.side_effect = exception self.assertRaises(SoftLayer.SoftLayerAPIError, self.metadata.get, 'user_data') def test_w_param_error(self): self.assertRaises(SoftLayer.SoftLayerError, self.metadata.get, 'vlans') def test_not_exists(self): self.assertRaises(SoftLayer.SoftLayerError, self.metadata.get, 'something') def test_networks(self): r = self.metadata.public_network() self.assertEqual({ 'vlan_ids': [8384, 12446], 'router': 'brc01', 'vlans': [10, 124], 'mac_addresses': ['06-00-00-00-00-00'], }, r) r = self.metadata.private_network() self.assertEqual({ 'vlan_ids': [8384, 12446], 'router': 'brc01', 'vlans': [10, 124], 'mac_addresses': ['07-00-00-00-00-00'], }, r) softlayer-python-5.0.1/tests/managers/network_tests.py000066400000000000000000000252731267703721100233070ustar00rootroot00000000000000""" SoftLayer.tests.managers.network_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import SoftLayer from SoftLayer import fixtures from SoftLayer import testing class NetworkTests(testing.TestCase): def set_up(self): self.network = SoftLayer.NetworkManager(self.client) def test_ip_lookup(self): result = self.network.ip_lookup('10.0.1.37') expected = fixtures.SoftLayer_Network_Subnet_IpAddress.getByIpAddress self.assertEqual(result, expected) self.assert_called_with('SoftLayer_Network_Subnet_IpAddress', 'getByIpAddress', args=('10.0.1.37',)) def test_add_subnet_raises_exception_on_failure(self): self.assertRaises(TypeError, self.network.add_subnet, ('bad')) def test_add_global_ip(self): # Test a global IPv4 order result = self.network.add_global_ip(test_order=True) self.assertEqual(fixtures.SoftLayer_Product_Order.verifyOrder, result) def test_add_subnet_for_ipv4(self): # Test a four public address IPv4 order result = self.network.add_subnet('public', quantity=4, vlan_id=1234, version=4, test_order=True) self.assertEqual(fixtures.SoftLayer_Product_Order.verifyOrder, result) result = self.network.add_subnet('public', quantity=4, vlan_id=1234, version=4, test_order=False) self.assertEqual(fixtures.SoftLayer_Product_Order.verifyOrder, result) result = self.network.add_subnet('global', test_order=True) self.assertEqual(fixtures.SoftLayer_Product_Order.verifyOrder, result) def test_add_subnet_for_ipv6(self): # Test a public IPv6 order result = self.network.add_subnet('public', quantity=64, vlan_id=45678, version=6, test_order=True) self.assertEqual(fixtures.SoftLayer_Product_Order.verifyOrder, result) # Test a global IPv6 order result = self.network.add_subnet('global', version=6, test_order=True) self.assertEqual(fixtures.SoftLayer_Product_Order.verifyOrder, result) def test_assign_global_ip(self): result = self.network.assign_global_ip(9876, '172.16.24.76') self.assertEqual(result, True) self.assert_called_with('SoftLayer_Network_Subnet_IpAddress_Global', 'route', identifier=9876, args=('172.16.24.76',)) def test_cancel_global_ip(self): result = self.network.cancel_global_ip(1234) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Billing_Item', 'cancelService', identifier=1234) def test_cancel_subnet(self): result = self.network.cancel_subnet(1234) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Billing_Item', 'cancelService', identifier=1056) def test_edit_rwhois(self): result = self.network.edit_rwhois( abuse_email='abuse@test.foo', address1='123 Test Street', address2='Apt. #31', city='Anywhere', company_name='TestLayer', country='US', first_name='Bob', last_name='Bobinson', postal_code='9ba62', private_residence=False, state='TX') self.assertEqual(result, True) expected = { 'abuseEmail': 'abuse@test.foo', 'address1': '123 Test Street', 'address2': 'Apt. #31', 'city': 'Anywhere', 'companyName': 'TestLayer', 'country': 'US', 'firstName': 'Bob', 'lastName': 'Bobinson', 'postalCode': '9ba62', 'privateResidenceFlag': False, 'state': 'TX', } self.assert_called_with('SoftLayer_Network_Subnet_Rwhois_Data', 'editObject', identifier='id', args=(expected,)) def test_get_rwhois(self): result = self.network.get_rwhois() self.assertEqual(result, fixtures.SoftLayer_Account.getRwhoisData) self.assert_called_with('SoftLayer_Account', 'getRwhoisData') def test_get_subnet(self): result = self.network.get_subnet(9876) self.assertEqual(result, fixtures.SoftLayer_Network_Subnet.getObject) self.assert_called_with('SoftLayer_Network_Subnet', 'getObject', identifier=9876) def test_get_vlan(self): result = self.network.get_vlan(1234) self.assertEqual(result, fixtures.SoftLayer_Network_Vlan.getObject) self.assert_called_with('SoftLayer_Network_Vlan', 'getObject', identifier=1234) def test_list_global_ips_default(self): result = self.network.list_global_ips() self.assertEqual(result, fixtures.SoftLayer_Account.getGlobalIpRecords) mask = 'mask[destinationIpAddress[hardware, virtualGuest],ipAddress]' self.assert_called_with('SoftLayer_Account', 'getGlobalIpRecords', mask=mask) def test_list_global_ips_with_filter(self): result = self.network.list_global_ips(version=4) self.assertEqual(result, fixtures.SoftLayer_Account.getGlobalIpRecords) mask = 'mask[destinationIpAddress[hardware, virtualGuest],ipAddress]' _filter = { 'globalIpRecords': { 'ipAddress': { 'subnet': { 'version': {'operation': 4}, } } } } mask = 'mask[destinationIpAddress[hardware, virtualGuest],ipAddress]' self.assert_called_with('SoftLayer_Account', 'getGlobalIpRecords', mask=mask, filter=_filter) def test_list_subnets_default(self): result = self.network.list_subnets() self.assertEqual(result, fixtures.SoftLayer_Account.getSubnets) _filter = {'subnets': {'subnetType': {'operation': '!= GLOBAL_IP'}}} mask = 'mask[hardware,datacenter,ipAddressCount,virtualGuests]' self.assert_called_with('SoftLayer_Account', 'getSubnets', mask=mask, filter=_filter) def test_list_subnets_with_filters(self): result = self.network.list_subnets( identifier='10.0.0.1', datacenter='dal00', subnet_type='PRIMARY', version=4, ) self.assertEqual(result, fixtures.SoftLayer_Account.getSubnets) _filter = { 'subnets': { 'datacenter': { 'name': {'operation': '_= dal00'} }, 'version': {'operation': 4}, 'subnetType': {'operation': '_= PRIMARY'}, 'networkIdentifier': {'operation': '_= 10.0.0.1'} } } mask = 'mask[hardware,datacenter,ipAddressCount,virtualGuests]' self.assert_called_with('SoftLayer_Account', 'getSubnets', mask=mask, filter=_filter) def test_list_vlans_default(self): result = self.network.list_vlans() self.assertEqual(result, fixtures.SoftLayer_Account.getNetworkVlans) self.assert_called_with('SoftLayer_Account', 'getNetworkVlans') def test_list_vlans_with_filters(self): result = self.network.list_vlans( vlan_number=5, datacenter='dal00', name='primary-vlan', ) self.assertEqual(result, fixtures.SoftLayer_Account.getNetworkVlans) _filter = { 'networkVlans': { 'primaryRouter': { 'datacenter': { 'name': {'operation': '_= dal00'}}, }, 'vlanNumber': {'operation': 5}, 'name': {'operation': '_= primary-vlan'}, }, } self.assert_called_with('SoftLayer_Account', 'getNetworkVlans', filter=_filter) def test_summary_by_datacenter(self): result = self.network.summary_by_datacenter() expected = {'dal00': {'hardware_count': 1, 'virtual_guest_count': 1, 'subnet_count': 0, 'public_ip_count': 6, 'vlan_count': 3}} self.assertEqual(expected, result) def test_resolve_global_ip_ids(self): _id = self.network.resolve_global_ip_ids('10.0.0.1') self.assertEqual(_id, ['200', '201']) def test_resolve_global_ip_ids_no_results(self): mock = self.set_mock('SoftLayer_Account', 'getGlobalIpRecords') mock.return_value = [] _id = self.network.resolve_global_ip_ids('nope') self.assertEqual(_id, []) def test_resolve_subnet_ids(self): _id = self.network.resolve_subnet_ids('10.0.0.1/29') self.assertEqual(_id, ['100']) def test_resolve_subnet_ids_no_results(self): mock = self.set_mock('SoftLayer_Account', 'getSubnets') mock.return_value = [] _id = self.network.resolve_subnet_ids('nope') self.assertEqual(_id, []) def test_resolve_vlan_ids(self): mock = self.set_mock('SoftLayer_Account', 'getNetworkVlans') mock.return_value = [{'id': '100'}] _id = self.network.resolve_vlan_ids('vlan_name') self.assertEqual(_id, ['100']) def test_resolve_vlan_ids_no_results(self): mock = self.set_mock('SoftLayer_Account', 'getNetworkVlans') mock.return_value = [] _id = self.network.resolve_vlan_ids('nope') self.assertEqual(_id, []) def test_unassign_global_ip(self): result = self.network.unassign_global_ip(9876) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Network_Subnet_IpAddress_Global', 'unroute', identifier=9876) softlayer-python-5.0.1/tests/managers/object_storage_tests.py000066400000000000000000000023361267703721100246030ustar00rootroot00000000000000""" SoftLayer.tests.managers.object_storage_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import SoftLayer from SoftLayer import fixtures from SoftLayer import testing class ObjectStorageTests(testing.TestCase): def set_up(self): self.object_storage = SoftLayer.ObjectStorageManager(self.client) def test_list_accounts(self): accounts = self.object_storage.list_accounts() self.assertEqual(accounts, fixtures.SoftLayer_Account.getHubNetworkStorage) def test_list_endpoints(self): accounts = self.set_mock('SoftLayer_Account', 'getHubNetworkStorage') accounts.return_value = { 'storageNodes': [{ 'datacenter': {'name': 'dal05'}, 'frontendIpAddress': 'https://dal05/auth/v1.0/', 'backendIpAddress': 'https://dal05/auth/v1.0/'} ], } endpoints = self.object_storage.list_endpoints() self.assertEqual(endpoints, [{'datacenter': {'name': 'dal05'}, 'private': 'https://dal05/auth/v1.0/', 'public': 'https://dal05/auth/v1.0/'}]) softlayer-python-5.0.1/tests/managers/ordering_tests.py000066400000000000000000000117621267703721100234250ustar00rootroot00000000000000""" SoftLayer.tests.managers.ordering_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import SoftLayer from SoftLayer import fixtures from SoftLayer import testing class OrderingTests(testing.TestCase): def set_up(self): self.ordering = SoftLayer.OrderingManager(self.client) def test_get_package_by_type_returns_no_outlet_packages(self): packages = self._get_server_packages() filtered_packages = self.ordering.filter_outlet_packages(packages) for package_id in [27, 28]: self._assert_package_id_not_present(package_id, filtered_packages) def _get_server_packages(self): return self.ordering.get_packages_of_type(['BARE_METAL_CPU']) def _assert_package_id_not_present(self, package_id, packages): package_ids = [] for package in packages: package_ids.append(package['id']) self.assertNotIn(package_id, package_ids) def test_get_active_packages(self): packages = self._get_server_packages() filtered_packages = self.ordering.get_only_active_packages(packages) for package_id in [15]: self._assert_package_id_not_present(package_id, filtered_packages) def test_get_package_by_type_returns_if_found(self): package_type = "BARE_METAL_CORE" mask = "mask[id, name]" package = self.ordering.get_package_by_type(package_type, mask) self.assertIsNotNone(package) def test_get_package_by_type_returns_none_if_not_found(self): mock = self.set_mock('SoftLayer_Product_Package', 'getAllObjects') mock.return_value = [] package = self.ordering.get_package_by_type("PIZZA_FLAVORED_SERVERS") self.assertIsNone(package) def test_get_package_id_by_type_returns_valid_id(self): mock = self.set_mock('SoftLayer_Product_Package', 'getAllObjects') mock.return_value = [ {'id': 46, 'name': 'Virtual Servers', 'description': 'Virtual Server Instances', 'type': {'keyName': 'VIRTUAL_SERVER_INSTANCE'}, 'isActive': 1}, ] package_type = "VIRTUAL_SERVER_INSTANCE" package_id = self.ordering.get_package_id_by_type(package_type) self.assertEqual(46, package_id) def test_get_package_id_by_type_fails_for_nonexistent_package_type(self): mock = self.set_mock('SoftLayer_Product_Package', 'getAllObjects') mock.return_value = [] self.assertRaises(ValueError, self.ordering.get_package_id_by_type, "STRAWBERRY_FLAVORED_SERVERS") def test_get_order_container(self): container = self.ordering.get_order_container(1234) quote = self.ordering.client['Billing_Order_Quote'] container_fixture = quote.getRecalculatedOrderContainer(id=1234) self.assertEqual(container, container_fixture['orderContainers'][0]) def test_get_quotes(self): quotes = self.ordering.get_quotes() quotes_fixture = self.ordering.client['Account'].getActiveQuotes() self.assertEqual(quotes, quotes_fixture) def test_get_quote_details(self): quote = self.ordering.get_quote_details(1234) quote_service = self.ordering.client['Billing_Order_Quote'] quote_fixture = quote_service.getObject(id=1234) self.assertEqual(quote, quote_fixture) def test_verify_quote(self): result = self.ordering.verify_quote(1234, [{'hostname': 'test1', 'domain': 'example.com'}], quantity=1) self.assertEqual(result, fixtures.SoftLayer_Product_Order.verifyOrder) self.assert_called_with('SoftLayer_Product_Order', 'verifyOrder') def test_order_quote(self): result = self.ordering.order_quote(1234, [{'hostname': 'test1', 'domain': 'example.com'}], quantity=1) self.assertEqual(result, fixtures.SoftLayer_Product_Order.placeOrder) self.assert_called_with('SoftLayer_Product_Order', 'placeOrder') def test_generate_order_template(self): result = self.ordering.generate_order_template( 1234, [{'hostname': 'test1', 'domain': 'example.com'}], quantity=1) self.assertEqual(result, {'presetId': None, 'hardware': [{'domain': 'example.com', 'hostname': 'test1'}], 'useHourlyPricing': '', 'packageId': 50, 'prices': [{'id': 1921}], 'quantity': 1}) def test_generate_order_template_extra_quantity(self): self.assertRaises(ValueError, self.ordering.generate_order_template, 1234, [], quantity=1) softlayer-python-5.0.1/tests/managers/queue_tests.py000066400000000000000000000426241267703721100227410ustar00rootroot00000000000000""" SoftLayer.tests.managers.queue_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import mock import SoftLayer from SoftLayer import consts from SoftLayer.managers import messaging from SoftLayer import testing QUEUE_1 = { 'expiration': 40000, 'message_count': 0, 'name': 'example_queue', 'tags': ['tag1', 'tag2', 'tag3'], 'visibility_interval': 10, 'visible_message_count': 0} QUEUE_LIST = {'item_count': 1, 'items': [QUEUE_1]} MESSAGE_1 = { 'body': '', 'fields': {'field': 'value'}, 'id': 'd344a01133b61181f57d9950a852eb10', 'initial_entry_time': 1343402631.3917992, 'message': 'Object created', 'visibility_delay': 0, 'visibility_interval': 30000} MESSAGE_POP = { 'item_count': 1, 'items': [MESSAGE_1], } MESSAGE_POP_EMPTY = { 'item_count': 0, 'items': [] } TOPIC_1 = {'name': 'example_topic', 'tags': ['tag1', 'tag2', 'tag3']} TOPIC_LIST = {'item_count': 1, 'items': [TOPIC_1]} SUBSCRIPTION_1 = { 'endpoint': { 'account_id': 'test', 'queue_name': 'topic_subscription_queue'}, 'endpoint_type': 'queue', 'id': 'd344a01133b61181f57d9950a85704d4', 'message': 'Object created'} SUBSCRIPTION_LIST = {'item_count': 1, 'items': [SUBSCRIPTION_1]} def mocked_auth_call(self): self.auth_token = 'NEW_AUTH_TOKEN' class QueueAuthTests(testing.TestCase): def set_up(self): self.auth = messaging.QueueAuth( 'endpoint', 'username', 'api_key', auth_token='auth_token') def test_init(self): auth = SoftLayer.managers.messaging.QueueAuth( 'endpoint', 'username', 'api_key', auth_token='auth_token') self.assertEqual(auth.endpoint, 'endpoint') self.assertEqual(auth.username, 'username') self.assertEqual(auth.api_key, 'api_key') self.assertEqual(auth.auth_token, 'auth_token') @mock.patch('SoftLayer.managers.messaging.requests.post') def test_auth(self, post): post().headers = {'X-Auth-Token': 'NEW_AUTH_TOKEN'} post().ok = True self.auth.auth() self.auth.auth_token = 'NEW_AUTH_TOKEN' post().ok = False self.assertRaises(SoftLayer.Unauthenticated, self.auth.auth) @mock.patch('SoftLayer.managers.messaging.QueueAuth.auth', mocked_auth_call) def test_handle_error_200(self): # No op on no error request = mock.MagicMock() request.status_code = 200 self.auth.handle_error(request) self.assertEqual(self.auth.auth_token, 'auth_token') self.assertFalse(request.request.send.called) @mock.patch('SoftLayer.managers.messaging.QueueAuth.auth', mocked_auth_call) def test_handle_error_503(self): # Retry once more on 503 error request = mock.MagicMock() request.status_code = 503 self.auth.handle_error(request) self.assertEqual(self.auth.auth_token, 'auth_token') request.connection.send.assert_called_with(request.request) @mock.patch('SoftLayer.managers.messaging.QueueAuth.auth', mocked_auth_call) def test_handle_error_401(self): # Re-auth on 401 request = mock.MagicMock() request.status_code = 401 request.request.headers = {'X-Auth-Token': 'OLD_AUTH_TOKEN'} self.auth.handle_error(request) self.assertEqual(self.auth.auth_token, 'NEW_AUTH_TOKEN') request.connection.send.assert_called_with(request.request) @mock.patch('SoftLayer.managers.messaging.QueueAuth.auth', mocked_auth_call) def test_call_unauthed(self): request = mock.MagicMock() request.headers = {} self.auth.auth_token = None self.auth(request) self.assertEqual(self.auth.auth_token, 'NEW_AUTH_TOKEN') request.register_hook.assert_called_with( 'response', self.auth.handle_error) self.assertEqual(request.headers, {'X-Auth-Token': 'NEW_AUTH_TOKEN'}) class MessagingManagerTests(testing.TestCase): def set_up(self): self.client = mock.MagicMock() self.manager = SoftLayer.MessagingManager(self.client) def test_list_accounts(self): self.manager.list_accounts() self.client['Account'].getMessageQueueAccounts.assert_called_with( mask=mock.ANY) def test_get_endpoints(self): endpoints = self.manager.get_endpoints() self.assertEqual(endpoints, SoftLayer.managers.messaging.ENDPOINTS) @mock.patch('SoftLayer.managers.messaging.ENDPOINTS', { 'datacenter01': { 'private': 'private_endpoint', 'public': 'public_endpoint'}, 'dal05': { 'private': 'dal05_private', 'public': 'dal05_public'}}) def test_get_endpoint(self): # Defaults to dal05, public endpoint = self.manager.get_endpoint() self.assertEqual(endpoint, 'https://dal05_public') endpoint = self.manager.get_endpoint(network='private') self.assertEqual(endpoint, 'https://dal05_private') endpoint = self.manager.get_endpoint(datacenter='datacenter01') self.assertEqual(endpoint, 'https://public_endpoint') endpoint = self.manager.get_endpoint(datacenter='datacenter01', network='private') self.assertEqual(endpoint, 'https://private_endpoint') endpoint = self.manager.get_endpoint(datacenter='datacenter01', network='private') self.assertEqual(endpoint, 'https://private_endpoint') # ERROR CASES self.assertRaises( TypeError, self.manager.get_endpoint, datacenter='doesnotexist') self.assertRaises( TypeError, self.manager.get_endpoint, network='doesnotexist') @mock.patch('SoftLayer.managers.messaging.MessagingConnection') def test_get_connection(self, conn): queue_conn = self.manager.get_connection('QUEUE_ACCOUNT_ID') conn.assert_called_with( 'QUEUE_ACCOUNT_ID', endpoint='https://dal05.mq.softlayer.net') conn().authenticate.assert_called_with( self.client.auth.username, self.client.auth.api_key) self.assertEqual(queue_conn, conn()) def test_get_connection_no_auth(self): self.client.auth = None self.assertRaises(SoftLayer.SoftLayerError, self.manager.get_connection, 'QUEUE_ACCOUNT_ID') def test_get_connection_no_username(self): self.client.auth.username = None self.assertRaises(SoftLayer.SoftLayerError, self.manager.get_connection, 'QUEUE_ACCOUNT_ID') def test_get_connection_no_api_key(self): self.client.auth.api_key = None self.assertRaises(SoftLayer.SoftLayerError, self.manager.get_connection, 'QUEUE_ACCOUNT_ID') @mock.patch('SoftLayer.managers.messaging.requests.get') def test_ping(self, get): result = self.manager.ping() get.assert_called_with('https://dal05.mq.softlayer.net/v1/ping') get().raise_for_status.assert_called_with() self.assertTrue(result) class MessagingConnectionTests(testing.TestCase): def set_up(self): self.conn = SoftLayer.managers.messaging.MessagingConnection( 'acount_id', endpoint='endpoint') self.auth = mock.MagicMock() self.conn.auth = self.auth def test_init(self): self.assertEqual(self.conn.account_id, 'acount_id') self.assertEqual(self.conn.endpoint, 'endpoint') self.assertEqual(self.conn.auth, self.auth) @mock.patch('SoftLayer.managers.messaging.requests.request') def test_make_request(self, request): resp = self.conn._make_request('GET', 'path') request.assert_called_with( 'GET', 'endpoint/v1/acount_id/path', headers={ 'Content-Type': 'application/json', 'User-Agent': consts.USER_AGENT}, auth=self.auth) request().raise_for_status.assert_called_with() self.assertEqual(resp, request()) @mock.patch('SoftLayer.managers.messaging.QueueAuth') def test_authenticate(self, auth): self.conn.authenticate('username', 'api_key', auth_token='auth_token') auth.assert_called_with( 'endpoint/v1/acount_id/auth', 'username', 'api_key', auth_token='auth_token') auth().auth.assert_called_with() self.assertEqual(self.conn.auth, auth()) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_stats(self, make_request): content = { 'notifications': [{'key': [2012, 7, 27, 14, 31], 'value': 2}], 'requests': [{'key': [2012, 7, 27, 14, 31], 'value': 11}]} make_request().json.return_value = content result = self.conn.stats() make_request.assert_called_with('get', 'stats/hour') self.assertEqual(content, result) # Queue-based Tests @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_get_queues(self, make_request): make_request().json.return_value = QUEUE_LIST result = self.conn.get_queues() make_request.assert_called_with('get', 'queues', params={}) self.assertEqual(QUEUE_LIST, result) # with tags result = self.conn.get_queues(tags=['tag1', 'tag2']) make_request.assert_called_with( 'get', 'queues', params={'tags': 'tag1,tag2'}) self.assertEqual(QUEUE_LIST, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_create_queue(self, make_request): make_request().json.return_value = QUEUE_1 result = self.conn.create_queue('example_queue') make_request.assert_called_with( 'put', 'queues/example_queue', data='{}') self.assertEqual(QUEUE_1, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_modify_queue(self, make_request): make_request().json.return_value = QUEUE_1 result = self.conn.modify_queue('example_queue') make_request.assert_called_with( 'put', 'queues/example_queue', data='{}') self.assertEqual(QUEUE_1, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_get_queue(self, make_request): make_request().json.return_value = QUEUE_1 result = self.conn.get_queue('example_queue') make_request.assert_called_with('get', 'queues/example_queue') self.assertEqual(QUEUE_1, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_delete_queue(self, make_request): result = self.conn.delete_queue('example_queue') make_request.assert_called_with( 'delete', 'queues/example_queue', params={}) self.assertTrue(result) # With Force result = self.conn.delete_queue('example_queue', force=True) make_request.assert_called_with( 'delete', 'queues/example_queue', params={'force': 1}) self.assertTrue(result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_push_queue_message(self, make_request): make_request().json.return_value = MESSAGE_1 result = self.conn.push_queue_message('example_queue', '') make_request.assert_called_with( 'post', 'queues/example_queue/messages', data='{"body": ""}') self.assertEqual(MESSAGE_1, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_pop_messages(self, make_request): make_request().json.return_value = MESSAGE_POP result = self.conn.pop_messages('example_queue') make_request.assert_called_with( 'get', 'queues/example_queue/messages', params={'batch': 1}) self.assertEqual(MESSAGE_POP, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_pop_message(self, make_request): make_request().json.return_value = MESSAGE_POP result = self.conn.pop_message('example_queue') make_request.assert_called_with( 'get', 'queues/example_queue/messages', params={'batch': 1}) self.assertEqual(MESSAGE_1, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_pop_message_empty(self, make_request): make_request().json.return_value = MESSAGE_POP_EMPTY result = self.conn.pop_message('example_queue') make_request.assert_called_with( 'get', 'queues/example_queue/messages', params={'batch': 1}) self.assertEqual(None, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_delete_message(self, make_request): result = self.conn.delete_message('example_queue', MESSAGE_1['id']) make_request.assert_called_with( 'delete', 'queues/example_queue/messages/%s' % MESSAGE_1['id']) self.assertTrue(result) # Topic-based Tests @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_get_topics(self, make_request): make_request().json.return_value = TOPIC_LIST result = self.conn.get_topics() make_request.assert_called_with('get', 'topics', params={}) self.assertEqual(TOPIC_LIST, result) # with tags result = self.conn.get_topics(tags=['tag1', 'tag2']) make_request.assert_called_with( 'get', 'topics', params={'tags': 'tag1,tag2'}) self.assertEqual(TOPIC_LIST, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_create_topic(self, make_request): make_request().json.return_value = TOPIC_1 result = self.conn.create_topic('example_topic') make_request.assert_called_with( 'put', 'topics/example_topic', data='{}') self.assertEqual(TOPIC_1, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_modify_topic(self, make_request): make_request().json.return_value = TOPIC_1 result = self.conn.modify_topic('example_topic') make_request.assert_called_with( 'put', 'topics/example_topic', data='{}') self.assertEqual(TOPIC_1, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_get_topic(self, make_request): make_request().json.return_value = TOPIC_1 result = self.conn.get_topic('example_topic') make_request.assert_called_with('get', 'topics/example_topic') self.assertEqual(TOPIC_1, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_delete_topic(self, make_request): result = self.conn.delete_topic('example_topic') make_request.assert_called_with( 'delete', 'topics/example_topic', params={}) self.assertTrue(result) # With Force result = self.conn.delete_topic('example_topic', force=True) make_request.assert_called_with( 'delete', 'topics/example_topic', params={'force': 1}) self.assertTrue(result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_push_topic_message(self, make_request): make_request().json.return_value = MESSAGE_1 result = self.conn.push_topic_message('example_topic', '') make_request.assert_called_with( 'post', 'topics/example_topic/messages', data='{"body": ""}') self.assertEqual(MESSAGE_1, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_get_subscriptions(self, make_request): make_request().json.return_value = SUBSCRIPTION_LIST result = self.conn.get_subscriptions('example_topic') make_request.assert_called_with( 'get', 'topics/example_topic/subscriptions') self.assertEqual(SUBSCRIPTION_LIST, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection' '._make_request') def test_create_subscription(self, make_request): make_request().json.return_value = SUBSCRIPTION_1 endpoint_details = { 'account_id': 'test', 'queue_name': 'topic_subscription_queue'} result = self.conn.create_subscription( 'example_topic', 'queue', **endpoint_details) make_request.assert_called_with( 'post', 'topics/example_topic/subscriptions', data=mock.ANY) self.assertEqual(SUBSCRIPTION_1, result) @mock.patch('SoftLayer.managers.messaging.MessagingConnection.' '_make_request') def test_delete_subscription(self, make_request): make_request().json.return_value = SUBSCRIPTION_1 result = self.conn.delete_subscription( 'example_topic', SUBSCRIPTION_1['id']) make_request.assert_called_with( 'delete', 'topics/example_topic/subscriptions/%s' % SUBSCRIPTION_1['id']) self.assertTrue(result) softlayer-python-5.0.1/tests/managers/sshkey_tests.py000066400000000000000000000037511267703721100231210ustar00rootroot00000000000000""" SoftLayer.tests.managers.sshkey_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import SoftLayer from SoftLayer import testing class SshKeyTests(testing.TestCase): def set_up(self): self.sshkey = SoftLayer.SshKeyManager(self.client) def test_add_key(self): self.sshkey.add_key(key='pretend this is a public SSH key', label='Test label', notes='My notes') args = ({ 'key': 'pretend this is a public SSH key', 'label': 'Test label', 'notes': 'My notes', },) self.assert_called_with('SoftLayer_Security_Ssh_Key', 'createObject', args=args) def test_delete_key(self): self.sshkey.delete_key(1234) self.assert_called_with('SoftLayer_Security_Ssh_Key', 'deleteObject', identifier=1234) def test_edit_key(self): self.sshkey.edit_key(1234, label='Test label', notes='My notes') args = ({ 'label': 'Test label', 'notes': 'My notes', },) self.assert_called_with('SoftLayer_Security_Ssh_Key', 'editObject', identifier=1234, args=args) def test_get_key(self): self.sshkey.get_key(1234) self.assert_called_with('SoftLayer_Security_Ssh_Key', 'getObject', identifier=1234) def test_list_keys(self): self.sshkey.list_keys(label='some label') _filter = {'sshKeys': {'label': {'operation': '_= some label'}}} self.assert_called_with('SoftLayer_Account', 'getSshKeys', filter=_filter) def test_resolve_ids_label(self): _id = self.sshkey._get_ids_from_label('Test 1') self.assertEqual(_id, ['100']) _id = self.sshkey._get_ids_from_label('nope') self.assertEqual(_id, []) softlayer-python-5.0.1/tests/managers/ssl_tests.py000066400000000000000000000057541267703721100224210ustar00rootroot00000000000000""" SoftLayer.tests.managers.ssl_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import SoftLayer from SoftLayer import fixtures from SoftLayer import testing class SSLTests(testing.TestCase): def set_up(self): self.ssl = SoftLayer.SSLManager(self.client) self.test_id = 10 def test_list_certs_valid(self): result = self.ssl.list_certs('valid') self.assertEqual( result, fixtures.SoftLayer_Account.getValidSecurityCertificates) self.assert_called_with('SoftLayer_Account', 'getValidSecurityCertificates') def test_list_certs_expired(self): result = self.ssl.list_certs('expired') self.assertEqual( result, fixtures.SoftLayer_Account.getExpiredSecurityCertificates) self.assert_called_with('SoftLayer_Account', 'getExpiredSecurityCertificates') def test_list_certs_all(self): result = self.ssl.list_certs('all') self.assertEqual( result, fixtures.SoftLayer_Account.getSecurityCertificates) self.assert_called_with('SoftLayer_Account', 'getSecurityCertificates') def test_add_certificate(self): test_cert = { 'certificate': 'cert', 'privateKey': 'key', } result = self.ssl.add_certificate(test_cert) self.assertEqual(result, fixtures.SoftLayer_Security_Certificate.createObject) self.assert_called_with('SoftLayer_Security_Certificate', 'createObject', args=(test_cert,)) def test_remove_certificate(self): result = self.ssl.remove_certificate(self.test_id) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Security_Certificate', 'deleteObject', identifier=self.test_id) def test_edit_certificate(self): test_cert = { 'id': self.test_id, 'certificate': 'cert', 'privateKey': 'key' } result = self.ssl.edit_certificate(test_cert) self.assertEqual(result, True) args = ({ 'id': self.test_id, 'certificate': 'cert', 'privateKey': 'key' },) self.assert_called_with('SoftLayer_Security_Certificate', 'editObject', args=args, identifier=self.test_id) def test_get_certificate(self): result = self.ssl.get_certificate(self.test_id) self.assertEqual(result, fixtures.SoftLayer_Security_Certificate.getObject) self.assert_called_with('SoftLayer_Security_Certificate', 'getObject', identifier=self.test_id) softlayer-python-5.0.1/tests/managers/ticket_tests.py000066400000000000000000000054071267703721100230760ustar00rootroot00000000000000""" SoftLayer.tests.managers.ticket_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import SoftLayer from SoftLayer import fixtures from SoftLayer import testing class TicketTests(testing.TestCase): def set_up(self): self.ticket = SoftLayer.TicketManager(self.client) def test_list_tickets(self): results = self.ticket.list_tickets() for result in results: self.assertIn(result['id'], [100, 101, 102]) self.assert_called_with('SoftLayer_Account', 'getTickets') def test_list_tickets_all(self): results = self.ticket.list_tickets(open_status=True, closed_status=True) for result in results: self.assertIn(result['id'], [100, 101, 102]) self.assert_called_with('SoftLayer_Account', 'getTickets') def test_list_tickets_open(self): results = self.ticket.list_tickets(open_status=True, closed_status=False) for result in results: self.assertIn(result['id'], [102]) self.assert_called_with('SoftLayer_Account', 'getOpenTickets') def test_list_tickets_closed(self): results = self.ticket.list_tickets(open_status=False, closed_status=True) for result in results: self.assertIn(result['id'], [100, 101]) self.assert_called_with('SoftLayer_Account', 'getClosedTickets') def test_list_subjects(self): list_expected_ids = [1001, 1002, 1003, 1004, 1005] results = self.ticket.list_subjects() for result in results: self.assertIn(result['id'], list_expected_ids) def test_get_instance(self): result = self.ticket.get_ticket(100) self.assertEqual(result, fixtures.SoftLayer_Ticket.getObject) self.assert_called_with('SoftLayer_Ticket', 'getObject', identifier=100) def test_create_ticket(self): self.ticket.create_ticket( title="Cloud Instance Cancellation - 08/01/13", body="body", subject=1004) args = ({"assignedUserId": 12345, "contents": "body", "subjectId": 1004, "title": "Cloud Instance Cancellation - 08/01/13"}, "body") self.assert_called_with('SoftLayer_Ticket', 'createStandardTicket', args=args) def test_update_ticket(self): # test a full update self.ticket.update_ticket(100, body='Update1') self.assert_called_with('SoftLayer_Ticket', 'addUpdate', args=({'entry': 'Update1'},), identifier=100) softlayer-python-5.0.1/tests/managers/vs_tests.py000066400000000000000000000675621267703721100222550ustar00rootroot00000000000000""" SoftLayer.tests.managers.vs_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import mock import SoftLayer from SoftLayer import exceptions from SoftLayer import fixtures from SoftLayer import testing class VSTests(testing.TestCase): def set_up(self): self.vs = SoftLayer.VSManager(self.client, SoftLayer.OrderingManager(self.client)) def test_list_instances(self): results = self.vs.list_instances(hourly=True, monthly=True) for result in results: self.assertIn(result['id'], [100, 104]) self.assert_called_with('SoftLayer_Account', 'getVirtualGuests') def test_list_instances_neither(self): results = self.vs.list_instances(hourly=False, monthly=False) for result in results: self.assertIn(result['id'], [100, 104]) self.assert_called_with('SoftLayer_Account', 'getVirtualGuests') def test_list_instances_monthly(self): results = self.vs.list_instances(hourly=False, monthly=True) for result in results: self.assertIn(result['id'], [100]) self.assert_called_with('SoftLayer_Account', 'getMonthlyVirtualGuests') def test_list_instances_hourly(self): results = self.vs.list_instances(hourly=True, monthly=False) for result in results: self.assertIn(result['id'], [104]) self.assert_called_with('SoftLayer_Account', 'getHourlyVirtualGuests') def test_list_instances_with_filters(self): self.vs.list_instances( hourly=True, monthly=True, tags=['tag1', 'tag2'], cpus=2, memory=1024, hostname='hostname', domain='example.com', local_disk=True, datacenter='dal05', nic_speed=100, public_ip='1.2.3.4', private_ip='4.3.2.1', ) _filter = { 'virtualGuests': { 'datacenter': { 'name': {'operation': '_= dal05'}}, 'domain': {'operation': '_= example.com'}, 'tagReferences': { 'tag': {'name': { 'operation': 'in', 'options': [{ 'name': 'data', 'value': ['tag1', 'tag2']}]}}}, 'maxCpu': {'operation': 2}, 'localDiskFlag': {'operation': True}, 'maxMemory': {'operation': 1024}, 'hostname': {'operation': '_= hostname'}, 'networkComponents': {'maxSpeed': {'operation': 100}}, 'primaryIpAddress': {'operation': '_= 1.2.3.4'}, 'primaryBackendIpAddress': {'operation': '_= 4.3.2.1'} } } self.assert_called_with('SoftLayer_Account', 'getVirtualGuests', filter=_filter) def test_resolve_ids_ip(self): _id = self.vs._get_ids_from_ip('172.16.240.2') self.assertEqual(_id, [100, 104]) def test_resolve_ids_ip_private(self): # Now simulate a private IP test mock = self.set_mock('SoftLayer_Account', 'getVirtualGuests') mock.side_effect = [[], [{'id': 99}]] _id = self.vs._get_ids_from_ip('10.0.1.87') self.assertEqual(_id, [99]) def test_resolve_ids_ip_invalid(self): _id = self.vs._get_ids_from_ip('nope') self.assertEqual(_id, []) def test_resolve_ids_hostname(self): _id = self.vs._get_ids_from_hostname('vs-test1') self.assertEqual(_id, [100, 104]) def test_get_instance(self): result = self.vs.get_instance(100) self.assertEqual(fixtures.SoftLayer_Virtual_Guest.getObject, result) self.assert_called_with('SoftLayer_Virtual_Guest', 'getObject', identifier=100) def test_get_create_options(self): results = self.vs.get_create_options() self.assertEqual( fixtures.SoftLayer_Virtual_Guest.getCreateObjectOptions, results) def test_cancel_instance(self): result = self.vs.cancel_instance(1) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Virtual_Guest', 'deleteObject', identifier=1) def test_reload_instance(self): self.vs.reload_instance(1) self.assert_called_with('SoftLayer_Virtual_Guest', 'reloadOperatingSystem', args=('FORCE', {}), identifier=1) def test_reload_instance_posturi_sshkeys(self): post_uri = 'http://test.sftlyr.ws/test.sh' self.vs.reload_instance(1, post_uri=post_uri, ssh_keys=[1701]) args = ('FORCE', {'customProvisionScriptUri': post_uri, 'sshKeyIds': [1701]}) self.assert_called_with('SoftLayer_Virtual_Guest', 'reloadOperatingSystem', args=args, identifier=1) def test_reload_instance_with_new_os(self): self.vs.reload_instance(1, image_id=1234) args = ('FORCE', {'imageTemplateId': 1234}) self.assert_called_with('SoftLayer_Virtual_Guest', 'reloadOperatingSystem', args=args, identifier=1) @mock.patch('SoftLayer.managers.vs.VSManager._generate_create_dict') def test_create_verify(self, create_dict): create_dict.return_value = {'test': 1, 'verify': 1} self.vs.verify_create_instance(test=1, verify=1, tags=['test', 'tags']) create_dict.assert_called_once_with(test=1, verify=1) self.assert_called_with('SoftLayer_Virtual_Guest', 'generateOrderTemplate', args=({'test': 1, 'verify': 1},)) @mock.patch('SoftLayer.managers.vs.VSManager._generate_create_dict') def test_create_instance(self, create_dict): create_dict.return_value = {'test': 1, 'verify': 1} self.vs.create_instance(test=1, verify=1, tags='dev,green') create_dict.assert_called_once_with(test=1, verify=1) self.assert_called_with('SoftLayer_Virtual_Guest', 'createObject', args=({'test': 1, 'verify': 1},)) self.assert_called_with('SoftLayer_Virtual_Guest', 'setTags', args=('dev,green',), identifier=100) def test_create_instances(self): self.vs.create_instances([{'cpus': 1, 'memory': 1024, 'hostname': 'server', 'domain': 'example.com', 'tags': 'dev,green'}]) args = ([{'domain': 'example.com', 'hourlyBillingFlag': True, 'localDiskFlag': True, 'maxMemory': 1024, 'hostname': 'server', 'startCpus': 1}],) self.assert_called_with('SoftLayer_Virtual_Guest', 'createObjects', args=args) self.assert_called_with('SoftLayer_Virtual_Guest', 'setTags', args=('dev,green',), identifier=100) def test_generate_os_and_image(self): self.assertRaises( ValueError, self.vs._generate_create_dict, cpus=1, memory=1, hostname='test', domain='example.com', os_code=1, image_id=1, ) def test_generate_missing(self): self.assertRaises(ValueError, self.vs._generate_create_dict) self.assertRaises(ValueError, self.vs._generate_create_dict, cpus=1) def test_generate_basic(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', os_code="STRING", ) assert_data = { 'startCpus': 1, 'maxMemory': 1, 'hostname': 'test', 'domain': 'example.com', 'localDiskFlag': True, 'operatingSystemReferenceCode': "STRING", 'hourlyBillingFlag': True, } self.assertEqual(data, assert_data) def test_generate_monthly(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', os_code="STRING", hourly=False, ) assert_data = { 'hourlyBillingFlag': False, 'startCpus': 1, 'maxMemory': 1, 'hostname': 'test', 'domain': 'example.com', 'localDiskFlag': True, 'operatingSystemReferenceCode': "STRING", } self.assertEqual(data, assert_data) def test_generate_image_id(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', image_id="45", ) assert_data = { 'startCpus': 1, 'maxMemory': 1, 'hostname': 'test', 'domain': 'example.com', 'localDiskFlag': True, 'blockDeviceTemplateGroup': {"globalIdentifier": "45"}, 'hourlyBillingFlag': True, } self.assertEqual(data, assert_data) def test_generate_dedicated(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', os_code="STRING", dedicated=True, ) assert_data = { 'startCpus': 1, 'maxMemory': 1, 'hostname': 'test', 'domain': 'example.com', 'localDiskFlag': True, 'operatingSystemReferenceCode': "STRING", 'hourlyBillingFlag': True, 'dedicatedAccountHostOnlyFlag': True, } self.assertEqual(data, assert_data) def test_generate_datacenter(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', os_code="STRING", datacenter="sng01", ) assert_data = { 'startCpus': 1, 'maxMemory': 1, 'hostname': 'test', 'domain': 'example.com', 'localDiskFlag': True, 'operatingSystemReferenceCode': "STRING", 'hourlyBillingFlag': True, 'datacenter': {"name": 'sng01'}, } self.assertEqual(data, assert_data) def test_generate_public_vlan(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', os_code="STRING", public_vlan=1, ) assert_data = { 'startCpus': 1, 'maxMemory': 1, 'hostname': 'test', 'domain': 'example.com', 'localDiskFlag': True, 'operatingSystemReferenceCode': "STRING", 'hourlyBillingFlag': True, 'primaryNetworkComponent': {"networkVlan": {"id": 1}}, } self.assertEqual(data, assert_data) def test_generate_private_vlan(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', os_code="STRING", private_vlan=1, ) assert_data = { 'startCpus': 1, 'maxMemory': 1, 'hostname': 'test', 'domain': 'example.com', 'localDiskFlag': True, 'operatingSystemReferenceCode': "STRING", 'hourlyBillingFlag': True, 'primaryBackendNetworkComponent': {"networkVlan": {"id": 1}}, } self.assertEqual(data, assert_data) def test_generate_userdata(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', os_code="STRING", userdata="ICANHAZVSI", ) assert_data = { 'startCpus': 1, 'maxMemory': 1, 'hostname': 'test', 'domain': 'example.com', 'localDiskFlag': True, 'operatingSystemReferenceCode': "STRING", 'hourlyBillingFlag': True, 'userData': [{'value': "ICANHAZVSI"}], } self.assertEqual(data, assert_data) def test_generate_network(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', os_code="STRING", nic_speed=9001, ) assert_data = { 'startCpus': 1, 'maxMemory': 1, 'hostname': 'test', 'domain': 'example.com', 'localDiskFlag': True, 'operatingSystemReferenceCode': "STRING", 'hourlyBillingFlag': True, 'networkComponents': [{'maxSpeed': 9001}], } self.assertEqual(data, assert_data) def test_generate_private_network_only(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', os_code="STRING", nic_speed=9001, private=True ) assert_data = { 'startCpus': 1, 'maxMemory': 1, 'hostname': 'test', 'domain': 'example.com', 'localDiskFlag': True, 'operatingSystemReferenceCode': "STRING", 'privateNetworkOnlyFlag': True, 'hourlyBillingFlag': True, 'networkComponents': [{'maxSpeed': 9001}], } self.assertEqual(data, assert_data) def test_generate_post_uri(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', os_code="STRING", post_uri='https://example.com/boostrap.sh', ) assert_data = { 'startCpus': 1, 'maxMemory': 1, 'hostname': 'test', 'domain': 'example.com', 'localDiskFlag': True, 'operatingSystemReferenceCode': "STRING", 'hourlyBillingFlag': True, 'postInstallScriptUri': 'https://example.com/boostrap.sh', } self.assertEqual(data, assert_data) def test_generate_sshkey(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', os_code="STRING", ssh_keys=[543], ) assert_data = { 'startCpus': 1, 'maxMemory': 1, 'hostname': 'test', 'domain': 'example.com', 'localDiskFlag': True, 'operatingSystemReferenceCode': "STRING", 'hourlyBillingFlag': True, 'sshKeys': [{'id': 543}], } self.assertEqual(data, assert_data) def test_generate_no_disks(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', os_code="STRING" ) self.assertEqual(data.get('blockDevices'), None) def test_generate_single_disk(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', os_code="STRING", disks=[50] ) assert_data = { 'blockDevices': [ {"device": "0", "diskImage": {"capacity": 50}}] } self.assertTrue(data.get('blockDevices')) self.assertEqual(data['blockDevices'], assert_data['blockDevices']) def test_generate_multi_disk(self): data = self.vs._generate_create_dict( cpus=1, memory=1, hostname='test', domain='example.com', os_code="STRING", disks=[50, 70, 100] ) assert_data = { 'blockDevices': [ {"device": "0", "diskImage": {"capacity": 50}}, {"device": "2", "diskImage": {"capacity": 70}}, {"device": "3", "diskImage": {"capacity": 100}}] } self.assertTrue(data.get('blockDevices')) self.assertEqual(data['blockDevices'], assert_data['blockDevices']) def test_change_port_speed_public(self): result = self.vs.change_port_speed(1, True, 100) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Virtual_Guest', 'setPublicNetworkInterfaceSpeed', identifier=1, args=(100,)) def test_change_port_speed_private(self): result = self.vs.change_port_speed(2, False, 10) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Virtual_Guest', 'setPrivateNetworkInterfaceSpeed', identifier=2, args=(10,)) def test_rescue(self): # Test rescue environment result = self.vs.rescue(1234) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Virtual_Guest', 'executeRescueLayer', identifier=1234) def test_edit_metadata(self): # Test editing user data result = self.vs.edit(100, userdata='my data') self.assertEqual(result, True) self.assert_called_with('SoftLayer_Virtual_Guest', 'setUserMetadata', identifier=100, args=(['my data'],)) def test_edit_blank(self): # Now test a blank edit self.assertTrue(self.vs.edit, 100) def test_edit_full(self): result = self.vs.edit(100, hostname='new-host', domain='new.sftlyr.ws', notes='random notes') self.assertEqual(result, True) args = ({ 'hostname': 'new-host', 'domain': 'new.sftlyr.ws', 'notes': 'random notes', },) self.assert_called_with('SoftLayer_Virtual_Guest', 'editObject', identifier=100, args=args) def test_edit_tags(self): # Test tag support result = self.vs.edit(100, tags='dev,green') self.assertEqual(result, True) self.assert_called_with('SoftLayer_Virtual_Guest', 'setTags', identifier=100, args=('dev,green',)) def test_edit_tags_blank(self): result = self.vs.edit(100, tags='') self.assertEqual(result, True) self.assert_called_with('SoftLayer_Virtual_Guest', 'setTags', identifier=100, args=('',)) def test_captures(self): # capture only the OS disk result = self.vs.capture(1, 'a') expected = fixtures.SoftLayer_Virtual_Guest.createArchiveTransaction self.assertEqual(result, expected) args = ('a', [], None) self.assert_called_with('SoftLayer_Virtual_Guest', 'createArchiveTransaction', args=args, identifier=1) def test_capture_additional_disks(self): # capture all the disks, minus the swap # make sure the data is carried along with it result = self.vs.capture(1, 'a', additional_disks=True) expected = fixtures.SoftLayer_Virtual_Guest.createArchiveTransaction self.assertEqual(result, expected) args = ('a', [{'device': 0, 'mountType': 'Disk', 'uuid': 1}, {'device': 3, 'mountType': 'Disk', 'uuid': 3}], None) self.assert_called_with('SoftLayer_Virtual_Guest', 'createArchiveTransaction', args=args, identifier=1) def test_upgrade(self): mock = self.set_mock('SoftLayer_Product_Package', 'getAllObjects') mock.return_value = [ {'id': 46, 'name': 'Virtual Servers', 'description': 'Virtual Server Instances', 'type': {'keyName': 'VIRTUAL_SERVER_INSTANCE'}, 'isActive': 1}, ] # test single upgrade result = self.vs.upgrade(1, cpus=4, public=False) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Product_Order', 'placeOrder') call = self.calls('SoftLayer_Product_Order', 'placeOrder')[0] order_container = call.args[0] self.assertEqual(order_container['prices'], [{'id': 1007}]) self.assertEqual(order_container['virtualGuests'], [{'id': 1}]) def test_upgrade_blank(self): # Now test a blank upgrade result = self.vs.upgrade(1) self.assertEqual(result, False) self.assertEqual(self.calls('SoftLayer_Product_Order', 'placeOrder'), []) def test_upgrade_full(self): # Testing all parameters Upgrade result = self.vs.upgrade(1, cpus=4, memory=2, nic_speed=1000, public=True) self.assertEqual(result, True) self.assert_called_with('SoftLayer_Product_Order', 'placeOrder') call = self.calls('SoftLayer_Product_Order', 'placeOrder')[0] order_container = call.args[0] self.assertIn({'id': 1144}, order_container['prices']) self.assertIn({'id': 1133}, order_container['prices']) self.assertIn({'id': 1122}, order_container['prices']) self.assertEqual(order_container['virtualGuests'], [{'id': 1}]) def test_upgrade_skips_location_based_prices(self): # Test that no prices that have locationGroupId set are used self.assertRaises(exceptions.SoftLayerError, self.vs.upgrade, 1, cpus=55, memory=2, public=True) def test_get_item_id_for_upgrade(self): item_id = 0 package_items = self.client['Product_Package'].getItems(id=46) for item in package_items: if ((item['prices'][0]['categories'][0]['id'] == 3) and (item.get('capacity') == '2')): item_id = item['prices'][0]['id'] break self.assertEqual(1133, item_id) class VSWaitReadyGoTests(testing.TestCase): def set_up(self): self.client = mock.MagicMock() self.vs = SoftLayer.VSManager(self.client) self.guestObject = self.client['Virtual_Guest'].getObject @mock.patch('SoftLayer.managers.vs.VSManager.wait_for_ready') def test_wait_interface(self, ready): # verify interface to wait_for_ready is intact self.vs.wait_for_transaction(1, 1) ready.assert_called_once_with(1, 1, delay=1, pending=True) def test_active_not_provisioned(self): # active transaction and no provision date should be false self.guestObject.side_effect = [ {'activeTransaction': {'id': 1}}, ] value = self.vs.wait_for_ready(1, 0) self.assertFalse(value) def test_active_and_provisiondate(self): # active transaction and provision date should be True self.guestObject.side_effect = [ {'activeTransaction': {'id': 1}, 'provisionDate': 'aaa'}, ] value = self.vs.wait_for_ready(1, 1) self.assertTrue(value) def test_active_provision_pending(self): # active transaction and provision date # and pending should be false self.guestObject.side_effect = [ {'activeTransaction': {'id': 1}, 'provisionDate': 'aaa'}, ] value = self.vs.wait_for_ready(1, 0, pending=True) self.assertFalse(value) def test_active_reload(self): # actively running reload self.guestObject.side_effect = [ { 'activeTransaction': {'id': 1}, 'provisionDate': 'aaa', 'lastOperatingSystemReload': {'id': 1}, }, ] value = self.vs.wait_for_ready(1, 0) self.assertFalse(value) def test_reload_no_pending(self): # reload complete, maintance transactions self.guestObject.side_effect = [ { 'activeTransaction': {'id': 2}, 'provisionDate': 'aaa', 'lastOperatingSystemReload': {'id': 1}, }, ] value = self.vs.wait_for_ready(1, 1) self.assertTrue(value) def test_reload_pending(self): # reload complete, pending maintance transactions self.guestObject.side_effect = [ { 'activeTransaction': {'id': 2}, 'provisionDate': 'aaa', 'lastOperatingSystemReload': {'id': 1}, }, ] value = self.vs.wait_for_ready(1, 0, pending=True) self.assertFalse(value) @mock.patch('time.sleep') def test_ready_iter_once_incomplete(self, _sleep): self.guestObject = self.client['Virtual_Guest'].getObject # no iteration, false self.guestObject.side_effect = [ {'activeTransaction': {'id': 1}}, ] value = self.vs.wait_for_ready(1, 0) self.assertFalse(value) self.assertFalse(_sleep.called) @mock.patch('time.sleep') def test_iter_once_complete(self, _sleep): # no iteration, true self.guestObject.side_effect = [ {'provisionDate': 'aaa'}, ] value = self.vs.wait_for_ready(1, 1) self.assertTrue(value) self.assertFalse(_sleep.called) @mock.patch('time.sleep') def test_iter_four_complete(self, _sleep): # test 4 iterations with positive match self.guestObject.side_effect = [ {'activeTransaction': {'id': 1}}, {'activeTransaction': {'id': 1}}, {'activeTransaction': {'id': 1}}, {'provisionDate': 'aaa'}, ] value = self.vs.wait_for_ready(1, 4) self.assertTrue(value) _sleep.assert_has_calls([mock.call(1), mock.call(1), mock.call(1)]) self.guestObject.assert_has_calls([ mock.call(id=1, mask=mock.ANY), mock.call(id=1, mask=mock.ANY), mock.call(id=1, mask=mock.ANY), mock.call(id=1, mask=mock.ANY), ]) @mock.patch('time.time') @mock.patch('time.sleep') def test_iter_two_incomplete(self, _sleep, _time): # test 2 iterations, with no matches self.guestObject.side_effect = [ {'activeTransaction': {'id': 1}}, {'activeTransaction': {'id': 1}}, {'provisionDate': 'aaa'} ] _time.side_effect = [0, 1, 2] value = self.vs.wait_for_ready(1, 2) self.assertFalse(value) _sleep.assert_called_once_with(1) self.guestObject.assert_has_calls([ mock.call(id=1, mask=mock.ANY), mock.call(id=1, mask=mock.ANY), ]) @mock.patch('time.time') @mock.patch('time.sleep') def test_iter_20_incomplete(self, _sleep, _time): """Wait for up to 20 seconds (sleeping for 10 seconds) for a server.""" self.guestObject.return_value = {'activeTransaction': {'id': 1}} _time.side_effect = [0, 10, 20] value = self.vs.wait_for_ready(1, 20, delay=10) self.assertFalse(value) self.guestObject.assert_has_calls([mock.call(id=1, mask=mock.ANY)]) _sleep.assert_has_calls([mock.call(10)]) softlayer-python-5.0.1/tests/transport_tests.py000066400000000000000000000332211267703721100220450ustar00rootroot00000000000000""" SoftLayer.tests.transport_tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :license: MIT, see LICENSE for more details. """ import io import warnings import mock import requests import six import SoftLayer from SoftLayer import consts from SoftLayer import testing from SoftLayer import transports class TestXmlRpcAPICall(testing.TestCase): def set_up(self): self.transport = transports.XmlRpcTransport( endpoint_url='http://something.com', ) self.response = requests.Response() list_body = six.b(''' ''') self.response.raw = io.BytesIO(list_body) self.response.headers['SoftLayer-Total-Items'] = 10 self.response.status_code = 200 @mock.patch('requests.request') def test_call(self, request): request.return_value = self.response data = ''' getObject headers ''' req = transports.Request() req.service = 'SoftLayer_Service' req.method = 'getObject' resp = self.transport(req) request.assert_called_with('POST', 'http://something.com/SoftLayer_Service', headers={'Content-Type': 'application/xml', 'User-Agent': consts.USER_AGENT}, proxies=None, data=data, timeout=None, cert=None, verify=True) self.assertEqual(resp, []) self.assertIsInstance(resp, transports.SoftLayerListResult) self.assertEqual(resp.total_count, 10) def test_proxy_without_protocol(self): req = transports.Request() req.service = 'SoftLayer_Service' req.method = 'Resource' req.proxy = 'localhost:3128' try: self.assertRaises(SoftLayer.TransportError, self.transport, req) except AssertionError: warnings.warn("Incorrect Exception raised. Expected a " "SoftLayer.TransportError error") @mock.patch('requests.request') def test_valid_proxy(self, request): request.return_value = self.response self.transport.proxy = 'http://localhost:3128' req = transports.Request() req.service = 'SoftLayer_Service' req.method = 'Resource' self.transport(req) request.assert_called_with( 'POST', mock.ANY, proxies={'https': 'http://localhost:3128', 'http': 'http://localhost:3128'}, data=mock.ANY, headers=mock.ANY, timeout=None, cert=None, verify=True) @mock.patch('requests.request') def test_identifier(self, request): request.return_value = self.response req = transports.Request() req.endpoint = "http://something.com" req.service = "SoftLayer_Service" req.method = "getObject" req.identifier = 1234 self.transport(req) args, kwargs = request.call_args self.assertIn( """ id 1234 """, kwargs['data']) @mock.patch('requests.request') def test_filter(self, request): request.return_value = self.response req = transports.Request() req.endpoint = "http://something.com" req.service = "SoftLayer_Service" req.method = "getObject" req.filter = {'TYPE': {'attribute': {'operation': '^= prefix'}}} self.transport(req) args, kwargs = request.call_args self.assertIn( """ operation ^= prefix """, kwargs['data']) @mock.patch('requests.request') def test_limit_offset(self, request): request.return_value = self.response req = transports.Request() req.endpoint = "http://something.com" req.service = "SoftLayer_Service" req.method = "getObject" req.limit = 10 self.transport(req) args, kwargs = request.call_args self.assertIn(""" resultLimit """, kwargs['data']) self.assertIn("""limit 10 """, kwargs['data']) @mock.patch('requests.request') def test_old_mask(self, request): request.return_value = self.response req = transports.Request() req.endpoint = "http://something.com" req.service = "SoftLayer_Service" req.method = "getObject" req.mask = {"something": "nested"} self.transport(req) args, kwargs = request.call_args self.assertIn(""" mask something nested """, kwargs['data']) @mock.patch('requests.request') def test_mask_call_no_mask_prefix(self, request): request.return_value = self.response req = transports.Request() req.endpoint = "http://something.com" req.service = "SoftLayer_Service" req.method = "getObject" req.mask = "something.nested" self.transport(req) args, kwargs = request.call_args self.assertIn( "mask[something.nested]", kwargs['data']) @mock.patch('requests.request') def test_mask_call_v2(self, request): request.return_value = self.response req = transports.Request() req.endpoint = "http://something.com" req.service = "SoftLayer_Service" req.method = "getObject" req.mask = "mask[something[nested]]" self.transport(req) args, kwargs = request.call_args self.assertIn( "mask[something[nested]]", kwargs['data']) @mock.patch('requests.request') def test_mask_call_v2_dot(self, request): request.return_value = self.response req = transports.Request() req.endpoint = "http://something.com" req.service = "SoftLayer_Service" req.method = "getObject" req.mask = "mask.something.nested" self.transport(req) args, kwargs = request.call_args self.assertIn("mask.something.nested", kwargs['data']) @mock.patch('requests.request') def test_request_exception(self, request): # Test Text Error e = requests.HTTPError('error') e.response = mock.MagicMock() e.response.status_code = 404 e.response.content = 'Error Code' request().raise_for_status.side_effect = e req = transports.Request() req.service = 'SoftLayer_Service' req.method = 'getObject' self.assertRaises(SoftLayer.TransportError, self.transport, req) class TestRestAPICall(testing.TestCase): def set_up(self): self.transport = transports.RestTransport( endpoint_url='http://something.com', ) @mock.patch('requests.request') def test_basic(self, request): request().content = '[]' request().headers = requests.structures.CaseInsensitiveDict({ 'SoftLayer-Total-Items': '10', }) req = transports.Request() req.service = 'SoftLayer_Service' req.method = 'Resource' resp = self.transport(req) self.assertEqual(resp, []) self.assertIsInstance(resp, transports.SoftLayerListResult) self.assertEqual(resp.total_count, 10) request.assert_called_with( 'GET', 'http://something.com/SoftLayer_Service/Resource.json', headers=mock.ANY, auth=None, data=None, params={}, verify=True, cert=None, proxies=None, timeout=None) @mock.patch('requests.request') def test_error(self, request): # Test JSON Error e = requests.HTTPError('error') e.response = mock.MagicMock() e.response.status_code = 404 e.response.content = '''{ "error": "description", "code": "Error Code" }''' request().raise_for_status.side_effect = e req = transports.Request() req.service = 'SoftLayer_Service' req.method = 'Resource' self.assertRaises(SoftLayer.SoftLayerAPIError, self.transport, req) def test_proxy_without_protocol(self): req = transports.Request() req.service = 'SoftLayer_Service' req.method = 'Resource' req.proxy = 'localhost:3128' try: self.assertRaises(SoftLayer.TransportError, self.transport, req) except AssertionError: warnings.warn("AssertionError raised instead of a " "SoftLayer.TransportError error") @mock.patch('requests.request') def test_valid_proxy(self, request): request().content = '{}' self.transport.proxy = 'http://localhost:3128' req = transports.Request() req.service = 'SoftLayer_Service' req.method = 'Resource' self.transport(req) request.assert_called_with( 'GET', 'http://something.com/SoftLayer_Service/Resource.json', proxies={'https': 'http://localhost:3128', 'http': 'http://localhost:3128'}, auth=None, data=None, params={}, verify=True, cert=None, timeout=mock.ANY, headers=mock.ANY) @mock.patch('requests.request') def test_with_id(self, request): request().content = '{}' req = transports.Request() req.service = 'SoftLayer_Service' req.method = 'getObject' req.identifier = 2 resp = self.transport(req) self.assertEqual(resp, {}) request.assert_called_with( 'GET', 'http://something.com/SoftLayer_Service/2/getObject.json', headers=mock.ANY, auth=None, data=None, params={}, verify=True, cert=None, proxies=None, timeout=None) @mock.patch('requests.request') def test_with_args(self, request): request().content = '{}' req = transports.Request() req.service = 'SoftLayer_Service' req.method = 'getObject' req.args = ('test', 1) resp = self.transport(req) self.assertEqual(resp, {}) request.assert_called_with( 'POST', 'http://something.com/SoftLayer_Service/getObject.json', headers=mock.ANY, auth=None, data='{"parameters": ["test", 1]}', params={}, verify=True, cert=None, proxies=None, timeout=None) @mock.patch('requests.request') def test_with_filter(self, request): request().content = '{}' req = transports.Request() req.service = 'SoftLayer_Service' req.method = 'getObject' req.filter = {'TYPE': {'attribute': {'operation': '^= prefix'}}} resp = self.transport(req) self.assertEqual(resp, {}) request.assert_called_with( 'GET', 'http://something.com/SoftLayer_Service/getObject.json', params={'objectFilter': '{"TYPE": {"attribute": {"operation": "^= prefix"}}}'}, headers=mock.ANY, auth=None, data=None, verify=True, cert=None, proxies=None, timeout=None) @mock.patch('requests.request') def test_with_mask(self, request): request().content = '{}' req = transports.Request() req.service = 'SoftLayer_Service' req.method = 'getObject' req.mask = 'id,property' resp = self.transport(req) self.assertEqual(resp, {}) request.assert_called_with( 'GET', 'http://something.com/SoftLayer_Service/getObject.json', params={'objectMask': 'mask[id,property]'}, headers=mock.ANY, auth=None, data=None, verify=True, cert=None, proxies=None, timeout=None) # Now test with mask[] prefix req = transports.Request() req.service = 'SoftLayer_Service' req.method = 'getObject' req.mask = 'mask[id,property]' resp = self.transport(req) self.assertEqual(resp, {}) request.assert_called_with( 'GET', 'http://something.com/SoftLayer_Service/getObject.json', params={'objectMask': 'mask[id,property]'}, headers=mock.ANY, auth=None, data=None, verify=True, cert=None, proxies=None, timeout=None) @mock.patch('requests.request') def test_unknown_error(self, request): e = requests.RequestException('error') e.response = mock.MagicMock() e.response.status_code = 404 e.response.content = 'Error Code' request().raise_for_status.side_effect = e req = transports.Request() req.service = 'SoftLayer_Service' req.method = 'getObject' self.assertRaises(SoftLayer.TransportError, self.transport, req) softlayer-python-5.0.1/tools/000077500000000000000000000000001267703721100162125ustar00rootroot00000000000000softlayer-python-5.0.1/tools/requirements.txt000066400000000000000000000001051267703721100214720ustar00rootroot00000000000000requests click >= 5 prettytable >= 0.7.0 six >= 1.7.0 prompt_toolkit softlayer-python-5.0.1/tools/test-requirements.txt000066400000000000000000000000541267703721100224520ustar00rootroot00000000000000tox pytest pytest-cov mock sphinx testtools softlayer-python-5.0.1/tox.ini000066400000000000000000000024101267703721100163620ustar00rootroot00000000000000[tox] envlist = py27,py33,py34,py35,pypy,analysis,coverage [testenv] setenv = LANG=C.UTF-8 LC_ALL=C.UTF-8 deps = -r{toxinidir}/tools/test-requirements.txt commands = py.test tests [testenv:coverage] basepython = python2.7 commands = py.test tests \ --cov=SoftLayer \ --cov-fail-under=77 \ --cov-report=html \ --cov-report=term-missing [testenv:analysis] basepython = python2.7 deps = -r{toxinidir}/tools/test-requirements.txt hacking pylint commands = flake8 SoftLayer tests # redefined-variable-type - This prevents polymorphism pylint SoftLayer \ -r n \ --ignore=tests,fixtures \ -d too-many-locals \ -d star-args \ -d redefined-variable-type \ -d locally-disabled \ --max-args=20 \ --max-branches=20 \ --max-statements=60 \ --min-public-methods=0 \ --min-similarity-lines=30 # invalid-name - Fixtures don't follow proper naming conventions # missing-docstring - Fixtures don't have docstrings pylint SoftLayer/fixtures \ -d invalid-name \ -d missing-docstring \ --max-module-lines=2000 \ --min-similarity-lines=50 \ -r n