pax_global_header00006660000000000000000000000064135714303750014522gustar00rootroot0000000000000052 comment=6201865f88a51ea312d83df239be896432fe2f96 python-cloudscale-0.6.1/000077500000000000000000000000001357143037500151635ustar00rootroot00000000000000python-cloudscale-0.6.1/.github/000077500000000000000000000000001357143037500165235ustar00rootroot00000000000000python-cloudscale-0.6.1/.github/workflows/000077500000000000000000000000001357143037500205605ustar00rootroot00000000000000python-cloudscale-0.6.1/.github/workflows/flake8.yml000066400000000000000000000003111357143037500224500ustar00rootroot00000000000000name: Flake8 on: [push] jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v1 - name: GitHub Action for Flake8 uses: cclauss/GitHub-Action-for-Flake8@v0.5.0 python-cloudscale-0.6.1/.github/workflows/pythonpublish.yml000066400000000000000000000011501357143037500242100ustar00rootroot00000000000000name: Upload Python Package on: push: tags: - 'v*' jobs: deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v1 - name: Set up Python uses: actions/setup-python@v1 with: python-version: '3.x' - name: Install dependencies run: | python -m pip install --upgrade pip pip install setuptools wheel twine - name: Build and publish env: TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} run: | python setup.py sdist bdist_wheel twine upload dist/* python-cloudscale-0.6.1/.github/workflows/test.yml000066400000000000000000000016161357143037500222660ustar00rootroot00000000000000name: Python package on: [push] jobs: build: runs-on: ubuntu-latest strategy: max-parallel: 4 matrix: python-version: - "3.6" - "3.7" - "3.8" steps: - uses: actions/checkout@v1 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v1 with: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | python -m pip install --upgrade pip pip install tox tox-gh-actions - name: Test with tox run: tox - name: GitHub Action for Flake8 uses: cclauss/GitHub-Action-for-Flake8@v0.5.0 - name: Upload coverage to Codecov uses: codecov/codecov-action@v1 with: token: ${{ secrets.CODECOV_TOKEN }} file: ./coverage.xml flags: unittests name: codecov-umbrella yml: ./codecov.yml python-cloudscale-0.6.1/.gitignore000066400000000000000000000001311357143037500171460ustar00rootroot00000000000000.vscode build dist *.egg-info .eggs __pycache__/ *.pyc .coverage .tox .venv coverage.xml python-cloudscale-0.6.1/.gitlab-ci.yml000066400000000000000000000005461357143037500176240ustar00rootroot00000000000000--- image: python stages: - test before_script: - curl -O https://bootstrap.pypa.io/get-pip.py - python get-pip.py - pip install -r requirements.dev.txt python36: image: python:3.6 stage: test script: tox -e py36 python37: image: python:3.7 stage: test script: tox -e py37 python38: image: python:3.8 stage: test script: tox -e py38 python-cloudscale-0.6.1/LICENSE000066400000000000000000000020701357143037500161670ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2019 - René Moser 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. python-cloudscale-0.6.1/README.md000066400000000000000000000076641357143037500164570ustar00rootroot00000000000000![license](https://img.shields.io/pypi/l/cloudscale.svg) ![python versions](https://img.shields.io/pypi/pyversions/cloudscale.svg) ![status](https://img.shields.io/pypi/status/cloudscale.svg) [![pypi version](https://img.shields.io/pypi/v/cloudscale.svg)](https://pypi.org/project/cloudscale/) ![PyPI - Downloads](https://img.shields.io/pypi/dw/cloudscale) [![codecov](https://codecov.io/gh/resmo/python-cloudscale/branch/master/graph/badge.svg)](https://codecov.io/gh/resmo/python-cloudscale) # Cloudscale A [cloudscale.ch](https://www.cloudscale.ch) API client for Python3 and your command line. ## Install / Update ~~~ pip3 install -U cloudscale --user export PATH=$PATH:$HOME/.local/bin cloudscale-cli version ~~~ ## Command Line Interface ### Autocompletion zsh: ~~~shell eval "$(_CLOUDSCALE_CLI_COMPLETE=source_zsh cloudscale-cli)" ~~~ bash: ~~~shell eval "$(_CLOUDSCALE_CLI_COMPLETE=source cloudscale-cli)" ~~~ ### Authentication #### Evironment variable Using the ENV `CLOUDSCALE_API_TOKEN` variable: ~~~shell export CLOUDSCALE_API_TOKEN= cloudscale-cli flavor list ~~~ #### Command line argument Passing the `--api-token` parameter: ~~~shell cloudscale-cli server --api-token create ... ~~~ #### Config file Creating an ini file `.cloudscale.ini` (leading dot) in your `$HOME` or a `cloudscale.ini` (without leading dot) in the `CWD` with the following schema: ~~~ini [default] api_token = ~~~ The default profile taken if available is `default`. The profile can be chosen by passing `--profile` or `CLOUDSCALE_PROFILE` ENV variable. ~~~ export CLOUDSCALE_PROFILE=staging ~~~ ~~~ini [production] api_token = [staging] api_token = ~~~ Passing the command line option will overwrite the ENV var as one would expect: ~~~ cloudscale-cli server --profile production list ~~~ ## Help See all options: ~~~shell $ cloudscale-cli --help Usage: cloudscale-cli [OPTIONS] COMMAND [ARGS]... Options: -h, --help Show this message and exit. Commands: version server server-group floating-ip flavor image region network ~~~ ### Usage Examples #### Create a Server ~~~shell cloudscale-cli server create --flavor flex-2 --name my-server --image centos-7 --ssh-keys "$(cat ~/.ssh/id_rsa.pub)" ~~~ #### List all Servers ~~~shell cloudscale-cli server list ~~~ #### Get Servers having the tag project=gemini ~~~shell cloudscale-cli server list --filter-tag project=gemini ~~~ ## Usage in Python ### List the slug of all flavors ~~~python import os from cloudscale import Cloudscale, CloudscaleApiException api_token = os.getenv('CLOUDSCALE_API_TOKEN') cloudscale = Cloudscale(api_token=api_token) flavors = cloudscale.flavor.get_all() for flavor in flavors: print(flavor['slug']) ~~~ ### Print the server names of running servers ~~~python import os from cloudscale import Cloudscale, CloudscaleApiException api_token = os.getenv('CLOUDSCALE_API_TOKEN') cloudscale = Cloudscale(api_token=api_token) servers = cloudscale.server.get_all() for server in servers: if server['status'] == "running": print(server['name']) ~~~ ### Get resource by UUID ~~~python import os from cloudscale import Cloudscale, CloudscaleApiException api_token = os.getenv('CLOUDSCALE_API_TOKEN') try: cloudscale = Cloudscale(api_token=api_token) server_group = cloudscale.server_group.get_by_uuid(uuid="5a1e5b28-d354-47a8-bfb2-01b048c20204") print(server_group['name']) except CloudscaleApiException as e: print(e) ~~~ ### Error handling ~~~python import os from cloudscale import Cloudscale, CloudscaleApiException api_token = os.getenv('CLOUDSCALE_API_TOKEN') try: cloudscale = Cloudscale(api_token=api_token) server = cloudscale.server.get_by_uuid(uuid="does-not-exist") print(server['name']) except CloudscaleApiException as e: # Prints "API Response Error (404): Not found." print(e) # Prints "404" print(e.status_code) # Prints raw API response print(e.response) ~~~ python-cloudscale-0.6.1/cloudscale/000077500000000000000000000000001357143037500173015ustar00rootroot00000000000000python-cloudscale-0.6.1/cloudscale/__init__.py000066400000000000000000000044771357143037500214260ustar00rootroot00000000000000import os import configparser from .client import RestAPI from .lib.server import Server from .lib.server_group import ServerGroup from .lib.volume import Volume from .lib.flavor import Flavor from .lib.floating_ip import FloatingIp from .lib.image import Image from .lib.region import Region from .lib.network import Network from .lib.subnet import Subnet from .lib.objects_user import ObjectsUser from .error import CloudscaleException, CloudscaleApiException # noqa F401 __version__ = '0.6.1' APP_NAME = 'cloudscale-cli' CLOUDSCALE_API_ENDPOINT = 'https://api.cloudscale.ch/v1' class Cloudscale: def __init__(self, api_token=None, profile=None, verbose=False): config = self._read_from_configfile(profile=profile) self.api_token = api_token or config.get('api_token') if not self.api_token: raise CloudscaleException("Missing API key: see -h for help") self.verbose = verbose self.service_classes = { 'server': Server, 'server_group': ServerGroup, 'volume': Volume, 'flavor': Flavor, 'floating_ip': FloatingIp, 'image': Image, 'region': Region, 'network': Network, 'subnet': Subnet, 'objects_user': ObjectsUser, } def _read_from_configfile(self, profile=None): paths = ( os.path.join(os.path.expanduser('~'), '.cloudscale.ini'), os.path.join(os.getcwd(), 'cloudscale.ini'), ) conf = configparser.ConfigParser() conf.read(paths) if profile: if profile not in conf._sections: raise CloudscaleException("Profile not found in config files: {}, ({})".format(profile, ', '. join(paths))) else: profile = os.getenv('CLOUDSCALE_PROFILE', 'default') if not conf._sections.get(profile): return dict() return dict(conf.items(profile)) def __getattr__(self, name): try: client = RestAPI( api_token=self.api_token, endpoint=CLOUDSCALE_API_ENDPOINT ) obj = self.service_classes[name]() obj._client = client obj.verbose = self.verbose return obj except NameError as e: raise CloudscaleException(e) python-cloudscale-0.6.1/cloudscale/cli.py000066400000000000000000000016561357143037500204320ustar00rootroot00000000000000import click from click_repl import register_repl from .util import OrderedGroup from .commands.version import cmd_version from .commands.server import server from .commands.server_group import server_group from .commands.flavor import flavor from .commands.floating_ip import floating_ip from .commands.image import image from .commands.region import region from .commands.network import network from .commands.subnet import subnet from .commands.volume import volume from .commands.objects_user import objects_user @click.group(cls=OrderedGroup, context_settings={ 'help_option_names': ['-h', '--help'], }) def cli(): pass cli.add_command(cmd_version) cli.add_command(server) cli.add_command(server_group) cli.add_command(floating_ip) cli.add_command(flavor) cli.add_command(image) cli.add_command(region) cli.add_command(network) cli.add_command(subnet) cli.add_command(volume) cli.add_command(objects_user) register_repl(cli) python-cloudscale-0.6.1/cloudscale/client.py000066400000000000000000000045251357143037500211370ustar00rootroot00000000000000import requests from urllib.parse import urlencode class RestAPI: def __init__(self, endpoint, api_token): self.endpoint = endpoint self.headers = { 'Authorization': 'Bearer %s' % api_token, 'Content-type': 'application/json', } def _return_result(self, r): result = { 'status_code': r.status_code, } try: result['data'] = r.json() except ValueError: result['data'] = None return result def _handle_payload(self, payload): if not payload: return data = dict() for k, v in payload.items(): if v is not None: data[k] = v return data def get_resources(self, resource, payload=None, resource_id=None): if not resource: return {} query_url = self.endpoint + '/' + resource if resource_id: query_url = query_url + '/' + resource_id if payload: for k, v in payload.items(): if v is not None: data = urlencode({k: v}) else: data = k break query_url = query_url + '?' + data r = requests.get(query_url, headers=self.headers) return self._return_result(r) def post_patch_resource(self, resource, payload=None, resource_id=None, action=None): data = self._handle_payload(payload) query_url = self.endpoint + '/' + resource # TODO: undecided yet, whether this is the best way we should distinquish between post or patch method or not. if resource_id: query_url += '/' + resource_id if action: query_url += '/' + action r = requests.post(query_url, json=data, headers=self.headers) return self._return_result(r) r = requests.patch(query_url, json=data, headers=self.headers) return self._return_result(r) else: r = requests.post(query_url, json=data, headers=self.headers) return self._return_result(r) def delete_resource(self, resource, resource_id): query_url = self.endpoint + '/' + resource + '/' + resource_id r = requests.delete(query_url, headers=self.headers) return self._return_result(r) python-cloudscale-0.6.1/cloudscale/commands/000077500000000000000000000000001357143037500211025ustar00rootroot00000000000000python-cloudscale-0.6.1/cloudscale/commands/__init__.py000066400000000000000000000000001357143037500232010ustar00rootroot00000000000000python-cloudscale-0.6.1/cloudscale/commands/flavor.py000066400000000000000000000017521357143037500227520ustar00rootroot00000000000000import sys import click from ..util import to_table from .. import Cloudscale, CloudscaleException, CloudscaleApiException @click.group() @click.option('--api-token', '-a', envvar='CLOUDSCALE_API_TOKEN', help="API token.") @click.option('--profile', '-p', envvar='CLOUDSCALE_PROFILE', help="Profile used in config file.") @click.option('--verbose', '-v', is_flag=True, help='Enables verbose mode.') @click.pass_context def flavor(ctx, profile, api_token, verbose): try: ctx.obj = Cloudscale(api_token, profile, verbose) except CloudscaleException as e: click.echo(e, err=True) sys.exit(1) @flavor.command("list") @click.pass_obj def cmd_list(cloudscale): try: response = cloudscale.flavor.get_all() if response: headers = ['name', 'vcpu_count', 'memory_gb', 'slug'] table = to_table(response, headers) click.echo(table) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) python-cloudscale-0.6.1/cloudscale/commands/floating_ip.py000066400000000000000000000061611357143037500237530ustar00rootroot00000000000000import sys import click from ..util import to_table, to_pretty_json, to_dict from .. import Cloudscale, CloudscaleApiException, CloudscaleException @click.group() @click.option('--api-token', '-a', envvar='CLOUDSCALE_API_TOKEN', help="API token.") @click.option('--profile', '-p', envvar='CLOUDSCALE_PROFILE', help="Profile used in config file.") @click.option('--verbose', '-v', is_flag=True, help='Enables verbose mode.') @click.pass_context def floating_ip(ctx, profile, api_token, verbose): try: ctx.obj = Cloudscale(api_token, profile, verbose) except CloudscaleException as e: click.echo(e, err=True) sys.exit(1) @floating_ip.command("list") @click.pass_obj def cmd_list(cloudscale): try: response = cloudscale.floating_ip.get_all() if response: headers = ['network', 'ip_version', 'server', 'reverse_ptr', 'region', 'tags'] table = to_table(response, headers) click.echo(table) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--network-id', 'uuid', required=True) @floating_ip.command("show") @click.pass_obj def cmd_show(cloudscale, uuid): try: response = cloudscale.floating_ip.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--ip-version', default=4, show_default=True) @click.option('--server-uuid', '--server', required=True) @click.option('--prefix-length', default=32, show_default=True) @click.option('--reverse-ptr') @click.option('--region') @click.option('--tags') @floating_ip.command("create") @click.pass_obj def cmd_create(cloudscale, ip_version, server_uuid, prefix_length, reverse_ptr, region, tags): try: response = cloudscale.floating_ip.create( ip_version=ip_version, server_uuid=server_uuid, prefix_length=prefix_length, reverse_ptr=reverse_ptr, region=region, tags=to_dict(tags), ) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--network-id', 'uuid', required=True) @click.option('--server-uuid', '--server') @click.option('--reverse-ptr') @click.option('--tags') @floating_ip.command("update") @click.pass_obj def cmd_update(cloudscale, uuid, server_uuid, reverse_ptr, tags): try: cloudscale.floating_ip.update( uuid=uuid, server_uuid=server_uuid, reverse_ptr=reverse_ptr, tags=to_dict(tags), ) response = cloudscale.floating_ip.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--network-id', 'uuid', required=True) @floating_ip.command("delete") @click.pass_obj def cmd_delete(cloudscale, uuid): try: cloudscale.floating_ip.delete(uuid) click.echo("Deleted!") except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) python-cloudscale-0.6.1/cloudscale/commands/image.py000066400000000000000000000017641357143037500225460ustar00rootroot00000000000000import sys import click from ..util import to_table from .. import Cloudscale, CloudscaleApiException, CloudscaleException @click.group() @click.option('--api-token', '-a', envvar='CLOUDSCALE_API_TOKEN', help="API token.") @click.option('--profile', '-p', envvar='CLOUDSCALE_PROFILE', help="Profile used in config file.") @click.option('--verbose', '-v', is_flag=True, help='Enables verbose mode.') @click.pass_context def image(ctx, profile, api_token, verbose): try: ctx.obj = Cloudscale(api_token, profile, verbose) except CloudscaleException as e: click.echo(e, err=True) sys.exit(1) @image.command("list") @click.pass_obj def cmd_list(cloudscale): try: response = cloudscale.image.get_all() if response: headers = ['name', 'operating_system', 'default_username', 'slug'] table = to_table(response, headers) click.echo(table) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) python-cloudscale-0.6.1/cloudscale/commands/network.py000066400000000000000000000055261357143037500231550ustar00rootroot00000000000000import sys import click from ..util import to_table, to_pretty_json, to_dict from .. import Cloudscale, CloudscaleApiException, CloudscaleException @click.group() @click.option('--api-token', '-a', envvar='CLOUDSCALE_API_TOKEN', help="API token.") @click.option('--profile', '-p', envvar='CLOUDSCALE_PROFILE', help="Profile used in config file.") @click.option('--verbose', '-v', is_flag=True, help='Enables verbose mode.') @click.pass_context def network(ctx, profile, api_token, verbose): try: ctx.obj = Cloudscale(api_token, profile, verbose) except CloudscaleException as e: click.echo(e, err=True) sys.exit(1) @network.command("list") @click.pass_obj def cmd_list(cloudscale): try: response = cloudscale.network.get_all() if response: headers = ['name', 'created_at', 'zone', 'tags', 'uuid'] table = to_table(response, headers) click.echo(table) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @network.command("show") @click.pass_obj def cmd_show(cloudscale, uuid): try: response = cloudscale.network.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--name', required=True) @click.option('--zone') @click.option('--mtu', type=int, default=9000) @click.option('--auto-create-ipv4-subnet', type=bool, default=True) @click.option('--tags', multiple=True) @network.command("create") @click.pass_obj def cmd_create(cloudscale, name, zone, mtu, auto_create_ipv4_subnet, tags): try: response = cloudscale.network.create( name=name, zone=zone, mtu=mtu, auto_create_ipv4_subnet=auto_create_ipv4_subnet, tags=to_dict(tags), ) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @click.option('--name') @click.option('--mtu') @click.option('--tags', multiple=True) @network.command("update") @click.pass_obj def cmd_update(cloudscale, uuid, name, mtu, tags): try: cloudscale.network.update( uuid=uuid, name=name, mtu=mtu, tags=to_dict(tags), ) response = cloudscale.network.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @network.command("delete") @click.pass_obj def cmd_delete(cloudscale, uuid): try: cloudscale.network.delete(uuid) click.echo("Deleted!") except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) python-cloudscale-0.6.1/cloudscale/commands/objects_user.py000066400000000000000000000051421357143037500241450ustar00rootroot00000000000000import sys import click from ..util import to_table, to_pretty_json, to_dict from .. import Cloudscale, CloudscaleApiException, CloudscaleException @click.group() @click.option('--api-token', '-a', envvar='CLOUDSCALE_API_TOKEN', help="API token.") @click.option('--profile', '-p', envvar='CLOUDSCALE_PROFILE', help="Profile used in config file.") @click.option('--verbose', '-v', is_flag=True, help='Enables verbose mode.') @click.pass_context def objects_user(ctx, profile, api_token, verbose): try: ctx.obj = Cloudscale(api_token, profile, verbose) except CloudscaleException as e: click.echo(e, err=True) sys.exit(1) @click.option('--filter-tag') @objects_user.command("list") @click.pass_obj def cmd_list(cloudscale, filter_tag): try: response = cloudscale.objects_user.get_all(filter_tag) if response: headers = ['display_name', 'id', 'tags'] table = to_table(response, headers) click.echo(table) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--id', '--uuid', 'uuid', required=True) @objects_user.command("show") @click.pass_obj def cmd_show(cloudscale, uuid): try: response = cloudscale.objects_user.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--display-name', required=True) @click.option('--tags', multiple=True) @objects_user.command("create") @click.pass_obj def cmd_create(cloudscale, display_name, tags): try: response = cloudscale.objects_user.create(display_name, to_dict(tags)) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--id', '--uuid', 'uuid', required=True) @click.option('--display-name') @click.option('--tags', multiple=True) @objects_user.command("update") @click.pass_obj def cmd_update(cloudscale, uuid, display_name, tags): try: cloudscale.objects_user.update(uuid, display_name, to_dict(tags)) response = cloudscale.objects_user.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--id', '--uuid', 'uuid', required=True) @objects_user.command("delete") @click.pass_obj def cmd_delete(cloudscale, uuid): try: cloudscale.objects_user.delete(uuid) click.echo("Deleted!") except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) python-cloudscale-0.6.1/cloudscale/commands/region.py000066400000000000000000000017201357143037500227370ustar00rootroot00000000000000import sys import click from ..util import to_table from .. import Cloudscale, CloudscaleApiException, CloudscaleException @click.group() @click.option('--api-token', '-a', envvar='CLOUDSCALE_API_TOKEN', help="API token.") @click.option('--profile', '-p', envvar='CLOUDSCALE_PROFILE', help="Profile used in config file.") @click.option('--verbose', '-v', is_flag=True, help='Enables verbose mode.') @click.pass_context def region(ctx, profile, api_token, verbose): try: ctx.obj = Cloudscale(api_token, profile, verbose) except CloudscaleException as e: click.echo(e, err=True) sys.exit(1) @region.command("list") @click.pass_obj def cmd_list(cloudscale): try: response = cloudscale.region.get_all() if response: headers = ['zones', 'slug'] table = to_table(response, headers) click.echo(table) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) python-cloudscale-0.6.1/cloudscale/commands/server.py000066400000000000000000000115641357143037500227710ustar00rootroot00000000000000import sys import click from ..util import to_table, to_pretty_json, to_dict from .. import Cloudscale, CloudscaleApiException, CloudscaleException @click.group() @click.option('--api-token', '-a', envvar='CLOUDSCALE_API_TOKEN', help="API token.") @click.option('--profile', '-p', envvar='CLOUDSCALE_PROFILE', help="Profile used in config file.") @click.option('--verbose', '-v', is_flag=True, help='Enables verbose mode.') @click.pass_context def server(ctx, profile, api_token, verbose): try: ctx.obj = Cloudscale(api_token, profile, verbose) except CloudscaleException as e: click.echo(e, err=True) sys.exit(1) @click.option('--filter-tag') @server.command("list") @click.pass_obj def cmd_list(cloudscale, filter_tag): try: response = cloudscale.server.get_all(filter_tag) if response: headers = ['name', 'flavor', 'zone', 'tags', 'uuid', 'status'] table = to_table(response, headers) click.echo(table) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @server.command("show") @click.pass_obj def cmd_show(cloudscale, uuid): try: response = cloudscale.server.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--name', required=True) @click.option('--flavor', required=True) @click.option('--image', required=True) @click.option('--zone') @click.option('--volume-size', type=int) @click.option('--volumes', multiple=True) @click.option('--interfaces', multiple=True) @click.option('--ssh-keys', multiple=True) @click.option('--password') @click.option('--use-public-network', is_flag=True, default=True) @click.option('--use-private-network', is_flag=True) @click.option('--use-ipv6', is_flag=True) @click.option('--server-groups', multiple=True) @click.option('--user-data') @click.option('--tags', multiple=True) @server.command("create") @click.pass_obj def cmd_create( cloudscale, name, flavor, image, zone, volume_size, volumes, interfaces, ssh_keys, password, use_public_network, use_private_network, use_ipv6, server_groups, user_data, tags, ): try: response = cloudscale.server.create( name=name, flavor=flavor, image=image, zone=zone, volume_size=volume_size, volumes=volumes or None, interfaces=interfaces or None, ssh_keys=ssh_keys or None, password=password, use_public_network=use_public_network, use_private_network=use_private_network, use_ipv6=use_ipv6, server_groups=server_groups or None, user_data=user_data, tags=to_dict(tags), ) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @click.option('--name') @click.option('--flavor') @click.option('--tags', multiple=True) @server.command("update") @click.pass_obj def cmd_update(cloudscale, uuid, name, flavor, tags): try: cloudscale.server.update( uuid=uuid, name=name, flavor=flavor, tags=to_dict(tags), ) response = cloudscale.server.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @server.command("delete") @click.pass_obj def cmd_delete(cloudscale, uuid): try: cloudscale.server.delete(uuid) click.echo("Deleted!") except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @server.command("start") @click.pass_obj def cmd_start(cloudscale, uuid): try: cloudscale.server.start(uuid) response = cloudscale.server.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @server.command("stop") @click.pass_obj def cmd_stop(cloudscale, uuid): try: cloudscale.server.stop(uuid) response = cloudscale.server.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @server.command("reboot") @click.pass_obj def cmd_reboot(cloudscale, uuid): try: cloudscale.server.reboot(uuid) response = cloudscale.server.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) python-cloudscale-0.6.1/cloudscale/commands/server_group.py000066400000000000000000000051711357143037500242020ustar00rootroot00000000000000import sys import click from ..util import to_table, to_pretty_json, to_dict from .. import Cloudscale, CloudscaleApiException, CloudscaleException @click.group() @click.option('--api-token', '-a', envvar='CLOUDSCALE_API_TOKEN', help="API token.") @click.option('--profile', '-p', envvar='CLOUDSCALE_PROFILE', help="Profile used in config file.") @click.option('--verbose', '-v', is_flag=True, help='Enables verbose mode.') @click.pass_context def server_group(ctx, profile, api_token, verbose): try: ctx.obj = Cloudscale(api_token, profile, verbose) except CloudscaleException as e: click.echo(e, err=True) sys.exit(1) @click.option('--filter-tag') @server_group.command("list") @click.pass_obj def cmd_list(cloudscale, filter_tag): try: response = cloudscale.server_group.get_all(filter_tag) if response: headers = ['name', 'type', 'servers', 'tags', 'uuid'] table = to_table(response, headers) click.echo(table) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @server_group.command("show") @click.pass_obj def cmd_show(cloudscale, uuid): try: response = cloudscale.server_group.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--name', required=True) @click.option('--type', 'group_type', default='anti-affinity', show_default=True) @click.option('--tags', multiple=True) @server_group.command("create") @click.pass_obj def cmd_create(cloudscale, name, group_type, tags): try: response = cloudscale.server_group.create(name, group_type, to_dict(tags)) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @click.option('--name') @click.option('--tags', multiple=True) @server_group.command("update") @click.pass_obj def cmd_update(cloudscale, uuid, name, tags): try: cloudscale.server_group.update(uuid, name, to_dict(tags)) response = cloudscale.server_group.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @server_group.command("delete") @click.pass_obj def cmd_delete(cloudscale, uuid): try: cloudscale.server_group.delete(uuid) click.echo("Deleted!") except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) python-cloudscale-0.6.1/cloudscale/commands/subnet.py000066400000000000000000000024531357143037500227600ustar00rootroot00000000000000import sys import click from ..util import to_table, to_pretty_json from .. import Cloudscale, CloudscaleException, CloudscaleApiException @click.group() @click.option('--api-token', '-a', envvar='CLOUDSCALE_API_TOKEN', help="API token.") @click.option('--profile', '-p', envvar='CLOUDSCALE_PROFILE', help="Profile used in config file.") @click.option('--verbose', '-v', is_flag=True, help='Enables verbose mode.') @click.pass_context def subnet(ctx, profile, api_token, verbose): try: ctx.obj = Cloudscale(api_token, profile, verbose) except CloudscaleException as e: click.echo(e, err=True) sys.exit(1) @subnet.command("list") @click.pass_obj def cmd_list(cloudscale): try: response = cloudscale.subnet.get_all() if response: headers = ['uuid', 'cidr', 'network', 'tags'] table = to_table(response, headers) click.echo(table) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @subnet.command("show") @click.pass_obj def cmd_show(cloudscale, uuid): try: response = cloudscale.subnet.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) python-cloudscale-0.6.1/cloudscale/commands/version.py000066400000000000000000000002221357143037500231350ustar00rootroot00000000000000import click from .. import APP_NAME, __version__ @click.command("version") def cmd_version(): click.echo("%s %s" % (APP_NAME, __version__)) python-cloudscale-0.6.1/cloudscale/commands/volume.py000066400000000000000000000062121357143037500227640ustar00rootroot00000000000000import sys import click from ..util import to_table, to_pretty_json, to_dict from .. import Cloudscale, CloudscaleApiException, CloudscaleException @click.group() @click.option('--api-token', '-a', envvar='CLOUDSCALE_API_TOKEN', help="API token.") @click.option('--profile', '-p', envvar='CLOUDSCALE_PROFILE', help="Profile used in config file.") @click.option('--verbose', '-v', is_flag=True, help='Enables verbose mode.') @click.pass_context def volume(ctx, profile, api_token, verbose): try: ctx.obj = Cloudscale(api_token, profile, verbose) except CloudscaleException as e: click.echo(e, err=True) sys.exit(1) @click.option('--filter-tag') @volume.command("list") @click.pass_obj def cmd_list(cloudscale, filter_tag): try: response = cloudscale.volume.get_all(filter_tag) if response: headers = ['name', 'type', 'size_gb', 'zone', 'tags', 'uuid'] table = to_table(response, headers) click.echo(table) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @volume.command("show") @click.pass_obj def cmd_show(cloudscale, uuid): try: response = cloudscale.volume.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--name', required=True) @click.option('--server-uuids', multiple=True, required=True) @click.option('--size-gb', type=int, required=True) @click.option('--type', 'volume_type', type=click.Choice(['ssd', 'bulk']), default='ssd', show_default=True) @click.option('--zone') @click.option('--tags', multiple=True) @volume.command("create") @click.pass_obj def cmd_create(cloudscale, name, server_uuids, size_gb, volume_type, zone, tags): try: response = cloudscale.volume.create( name=name, server_uuids=server_uuids, size_gb=size_gb, volume_type=volume_type, zone=zone, tags=to_dict(tags), ) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @click.option('--name') @click.option('--server-uuids', multiple=True) @click.option('--size-gb', type=int) @click.option('--tags', multiple=True) @volume.command("update") @click.pass_obj def cmd_update(cloudscale, uuid, name, server_uuids, size_gb, tags): try: cloudscale.volume.update( uuid=uuid, name=name, server_uuids=server_uuids, size_gb=size_gb, tags=to_dict(tags), ) response = cloudscale.volume.get_by_uuid(uuid) click.echo(to_pretty_json(response)) except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) @click.option('--uuid', required=True) @volume.command("delete") @click.pass_obj def cmd_delete(cloudscale, uuid): try: cloudscale.volume.delete(uuid) click.echo("Deleted!") except CloudscaleApiException as e: click.echo(e, err=True) sys.exit(1) python-cloudscale-0.6.1/cloudscale/error.py000066400000000000000000000003471357143037500210100ustar00rootroot00000000000000class CloudscaleException(Exception): pass class CloudscaleApiException(Exception): def __init__(self, *args, **kwargs): self.response = kwargs.pop('response') self.status_code = kwargs.pop('status_code') python-cloudscale-0.6.1/cloudscale/lib/000077500000000000000000000000001357143037500200475ustar00rootroot00000000000000python-cloudscale-0.6.1/cloudscale/lib/__init__.py000066400000000000000000000037461357143037500221720ustar00rootroot00000000000000from ..error import CloudscaleApiException class CloudscaleBase: def __init__(self): self.verbose = False self._client = None self.resource = None def _process_response(self, response): status_code = response.get('status_code') data = response.get('data', dict()) if status_code not in (200, 201, 204): raise CloudscaleApiException( "API Response Error ({0}): {1}".format( status_code, data.get('detail', data), ), response=response, status_code=status_code, ) return data def get_all(self, filter_tag=None): if filter_tag is not None: if '=' in filter_tag: tag_key, tag_value = filter_tag.split('=') else: tag_key = filter_tag tag_value = None if not tag_key.startswith('tag:'): tag_key = 'tag:%s' % tag_key payload = { tag_key: tag_value } else: payload = None result = self._client.get_resources(self.resource, payload=payload) return self._process_response(result) or [] class CloudscaleBaseExt(CloudscaleBase): def get_by_uuid(self, uuid): response = self._client.get_resources(self.resource, resource_id=uuid) return self._process_response(response) class CloudscaleMutable(CloudscaleBaseExt): def delete(self, uuid): response = self._client.delete_resource(self.resource, resource_id=uuid) return self._process_response(response) def update(self, uuid, payload): response = self._client.post_patch_resource(self.resource, resource_id=uuid, payload=payload) return self._process_response(response) def create(self, payload): response = self._client.post_patch_resource(self.resource, payload=payload) return self._process_response(response) python-cloudscale-0.6.1/cloudscale/lib/flavor.py000066400000000000000000000002221357143037500217060ustar00rootroot00000000000000from . import CloudscaleBase class Flavor(CloudscaleBase): def __init__(self): super().__init__() self.resource = 'flavors' python-cloudscale-0.6.1/cloudscale/lib/floating_ip.py000066400000000000000000000016161357143037500227200ustar00rootroot00000000000000from . import CloudscaleMutable class FloatingIp(CloudscaleMutable): def __init__(self): super(FloatingIp, self).__init__() self.resource = 'floating-ips' def create( self, ip_version, prefix_length=None, reverse_ptr=None, server_uuid=None, region=None, tags=None, ): payload = { 'ip_version': ip_version, 'prefix_length': prefix_length, 'reverse_ptr': reverse_ptr, 'server': server_uuid, 'region': region, 'tags': tags, } return super().create(payload=payload) def update(self, uuid, reverse_ptr=None, server_uuid=None, tags=None): payload = { 'reverse_ptr': reverse_ptr, 'server': server_uuid, 'tags': tags, } return super().update(uuid=uuid, payload=payload) python-cloudscale-0.6.1/cloudscale/lib/image.py000066400000000000000000000002331357143037500215010ustar00rootroot00000000000000from . import CloudscaleBase class Image(CloudscaleBase): def __init__(self): super(Image, self).__init__() self.resource = 'images' python-cloudscale-0.6.1/cloudscale/lib/network.py000066400000000000000000000013111357143037500221060ustar00rootroot00000000000000from . import CloudscaleMutable class Network(CloudscaleMutable): def __init__(self): super().__init__() self.resource = 'networks' def create(self, name, zone=None, mtu=None, auto_create_ipv4_subnet=None, tags=None): payload = { 'name': name, 'zone': zone, 'mtu': mtu, 'auto_create_ipv4_subnet': auto_create_ipv4_subnet, 'tags': tags, } return super().create(payload=payload) def update(self, uuid, name=None, mtu=None, tags=None): payload = { 'name': name, 'mtu': mtu, 'tags': tags, } return super().update(uuid=uuid, payload=payload) python-cloudscale-0.6.1/cloudscale/lib/objects_user.py000066400000000000000000000010731357143037500231110ustar00rootroot00000000000000from . import CloudscaleMutable class ObjectsUser(CloudscaleMutable): def __init__(self): super().__init__() self.resource = 'objects-users' def create(self, display_name, tags=None): payload = { 'display_name': display_name, 'tags': tags, } return super().create(payload=payload) def update(self, uuid, display_name=None, tags=None): payload = { 'display_name': display_name, 'tags': tags, } return super().update(uuid=uuid, payload=payload) python-cloudscale-0.6.1/cloudscale/lib/region.py000066400000000000000000000002221357143037500217000ustar00rootroot00000000000000from . import CloudscaleBase class Region(CloudscaleBase): def __init__(self): super().__init__() self.resource = 'regions' python-cloudscale-0.6.1/cloudscale/lib/server.py000066400000000000000000000035061357143037500217330ustar00rootroot00000000000000from . import CloudscaleMutable class Server(CloudscaleMutable): def __init__(self): super().__init__() self.resource = 'servers' def create( self, name, flavor, image, zone=None, volume_size=None, volumes=None, interfaces=None, ssh_keys=None, password=None, use_public_network=None, use_private_network=None, use_ipv6=None, server_groups=None, user_data=None, tags=None, ): payload = { 'name': name, 'flavor': flavor, 'image': image, 'zone': zone, 'volumes': volumes, 'interfaces': interfaces, 'ssh_keys': ssh_keys, 'password': password, 'use_public_network': use_public_network, 'use_private_network': use_private_network, 'use_ipv6': use_ipv6, 'server_groups': server_groups, 'user_data': user_data, 'tags': tags, } return super().create(payload=payload) def update(self, uuid, name=None, flavor=None, tags=None): payload = { 'name': name, 'flavor': flavor, 'tags': tags, } return super().update(uuid=uuid, payload=payload) def start(self, uuid): result = self._client.post_patch_resource(self.resource, resource_id=uuid, action='start') return self._process_response(result) def stop(self, uuid): result = self._client.post_patch_resource(self.resource, resource_id=uuid, action='stop') return self._process_response(result) def reboot(self, uuid): result = self._client.post_patch_resource(self.resource, resource_id=uuid, action='reboot') return self._process_response(result) python-cloudscale-0.6.1/cloudscale/lib/server_group.py000066400000000000000000000010741357143037500231450ustar00rootroot00000000000000from . import CloudscaleMutable class ServerGroup(CloudscaleMutable): def __init__(self): super().__init__() self.resource = 'server-groups' def create(self, name, group_type=None, tags=None): payload = { 'name': name, 'type': group_type, 'tags': tags, } return super().create(payload=payload) def update(self, uuid, name=None, tags=None): payload = { 'name': name, 'tags': tags, } return super().update(uuid=uuid, payload=payload) python-cloudscale-0.6.1/cloudscale/lib/subnet.py000066400000000000000000000002301357143037500217140ustar00rootroot00000000000000from . import CloudscaleBaseExt class Subnet(CloudscaleBaseExt): def __init__(self): super().__init__() self.resource = 'subnets' python-cloudscale-0.6.1/cloudscale/lib/volume.py000066400000000000000000000014701357143037500217320ustar00rootroot00000000000000from . import CloudscaleMutable class Volume(CloudscaleMutable): def __init__(self): super(Volume, self).__init__() self.resource = 'volumes' def create(self, name, server_uuids, size_gb, volume_type=None, zone=None, tags=None): payload = { 'name': name, 'server_uuids': server_uuids, 'size_gb': size_gb, 'type': volume_type, 'zone': zone, 'tags': tags, } return super().create(payload=payload) def update(self, uuid, name=None, server_uuids=None, size_gb=None, tags=None): payload = { 'name': name, 'server_uuids': server_uuids or None, 'size_gb': size_gb, 'tags': tags, } return super().update(uuid=uuid, payload=payload) python-cloudscale-0.6.1/cloudscale/util.py000066400000000000000000000042571357143037500206400ustar00rootroot00000000000000 import json from click import Group from collections import OrderedDict from tabulate import tabulate class OrderedGroup(Group): ''' A click Group with ordered command list. ''' def __init__(self, name=None, commands=[], **attrs): Group.__init__(self, name, **attrs) self.commands = OrderedDict(commands) def list_commands(self, ctx): return self.commands.keys() def to_table(data: list, headers: list) -> str: ''' Turn a list into a table ''' cols = list() for d in data: rows = list() for header in headers: if header in d: if header == 'tags': row = ', '.join(['%s=%s' % (k, v) for k, v in d[header].items()]) elif isinstance(d[header], dict): if 'name' in d[header]: row = d[header]['name'] elif 'slug' in d[header]: row = d[header]['slug'] else: row = d[header] elif isinstance(d[header], list): row_list = [] for i in d[header]: if 'slug' in i: row_list.append(i['slug']) elif 'name' in i: row_list.append(i['name']) row = ', '.join(row_list) else: row = d[header] rows.append(row) cols.append(rows) result = tabulate(cols, headers=headers) return result def to_pretty_json(data: dict) -> tuple: ''' Format JSON to human readable. ''' result = json.dumps(data, sort_keys=True, indent=4) try: from pygments import highlight, lexers, formatters result = highlight(result, lexers.JsonLexer(), formatters.TerminalFormatter()) except ImportError: pass return result def to_dict(data: tuple) -> dict: ''' Split a tuple of tags (key=value) into a dict. ''' if not data: return result = dict() for d in data: if '=' in d: k, v = d.split('=') result[k] = v return result python-cloudscale-0.6.1/requirements.dev.txt000066400000000000000000000000641357143037500212240ustar00rootroot00000000000000pytest>=5.0.0 pytest-cache pytest-cov responses tox python-cloudscale-0.6.1/requirements.txt000066400000000000000000000000521357143037500204440ustar00rootroot00000000000000requests click>=7.0.0 click-repl tabulate python-cloudscale-0.6.1/setup.cfg000066400000000000000000000001441357143037500170030ustar00rootroot00000000000000[flake8] ignore = E261,E301,E302,E402,E731 max-line-length = 160 [metadata] license_file = LICENSE python-cloudscale-0.6.1/setup.py000066400000000000000000000027451357143037500167050ustar00rootroot00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- from setuptools import find_packages, setup with open("README.md", "r") as fh: long_description = fh.read() install_requires = [] with open("requirements.txt", "r", encoding="utf-8") as f: install_requires = list(i.rstrip() for i in f.readlines()) extras_require = { 'highlight': ['pygments'], } tests_require = [] with open("requirements.dev.txt", "r", encoding="utf-8") as f: tests_require = list(i.rstrip() for i in f.readlines()) setup( name="cloudscale", version="0.6.1", author="René Moser", author_email="mail@renemoser.net", license="MIT", description="A library and command line interface for cloudscale.ch", long_description=long_description, long_description_content_type="text/markdown", url="https://github.com/resmo/python-cloudscale", packages=find_packages(exclude=["test.*", "tests"]), classifiers=[ "Intended Audience :: Developers", "Intended Audience :: System Administrators", "Development Status :: 4 - Beta", "Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", "Environment :: Console", ], install_requires=install_requires, extras_require=extras_require, tests_require=tests_require, python_requires='>=3.6', entry_points={ 'console_scripts': [ 'cloudscale-cli = cloudscale.cli:cli', ], }, ) python-cloudscale-0.6.1/test_flavor.py000066400000000000000000000024771357143037500200770ustar00rootroot00000000000000from cloudscale import Cloudscale, CloudscaleApiException, CloudscaleException, CLOUDSCALE_API_ENDPOINT from cloudscale.cli import cli import responses import click from click.testing import CliRunner FLAVOR_RESP = { "slug": "flex-2", "name": "Flex-2", "vcpu_count": 1, "memory_gb": 2, "zones": [ { "slug": "rma1" }, { "slug": "lpg1" } ] } @responses.activate def test_flavor_get_all(): responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/flavors', json=[FLAVOR_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/flavors', json=[FLAVOR_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/flavors', json={}, status=500) cloudscale = Cloudscale(api_token="token") flavors = cloudscale.flavor.get_all() assert flavors[0]['slug'] == "flex-2" assert flavors[0]['name'] == "Flex-2" runner = CliRunner() result = runner.invoke(cli, [ 'flavor', '-a', 'token', 'list', ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'flavor', '-a', 'token', 'list', ]) assert result.exit_code > 0 python-cloudscale-0.6.1/test_floating_ip.py000066400000000000000000000150021357143037500210650ustar00rootroot00000000000000from cloudscale import Cloudscale, CloudscaleApiException, CloudscaleException, CLOUDSCALE_API_ENDPOINT from cloudscale.cli import cli import responses import click from click.testing import CliRunner FLOATING_IP_RESP = { "href": "https://api.cloudscale.ch/v1/floating-ips/192.0.2.123", "created_at": "2019-05-29T13:18:42.505197Z", "network": "192.0.2.123/32", "ip_version": 4, "server": { "href": "https://api.cloudscale.ch/v1/servers/47cec963-fcd2-482f-bdb6-24461b2d47b1", "uuid": "47cec963-fcd2-482f-bdb6-24461b2d47b1", "name": "db-master" }, "region": { "slug": "lpg" }, "next_hop": "198.51.100.1", "reverse_ptr": "192.0.2.123.cust.cloudscale.ch", "tags": {} } @responses.activate def test_floating_ip_get_all(): network_id = "192.0.2.123" responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/floating-ips', json=[FLOATING_IP_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/floating-ips', json=[FLOATING_IP_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/floating-ips', json={}, status=500) cloudscale = Cloudscale(api_token="token") floating_ips = cloudscale.floating_ip.get_all() assert floating_ips[0]['network'] == network_id + '/32' runner = CliRunner() result = runner.invoke(cli, [ 'floating-ip', '-a', 'token', 'list', ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'floating-ip', '-a', 'token', 'list', ]) assert result.exit_code > 0 @responses.activate def test_floating_ip_get_by_uuid(): network_id = "192.0.2.123" responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/floating-ips/' + network_id, json=FLOATING_IP_RESP, status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/floating-ips/' + network_id, json=FLOATING_IP_RESP, status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/floating-ips/' + network_id, json={}, status=500) cloudscale = Cloudscale(api_token="token") floating_ip = cloudscale.floating_ip.get_by_uuid(uuid=network_id) assert floating_ip['network'] == network_id + '/32' runner = CliRunner() result = runner.invoke(cli, [ 'floating-ip', '-a', 'token', 'show', '--network-id', network_id, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'floating-ip', '-a', 'token', 'show', '--network-id', network_id, ]) assert result.exit_code > 0 @responses.activate def test_floating_ip_delete(): network_id = "192.0.2.123" responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/floating-ips/' + network_id, status=204) responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/floating-ips/' + network_id, status=204) responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/floating-ips/' + network_id, json={}, status=500) cloudscale = Cloudscale(api_token="token") floating_ip = cloudscale.floating_ip.delete(uuid=network_id) assert floating_ip is None runner = CliRunner() result = runner.invoke(cli, [ 'floating-ip', '-a', 'token', 'delete', '--network-id', network_id, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'floating-ip', '-a', 'token', 'delete', '--network-id', network_id, ]) assert result.exit_code > 0 @responses.activate def test_floating_ip_create(): ip_version = 4 server_uuid = "47cec963-fcd2-482f-bdb6-24461b2d47b1" responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/floating-ips', json=FLOATING_IP_RESP, status=201) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/floating-ips', json=FLOATING_IP_RESP, status=201) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/floating-ips', json=FLOATING_IP_RESP, status=500) cloudscale = Cloudscale(api_token="token") cloudscale.floating_ip.create( ip_version=ip_version, ) runner = CliRunner() result = runner.invoke(cli, [ 'floating-ip', '-a', 'token', 'create', '--ip-version', ip_version, '--server-uuid', server_uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'floating-ip', '-a', 'token', 'create', '--ip-version', ip_version, '--server-uuid', server_uuid, ]) assert result.exit_code > 0 @responses.activate def test_floating_ip_update(): network_id = "192.0.2.123" reverse_ptr = "192.0.2.123.cust.cloudscale.ch" responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/floating-ips/' + network_id, json=FLOATING_IP_RESP, status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/floating-ips/' + network_id, json=FLOATING_IP_RESP, status=200) responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/floating-ips/' + network_id, json=FLOATING_IP_RESP, status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/floating-ips/' + network_id, json=FLOATING_IP_RESP, status=200) responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/floating-ips/' + network_id, json={}, status=500) cloudscale = Cloudscale(api_token="token") floating_ip = cloudscale.floating_ip.update(uuid=network_id, reverse_ptr=reverse_ptr) assert floating_ip['network'] == network_id + '/32' assert floating_ip['reverse_ptr'] == reverse_ptr runner = CliRunner() result = runner.invoke(cli, [ 'floating-ip', '-a', 'token', 'update', '--network-id', network_id, '--reverse-ptr', reverse_ptr, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'floating-ip', '-a', 'token', 'update', '--network-id', network_id, '--reverse-ptr', reverse_ptr, ]) assert result.exit_code > 0 python-cloudscale-0.6.1/test_image.py000066400000000000000000000025311357143037500176570ustar00rootroot00000000000000from cloudscale import Cloudscale, CloudscaleApiException, CloudscaleException, CLOUDSCALE_API_ENDPOINT from cloudscale.cli import cli import responses import click from click.testing import CliRunner IMAGE_RESP = { "slug": "arch-18.06", "name": "Arch 18.06", "operating_system": "Arch", "default_username": "arch", "zones": [ { "slug": "rma1" }, { "slug": "lpg1" } ] } @responses.activate def test_image_get_all(): responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/images', json=[IMAGE_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/images', json=[IMAGE_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/images', json={}, status=500) cloudscale = Cloudscale(api_token="token") images = cloudscale.image.get_all() assert images[0]['slug'] == "arch-18.06" assert images[0]['name'] == "Arch 18.06" runner = CliRunner() result = runner.invoke(cli, [ 'image', '-a', 'token', 'list', ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'image', '-a', 'token', 'list', ]) assert result.exit_code > 0 python-cloudscale-0.6.1/test_network.py000066400000000000000000000150621357143037500202710ustar00rootroot00000000000000from cloudscale import Cloudscale, CloudscaleApiException, CloudscaleException, CLOUDSCALE_API_ENDPOINT from cloudscale.cli import cli import responses import click from click.testing import CliRunner NETWORK_RESP = { "href": "https://api.cloudscale.ch/v1/networks/2db69ba3-1864-4608-853a-0771b6885a3a", "uuid": "2db69ba3-1864-4608-853a-0771b6885a3a", "name": "my-network-name", "created_at": "2019-05-29T13:18:42.511407Z", "zone": { "slug": "lpg1" }, "mtu": 9000, "subnets": [ { "href": "https://api.cloudscale.ch/v1/subnets/33333333-1864-4608-853a-0771b6885a3a", "uuid": "33333333-1864-4608-853a-0771b6885a3a", "cidr": "172.16.0.0/24" } ], "tags": {} } @responses.activate def test_network_get_all(): responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/networks', json=[NETWORK_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/networks', json=[NETWORK_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/networks', json={}, status=500) cloudscale = Cloudscale(api_token="token") networks = cloudscale.network.get_all() assert networks[0]['name'] == "my-network-name" assert networks[0]['uuid'] == "2db69ba3-1864-4608-853a-0771b6885a3a" runner = CliRunner() result = runner.invoke(cli, [ 'network', '-a', 'token', 'list', ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'network', '-a', 'token', 'list', ]) assert result.exit_code > 0 @responses.activate def test_network_get_by_uuid(): uuid = "2db69ba3-1864-4608-853a-0771b6885a3a" responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/networks/' + uuid, json=NETWORK_RESP, status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/networks/' + uuid, json=NETWORK_RESP, status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/networks/' + uuid, json={}, status=500) cloudscale = Cloudscale(api_token="token") network = cloudscale.network.get_by_uuid(uuid=uuid) assert network['name'] == "my-network-name" assert network['uuid'] == uuid runner = CliRunner() result = runner.invoke(cli, [ 'network', '-a', 'token', 'show', '--uuid', uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'network', '-a', 'token', 'show', '--uuid', uuid, ]) assert result.exit_code > 0 @responses.activate def test_network_delete(): uuid = "2db69ba3-1864-4608-853a-0771b6885a3a" responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/networks/' + uuid, status=204) responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/networks/' + uuid, status=204) responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/networks/' + uuid, json={}, status=500) cloudscale = Cloudscale(api_token="token") network = cloudscale.network.delete(uuid=uuid) assert network is None runner = CliRunner() result = runner.invoke(cli, [ 'network', '-a', 'token', 'delete', '--uuid', uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'network', '-a', 'token', 'delete', '--uuid', uuid, ]) assert result.exit_code > 0 @responses.activate def test_network_get_by_uuid_not_found(): responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/networks/unknown', json={ "detail": "Not found." }, status=404) try: cloudscale = Cloudscale(api_token="token") cloudscale.network.get_by_uuid(uuid="unknown") except CloudscaleApiException as e: assert e.status_code == 404 assert str(e) == "API Response Error (404): Not found." assert e.response == {'data': {'detail': 'Not found.'}, 'status_code': 404} @responses.activate def test_network_create(): name = "my-network-name" responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/networks', json=NETWORK_RESP, status=201) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/networks', json=NETWORK_RESP, status=201) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/networks', json={}, status=500) cloudscale = Cloudscale(api_token="token") cloudscale.network.create( name=name, ) runner = CliRunner() result = runner.invoke(cli, [ 'network', '-a', 'token', 'create', '--name', name, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'network', '-a', 'token', 'create', '--name', name, ]) assert result.exit_code > 0 @responses.activate def test_network_update(): uuid = "2db69ba3-1864-4608-853a-0771b6885a3a" name = "my-network-name" responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/networks/' + uuid, json=NETWORK_RESP, status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/networks/' + uuid, json=NETWORK_RESP, status=200) responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/networks/' + uuid, json=NETWORK_RESP, status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/networks/' + uuid, json=NETWORK_RESP, status=200) responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/networks/' + uuid, json={}, status=500) cloudscale = Cloudscale(api_token="token") network = cloudscale.network.update(uuid=uuid, name=name) assert network['name'] == name assert network['uuid'] == uuid runner = CliRunner() result = runner.invoke(cli, [ 'network', '-a', 'token', 'update', '--uuid', uuid, '--name', name, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'network', '-a', 'token', 'update', '--uuid', uuid, '--name', name, ]) assert result.exit_code > 0 python-cloudscale-0.6.1/test_objects_user.py000066400000000000000000000156751357143037500213010ustar00rootroot00000000000000from cloudscale import Cloudscale, CloudscaleApiException, CloudscaleException, CLOUDSCALE_API_ENDPOINT from cloudscale.cli import cli import responses import click from click.testing import CliRunner OBJECTS_USER_RESP = { "href": "https://api.cloudscale.ch/v1/objects-users/6fe39134bf4178747eebc429f82cfafdd08891d4279d0d899bc4012db1db6a15", "id": "6fe39134bf4178747eebc429f82cfafdd08891d4279d0d899bc4012db1db6a15", "display_name": "alan", "keys": [ { "access_key": "0ZTAIBKSGYBRHQ09G11W", "secret_key": "bn2ufcwbIa0ARLc5CLRSlVaCfFxPHOpHmjKiH34T" } ], "tags": {} } @responses.activate def test_objects_user_get_all(): responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/objects-users', json=[OBJECTS_USER_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/objects-users', json=[OBJECTS_USER_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/objects-users', json={}, status=500) cloudscale = Cloudscale(api_token="token") objects_users = cloudscale.objects_user.get_all() assert objects_users[0]['display_name'] == "alan" assert objects_users[0]['id'] == "6fe39134bf4178747eebc429f82cfafdd08891d4279d0d899bc4012db1db6a15" runner = CliRunner() result = runner.invoke(cli, [ 'objects-user', '-a', 'token', 'list', ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'objects-user', '-a', 'token', 'list', ]) assert result.exit_code > 0 @responses.activate def test_objects_user_get_by_uuid(): uuid = "6fe39134bf4178747eebc429f82cfafdd08891d4279d0d899bc4012db1db6a15" responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/objects-users/' + uuid, json=OBJECTS_USER_RESP, status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/objects-users/' + uuid, json=OBJECTS_USER_RESP, status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/objects-users/' + uuid, json={}, status=500) cloudscale = Cloudscale(api_token="token") objects_user = cloudscale.objects_user.get_by_uuid(uuid=uuid) assert objects_user['display_name'] == "alan" assert objects_user['id'] == uuid runner = CliRunner() result = runner.invoke(cli, [ 'objects-user', '-a', 'token', 'show', '--uuid', uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'objects-user', '-a', 'token', 'show', '--uuid', uuid, ]) assert result.exit_code > 0 @responses.activate def test_objects_user_delete(): uuid = "6fe39134bf4178747eebc429f82cfafdd08891d4279d0d899bc4012db1db6a15" responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/objects-users/' + uuid, status=204) responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/objects-users/' + uuid, status=204) responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/objects-users/' + uuid, json={}, status=500) cloudscale = Cloudscale(api_token="token") objects_user = cloudscale.objects_user.delete(uuid=uuid) assert objects_user is None runner = CliRunner() result = runner.invoke(cli, [ 'objects-user', '-a', 'token', 'delete', '--uuid', uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'objects-user', '-a', 'token', 'delete', '--uuid', uuid, ]) assert result.exit_code > 0 @responses.activate def test_objects_user_get_by_uuid_not_found(): responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/objects-users/unknown', json={ "detail": "Not found." }, status=404) try: cloudscale = Cloudscale(api_token="token") cloudscale.objects_user.get_by_uuid(uuid="unknown") except CloudscaleApiException as e: assert e.status_code == 404 assert str(e) == "API Response Error (404): Not found." assert e.response == {'data': {'detail': 'Not found.'}, 'status_code': 404} @responses.activate def test_objects_user_create(): display_name = "alan" responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/objects-users', json=OBJECTS_USER_RESP, status=201) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/objects-users', json=OBJECTS_USER_RESP, status=201) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/objects-users', json={}, status=500) cloudscale = Cloudscale(api_token="token") cloudscale.objects_user.create( display_name=display_name, ) runner = CliRunner() result = runner.invoke(cli, [ 'objects-user', '-a', 'token', 'create', '--display-name', display_name, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'objects-user', '-a', 'token', 'create', '--display-name', display_name, ]) assert result.exit_code > 0 @responses.activate def test_objects_user_update(): uuid = "6fe39134bf4178747eebc429f82cfafdd08891d4279d0d899bc4012db1db6a15" display_name = "alan" responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/objects-users/' + uuid, json=OBJECTS_USER_RESP, status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/objects-users/' + uuid, json=OBJECTS_USER_RESP, status=200) responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/objects-users/' + uuid, json=OBJECTS_USER_RESP, status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/objects-users/' + uuid, json=OBJECTS_USER_RESP, status=200) responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/objects-users/' + uuid, json={}, status=500) cloudscale = Cloudscale(api_token="token") objects_user = cloudscale.objects_user.update(uuid=uuid, display_name=display_name) assert objects_user['display_name'] == display_name assert objects_user['id'] == uuid runner = CliRunner() result = runner.invoke(cli, [ 'objects-user', '-a', 'token', 'update', '--uuid', uuid, '--display-name', display_name, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'objects-user', '-a', 'token', 'update', '--uuid', uuid, '--display-name', display_name, ]) assert result.exit_code > 0 python-cloudscale-0.6.1/test_region.py000066400000000000000000000022401357143037500200550ustar00rootroot00000000000000from cloudscale import Cloudscale, CloudscaleApiException, CloudscaleException, CLOUDSCALE_API_ENDPOINT from cloudscale.cli import cli import responses import click from click.testing import CliRunner REGION_RESP = { "slug": "rma", "zones": [ { "slug": "rma1" } ] } @responses.activate def test_region_get_all(): responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/regions', json=[REGION_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/regions', json=[REGION_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/regions', json={}, status=500) cloudscale = Cloudscale(api_token="token") regions = cloudscale.region.get_all() assert regions[0]['slug'] == "rma" runner = CliRunner() result = runner.invoke(cli, [ 'region', '-a', 'token', 'list', ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'region', '-a', 'token', 'list', ]) assert result.exit_code > 0 python-cloudscale-0.6.1/test_server.py000066400000000000000000000306771357143037500201170ustar00rootroot00000000000000from cloudscale import Cloudscale, CloudscaleApiException, CloudscaleException, CLOUDSCALE_API_ENDPOINT from cloudscale.cli import cli import responses import click from click.testing import CliRunner SERVER_RESP = { "uuid": "47cec963-fcd2-482f-bdb6-24461b2d47b1", "name": "db-master", "status": "running", "zone": { "slug": "lpg1" }, "flavor": { "slug": "flex-4", }, "image": { "slug": "debian-9", }, "server_groups": [], "anti_affinity_with": [], "tags": { "project": "gemini" } } @responses.activate def test_server_get_all(): responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers', json=[SERVER_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers', json=[SERVER_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers', json={ "detail": "Server error." }, status=500) cloudscale = Cloudscale(api_token="token") servers = cloudscale.server.get_all() assert servers[0]['name'] == "db-master" assert servers[0]['uuid'] == "47cec963-fcd2-482f-bdb6-24461b2d47b1" assert servers[0]['tags']['project'] == "gemini" runner = CliRunner() result = runner.invoke(cli, [ 'server', '-a', 'token', 'list', ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'server', '-a', 'token', 'list', ]) assert result.exit_code > 0 @responses.activate def test_server_get_all_fitlered(): responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers', json=[SERVER_RESP], status=200) cloudscale = Cloudscale(api_token="token") servers = cloudscale.server.get_all(filter_tag='project=gemini') assert servers[0]['name'] == "db-master" assert servers[0]['uuid'] == "47cec963-fcd2-482f-bdb6-24461b2d47b1" assert servers[0]['tags']['project'] == "gemini" runner = CliRunner() result = runner.invoke(cli, [ 'server', '-a', 'token', 'list', '--filter-tag', 'project=gemini' ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'server', '-a', 'token', 'list', '--filter-tag', 'project' ]) assert result.exit_code == 0 @responses.activate def test_server_get_by_uuid(): uuid = "47cec963-fcd2-482f-bdb6-24461b2d47b1" responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json=SERVER_RESP, status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json=SERVER_RESP, status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json={ "detail": "Server error." }, status=500) cloudscale = Cloudscale(api_token="token") server = cloudscale.server.get_by_uuid(uuid=uuid) assert server['name'] == "db-master" assert server['uuid'] == uuid assert server['tags']['project'] == "gemini" runner = CliRunner() result = runner.invoke(cli, [ 'server', '-a', 'token', 'show', '--uuid', uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'server', '-a', 'token', 'show', '--uuid', uuid, ]) assert result.exit_code > 0 @responses.activate def test_server_delete(): uuid = "47cec963-fcd2-482f-bdb6-24461b2d47b1" responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, status=204) responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, status=204) responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json={ "detail": "Server error." }, status=500) cloudscale = Cloudscale(api_token="token") server = cloudscale.server.delete(uuid=uuid) assert server is None runner = CliRunner() result = runner.invoke(cli, [ 'server', '-a', 'token', 'delete', '--uuid', uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'server', '-a', 'token', 'delete', '--uuid', uuid, ]) assert result.exit_code > 0 @responses.activate def test_server_get_by_uuid_not_found(): responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers/unknown', json={ "detail": "Not found." }, status=404) try: cloudscale = Cloudscale(api_token="token") cloudscale.server.get_by_uuid(uuid="unknown") except CloudscaleApiException as e: assert e.status_code == 404 assert str(e) == "API Response Error (404): Not found." assert e.response == {'data': {'detail': 'Not found.'}, 'status_code': 404} @responses.activate def test_server_get_auth_not_provided(): responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers/unknown', json={ "detail": "Authentication credentials were not provided." }, status=401) try: cloudscale = Cloudscale(api_token="token") cloudscale.server.get_by_uuid(uuid="unknown") except CloudscaleApiException as e: assert e.status_code == 401 assert str(e) == "API Response Error (401): Authentication credentials were not provided." @responses.activate def test_server_missing_api_key(): try: cloudscale = Cloudscale(api_token=None) cloudscale.server.get_all() except CloudscaleException as e: assert str(e) == "Missing API key: see -h for help" @responses.activate def test_server_create(): name = "db-master" flavor = "flex-4" image = "debian9" responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/servers', json=SERVER_RESP, status=201) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/servers', json=SERVER_RESP, status=201) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/servers', json={ "detail": "Server error." }, status=500) cloudscale = Cloudscale(api_token="token") cloudscale.server.create( name=name, flavor=flavor, image=image, ) runner = CliRunner() result = runner.invoke(cli, [ 'server', '-a', 'token', 'create', '--name', name, '--flavor', flavor, '--image', image ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'server', '-a', 'token', 'create', '--name', name, '--flavor', flavor, '--image', image ]) assert result.exit_code > 0 @responses.activate def test_server_update(): uuid = "47cec963-fcd2-482f-bdb6-24461b2d47b1" name = "db-master" responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json=SERVER_RESP, status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json=SERVER_RESP, status=200) responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json=SERVER_RESP, status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json=SERVER_RESP, status=200) responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json={ "detail": "Server error." }, status=500) cloudscale = Cloudscale(api_token="token") server = cloudscale.server.update(uuid=uuid, name=name) assert server['name'] == name assert server['uuid'] == uuid assert server['tags']['project'] == "gemini" runner = CliRunner() result = runner.invoke(cli, [ 'server', '-a', 'token', 'update', '--uuid', uuid, '--name', name, '--tags', 'project=gemini' ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'server', '-a', 'token', 'update', '--uuid', uuid, '--name', name, '--tags', 'project=gemini' ]) assert result.exit_code > 0 @responses.activate def test_server_start(): uuid = "47cec963-fcd2-482f-bdb6-24461b2d47b1" responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid + '/start', status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json=SERVER_RESP, status=200) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid + '/start', status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json=SERVER_RESP, status=200) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid + '/start', json={ "detail": "Server error." }, status=500) cloudscale = Cloudscale(api_token="token") server = cloudscale.server.start(uuid=uuid) assert server is None runner = CliRunner() result = runner.invoke(cli, [ 'server', '-a', 'token', 'start', '--uuid', uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'server', '-a', 'token', 'start', '--uuid', uuid, ]) assert result.exit_code > 0 @responses.activate def test_server_stop(): uuid = "47cec963-fcd2-482f-bdb6-24461b2d47b1" responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid + '/stop', status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json=SERVER_RESP, status=200) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid + '/stop', status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json=SERVER_RESP, status=200) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid + '/stop', json={ "detail": "Server error." }, status=500) cloudscale = Cloudscale(api_token="token") server = cloudscale.server.stop(uuid=uuid) assert server is None runner = CliRunner() result = runner.invoke(cli, [ 'server', '-a', 'token', 'stop', '--uuid', uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'server', '-a', 'token', 'stop', '--uuid', uuid, ]) assert result.exit_code > 0 @responses.activate def test_server_reboot(): uuid = "47cec963-fcd2-482f-bdb6-24461b2d47b1" responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid + '/reboot', status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json=SERVER_RESP, status=200) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid + '/reboot', status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid, json=SERVER_RESP, status=200) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/servers/' + uuid + '/reboot', json={ "detail": "Server error." }, status=500) cloudscale = Cloudscale(api_token="token") server = cloudscale.server.reboot(uuid=uuid) assert server is None runner = CliRunner() result = runner.invoke(cli, [ 'server', '-a', 'token', 'reboot', '--uuid', uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'server', '-a', 'token', 'reboot', '--uuid', uuid, ]) assert result.exit_code > 0 python-cloudscale-0.6.1/test_server_group.py000066400000000000000000000147161357143037500213270ustar00rootroot00000000000000from cloudscale import Cloudscale, CloudscaleApiException, CloudscaleException, CLOUDSCALE_API_ENDPOINT from cloudscale.cli import cli import responses import click from click.testing import CliRunner SERVER_GROUP_RESP = { "href": "https://api.cloudscale.ch/v1/server-groups/e3b63018-fad6-45f2-9f57-3ea0da726d8c", "uuid": "e3b63018-fad6-45f2-9f57-3ea0da726d8c", "name": "load balancers", "type": "anti-affinity", "servers": [ { "href": "https://api.cloudscale.ch/v1/server-groups/32d2f586-14ff-4da9-81df-134ca45d635f", "uuid": "32d2f586-14ff-4da9-81df-134ca45d635f", "name": "tesla" }, { "href": "https://api.cloudscale.ch/v1/server-groups/375870c2-d4ee-49af-a048-efcf59ef14ef", "uuid": "375870c2-d4ee-49af-a048-efcf59ef14ef", "name": "edison" } ], "zone": { "slug": "rma1" }, "tags": {} } @responses.activate def test_server_groups_get_all(): responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/server-groups', json=[SERVER_GROUP_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/server-groups', json=[SERVER_GROUP_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/server-groups', json={}, status=500) cloudscale = Cloudscale(api_token="token") server_groups = cloudscale.server_group.get_all() assert server_groups[0]['name'] == "load balancers" assert server_groups[0]['uuid'] == "e3b63018-fad6-45f2-9f57-3ea0da726d8c" runner = CliRunner() result = runner.invoke(cli, [ 'server-group', '-a', 'token', 'list', ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'server-group', '-a', 'token', 'list', ]) assert result.exit_code > 0 @responses.activate def test_server_groups_get_by_uuid(): uuid = "e3b63018-fad6-45f2-9f57-3ea0da726d8c" responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/server-groups/' + uuid, json=SERVER_GROUP_RESP, status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/server-groups/' + uuid, json=SERVER_GROUP_RESP, status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/server-groups/' + uuid, json={}, status=500) cloudscale = Cloudscale(api_token="token") server_group = cloudscale.server_group.get_by_uuid(uuid=uuid) assert server_group['name'] == "load balancers" assert server_group['uuid'] == uuid runner = CliRunner() result = runner.invoke(cli, [ 'server-group', '-a', 'token', 'show', '--uuid', uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'server-group', '-a', 'token', 'show', '--uuid', uuid, ]) assert result.exit_code > 0 @responses.activate def test_server_groups_delete(): uuid = "e3b63018-fad6-45f2-9f57-3ea0da726d8c" responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/server-groups/' + uuid, status=204) responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/server-groups/' + uuid, status=204) responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/server-groups/' + uuid, status=500) cloudscale = Cloudscale(api_token="token") server_group = cloudscale.server_group.delete(uuid=uuid) assert server_group is None runner = CliRunner() result = runner.invoke(cli, [ 'server-group', '-a', 'token', 'delete', '--uuid', uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'server-group', '-a', 'token', 'delete', '--uuid', uuid, ]) assert result.exit_code > 0 @responses.activate def test_server_groups_create(): name = "load balancers" responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/server-groups', json=SERVER_GROUP_RESP, status=201) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/server-groups', json=SERVER_GROUP_RESP, status=201) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/server-groups', json=SERVER_GROUP_RESP, status=500) cloudscale = Cloudscale(api_token="token") cloudscale.server_group.create( name=name, ) runner = CliRunner() result = runner.invoke(cli, [ 'server-group', '-a', 'token', 'create', '--name', name, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'server-group', '-a', 'token', 'create', '--name', name, ]) assert result.exit_code > 0 @responses.activate def test_server_groups_update(): uuid = "e3b63018-fad6-45f2-9f57-3ea0da726d8c" name = "load balancers" responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/server-groups/' + uuid, json=SERVER_GROUP_RESP, status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/server-groups/' + uuid, json=SERVER_GROUP_RESP, status=200) responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/server-groups/' + uuid, json=SERVER_GROUP_RESP, status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/server-groups/' + uuid, json=SERVER_GROUP_RESP, status=200) responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/server-groups/' + uuid, json={}, status=500) cloudscale = Cloudscale(api_token="token") server_group = cloudscale.server_group.update(uuid=uuid, name=name) assert server_group['name'] == name assert server_group['uuid'] == uuid runner = CliRunner() result = runner.invoke(cli, [ 'server-group', '-a', 'token', 'update', '--uuid', uuid, '--name', name, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'server-group', '-a', 'token', 'update', '--uuid', uuid, '--name', name, ]) assert result.exit_code > 0 python-cloudscale-0.6.1/test_subnet.py000066400000000000000000000047631357143037500201060ustar00rootroot00000000000000from cloudscale import Cloudscale, CloudscaleApiException, CloudscaleException, CLOUDSCALE_API_ENDPOINT from cloudscale.cli import cli import responses import click from click.testing import CliRunner SUBNET_RESP = { "href": "https://api.cloudscale.ch/v1/subnets/33333333-1864-4608-853a-0771b6885a3a", "uuid": "33333333-1864-4608-853a-0771b6885a3a", "cidr": "192.0.2.123/24", "network": { "href": "https://api.cloudscale.ch/v1/networks/2db69ba3-1864-4608-853a-0771b6885a3a", "uuid": "2db69ba3-1864-4608-853a-0771b6885a3a", "name": "my-network-name", }, "tags": {} } @responses.activate def test_subnet_get_all(): uuid = "33333333-1864-4608-853a-0771b6885a3a" responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/subnets', json=[SUBNET_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/subnets', json=[SUBNET_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/subnets', json={}, status=500) cloudscale = Cloudscale(api_token="token") subnets = cloudscale.subnet.get_all() assert subnets[0]['uuid'] == uuid runner = CliRunner() result = runner.invoke(cli, [ 'subnet', '-a', 'token', 'list', ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'subnet', '-a', 'token', 'list', ]) assert result.exit_code > 0 @responses.activate def test_subnet_get_by_uuid(): uuid = "33333333-1864-4608-853a-0771b6885a3a" responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/subnets/' + uuid, json=SUBNET_RESP, status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/subnets/' + uuid, json=SUBNET_RESP, status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/subnets/' + uuid, json={}, status=500) cloudscale = Cloudscale(api_token="token") subnet = cloudscale.subnet.get_by_uuid(uuid=uuid) assert subnet['uuid'] == uuid runner = CliRunner() result = runner.invoke(cli, [ 'subnet', '-a', 'token', 'show', '--uuid', uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'subnet', '-a', 'token', 'show', '--uuid', uuid, ]) assert result.exit_code > 0 python-cloudscale-0.6.1/test_version.py000066400000000000000000000003351357143037500202620ustar00rootroot00000000000000from cloudscale.cli import cli import click from click.testing import CliRunner def test_version(): runner = CliRunner() result = runner.invoke(cli, [ 'version', ]) assert result.exit_code == 0 python-cloudscale-0.6.1/test_volume.py000066400000000000000000000141341357143037500201060ustar00rootroot00000000000000from cloudscale import Cloudscale, CloudscaleApiException, CloudscaleException, CLOUDSCALE_API_ENDPOINT from cloudscale.cli import cli import responses import click from click.testing import CliRunner VOLUME_RESP = { "href": "https://api.cloudscale.ch/v1/volumes/2db69ba3-1864-4608-853a-0771b6885a3a", "created_at": "2019-05-29T13:18:42.511407Z", "uuid": "2db69ba3-1864-4608-853a-0771b6885a3a", "name": "capitano-root", "zone": { "slug": "lpg1" }, "size_gb": 150, "type": "ssd", "server_uuids": [ "9e1f9a7f-e8d0-4086-ad7e-fea161d7c5f7" ], "tags": {} } @responses.activate def test_volume_get_all(): responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/volumes', json=[VOLUME_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/volumes', json=[VOLUME_RESP], status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/volumes', json={}, status=500) cloudscale = Cloudscale(api_token="token") volumes = cloudscale.volume.get_all() assert volumes[0]['name'] == "capitano-root" assert volumes[0]['uuid'] == "2db69ba3-1864-4608-853a-0771b6885a3a" runner = CliRunner() result = runner.invoke(cli, [ 'volume', '-a', 'token', 'list', ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'volume', '-a', 'token', 'list', ]) assert result.exit_code > 0 @responses.activate def test_volume_get_by_uuid(): uuid = "2db69ba3-1864-4608-853a-0771b6885a3a" responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/volumes/' + uuid, json=VOLUME_RESP, status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/volumes/' + uuid, json=VOLUME_RESP, status=200) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/volumes/' + uuid, json={}, status=500) cloudscale = Cloudscale(api_token="token") volume = cloudscale.volume.get_by_uuid(uuid=uuid) assert volume['name'] == "capitano-root" assert volume['uuid'] == uuid runner = CliRunner() result = runner.invoke(cli, [ 'volume', '-a', 'token', 'show', '--uuid', uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'volume', '-a', 'token', 'show', '--uuid', uuid, ]) assert result.exit_code > 0 @responses.activate def test_volume_delete(): uuid = "2db69ba3-1864-4608-853a-0771b6885a3a" responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/volumes/' + uuid, status=204) responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/volumes/' + uuid, status=204) responses.add( responses.DELETE, CLOUDSCALE_API_ENDPOINT + '/volumes/' + uuid, json={}, status=500) cloudscale = Cloudscale(api_token="token") volume = cloudscale.volume.delete(uuid=uuid) assert volume is None runner = CliRunner() result = runner.invoke(cli, [ 'volume', '-a', 'token', 'delete', '--uuid', uuid, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'volume', '-a', 'token', 'delete', '--uuid', uuid, ]) assert result.exit_code > 0 @responses.activate def test_volume_create(): name = "capitano-root" size_gb = 150 server_uuids = "2db69ba3-1864-4608-853a-0771b6885a3a" responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/volumes', json=VOLUME_RESP, status=201) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/volumes', json=VOLUME_RESP, status=201) responses.add( responses.POST, CLOUDSCALE_API_ENDPOINT + '/volumes', json={}, status=500) cloudscale = Cloudscale(api_token="token") cloudscale.volume.create( name=name, server_uuids=server_uuids, size_gb=size_gb, ) runner = CliRunner() result = runner.invoke(cli, [ 'volume', '-a', 'token', 'create', '--name', name, '--server-uuids', server_uuids, '--size-gb', size_gb, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'volume', '-a', 'token', 'create', '--name', name, '--server-uuids', server_uuids, '--size-gb', size_gb, ]) assert result.exit_code > 0 @responses.activate def test_volume_update(): uuid = "2db69ba3-1864-4608-853a-0771b6885a3a" name = "capitano-root" responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/volumes/' + uuid, json=VOLUME_RESP, status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/volumes/' + uuid, json=VOLUME_RESP, status=200) responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/volumes/' + uuid, json=VOLUME_RESP, status=204) responses.add( responses.GET, CLOUDSCALE_API_ENDPOINT + '/volumes/' + uuid, json=VOLUME_RESP, status=200) responses.add( responses.PATCH, CLOUDSCALE_API_ENDPOINT + '/volumes/' + uuid, json={}, status=500) cloudscale = Cloudscale(api_token="token") volume = cloudscale.volume.update(uuid=uuid, name=name) assert volume['name'] == name assert volume['uuid'] == uuid runner = CliRunner() result = runner.invoke(cli, [ 'volume', '-a', 'token', 'update', '--uuid', uuid, '--name', name, ]) assert result.exit_code == 0 result = runner.invoke(cli, [ 'volume', '-a', 'token', 'update', '--uuid', uuid, '--name', name, ]) assert result.exit_code > 0 python-cloudscale-0.6.1/tox.ini000066400000000000000000000004711357143037500165000ustar00rootroot00000000000000[tox] envlist = py{36,37,38} skip_missing_interpreters = True skipsdist = True [gh-actions] python = 3.6: py36 3.7: py37 3.8: py38 [testenv] deps = -r{toxinidir}/requirements.txt -r{toxinidir}/requirements.dev.txt commands = python --version pytest --cov=cloudscale --cov-report=xml -v