pax_global_header00006660000000000000000000000064130417500170014510gustar00rootroot0000000000000052 comment=528d5948b965576faf2858331067a2ee6e702300 profitbricks-sdk-python-3.1.0/000077500000000000000000000000001304175001700163105ustar00rootroot00000000000000profitbricks-sdk-python-3.1.0/.gitignore000066400000000000000000000014201304175001700202750ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] # C extensions *.so # Distribution / packaging .Python env/ build/ develop-eggs/ dist/ downloads/ eggs/ lib/ lib64/ parts/ sdist/ var/ *.egg-info/ .installed.cfg *.egg # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .coverage .cache nosetests.xml coverage.xml # Result files *.csv # Translations *.mo *.pot # Django stuff: *.log # Sphinx documentation docs/_build/ # PyBuilder target/ examples/live_test.py *.iml .idea/ # Eclipse/PyDev metadatas /.project /.pydevproject profitbricks-sdk-python-3.1.0/Dockerfile000066400000000000000000000002501304175001700202770ustar00rootroot00000000000000FROM python:latest WORKDIR /usr/src COPY . /usr/src RUN pip install -r /usr/src/requirements.txt USER nobody CMD ["python", "-m", "unittest", "discover", "tests"] profitbricks-sdk-python-3.1.0/LICENSE000066400000000000000000000260631304175001700173240ustar00rootroot00000000000000Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. 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. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor 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 Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You 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 the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You 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 such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its 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. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright 2015 ProfitBricks GmbH Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. profitbricks-sdk-python-3.1.0/MANIFEST.in000066400000000000000000000001131304175001700200410ustar00rootroot00000000000000include examples/*.py include tests/*.py include LICENSE include README.md profitbricks-sdk-python-3.1.0/README.md000066400000000000000000000333711304175001700175760ustar00rootroot00000000000000The ProfitBricks Client Library for Python provides you with access to the ProfitBricks REST API. The client library supports both simple and complex requests. It is designed for developers who are building applications in Python. This guide will walk you through getting setup with the library and performing various actions against the API. ## Table of Contents * [Concepts](#concepts) * [Getting Started](#getting-started) * [Installation](#installation) * [Authenticating](#authenticating) * [Using the Module](#using-the-module) * [Additional Documentation and Support](#additional-documentation-and-support) * [How to: Create a Datacenter](#how-to-create-a-datacenter) * [How to: Delete a Datacenter](#how-to-delete-a-datacenter) * [How to: Update Cores, Memory, and Disk](#how-to-update-cores-memory-and-disk) * [How to: List Servers, Volumes, and Data Centers](#how-to-list-servers-volumes-and-data-centers) * [How to: Create Additional Network Interfaces](#how-to-create-additional-network-interfaces) * [How to: Check Resource Status](#how-to-check-resource-status) * [Conclusion](#conclusion) ## Concepts The Python Client Library wraps the latest version of the ProfitBricks REST API. All API operations are performed over SSL and authenticated using your ProfitBricks portal credentials. The API can be accessed within an instance running in ProfitBricks or directly over the Internet from any application that can send an HTTPS request and receive an HTTPS response. ## Getting Started Before you begin you will need to have [signed-up](https://www.profitbricks.com/signup) for a ProfitBricks account. The credentials you setup during sign-up will be used to authenticate against the API. ## Installation The Python Client Library is available on [PyPi](https://pypi.python.org/pypi/profitbricks). You can install the latest stable version using pip: pip install profitbricks Done! ## Authenticating Connecting to ProfitBricks is handled by first setting up your authentication. from profitbricks.client import ProfitBricksService client = ProfitBricksService( username='username', password='password') You can now use `client` for any future request. ## Using the Module Here are a few examples on how to use the module. In this first one we pull a list of our datacenters. from profitbricks.client import ProfitBricksService client = ProfitBricksService( username='username', password='password') datacenters = client.list_datacenters() And in this one we reserve an IPBlock: from profitbricks.client import ProfitBricksService, IPBlock client = ProfitBricksService( username='username', password='password') i = IPBlock(location='de/fra', size=5) ipblock = client.reserve_ipblock(i) Some object creation supports simple and complex requests, such as a server which can be created simply by doing this: from profitbricks.client import ProfitBricksService from profitbricks.client import Server, NIC, Volume datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService( username='username', password='password') i = Server( name='server1', ram=4096, cores=4 ) response = client.create_server( datacenter_id=datacenter_id, server=i) Or if you want one with some volumes and NICs you would do: from profitbricks.client import ProfitBricksService from profitbricks.client import Server, NIC, Volume server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService( username='username', password='password') nic1 = NIC( name='nic1', ips=['10.2.2.3'], dhcp='true', lan=1, firewall_active=True, nat=False ) nic2 = NIC( name='nic2', ips=['10.2.3.4'], dhcp='true', lan=1, firewall_active=True, ) volume1 = Volume( name='volume1', size=56, image='', bus='VIRTIO' ssh_keys=['ssh-rsa AAAAB3NzaC1yc2EAAAADAQ...'], image_password='s3cr3tpass0rd', availability_zone='ZONE_3' ) volume2 = Volume( name='volume2', size=56, image='', type='SSD', bus='VIRTIO', license_type='OTHER' ) nics = [nic1, nic2] create_volumes = [volume1, volume2] i = Server( name='server1', ram=4096, cores=4, cpu_family='INTEL_XEON', nics=nics, create_volumes=create_volumes ) response = client.create_server( datacenter_id=datacenter_id, server=i) **Notes on volumes**: * You will need to provide either the `image` or the `licence_type` parameter. The `licence_type` is required, but ProfitBricks images will already have a `licence_type` set. * A list of public SSH keys and/or the image root password can added to the volume. Only official ProfitBricks base images support the `ssh_keys` and `image_password` parameters. ## Additional Documentation and Support You can find additional examples in the repo `examples` directory. If you find any issues, please let us know via the DevOps Central community or GitHub's issue system and we'll check it out. ## How to: Create a Datacenter ProfitBricks introduces the concept of Virtual Datacenters. These are logically separated from one and the other and allow you to have a self-contained environment for all servers, volumes, networking, snapshots, and so forth. The goal is to give you the same experience as you would have if you were running your own physical datacenter. You will need a datacenter before you can create anything else. Like the server functions, the datacenter functions can be used to create a simple vDC or a complex one. To create a simple one you would do this: from profitbricks.client import ProfitBricksService from profitbricks.client import Datacenter, Volume, Server client = ProfitBricksService( username='username', password='password') i = Datacenter( username='username', password='password', name='datacenter1', description='My New Datacenter', location='de/fkb' ) response = client.create_datacenter(datacenter=i) To create a complex datacenter you would do this. As you can see, you can create quite a few of the objects you will need later all in one request. These all get serialized in a request queue which you can check using the Requests functions: from profitbricks.client import ProfitBricksService from profitbricks.client import Datacenter, Volume, Server from profitbricks.client import LAN, NIC, LoadBalancer, FirewallRule client = ProfitBricksService( username='username', password='password') fwrule1 = FirewallRule( name='Open SSH port', protocol='TCP', source_mac='01:23:45:67:89:00', port_range_start=22 ) fwrule2 = FirewallRule( name='Allow PING', protocol='ICMP', icmp_type=8, icmp_code=0 ) fw_rules = [fwrule1, fwrule2] nic1 = NIC( name='nic1', ips=['10.2.2.3'], dhcp='true', lan=1, firewall_active=True, firewall_rules=fw_rules ) nic2 = NIC( name='nic2', ips=['10.2.3.4'], dhcp='true', lan=1, firewall_active=True, firewall_rules=fw_rules ) nics = [nic1, nic2] volume1 = Volume( name='volume1', size=56, image='', bus='VIRTIO' ) volume2 = Volume( name='volume2', size=56, image='', bus='VIRTIO' ) volumes = [volume2] server1 = Server( name='server1', ram=4096, cores=4, nics=nics, create_volumes=[volume1] ) servers = [server1] balancednics = ['', ''] loadbalancer1 = LoadBalancer( name='My LB', balancednics=balancednics) loadbalancers = [loadbalancer1] lan1 = LAN( name='public Lan 4', public=True ) lan2 = LAN( name='public Lan 4', public=True ) lans = [lan1, lan2] d = Datacenter( name='datacenter1', description='my DC', location='de/fkb', servers=servers, volumes=volumes, loadbalancers=loadbalancers, lans=lans ) response = client.create_datacenter(datacenter=d) ## How to: Delete a Datacenter You will want to exercise a bit of caution here. Removing a datacenter will **destroy** all objects contained within that datacenter -- servers, volumes, snapshots, and so on. The objects -- once removed -- will be unrecoverable. from profitbricks.client import ProfitBricksService client = ProfitBricksService( username='username', password='password') datacenter_id = '700e1cab-99b2-4c30-ba8c- datacenter = client.delete_datacenter(datacenter_id=datacenter_id) ## How to: Update Cores, Memory, and Disk ProfitBricks allows users to dynamically update cores, memory, and disk independently of each other. This removes the restriction of needing to upgrade to the next size up to receive an increase in memory. You can now simply increase the instances memory keeping your costs in-line with your resource needs. The following code illustrates how you can update cores and memory: from profitbricks.client import ProfitBricksService datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' client = ProfitBricksService( username='username', password='password') server = client.update_server( datacenter_id=datacenter_id, server_id=server_id, cores=16, ram=2048) This is how you would update your volume's size: from profitbricks.client import ProfitBricksService, Volume datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' volume_id = '700e1cab-99b2-4c30-ba8c-1d273ddba025' client = ProfitBricksService( username='username', password='password') volume = client.update_volume( datacenter_id=datacenter_id, volume_id=volume_id, size=100, name='Resized storage to 100 GB', cpu_hot_unplug=True) ## How to: List Servers, Volumes, and Data Centers Listing resources is fairly straight forward. Grabbing the datacenters: from profitbricks.client import ProfitBricksService client = ProfitBricksService( username='username', password='password') datacenters = client.list_datacenters() Your servers: from profitbricks.client import ProfitBricksService datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService( username='username', password='password') servers = client.list_servers(datacenter_id=datacenter_id) Finally, your volumes: from profitbricks.client import ProfitBricksService datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService( username='username', password='password') volumes = self.volume.list_volumes( datacenter_id=datacenter_id) ## How to: Create Additional Network Interfaces The ProfitBricks platform supports adding multiple NICs to a server. These NICs can be used to create different, segmented networks on the platform. The sample below shows you how to add a second NIC to an existing server: from profitbricks.client import ProfitBricksService, FirewallRule, NIC datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' client = ProfitBricksService( username='username', password='password') i = NIC( name='nic1', ips=['10.2.2.3','10.2.3.4'], dhcp='true', lan=1, firewall_active=True ) response = client.create_nic( datacenter_id=datacenter_id, server_id=server_id, nic=i) ## How to: Check Resource Status When a new resource (server, volume, NIC, etc.) is created, the return value will include a `requestId` UUID value. This value can be passed to the `get_request()` method to retrieve the request status and any potential error messages produced by the request. client.get_request('3e2d336f-cdf5-482b-923a-f3026dfc934b', status=True) The request status can be repeatedly polled until the resource create resource operation completes with a `DONE` or `FAILED` status. An example poller method might look something like this: def wait_for_completion(conn, response, timeout): if not response: return timeout = time.time() + timeout while timeout > time.time(): time.sleep(5) request = conn.get_request( request_id=response['requestId'], status=True) if request['metadata']['status'] == 'DONE': return elif request['metadata']['status'] == 'FAILED': raise Exception('Request {0} failed to complete: {1}'.format( response['requestId'], request['metadata']['message'])) raise Exception('Timed out waiting for request {0}.'.format( response['requestId'])) The above method can then be called after creating a new resource. i = Server( name='server1', ram=4096, cores=4) response = client.create_server( datacenter_id=datacenter_id, server=i) wait_for_completion(client, response, 300) ## Conclusion We touched on only a few ways you can interact with the ProfitBricks API using python. Our repo, located [here], has further examples. If you have any other question, ping us in the community. profitbricks-sdk-python-3.1.0/examples/000077500000000000000000000000001304175001700201265ustar00rootroot00000000000000profitbricks-sdk-python-3.1.0/examples/datacenter_example.py000066400000000000000000000054311304175001700243300ustar00rootroot00000000000000"""List Datacenters """ from profitbricks.client import ProfitBricksService client = ProfitBricksService( username=os.getenv('PROFITBRICKS_USERNAME'), password=os.getenv('PROFITBRICKS_PASSWORD')) datacenters = client.list_datacenters() for d in datacenters['items']: vdc = client.get_datacenter(d['id']) name = vdc['properties']['name'] datacenter_id = vdc['id'] break """Get Datacenter """ from profitbricks.client import ProfitBricksService # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService( username='username', password='password') datacenter = client.get_datacenter( datacenter_id=datacenter_id) """Create Simple Datacenter """ from profitbricks.client import ProfitBricksService # noqa from profitbricks.client import Datacenter, Volume, Server # noqa i = Datacenter( name='dc1', description='My New Datacenter', location='de/fkb' ) response = client.create_datacenter(datacenter=i) """Create Complex Datacenter """ from profitbricks.client import ProfitBricksService # noqa from profitbricks.client import Datacenter, Volume, Server # noqa from profitbricks.client import LAN, NIC, LoadBalancer, FirewallRule, IPBlock, Server # noqa image_id = 'df8382a1-0f40-11e6-ab6b-52540005ab80' fwrule1 = FirewallRule( name='Open SSH port', protocol='TCP', source_mac='01:23:45:67:89:00', port_range_start=22, port_range_end=22 ) fwrule2 = FirewallRule( name='Allow PING', protocol='ICMP', icmp_type=8, icmp_code=0 ) fw_rules = [fwrule1, fwrule2] nic1 = NIC( name='nic1', ips=['10.2.2.3'], dhcp='true', lan=1, firewall_active=True, firewall_rules=fw_rules ) nic2 = NIC( name='nic2', ips=['10.2.3.4'], dhcp='true', lan=1, firewall_active=True, firewall_rules=fw_rules ) nics = [nic1, nic2] volume1 = Volume( name='volume1', size=56, image=image_id, bus='VIRTIO', image_password = "test1234" ) volume2 = Volume( name='volume2', size=56, image=image_id, bus='VIRTIO', image_password="test1234" ) volumes = [volume2] server1 = Server( name='My New Server1', ram=4096, cores=4, nics=nics, create_volumes=[volume1] ) servers = [server1] lan1 = LAN( name='public Lan 4', public=True ) lan2 = LAN( name='public Lan 5', public=True ) lans = [lan1, lan2] loadbalancer1 = LoadBalancer( name='LB01', ip='10.2.2.5', dhcp=False) loadbalancers = [loadbalancer1] d = Datacenter( name='My New Datacenter', description='Production environment', location='de/fkb', servers=servers, volumes=volumes, lans=lans, loadbalancers=loadbalancers ) response = client.create_datacenter(datacenter=d) del_response = client.delete_datacenter(response['id']) profitbricks-sdk-python-3.1.0/examples/image_examples.py000066400000000000000000000023651304175001700234660ustar00rootroot00000000000000"""List Images """ from profitbricks.client import ProfitBricksService client = ProfitBricksService( username='username', password='password') images = client.list_images() print(images) """ Update Image Valid image parameters are: * name (str) * description (str) * licence_type (one of 'LINUX', 'WINDOWS' or 'UNKNOWN') * cpu_hot_plug (bool) * ram_hot_plug (bool) * nic_hot_plug (bool) * nic_hot_unplug (bool) * disc_virtio_hot_plug (bool) * disc_virtio_hot_unplug (bool) * disc_scsi_hot_plug (bool) * disc_scsi_hot_unplug (bool) """ from profitbricks.client import ProfitBricksService # noqa client = ProfitBricksService( username='username', password='password') image_id = '7df81087-5835-41c6-a10b-3e098593bbd2' image = client.update_image( image_id, name='New name', description="Centos 7 with NGnix", licence_type='LINUX', cpu_hot_plug=True, ram_hot_plug=True, nic_hot_plug=True, nic_hot_unplug=True, disc_virtio_hot_plug=True, disc_virtio_hot_unplug=True) """Delete Image """ from profitbricks.client import ProfitBricksService # noqa client = ProfitBricksService( username='username', password='password') image_id = '7df81087-5835-41c6-a10b-3e098593bbd2' image = client.delete_image(image_id) profitbricks-sdk-python-3.1.0/examples/ipblock_examples.py000066400000000000000000000011331304175001700240170ustar00rootroot00000000000000import os """List IPBlocks """ from profitbricks.client import ProfitBricksService client = ProfitBricksService( username=os.getenv('PROFITBRICKS_USERNAME'), password=os.getenv('PROFITBRICKS_PASSWORD')) ipblocks = client.list_ipblocks() print(ipblocks) """Reserve IPBlock """ from profitbricks.client import ProfitBricksService, IPBlock # noqa i = IPBlock(name='py-test',location='de/fra', size=1) ipblock = client.reserve_ipblock(i) """Release IPBlock """ from profitbricks.client import ProfitBricksService # noqa ipblock_id = ipblock['id'] ipblock = client.delete_ipblock(ipblock_id) profitbricks-sdk-python-3.1.0/examples/lan_example.py000066400000000000000000000025261304175001700227720ustar00rootroot00000000000000"""List LANs """ from profitbricks.client import ProfitBricksService datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService( username='username', password='password') lans = client.list_lans(datacenter_id=datacenter_id) print(lans) """Create Complex LAN """ from profitbricks.client import ProfitBricksService, LAN # noqa lan_id = '4' datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService( username='username', password='password') nics = ['', ''] i = LAN( name='public Lan 4', public=True, nics=nics) response = client.create_lan(datacenter_id=datacenter_id, lan=i) """Create LAN """ from profitbricks.client import ProfitBricksService, LAN # noqa lan_id = '4' datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService( username='username', password='password') i = LAN( name='public Lan 4', public=True) response = client.create_lan(datacenter_id=datacenter_id, lan=i) """Get LAN Members """ from profitbricks.client import ProfitBricksService # noqa lan_id = '4' datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService( username='username', password='password') members = client.get_lan_members(datacenter_id=datacenter_id, lan_id=lan_id) profitbricks-sdk-python-3.1.0/examples/nic_examples.py000066400000000000000000000033261304175001700231530ustar00rootroot00000000000000"""List NICs """ from profitbricks.client import ProfitBricksService datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' client = ProfitBricksService( username='username', password='password') nics = client.list_nics( datacenter_id=datacenter_id, server_id=server_id) for n in nics['items']: print(n['properties']['name']) """Create NIC """ from profitbricks.client import ProfitBricksService, NIC # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' client = ProfitBricksService( username='username', password='password') i = NIC( name='nic1', ips=['10.2.2.3', '10.2.3.4'], dhcp='true', lan=1, firewall_active=True ) response = client.create_nic( datacenter_id=datacenter_id, server_id=server_id, nic=i) """Create NIC with FirewallRules """ from profitbricks.client import ProfitBricksService, FirewallRule, NIC # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' nic_id = '' client = ProfitBricksService( username='username', password='password') fwrule1 = FirewallRule( name='Open SSH port', protocol='TCP', source_mac='01:23:45:67:89:00', port_range_start=22, port_range_end=22 ) fwrule2 = FirewallRule( name='Allow PING', protocol='ICMP', icmp_type=8, icmp_code=0 ) fw_rules = [fwrule1, fwrule2] i = NIC( name='nic1', ips=['10.2.2.3', '10.2.3.4'], dhcp='true', lan=1, firewall_active=True, firewall_rules=fw_rules ) response = client.create_nic( datacenter_id=datacenter_id, server_id=server_id, nic=i) profitbricks-sdk-python-3.1.0/examples/pb_addNewServer.py000066400000000000000000000223671304175001700235640ustar00rootroot00000000000000#!/usr/local/bin/python # encoding: utf-8 ''' pb_addNewServer -- adds a new server to a data center pb_addNewServer is a tool to add a new server/storage composite to an existing data center. The server may be set up by a disk or cdrom image. @author: Jürgen Buchhammer @copyright: 2016 ProfitBricks GmbH. All rights reserved. @license: Apache License 2.0 @contact: juergen.buchhammer@profitbricks.com @deffield updated: Updated ''' import sys import os import traceback from time import sleep from datetime import datetime from argparse import ArgumentParser from argparse import RawDescriptionHelpFormatter from base64 import b64encode, b64decode from profitbricks.client import ProfitBricksService, Server, Volume, NIC __all__ = [] __version__ = 0.1 __date__ = '2016-02-16' __updated__ = '2016-02-16' class CLIError(Exception): '''Generic exception to raise and log different fatal errors.''' def __init__(self, msg): super(CLIError).__init__(type(self)) self.msg = "E: %s" % msg def __str__(self): return self.msg def __unicode__(self): return self.msg # end class CLIError def getLogin(filename, user, passwd): ''' write user/passwd to login file or get them from file. This method is not Py3 safe (byte vs. str) ''' if filename is None: return (user, passwd) if os.path.exists(filename): print("Using file {} for Login".format(filename)) with open(filename, "r") as loginfile: encoded_cred = loginfile.read() decoded_cred = b64decode(encoded_cred) login = decoded_cred.split(':', 1) return (login[0], login[1]) else: if user is None or passwd is None: raise ValueError("user and password must not be None") print("Writing file {} for Login".format(filename)) with open(filename, "w") as loginfile: encoded_cred = b64encode(user+":"+passwd) loginfile.write(encoded_cred) return (user, passwd) # end getLogin() def wait_for_request(pbclient, request_id, timeout=0, initial_wait=5, scaleup=10): ''' Waits for a request to finish until timeout. timeout==0 is interpreted as infinite wait time. Returns a tuple (return code, request status, message) where return code 0 : request successful 1 : request failed -1 : timeout exceeded The wait_period is increased every scaleup steps to adjust for long running requests. ''' total_wait = 0 wait_period = initial_wait next_scaleup = scaleup * wait_period wait = True while wait: request_status = pbclient.get_request(request_id, status=True) state = request_status['metadata']['status'] if state == "DONE": return(0, state, request_status['metadata']['message']) if state == 'FAILED': return(1, state, request_status['metadata']['message']) if verbose > 0: print("Request '{}' is in state '{}'. Sleeping for {} seconds..." .format(request_id, state, wait_period)) sleep(wait_period) total_wait += wait_period if timeout != 0 and total_wait > timeout: wait = False next_scaleup -= wait_period if next_scaleup == 0: wait_period += initial_wait next_scaleup = scaleup * wait_period if verbose > 0: print("scaling up wait_period to {}, next change in {} seconds" .format(wait_period, next_scaleup)) # end while(wait) return(-1, state, "request not finished before timeout") # end wait_for_request() def main(argv=None): '''Parse command line options and create a server/volume composite.''' if argv is None: argv = sys.argv else: sys.argv.extend(argv) program_name = os.path.basename(sys.argv[0]) program_version = "v%s" % __version__ program_build_date = str(__updated__) program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date) program_shortdesc = __import__('__main__').__doc__.split("\n")[1] program_license = '''%s Created by J. Buchhammer on %s. Copyright 2016 ProfitBricks GmbH. All rights reserved. Licensed under the Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 Distributed on an "AS IS" basis without warranties or conditions of any kind, either express or implied. USAGE ''' % (program_shortdesc, str(__date__)) try: # Setup argument parser parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('-u', '--user', dest='user', help='the login name') parser.add_argument('-p', '--password', dest='password', help='the login password') parser.add_argument('-L', '--Login', dest='loginfile', default=None, help='the login file to use') parser.add_argument('-d', '--datacenterid', dest='datacenterid', required=True, default=None, help='datacenter of the new server') parser.add_argument('-l', '--lanid', dest='lanid', required=True, default=None, help='LAN of the new server') parser.add_argument('-n', '--name', dest='servername', default="SRV_"+datetime.now().isoformat(), help='name of the new server') parser.add_argument('-c', '--cores', dest='cores', type=int, default=2, help='CPU cores') parser.add_argument('-r', '--ram', dest='ram', type=int, default=4, help='RAM in GB') parser.add_argument('-s', '--storage', dest='storage', type=int, default=4, help='storage in GB') parser.add_argument('-b', '--boot', dest='bootdevice', default="HDD", help='boot device') parser.add_argument('-i', '--imageid', dest='imageid', default=None, help='installation image') parser.add_argument('-P', '--imagepassword', dest='imgpassword', default=None, help='the image password') parser.add_argument('-v', '--verbose', dest="verbose", action="count", help="set verbosity level [default: %(default)s]") parser.add_argument('-V', '--version', action='version', version=program_version_message) # Process arguments args = parser.parse_args() global verbose verbose = args.verbose dc_id = args.datacenterid lan_id = args.lanid servername = args.servername if verbose > 0: print("Verbose mode on") print("start {} with args {}".format(program_name, str(args))) # Test images (location de/fra) # CDROM: 7fc885b3-c9a6-11e5-aa10-52540005ab80 # debian-8.3.0-amd64-netinst.iso # HDD: 28007a6d-c88a-11e5-aa10-52540005ab80 # CentOS-7-server-2016-02-01 hdimage = args.imageid cdimage = None if args.bootdevice == "CDROM": hdimage = None cdimage = args.imageid print("using boot device {} with image {}" .format(args.bootdevice, args.imageid)) (user, password) = getLogin(args.loginfile, args.user, args.password) if user is None or password is None: raise ValueError("user or password resolved to None") pbclient = ProfitBricksService(user, password) first_nic = NIC(name="local", ips=[], dhcp=True, lan=lan_id) volume = Volume(name=servername+"-Disk", size=args.storage, image=hdimage, image_password=args.imgpassword) server = Server(name=servername, cores=args.cores, ram=args.ram*1024, create_volumes=[volume], nics=[first_nic], boot_cdrom=cdimage) print("creating server..") if verbose > 0: print("SERVER: {}".format(str(server))) response = pbclient.create_server(dc_id, server) print("wait for provisioning..") wait_for_request(pbclient, response["requestId"]) server_id = response['id'] print("Server provisioned with ID {}".format(server_id)) nics = pbclient.list_nics(dc_id, server_id, 1) # server should have exactly one nic, but we only test empty nic list if len(nics['items']) == 0: raise CLIError("No NICs found for newly created server {}" .format(server_id)) nic0 = nics['items'][0] if verbose > 0: print("NIC0: {}".format(str(nic0))) (nic_id, nic_mac) = (nic0['id'], nic0['properties']['mac']) print("NIC of new Server has ID {} and MAC {}".format(nic_id, nic_mac)) print("{} finished w/o errors".format(program_name)) return 0 except KeyboardInterrupt: # handle keyboard interrupt # return 0 except Exception: traceback.print_exc() sys.stderr.write("\n" + program_name + ": for help use --help\n") return 2 # end main() if __name__ == "__main__": sys.exit(main()) profitbricks-sdk-python-3.1.0/examples/pb_controlServerState.py000066400000000000000000000316371304175001700250430ustar00rootroot00000000000000#!/usr/local/bin/python # encoding: utf-8 ''' pb_controlServerState -- control a server's state (start/stop) pb_controlServerState is a tool to control the state of a server/VM by stop/start actions @author: Jürgen Buchhammer @copyright: 2016 ProfitBricks GmbH. All rights reserved. @license: Apache License 2.0 @contact: juergen.buchhammer@profitbricks.com @deffield updated: Updated ''' import sys import os import traceback import time from argparse import ArgumentParser from argparse import RawDescriptionHelpFormatter from base64 import b64encode, b64decode from subprocess import call from profitbricks.client import ProfitBricksService __all__ = [] __version__ = 0.1 __date__ = '2016-02-25' __updated__ = '2016-02-25' class CLIError(Exception): '''Generic exception to raise and log different fatal errors.''' def __init__(self, msg): super(CLIError).__init__(type(self)) self.msg = "E: %s" % msg def __str__(self): return self.msg def __unicode__(self): return self.msg # end class CLIError def getLogin(filename, user, passwd): ''' write user/passwd to login file or get them from file. This method is not Py3 safe (byte vs. str) ''' if filename is None: return (user, passwd) if os.path.exists(filename): print("Using file {} for Login".format(filename)) with open(filename, "r") as loginfile: encoded_cred = loginfile.read() # print("encoded: {}".format(encoded_cred)) decoded_cred = b64decode(encoded_cred) login = decoded_cred.split(':', 1) return (login[0], login[1]) else: if user is None or passwd is None: raise ValueError("user and password must not be None") print("Writing file {} for Login".format(filename)) with open(filename, "w") as loginfile: encoded_cred = b64encode(user+":"+passwd) # print("encoded: {}".format(encoded_cred)) loginfile.write(encoded_cred) return (user, passwd) # end getLogin() def getServerInfo(pbclient=None, dc_id=None): ''' gets info of servers of a data center''' if pbclient is None: raise ValueError("argument 'pbclient' must not be None") if dc_id is None: raise ValueError("argument 'dc_id' must not be None") # list of all found server's info server_info = [] # depth 1 is enough for props/meta servers = pbclient.list_servers(dc_id, 1) for server in servers['items']: props = server['properties'] info = dict(id=server['id'], name=props['name'], state=server['metadata']['state'], vmstate=props['vmState']) server_info.append(info) # end for(servers) return(server_info) # end getServerInfo() def select_where(info=None, select=None, **where): if info is None: raise ValueError("argument 'info' must not be None") if len(info) == 0: return [] if select is None: select = info[0].keys() server_info = [] for old_si in info: w_matches = all(old_si[wk] == wv for (wk, wv) in where.items()) new_si = {k: v for (k, v) in old_si.items() if k in select and w_matches} if len(new_si) > 0: server_info.append(new_si) # end for(info) return(server_info) # end select_where() def getServerStates(pbclient=None, dc_id=None, serverid=None, servername=None): ''' gets states of a server''' if pbclient is None: raise ValueError("argument 'pbclient' must not be None") if dc_id is None: raise ValueError("argument 'dc_id' must not be None") server = None if serverid is None: if servername is None: raise ValueError("one of 'serverid' or 'servername' must be specified") # so, arg.servername is set (to whatever) server_info = select_where(getServerInfo(pbclient, dc_id), ['id', 'name', 'state', 'vmstate'], name=servername) if len(server_info) > 1: raise NameError("ambiguous server name '{}'".format(servername)) if len(server_info) == 1: server = server_info[0] else: # get by ID may also fail if it's removed # in this case, catch exception (message 404) and be quiet for a while # unfortunately this has changed from Py2 to Py3 try: server_info = pbclient.get_server(dc_id, serverid, 1) server = dict(id=server_info['id'], name=server_info['properties']['name'], state=server_info['metadata']['state'], vmstate=server_info['properties']['vmState']) except Exception: ex = sys.exc_info()[1] if ex.args[0] is not None and ex.args[0] == 404: print("Server w/ ID {} not found".format(serverid)) server = None else: raise ex # end try/except # end if/else(serverid) return server # end getServerStates() def wait_for_server(pbclient=None, dc_id=None, serverid=None, indicator='state', state='AVAILABLE', timeout=300): ''' wait for a server/VM to reach a defined state for a specified time indicator := {state|vmstate} specifies if server or VM stat is tested state specifies the status the indicator should have ''' if pbclient is None: raise ValueError("argument 'pbclient' must not be None") if dc_id is None: raise ValueError("argument 'dc_id' must not be None") if serverid is None: raise ValueError("argument 'serverid' must not be None") total_sleep_time = 0 seconds = 5 while total_sleep_time < timeout: time.sleep(seconds) total_sleep_time += seconds if total_sleep_time == 60: # Increase polling interval after one minute seconds = 10 elif total_sleep_time == 600: # Increase polling interval after 10 minutes seconds = 20 server = getServerStates(pbclient, dc_id, serverid) if server[indicator] == state: break # end while(total_sleep_time) return server # end wait_for_server() def main(argv=None): '''Command line options.''' if argv is None: argv = sys.argv else: sys.argv.extend(argv) program_name = os.path.basename(sys.argv[0]) program_version = "v%s" % __version__ program_build_date = str(__updated__) program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date) program_shortdesc = __import__('__main__').__doc__.split("\n")[1] program_license = '''%s Created by J. Buchhammer on %s. Copyright 2016 ProfitBricks GmbH. All rights reserved. Licensed under the Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 Distributed on an "AS IS" basis without warranties or conditions of any kind, either express or implied. USAGE ''' % (program_shortdesc, str(__date__)) try: # Setup argument parser parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('-u', '--user', dest='user', help='the login name') parser.add_argument('-p', '--password', dest='password', help='the login password') parser.add_argument('-L', '--Login', dest='loginfile', default=None, help='the login file to use') parser.add_argument('-d', '--datacenterid', dest='dc_id', required=True, default=None, help='datacenter of the server') parser.add_argument('-s', '--serverid', dest='serverid', default=None, help='ID of the server') parser.add_argument('-n', '--name', dest='servername', default=None, help='name of the server') parser.add_argument('-a', '--action', dest='action', default=None, required=True, help='what to do with the server') parser.add_argument('-C', '--command', dest='command', default=None, help='remote shell command to use for shutdown') parser.add_argument('-v', '--verbose', dest="verbose", action="count", help="set verbosity level [default: %(default)s]") parser.add_argument('-V', '--version', action='version', version=program_version_message) # Process arguments args = parser.parse_args() global verbose verbose = args.verbose dc_id = args.dc_id if verbose > 0: print("Verbose mode on") # normalize action action = args.action.upper() actions = set(['POWERON', 'POWEROFF', 'START', 'SHUTOFF']) if action not in actions: parser.error("action must be on of {}".format(str(actions))) if args.serverid is None and args.servername is None: parser.error("one of 'serverid' or 'name' must be specified") (user, password) = getLogin(args.loginfile, args.user, args.password) if user is None or password is None: raise ValueError("user or password resolved to None") pbclient = ProfitBricksService(user, password) server = getServerStates(pbclient, dc_id, args.serverid, args.servername) if server is None: raise Exception(1, "specified server not found") print("using server {}(id={}) in state {}, {}" .format(server['name'], server['id'], server['state'], server['vmstate'])) # !!! stop/start/reboot_server() simply return 'True' !!! # this implies, that there's NO response nor requestId to track! if action == 'POWEROFF': if server['state'] == 'INACTIVE': print("server is already powered off") else: # currently use 'forced' poweroff if server['vmstate'] != 'SHUTOFF': print("VM is in state {}, {} may lead to inconsistent state" .format(server['vmstate'], action)) if args.command is None: print("no command specified for shutdown of VM") else: print("executing {}".format(args.command)) cmdrc = call(args.command, shell=True) print("executing {} returned {}" .format(args.command, cmdrc)) pbclient.stop_server(dc_id, server['id']) server = wait_for_server(pbclient, dc_id, server['id'], state='INACTIVE', timeout=300) elif action == 'POWERON': if server['vmstate'] == 'RUNNING': print("VM is already up and running") else: pbclient.start_server(dc_id, server['id']) server = wait_for_server(pbclient, dc_id, server['id'], indicator='vmstate', state='RUNNING', timeout=300) elif action == 'START': # this is the same as POWERON if server['vmstate'] == 'RUNNING': print("VM is already up and running") else: pbclient.start_server(dc_id, server['id']) server = wait_for_server(pbclient, dc_id, server['id'], indicator='vmstate', state='RUNNING', timeout=300) elif action == 'SHUTOFF': if server['vmstate'] == 'SHUTOFF': print("VM is already shut off") else: if args.command is None: print("no command specified for shutdown of VM") else: print("executing {}".format(args.command)) cmdrc = call(args.command, shell=True) print("executing {} returned {}" .format(args.command, cmdrc)) server = wait_for_server(pbclient, dc_id, server['id'], indicator='vmstate', state='SHUTOFF', timeout=300) # end if/else(action) print("server {}(id={}) now in state {}, {}" .format(server['name'], server['id'], server['state'], server['vmstate'])) except KeyboardInterrupt: # handle keyboard interrupt # return 0 except Exception: traceback.print_exc() sys.stderr.write("\n" + program_name + ": for help use --help\n") return 2 # end main() if __name__ == "__main__": sys.exit(main()) profitbricks-sdk-python-3.1.0/examples/pb_createDatacenter.py000066400000000000000000000560251304175001700244270ustar00rootroot00000000000000#!/usr/local/bin/python # encoding: utf-8 ''' pb_createDatacenter is a sample script to create a complex datacenter. @author: Jürgen Buchhammer @copyright: 2016 ProfitBricks GmbH. All rights reserved. @license: Apache License 2.0 @contact: juergen.buchhammer@profitbricks.com @deffield updated: Updated ''' import sys import os from argparse import ArgumentParser from argparse import RawDescriptionHelpFormatter from time import sleep import json from base64 import b64decode, b64encode from profitbricks.client import ProfitBricksService from profitbricks.client import Datacenter, Volume, Server from profitbricks.client import LAN, NIC, FirewallRule __version__ = 0.2 __date__ = '2016-09-26' __updated__ = __date__ def getLogin(filename, user, passwd): ''' write user/passwd to login file or get them from file. This method is not Py3 safe (byte vs. str) ''' if filename is None: return (user, passwd) isPy2 = sys.version_info[0] == 2 if os.path.exists(filename): print("Using file {} for Login".format(filename)) with open(filename, "r") as loginfile: encoded_cred = loginfile.read() print("encoded: {}".format(encoded_cred)) if isPy2: decoded_cred = b64decode(encoded_cred) else: decoded_cred = b64decode(encoded_cred).decode('utf-8') login = decoded_cred.split(':', 1) return (login[0], login[1]) else: if user is None or passwd is None: raise ValueError("user and password must not be None") print("Writing file {} for Login".format(filename)) with open(filename, "wb") as loginfile: creds = user+":"+passwd if isPy2: encoded_cred = b64encode(creds) else: encoded_cred = b64encode(creds.encode('utf-8')) print("encoded: {}".format(encoded_cred)) loginfile.write(encoded_cred) return (user, passwd) # end getLogin() def wait_for_request(pbclient, request_id, timeout=0, initial_wait=5, scaleup=10): ''' Waits for a request to finish until timeout. timeout==0 is interpreted as infinite wait time. Returns a tuple (return code, request status, message) where return code 0 : request successful 1 : request failed -1 : timeout exceeded The wait_period is increased every scaleup steps to adjust for long running requests. ''' total_wait = 0 wait_period = initial_wait next_scaleup = scaleup * wait_period wait = True while wait: request_status = pbclient.get_request(request_id, status=True) state = request_status['metadata']['status'] if state == "DONE": return(0, state, request_status['metadata']['message']) if state == 'FAILED': return(1, state, request_status['metadata']['message']) print("Request '{}' is in state '{}'. Sleeping for {} seconds..." .format(request_id, state, wait_period)) sleep(wait_period) total_wait += wait_period if timeout != 0 and total_wait > timeout: wait = False next_scaleup -= wait_period if next_scaleup == 0: wait_period += initial_wait next_scaleup = scaleup * wait_period print("scaling up wait_period to {}, next change in {} seconds" .format(wait_period, next_scaleup)) # end while(wait) return(-1, state, "request not finished before timeout") # end wait_for_request() def wait_for_requests(pbclient, request_ids=[], timeout=0, initial_wait=5, scaleup=10): ''' Waits for a list of requests to finish until timeout. timeout==0 is interpreted as infinite wait time. Returns a dict of request_id -> result. result is a tuple (return code, request status, message) where return code 0 : request successful 1 : request failed -1 : timeout exceeded The wait_period is increased every scaleup steps to adjust for long running requests. ''' done = dict() if len(request_ids) == 0: print("empty request list") return done total_wait = 0 wait_period = initial_wait next_scaleup = scaleup * wait_period wait = True while wait: for request_id in request_ids: if request_id in done: continue request_status = pbclient.get_request(request_id, status=True) state = request_status['metadata']['status'] if state == "DONE": done[request_id] = (0, state, request_status['metadata']['message']) print("Request '{}' is in state '{}'.".format(request_id, state)) if state == 'FAILED': done[request_id] = (1, state, request_status['metadata']['message']) print("Request '{}' is in state '{}'.".format(request_id, state)) # end for(request_ids) if len(done) == len(request_ids): wait = False else: print("{} of {} requests are finished. Sleeping for {} seconds..." .format(len(done), len(request_ids), wait_period)) sleep(wait_period) total_wait += wait_period if timeout != 0 and total_wait > timeout: wait = False next_scaleup -= wait_period if next_scaleup == 0: wait_period += initial_wait next_scaleup = scaleup * wait_period print("scaling up wait_period to {}, next change in {} seconds" .format(wait_period, next_scaleup)) # end if/else(done) # end while(wait) if len(done) != len(request_ids): for request_id in request_ids: if request_id in done: continue done[request_id] = (-1, state, "request not finished before timeout") return done # end wait_for_requests() def create_datacenter_dict(pbclient, datacenter): """ Creates a Datacenter dict -- both simple and complex are supported. This is copied from createDatacenter() and uses private methods. """ server_items = [] volume_items = [] lan_items = [] loadbalancer_items = [] entities = dict() properties = { "name": datacenter.name, "location": datacenter.location, } ' Optional Properties' if datacenter.description: properties['description'] = datacenter.description ' Servers ' if len(datacenter.servers) > 0: for server in datacenter.servers: server_items.append(pbclient._create_server_dict(server)) servers = { "items": server_items } server_entities = { "servers": servers } entities.update(server_entities) ' Volumes ' if len(datacenter.volumes) > 0: for volume in datacenter.volumes: volume_items.append(pbclient._create_volume_dict(volume)) volumes = { "items": volume_items } volume_entities = { "volumes": volumes } entities.update(volume_entities) ' Load Balancers ' if len(datacenter.loadbalancers) > 0: for loadbalancer in datacenter.loadbalancers: loadbalancer_items.append( pbclient._create_loadbalancer_dict( loadbalancer ) ) loadbalancers = { "items": loadbalancer_items } loadbalancer_entities = { "loadbalancers": loadbalancers } entities.update(loadbalancer_entities) ' LANs ' if len(datacenter.lans) > 0: for lan in datacenter.lans: lan_items.append( pbclient._create_lan_dict(lan) ) lans = { "items": lan_items } lan_entities = { "lans": lans } entities.update(lan_entities) if len(entities) == 0: raw = { "properties": properties, } else: raw = { "properties": properties, "entities": entities } return raw # end create_datacenter_dict() def write_dc_definition(pbclient, dcdef=None, filename=None): with open(filename, 'w') as outfile: json.dump(dcdef, outfile, indent=2) return 0 # end write_dc_definition() def read_dc_definition(pbclient, filename=None): with open(filename) as infile: dcdef = json.load(infile) return dcdef # end read_dc_definition() # -- build objects from internal dict structures -- def getDatacenterObject(defdict=None): if defdict is None or not type(defdict) is dict or len(defdict.keys()) == 0: raise ValueError("argument 'defdict' must be non-empty dict") props = dict() for k, v in defdict['properties'].items(): # no renaming needed here, but this accounts for optional props too props[k] = v apiobj = Datacenter(**props) return(apiobj) # end getDatacenterObject() def getVolumeObject(defdict=None): if defdict is None or not type(defdict) is dict or len(defdict.keys()) == 0: raise ValueError("argument 'defdict' must be non-empty dict") # TODO: can we set deviceNumber too? Nope, not supported in Volume() # AARGH! some of Volume's fields have different names -> need to convert # so make a copy and let source as is props = dict() for k, v in defdict['properties'].items(): if k == 'type': props['disk_type'] = v continue if k == 'imagePassword': props['image_password'] = v continue if k == 'licenceType': props['licence_type'] = v continue if k == 'sshKeys': props['ssh_keys'] = v continue props[k] = v # end for(defdict) apiobj = Volume(**props) return(apiobj) # end getVolumeObject() def getServerObject(defdict=None): if defdict is None or not type(defdict) is dict or len(defdict.keys()) == 0: raise ValueError("argument 'defdict' must be non-empty dict") # AARGH! some of Servers's fields have different names -> need to convert manually # so make a copy and let source as is props = dict() for k, v in defdict['properties'].items(): if k == 'availabilityZone': props['availability_zone'] = v continue if k == 'bootCdrom': props['boot_cdrom'] = v continue if k == 'cpuFamily': props['cpu_family'] = v continue # -- TODO: if volumes entries have an ID -> attach, else create w/ properties of volume # if k == 'bootVolume': # props['boot_volume_id'] = v # continue # if k == 'volumes': # props['create_volumes'] = v # continue # if k == 'volumes': # props['attach_volumes'] = v # continue # Server() has no kwargs, so we must exactly match the known keywords if k in ['name', 'cores', 'ram']: props[k] = v # end for(defdict) apiobj = Server(**props) return(apiobj) # end getServerObject() def getNICObject(defdict=None): if defdict is None or not type(defdict) is dict or len(defdict.keys()) == 0: raise ValueError("argument 'defdict' must be non-empty dict") # AARGH! some of NIC's fields have different names -> need to convert manually # so make a copy and let source as is props = dict() for k, v in defdict['properties'].items(): if k == 'firewallActive': props['firewall_active'] = v continue if k == 'firewallrules': # this needs more to do: # if we have rules we must get rules objects too, irrespective of being active if len(v) != 0: rules = [getFwRuleObject(rule) for rule in v] props['firewall_rules'] = rules continue props[k] = v # end for(defdict) apiobj = NIC(**props) return(apiobj) # end getNICObject() def getFwRuleObject(defdict=None): if defdict is None or not type(defdict) is dict or len(defdict.keys()) == 0: raise ValueError("argument 'defdict' must be non-empty dict") # AARGH! some of NIC's fields have different names -> need to convert manually # so make a copy and let source as is props = dict() for k, v in defdict['properties'].items(): if k == 'sourceMac': props['source_mac'] = v continue if k == 'sourceIp': props['source_ip'] = v continue if k == 'targetIp': props['target_ip'] = v continue if k == 'portRangeStart': props['port_range_start'] = v continue if k == 'portRangeEnd': props['port_range_end'] = v continue if k == 'icmpType': props['icmp_type'] = v continue if k == 'icmpCode': props['icmp_code'] = v continue props[k] = v # end for(defdict) apiobj = FirewallRule(**props) return(apiobj) # end getFwRuleObject() def getLANObject(defdict=None): if defdict is None or not type(defdict) is dict or len(defdict.keys()) == 0: raise ValueError("argument 'defdict' must be non-empty dict") props = dict() for k, v in defdict['properties'].items(): # no renaming needed here, but this accounts for optional props too props[k] = v # end for(defdict) apiobj = LAN(**props) return(apiobj) # end getLANObject() # -- the (far too long) main method -- def main(argv=None): '''Parse command line options and create a server/volume composite.''' if argv is None: argv = sys.argv else: sys.argv.extend(argv) program_name = os.path.basename(sys.argv[0]) program_version = "v%s" % __version__ program_build_date = str(__updated__) program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date) program_shortdesc = __import__('__main__').__doc__.split("\n")[1] program_license = '''%s Created by J. Buchhammer on %s. Copyright 2016 ProfitBricks GmbH. All rights reserved. Licensed under the Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 Distributed on an "AS IS" basis without warranties or conditions of any kind, either express or implied. USAGE ''' % (program_shortdesc, str(__date__)) # Setup argument parser parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('-u', '--user', dest='user', help='the login name') parser.add_argument('-p', '--password', dest='password', help='the login password') parser.add_argument('-L', '--Login', dest='loginfile', default=None, help='the login file to use') parser.add_argument('-i', '--infile', dest='infile', default=None, required=True, help='the input file name') parser.add_argument('-D', '--DCname', dest='dcname', default=None, help='new datacenter name') # TODO: add/overwrite image password for creation # parser.add_argument('-P', '--imagepassword', dest='imgpassword', # default=None, help='the image password') parser.add_argument('-v', '--verbose', dest="verbose", action="count", default=0, help="set verbosity level [default: %(default)s]") parser.add_argument('-V', '--version', action='version', version=program_version_message) # Process arguments args = parser.parse_args() global verbose verbose = args.verbose if verbose > 0: print("Verbose mode on") print("start {} with args {}".format(program_name, str(args))) (user, password) = getLogin(args.loginfile, args.user, args.password) if user is None or password is None: raise ValueError("user or password resolved to None") pbclient = ProfitBricksService(user, password) usefile = args.infile print("read dc from {}".format(usefile)) dcdef = read_dc_definition(pbclient, usefile) if verbose > 0: print("using DC-DEF {}".format(json.dumps(dcdef))) # setup dc: # + create empty dc # + create volumes (unattached), map uuid to servers (custom dict) # + create servers # + create nics # + attach volumes if 'custom' in dcdef and 'id' in dcdef['custom']: dc_id = dcdef['custom']['id'] print("using existing DC w/ id {}".format(str(dc_id))) else: if args.dcname is not None: print("Overwrite DC name w/ '{}'".format(args.dcname)) dcdef['properties']['name'] = args.dcname dc = getDatacenterObject(dcdef) # print("create DC {}".format(str(dc))) response = pbclient.create_datacenter(dc) dc_id = response['id'] if 'custom' not in dcdef: dcdef['custom'] = dict() dcdef['custom']['id'] = dc_id result = wait_for_request(pbclient, response['requestId']) print("wait loop returned {}".format(result)) tmpfile = usefile+".tmp_postdc" write_dc_definition(pbclient, dcdef, tmpfile) requests = [] print("create Volumes {}".format(str(dc))) # we do NOT consider dangling volumes, only server-attached ones for server in dcdef['entities']['servers']['items']: print("- server {}".format(server['properties']['name'])) if 'volumes' not in server['entities']: print(" server {} has no volumes".format(server['properties']['name'])) continue for volume in server['entities']['volumes']['items']: if 'custom' in volume and 'id' in volume['custom']: vol_id = volume['custom']['id'] print("using existing volume w/ id {}".format(str(vol_id))) else: dcvol = getVolumeObject(volume) print("OBJ: {}".format(str(dcvol))) response = pbclient.create_volume(dc_id, dcvol) volume.update({'custom': {'id': response['id']}}) requests.append(response['requestId']) # end for(volume) # end for(server) if len(requests) != 0: result = wait_for_requests(pbclient, requests, initial_wait=10, scaleup=15) print("wait loop returned {}".format(str(result))) tmpfile = usefile+".tmp_postvol" write_dc_definition(pbclient, dcdef, tmpfile) else: print("all volumes existed already") requests = [] print("create Servers {}".format(str(dc))) # we do NOT consider dangling volumes, only server-attached ones for server in dcdef['entities']['servers']['items']: print("- server {}".format(server['properties']['name'])) if 'custom' in server and 'id' in server['custom']: srv_id = server['custom']['id'] print("using existing server w/ id {}".format(str(srv_id))) else: dcsrv = getServerObject(server) print("OBJ: {}".format(str(dcsrv))) response = pbclient.create_server(dc_id, dcsrv) server.update({'custom': {'id': response['id']}}) requests.append(response['requestId']) # end for(server) if len(requests) != 0: result = wait_for_requests(pbclient, requests, initial_wait=10, scaleup=15) print("wait loop returned {}".format(str(result))) tmpfile = usefile+".tmp_postsrv" write_dc_definition(pbclient, dcdef, tmpfile) else: print("all servers existed already") # TODO: only do this if we have lan entities requests = [] # Huuh, looks like we get unpredictable order for LANs! # Nope, order of creation determines the LAN id, # thus we better wait for each request print("create LANs {}".format(str(dc))) for lan in dcdef['entities']['lans']['items']: print("- lan {}".format(lan['properties']['name'])) dclan = getLANObject(lan) print("OBJ: {}".format(str(dclan))) response = pbclient.create_lan(dc_id, dclan) lan.update({'custom': {'id': response['id']}}) result = wait_for_request(pbclient, response['requestId']) print("wait loop returned {}".format(str(result))) # end for(lan) tmpfile = usefile+".tmp_postlan" write_dc_definition(pbclient, dcdef, tmpfile) requests = [] # Attention: # NICs appear in OS in the order, they are created. # But DCD rearranges the display by ascending MAC addresses. # This does not change the OS order. # MAC may not be available from create response, # thus we wait for each request :-( print("create NICs {}".format(str(dc))) for server in dcdef['entities']['servers']['items']: print("- server {}".format(server['properties']['name'])) srv_id = server['custom']['id'] if 'nics' not in server['entities']: print(" server {} has no NICs".format(server['properties']['name'])) continue macmap = dict() for nic in server['entities']['nics']['items']: dcnic = getNICObject(nic) response = pbclient.create_nic(dc_id, srv_id, dcnic) # print("dcnic response {}".format(str(response))) # mac = response['properties']['mac'] # we don't get it here !? nic_id = response['id'] result = wait_for_request(pbclient, response['requestId']) print("wait loop returned {}".format(str(result))) response = pbclient.get_nic(dc_id, srv_id, nic_id, 2) mac = response['properties']['mac'] print("dcnic has MAC {} for {}".format(mac, nic_id)) macmap[mac] = nic_id # end for(nic) macs = sorted(macmap) print("macs will be displayed by DCD in th following order:") for mac in macs: print("mac {} -> id{}".format(mac, macmap[mac])) # end for(server) tmpfile = usefile+".tmp_postnic" write_dc_definition(pbclient, dcdef, tmpfile) requests = [] # don't know if we get a race here too, so better wait for each request :-/ print("attach volumes {}".format(str(dc))) for server in dcdef['entities']['servers']['items']: print("- server {}".format(server['properties']['name'])) if 'volumes' not in server['entities']: print(" server {} has no volumes".format(server['properties']['name'])) continue srv_id = server['custom']['id'] for volume in server['entities']['volumes']['items']: print("OBJ: {}".format(volume['properties']['name'])) response = pbclient.attach_volume(dc_id, srv_id, volume['custom']['id']) result = wait_for_request(pbclient, response['requestId']) print("wait loop returned {}".format(str(result))) # end for(volume) # end for(server) tmpfile = usefile+".tmp_postatt" write_dc_definition(pbclient, dcdef, tmpfile) # TODO: do we need to set boot volume for each server? # looks like it's working without return 0 # end main() if __name__ == "__main__": sys.exit(main()) profitbricks-sdk-python-3.1.0/examples/pb_datacenter_inventory.py000077500000000000000000000447611304175001700254270ustar00rootroot00000000000000#!/usr/local/bin/python # encoding: utf-8 ''' pb_datacenter_inventory -- dump inventory of your Profitbricks data centers to CSV files pb_datacenter_inventory is a sample script to get an inventory overview of your data centers via Profitbricks REST-API. It collects some basic information on - reserved ip blocks: Location,RscType,RscID,State,Size,IP addresses - images and snapshots Visibility(public|private),Location,RscType,SubType(CDROM|HDD),RscID, RscName,State,LicType,Size,Created,Modified - servers DCID,DCName,Location,RscType,RscID,RscName,State,LicType,Cores,RAM, # NICs,# Volumes,(Total) Storage,---,Created,Modified and storage DCID,DCName,Location,RscType,RscID,RscName,State,LicType,---,---,---,---, (Total) Storage,Connected to,Created,Modified - networking infrastructure (LANs/NICs) DCID,DCName,Location,LAN ID,LAN name,public?,State,# NICs,NIC ID, MAC address,DHCP?,IP(s),NIC name,Firewall?,Connected to,ID,Name from all your datacenters. This data is written to a resource specific CSV file which can be used for reports or automatic post processing. @author: Jürgen Buchhammer @copyright: 2016 ProfitBricks GmbH. All rights reserved. @license: license @contact: juergen.buchhammer@profitbricks.com @deffield updated: Updated ''' import sys import os import traceback import re import pprint from argparse import ArgumentParser from argparse import RawDescriptionHelpFormatter from getpass import getpass import csv from profitbricks.client import ProfitBricksService __all__ = [] __version__ = 0.2 __date__ = '2016-01-15' __updated__ = '2016-01-15' verbose = 0 DEBUG = 1 def pp(value): """ Returns a pretty print string of the given value. @return: pretty print string @rtype: str """ pretty_printer = pprint.PrettyPrinter(indent=4) return pretty_printer.pformat(value) class CLIError(Exception): '''Generic exception to raise and log different fatal errors.''' def __init__(self, msg): super(CLIError).__init__(type(self)) self.msg = "E: %s" % msg def __str__(self): return self.msg def __unicode__(self): return self.msg def get_dc_inventory(pbclient, dc=None): ''' gets inventory of one data center''' if pbclient is None: raise ValueError("argument 'pbclient' must not be None") if dc is None: raise ValueError("argument 'dc' must not be None") dc_inv = [] # inventory list to return dcid = dc['id'] # dc_data contains dc specific columns dc_data = [dcid, dc['properties']['name'], dc['properties']['location']] # first get the servers # this will build a hash to relate volumes to servers later # depth 3 is enough to get into volume/nic level plus details servers = pbclient.list_servers(dcid, 3) print("found %i servers in data center %s" % (len(servers['items']), dc['properties']['name'])) if verbose > 2: print(str(servers)) # this will build a hash to relate volumes to servers later bound_vols = dict() # hash volume-to-server relations for server in servers['items']: if verbose > 2: print("SERVER: %s" % str(server)) serverid = server['id'] # server_data contains server specific columns for later output server_data = [ server['type'], serverid, server['properties']['name'], server['metadata']['state'] ] # OS is determined by boot device (volume||cdrom), not a server property. # Might even be unspecified bootOS = "NONE" bootdev = server['properties']['bootVolume'] if bootdev is None: bootdev = server['properties']['bootCdrom'] print("server %s has boot device %s" % (serverid, "CDROM")) if bootdev is None: print("server %s has NO boot device" % (serverid)) else: bootOS = bootdev['properties']['licenceType'] server_data += [bootOS, server['properties']['cores'], server['properties']['ram']] server_vols = server['entities']['volumes']['items'] n_volumes = len(server_vols) total_disk = 0 licence_type = "" for vol in server_vols: total_disk += vol['properties']['size'] licence_type = str(vol['properties']['licenceType']) bound_vols[vol['id']] = serverid if verbose: print("volume %s is connected to %s w/ OS %s" % ( vol['id'], bound_vols[vol['id']], licence_type)) server_nics = server['entities']['nics']['items'] n_nics = len(server_nics) server_data += [ n_nics, n_volumes, total_disk, "", server['metadata']['createdDate'], server['metadata']['lastModifiedDate'] ] dc_inv.append(dc_data + server_data) # end for(servers) # and now the volumes... volumes = pbclient.list_volumes(dcid, 2) # depth 2 gives max. details for volume in volumes['items']: if verbose > 2: print("VOLUME: %s" % str(volume)) volid = volume['id'] vol_data = [ volume['type'], volid, volume['properties']['name'], volume['metadata']['state'], volume['properties']['licenceType'], "", "", "", "", volume['properties']['size'] ] connect = 'NONE' if volid in bound_vols: connect = bound_vols[volid] vol_data += [ connect, volume['metadata']['createdDate'], volume['metadata']['lastModifiedDate'] ] dc_inv.append(dc_data + vol_data) # end for(volumes) return dc_inv # end get_dc_inventory() def get_images(pbclient): if pbclient is None: raise ValueError("argument 'pbclient' must not be None") print("getting images..") images = pbclient.list_images() print("found %i images" % len(images['items'])) img_inv = [] for image in images['items']: if verbose > 2: print("IMAGE: %s" % str(image)) img_data = [ ('public' if image['properties']['public'] else 'private'), image['properties']['location'], image['type'], image['properties']['imageType'], image['id'], image['properties']['name'], image['metadata']['state'], image['properties']['licenceType'], image['properties']['size'], image['metadata']['createdDate'], image['metadata']['lastModifiedDate'] ] img_inv.append(img_data) return img_inv # end get_images() def get_snapshots(pbclient): if pbclient is None: raise ValueError("argument 'pbclient' must not be None") print("getting snapshots..") snapshots = pbclient.list_snapshots() print("found %i snapshots" % len(snapshots['items'])) snap_inv = [] for snap in snapshots['items']: if verbose > 2: print("SNAPSHOT: %s" % str(snap)) snap_data = [ "private", snap['properties']['location'], snap['type'], "HDD", snap['id'], snap['properties']['name'], snap['metadata']['state'], snap['properties']['licenceType'], snap['properties']['size'], snap['metadata']['createdDate'], snap['metadata']['lastModifiedDate'] ] # print("SNAPSHOT: %s" % str(snap_data)) snap_inv.append(snap_data) # end for(snapshots) return snap_inv # end get_snapshots() def get_ipblocks(pbclient): if pbclient is None: raise ValueError("argument 'pbclient' must not be None") print("getting IP blocks..") ipblocks = pbclient.list_ipblocks() print("found %i IP blocks" % len(ipblocks['items'])) ip_inv = [] if verbose > 1: print(str(ipblocks)) for block in ipblocks['items']: ip_data = [ block['properties']['location'], block['type'], block['id'], block['metadata']['state'], block['properties']['size'] ] ip_data.extend(block['properties']['ips']) # print str(ip_data) ip_inv.append(ip_data) # end for(ipblocks) return ip_inv # end get_ipblocks() def get_dc_network(pbclient, dc=None): ''' gets inventory of one data center''' if pbclient is None: raise ValueError("argument 'pbclient' must not be None") if dc is None: raise ValueError("argument 'dc' must not be None") print("getting networks..") dcid = dc['id'] # dc_data contains dc specific columns dc_data = [dcid, dc['properties']['name'], dc['properties']['location']] lbs = pbclient.list_loadbalancers(dcid, 2) # build lookup hash for loadbalancer's ID->name lbnames = dict([(lb['id'], lb['properties']['name']) for lb in lbs['items']]) if verbose > 2: print("LBs: %s" % (str(lbs))) lans = pbclient.list_lans(dcid, 3) lan_inv = [] # lookup hash for server's ID->name servernames = dict() for lan in lans['items']: if verbose > 1: print("LAN: %s" % str(lan)) lan_data = dc_data + [ "LAN "+lan['id'], lan['properties']['name'], lan['properties']['public'], lan['metadata']['state'] ] nics = lan['entities']['nics']['items'] lan_data.append(len(nics)) if len(nics) > 0: for nic in nics: nic_props = nic['properties'] # get the serverid of this nic by href # !!! HUUUUH this might also be a loadbalancer ID, # although it's '/servers//...' !!! serverid = re.sub(r'^.*servers/([^/]+)/nics.*', r'\1', nic['href']) if serverid in lbnames: servertype = "LB" servername = lbnames[serverid] print("server entry for %s is LOADBALANCER %s" % (serverid, servername)) else: servertype = "Server" if serverid not in servernames: if verbose: print("add server entry for %s" % serverid) server = pbclient.get_server(dcid, serverid, 0) servernames[serverid] = server['properties']['name'] servername = servernames[serverid] # end if/else(serverid) ips = [str(ip) for ip in nic_props['ips']] nic_data = [ nic['id'], nic_props['mac'], nic_props['dhcp'], ips, nic_props['name'], nic_props['firewallActive'], servertype, serverid, servername ] lan_inv.append(lan_data+nic_data) # end for(nics) else: lan_inv.append(lan_data) # end for(lans) return lan_inv # end get_networks() def get_requests(pbclient): if pbclient is None: raise ValueError("argument 'pbclient' must not be None") print("getting requests..") requests = pbclient.list_requests() # higher depth gives no more details (API-doc BUG) print("found %i requests" % len(requests['items'])) if verbose: print("global: %s" % str(requests)) for req in requests['items']: reqid = req['id'] # False: get request (w/ body), True: get request status (DONE,..) req_data = pbclient.get_request(reqid) # False: get request (w/ body), True: get request status (DONE,..) req_stat = pbclient.get_request(reqid, True) if verbose > 2: print("REQ: %s\n %s" % (str(req_data), str(req_stat))) if verbose > 1: print( "request %s|%s|%s" % ( str(reqid), str(req_data['metadata']), str(req_stat['metadata']) ) ) # end for(requests) # end get_requests() def main(argv=None): # IGNORE:C0111 '''Command line options.''' if argv is None: argv = sys.argv else: sys.argv.extend(argv) program_name = os.path.basename(sys.argv[0]) program_version = "v%s" % __version__ program_build_date = str(__updated__) program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date) program_shortdesc = __import__('__main__').__doc__.split("\n")[1] program_license = '''%s Created by J.Buchhammer on %s. Copyright 2016 ProfitBricks GmbH. All rights reserved. Licensed under the Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 Distributed on an "AS IS" basis without warranties or conditions of any kind, either express or implied. USAGE ''' % (program_shortdesc, str(__date__)) try: # Setup argument parser parser = ArgumentParser( description=program_license, formatter_class=RawDescriptionHelpFormatter) parser.add_argument( '-u', '--user', dest='user', required=True, help='the login name') parser.add_argument( '-p', '--password', dest='password', help='the login password') parser.add_argument( '-d', '--datacenter', '--datacenterid', dest='datacenterid', nargs='?', const='*', help='show server/storage of datacenter(s)') parser.add_argument( '-i', '--image', dest='show_images', action="store_true", help='show images and snapshots') parser.add_argument( '-b', '--ipblock', dest='show_ipblocks', action="store_true", help='show reserved IP blocks') parser.add_argument( '-n', '--network', dest='show_networks', action="store_true", help='show network assignments') # parser.add_argument( # '-r', '--request', dest='show_requests', action="store_true", # help='show requests') parser.add_argument( "-v", "--verbose", dest="verbose", action="count", default=0, help="set verbosity level [default: %(default)s]") parser.add_argument( '-V', '--version', action='version', version=program_version_message) # Process arguments args = parser.parse_args() global verbose verbose = args.verbose # this is a global to be used in methods user = args.user password = args.password datacenterid = args.datacenterid print("Welcome to PB-API %s\n" % user) if password is None: password = getpass() if verbose > 0: print("Verbose mode on") print("using python ", sys.version_info) pbclient = ProfitBricksService(user, password) if datacenterid is not None: datacenters = {} if datacenterid == '*': # the default depth=1 is sufficient, higher values don't provide more details datacenters = pbclient.list_datacenters() else: datacenters['items'] = [] datacenters['items'] = [pbclient.get_datacenter(datacenterid, 1)] if verbose > 1: print(pp(datacenters)) print("retrieved %i datacenters " % len(datacenters['items'])) # dump inventory to file with open("pb_datacenter_inventory.csv", 'w') as csvfile: csvwriter = csv.writer(csvfile, delimiter=';', lineterminator='\n') csvwriter.writerow([ 'DCID', 'DCName', 'Loc', 'RscType', 'RscID', 'RscName', 'State', 'LicType', 'Cores', 'RAM', '# NICs', '# Volumes', '(Total) Storage', 'Connected to', 'Created', 'Modified' ]) for dc in datacenters['items']: try: dc_inv = get_dc_inventory(pbclient, dc) if verbose: print("DC %s has %i inventory entries" % (dc['id'], len(dc_inv))) for row in dc_inv: csvwriter.writerow(row) except Exception: traceback.print_exc() exit(2) # end for(datacenters) if args.show_images: with open("pb_datacenter_images.csv", 'w') as csvfile: csvwriter = csv.writer(csvfile, delimiter=';', lineterminator='\n') csvwriter.writerow([ 'Visibility', 'Loc', 'RscType', 'SubType', 'RscID', 'RscName', 'State', 'LicType', 'Size', 'Created', 'Modified' ]) img_inv = get_images(pbclient) for row in img_inv: csvwriter.writerow(row) snap_inv = get_snapshots(pbclient) for row in snap_inv: csvwriter.writerow(row) if args.show_ipblocks: with open("pb_datacenter_ipblocks.csv", 'w') as csvfile: csvwriter = csv.writer(csvfile, delimiter=';', lineterminator='\n') csvwriter.writerow([ 'Loc', 'RscType', 'RscID', 'State', 'Size', 'IP addresses']) ipblocks = get_ipblocks(pbclient) for row in ipblocks: csvwriter.writerow(row) # file is automatically closed after with block if args.show_networks: # the default depth=1 is sufficient, higher values don't provide more details datacenters = pbclient.list_datacenters() print("retrieved %i datacenters " % len(datacenters['items'])) with open("pb_datacenter_networks.csv", 'w') as csvfile: csvwriter = csv.writer(csvfile, delimiter=';', lineterminator='\n') csvwriter.writerow([ 'DCID', 'DCName', 'Loc', 'LAN ID', 'LAN name', 'public', 'State', '# NICs', 'NIC ID', 'MAC address', 'DHCP', 'IP(s)', 'NIC name', 'Firewall', 'Connected to', 'ID', 'Name']) for dc in datacenters['items']: try: dc_net = get_dc_network(pbclient, dc) if verbose: print("DC %s has %i network entries" % (dc['id'], len(dc_net))) for row in dc_net: csvwriter.writerow(row) except Exception: traceback.print_exc() exit(2) # end for(datacenters) # just for fun: # if args.show_requests: # get_requests(pbclient) print("%s finished w/o errors" % program_name) return 0 except KeyboardInterrupt: # handle keyboard interrupt return 0 except Exception: traceback.print_exc() sys.stderr.write("\n" + program_name + ": for help use --help\n") return 2 if __name__ == "__main__": sys.exit(main()) profitbricks-sdk-python-3.1.0/examples/pb_deleteServer.py000066400000000000000000000267171304175001700236270ustar00rootroot00000000000000#!/usr/local/bin/python # encoding: utf-8 ''' pb_deleteServer -- remove a server completely pb_deleteServer is a tool to completely remove a server and attached volumes. @author: Jürgen Buchhammer @copyright: 2016 ProfitBricks GmbH. All rights reserved. @license: Apache License 2.0 @contact: juergen.buchhammer@profitbricks.com @deffield updated: Updated ''' import sys import os import traceback import time from argparse import ArgumentParser from argparse import RawDescriptionHelpFormatter from base64 import b64encode, b64decode from subprocess import call from profitbricks.client import ProfitBricksService __all__ = [] __version__ = 0.1 __date__ = '2016-02-25' __updated__ = '2016-02-25' class CLIError(Exception): '''Generic exception to raise and log different fatal errors.''' def __init__(self, msg): super(CLIError).__init__(type(self)) self.msg = "E: %s" % msg def __str__(self): return self.msg def __unicode__(self): return self.msg # end class CLIError def getLogin(filename, user, passwd): ''' write user/passwd to login file or get them from file. This method is not Py3 safe (byte vs. str) ''' if filename is None: return (user, passwd) if os.path.exists(filename): print("Using file {} for Login".format(filename)) with open(filename, "r") as loginfile: encoded_cred = loginfile.read() # print("encoded: {}".format(encoded_cred)) decoded_cred = b64decode(encoded_cred) login = decoded_cred.split(':', 1) return (login[0], login[1]) else: if user is None or passwd is None: raise ValueError("user and password must not be None") print("Writing file {} for Login".format(filename)) with open(filename, "w") as loginfile: encoded_cred = b64encode(user+":"+passwd) # print("encoded: {}".format(encoded_cred)) loginfile.write(encoded_cred) return (user, passwd) # end getLogin() def getServerInfo(pbclient=None, dc_id=None): ''' gets info of servers of a data center''' if pbclient is None: raise ValueError("argument 'pbclient' must not be None") if dc_id is None: raise ValueError("argument 'dc_id' must not be None") # list of all found server's info server_info = [] # depth 1 is enough for props/meta servers = pbclient.list_servers(dc_id, 1) for server in servers['items']: props = server['properties'] info = dict(id=server['id'], name=props['name'], state=server['metadata']['state'], vmstate=props['vmState']) server_info.append(info) # end for(servers) return(server_info) # end getServerInfo() def select_where(info=None, select=None, **where): if info is None: raise ValueError("argument 'info' must not be None") if len(info) == 0: return [] if select is None: select = info[0].keys() server_info = [] for old_si in info: w_matches = all(old_si[wk] == wv for (wk, wv) in where.items()) new_si = {k: v for (k, v) in old_si.items() if k in select and w_matches} if len(new_si) > 0: server_info.append(new_si) # end for(info) return(server_info) # end select_where() def getServerStates(pbclient=None, dc_id=None, serverid=None, servername=None): ''' gets states of a server''' if pbclient is None: raise ValueError("argument 'pbclient' must not be None") if dc_id is None: raise ValueError("argument 'dc_id' must not be None") server = None if serverid is None: if servername is None: raise ValueError("one of 'serverid' or 'servername' must be specified") # so, arg.servername is set (to whatever) server_info = select_where(getServerInfo(pbclient, dc_id), ['id', 'name', 'state', 'vmstate'], name=servername) if len(server_info) > 1: raise NameError("ambiguous server name '{}'".format(servername)) if len(server_info) == 1: server = server_info[0] else: # get by ID may also fail if it's removed # in this case, catch exception (message 404) and be quiet for a while # unfortunately this has changed from Py2 to Py3 try: server_info = pbclient.get_server(dc_id, serverid, 1) server = dict(id=server_info['id'], name=server_info['properties']['name'], state=server_info['metadata']['state'], vmstate=server_info['properties']['vmState']) except Exception: ex = sys.exc_info()[1] if ex.args[0] is not None and ex.args[0] == 404: print("Server w/ ID {} not found".format(serverid)) server = None else: raise ex # end try/except # end if/else(serverid) return server # end getServerStates() def wait_for_server(pbclient=None, dc_id=None, serverid=None, indicator='state', state='AVAILABLE', timeout=300): ''' wait for a server/VM to reach a defined state for a specified time indicator := {state|vmstate} specifies if server or VM stat is tested state specifies the status the indicator should have ''' if pbclient is None: raise ValueError("argument 'pbclient' must not be None") if dc_id is None: raise ValueError("argument 'dc_id' must not be None") if serverid is None: raise ValueError("argument 'serverid' must not be None") total_sleep_time = 0 seconds = 5 while total_sleep_time < timeout: time.sleep(seconds) total_sleep_time += seconds if total_sleep_time == 60: # Increase polling interval after one minute seconds = 10 elif total_sleep_time == 600: # Increase polling interval after 10 minutes seconds = 20 server = getServerStates(pbclient, dc_id, serverid) if server[indicator] == state: break # end while(total_sleep_time) return server # end wait_for_server() def wait_for_datacenter(client, data_center_id): ''' Poll the data center to become available (for the next provisionig job) ''' total_sleep_time = 0 seconds = 5 while True: state = client.get_datacenter(data_center_id)['metadata']['state'] if verbose: print("datacenter is {}".format(state)) if state == "AVAILABLE": break time.sleep(seconds) total_sleep_time += seconds if total_sleep_time == 60: # Increase polling interval after one minute seconds = 10 elif total_sleep_time == 600: # Increase polling interval after 10 minutes seconds = 20 # end wait_for_datacenter() def main(argv=None): '''Command line options.''' if argv is None: argv = sys.argv else: sys.argv.extend(argv) program_name = os.path.basename(sys.argv[0]) program_version = "v%s" % __version__ program_build_date = str(__updated__) program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date) program_shortdesc = __import__('__main__').__doc__.split("\n")[1] program_license = '''%s Created by J. Buchhammer on %s. Copyright 2016 ProfitBricks GmbH. All rights reserved. Licensed under the Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 Distributed on an "AS IS" basis without warranties or conditions of any kind, either express or implied. USAGE ''' % (program_shortdesc, str(__date__)) try: # Setup argument parser parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('-u', '--user', dest='user', help='the login name') parser.add_argument('-p', '--password', dest='password', help='the login password') parser.add_argument('-L', '--Login', dest='loginfile', default=None, help='the login file to use') parser.add_argument('-d', '--datacenterid', dest='dc_id', required=True, default=None, help='datacenter of the server') parser.add_argument('-s', '--serverid', dest='serverid', default=None, help='ID of the server') parser.add_argument('-n', '--name', dest='servername', default=None, help='name of the server') parser.add_argument('-C', '--command', dest='command', default=None, help='remote shell command to use for shutdown') parser.add_argument('-v', '--verbose', dest="verbose", action="count", help="set verbosity level [default: %(default)s]") parser.add_argument('-V', '--version', action='version', version=program_version_message) # Process arguments args = parser.parse_args() global verbose verbose = args.verbose dc_id = args.dc_id if verbose > 0: print("Verbose mode on") if args.serverid is None and args.servername is None: parser.error("one of 'serverid' or 'name' must be specified") (user, password) = getLogin(args.loginfile, args.user, args.password) if user is None or password is None: raise ValueError("user or password resolved to None") pbclient = ProfitBricksService(user, password) server = getServerStates(pbclient, dc_id, args.serverid, args.servername) if server is None: raise Exception(1, "specified server not found") print("using server {}(id={}) in state {}, {}" .format(server['name'], server['id'], server['state'], server['vmstate'])) # ! stop/start/reboot_server() simply return 'True' ! # this implies, that there's NO response nor requestId to track! if server['vmstate'] == 'SHUTOFF': print("VM is already shut off") else: if args.command is None: print("no command specified for shutdown of VM") else: print("executing {}".format(args.command)) cmdrc = call(args.command, shell=True) print("executing {} returned {}".format(args.command, cmdrc)) server = wait_for_server(pbclient, dc_id, server['id'], indicator='vmstate', state='SHUTOFF', timeout=300) # first we have to delete all attached volumes volumes = pbclient.get_attached_volumes(dc_id, server['id'], 0) for vol in volumes['items']: print("deleting volume {} of server {}" .format(vol['id'], server['name'])) pbclient.delete_volume(dc_id, vol['id']) pbclient.delete_server(dc_id, server['id']) wait_for_datacenter(pbclient, dc_id) except KeyboardInterrupt: # handle keyboard interrupt # return 0 except Exception: traceback.print_exc() sys.stderr.write("\n" + program_name + ": for help use --help\n") return 2 # end main() if __name__ == "__main__": sys.exit(main()) profitbricks-sdk-python-3.1.0/examples/pb_importVM.py000066400000000000000000000647561304175001700227600ustar00rootroot00000000000000#!/usr/local/bin/python # encoding: utf-8 ''' pb_importVM -- import a 3rd party VM pb_importVM is a tool to create a VM that comes from another virtualization solution. It reads out the meta data accompanying the disk files and creates a VM out of it. The disk images must be uploaded already. @author: Jürgen Buchhammer @copyright: 2016 ProfitBricks GmbH. All rights reserved. @license: Apache License 2.0 @contact: juergen.buchhammer@profitbricks.com @deffield updated: Updated ''' import sys import os import traceback from argparse import ArgumentParser from argparse import RawDescriptionHelpFormatter from time import sleep from base64 import b64decode, b64encode import xml.etree.ElementTree as ET from profitbricks.client import ProfitBricksService from profitbricks.client import Datacenter, Volume, Server from profitbricks.client import NIC __all__ = [] __version__ = 0.1 __date__ = '2016-09-30' __updated__ = '2016-09-30' class CLIError(Exception): '''Generic exception to raise and log different fatal errors.''' def __init__(self, msg): super(CLIError).__init__(type(self)) self.msg = "E: %s" % msg def __str__(self): return self.msg def __unicode__(self): return self.msg # end class CLIError def getLogin(filename, user, passwd): ''' write user/passwd to login file or get them from file. This method is not Py3 safe (byte vs. str) ''' if filename is None: return (user, passwd) isPy2 = sys.version_info[0] == 2 if os.path.exists(filename): print("Using file {} for Login".format(filename)) with open(filename, "r") as loginfile: encoded_cred = loginfile.read() print("encoded: {}".format(encoded_cred)) if isPy2: decoded_cred = b64decode(encoded_cred) else: decoded_cred = b64decode(encoded_cred).decode('utf-8') login = decoded_cred.split(':', 1) return (login[0], login[1]) else: if user is None or passwd is None: raise ValueError("user and password must not be None") print("Writing file {} for Login".format(filename)) with open(filename, "wb") as loginfile: creds = user+":"+passwd if isPy2: encoded_cred = b64encode(creds) else: encoded_cred = b64encode(creds.encode('utf-8')) print("encoded: {}".format(encoded_cred)) loginfile.write(encoded_cred) return (user, passwd) # end getLogin() def wait_for_request(pbclient, request_id, timeout=0, initial_wait=5, scaleup=10): ''' Waits for a request to finish until timeout. timeout==0 is interpreted as infinite wait time. Returns a tuple (return code, request status, message) where return code 0 : request successful 1 : request failed -1 : timeout exceeded The wait_period is increased every scaleup steps to adjust for long running requests. ''' total_wait = 0 wait_period = initial_wait next_scaleup = scaleup * wait_period wait = True while wait: request_status = pbclient.get_request(request_id, status=True) state = request_status['metadata']['status'] if state == "DONE": return(0, state, request_status['metadata']['message']) if state == 'FAILED': return(1, state, request_status['metadata']['message']) print("Request '{}' is in state '{}'. Sleeping for {} seconds..." .format(request_id, state, wait_period)) sleep(wait_period) total_wait += wait_period if timeout != 0 and total_wait > timeout: wait = False next_scaleup -= wait_period if next_scaleup == 0: wait_period += initial_wait next_scaleup = scaleup * wait_period print("scaling up wait_period to {}, next change in {} seconds" .format(wait_period, next_scaleup)) # end while(wait) return(-1, state, "request not finished before timeout") # end wait_for_request() def wait_for_requests(pbclient, request_ids=[], timeout=0, initial_wait=5, scaleup=10): ''' Waits for a list of requests to finish until timeout. timeout==0 is interpreted as infinite wait time. Returns a dict of request_id -> result. result is a tuple (return code, request status, message) where return code 0 : request successful 1 : request failed -1 : timeout exceeded The wait_period is increased every scaleup steps to adjust for long running requests. ''' done = dict() if len(request_ids) == 0: print("empty request list") return done total_wait = 0 wait_period = initial_wait next_scaleup = scaleup * wait_period wait = True while wait: for request_id in request_ids: if request_id in done: continue request_status = pbclient.get_request(request_id, status=True) state = request_status['metadata']['status'] if state == "DONE": done[request_id] = (0, state, request_status['metadata']['message']) print("Request '{}' is in state '{}'.".format(request_id, state)) if state == 'FAILED': done[request_id] = (1, state, request_status['metadata']['message']) print("Request '{}' is in state '{}'.".format(request_id, state)) # end for(request_ids) if len(done) == len(request_ids): wait = False else: print("{} of {} requests are finished. Sleeping for {} seconds..." .format(len(done), len(request_ids), wait_period)) sleep(wait_period) total_wait += wait_period if timeout != 0 and total_wait > timeout: wait = False next_scaleup -= wait_period if next_scaleup == 0: wait_period += initial_wait next_scaleup = scaleup * wait_period print("scaling up wait_period to {}, next change in {} seconds" .format(wait_period, next_scaleup)) # end if/else(done) # end while(wait) if len(done) != len(request_ids): for request_id in request_ids: if request_id in done: continue done[request_id] = (-1, state, "request not finished before timeout") return done # end wait_for_requests() def get_disk_image_by_name(pbclient, location, image_name): """ Returns all disk images within a location with a given image name. The name must match exactly. The list may be empty. """ all_images = pbclient.list_images() matching = [i for i in all_images['items'] if i['properties']['name'] == image_name and i['properties']['imageType'] == "HDD" and i['properties']['location'] == location] return matching # end get_disk_image_by_name() # -- OVF parsing -- class OFVData(): '''OFV meta data - the data is only available after calling OFVData.parse''' def __init__(self, file=None): '''OVF meta data initializer''' # namespaces, dflt is default namespace xmlns, others are xmlns: # @TODO: read these from because version may change # e.g. OVF 2.0 exists: xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/2" self._ns = { # 'dflt': "http://schemas.dmtf.org/ovf/envelope/1", # same as ovf!?! 'cim': "http://schemas.dmtf.org/wbem/wscim/1/common", 'ovf': "http://schemas.dmtf.org/ovf/envelope/1", 'rasd': "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/" "CIM_ResourceAllocationSettingData", 'vmw': "http://www.vmware.com/schema/ovf", 'vssd': "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/" "CIM_VirtualSystemSettingData" } self.file = file self.root = None self.name = None self.osid = None self.licenseType = "OTHER" self.cpus = None self.ram = None self.disks = [] self.lans = dict() self.nics = [] self.resourceTypes = { '1': 'Other', '2': 'Computer System', '3': 'Processor', '4': 'Memory', '5': 'IDE Controller', '6': 'Parallel SCSI HBA', '7': 'FC HBA', '8': 'iSCSI HBA', '9': 'IB HCA', '10': 'Ethernet Adapter', '11': 'Other Network Adapter', '12': 'I/O Slot', '13': 'I/O Device', '14': 'Floppy Drive', '15': 'CD Drive', '16': 'DVD drive', '17': 'Disk Drive', '18': 'Tape Drive', '19': 'Storage Extent', '20': 'Other storage device', '21': 'Serial port', '22': 'Parallel port', '23': 'USB Controller', '24': 'Graphics controller', '25': 'IEEE 1394 Controller', '26': 'Partitionable Unit', '27': 'Base Partitionable Unit', '28': 'Power', '29': 'Cooling Capacity', '30': 'Ethernet Switch Port', '31': 'Logical Disk', '32': 'Storage Volume', '33': 'Ethernet Connection', '..': 'DMTF reserved', '0x8000..0xFFFF': 'Vendor Reserved' } # end resourceType self.osTypeOther = { '0': 'Unknown', '1': 'Other', '2': 'MACOS', '3': 'ATTUNIX', '4': 'DGUX', '5': 'DECNT', '6': 'Tru64 UNIX', '7': 'OpenVMS', '8': 'HPUX', '9': 'AIX', '10': 'MVS', '11': 'OS400', '12': 'OS/2', '13': 'JavaVM', '14': 'MSDOS', '15': 'WIN3x', '16': 'WIN95', '17': 'WIN98', '18': 'WINNT', '19': 'WINCE', '20': 'NCR3000', '21': 'NetWare', '22': 'OSF', '23': 'DC/OS', '24': 'Reliant UNIX', '25': 'SCO UnixWare', '26': 'SCO OpenServer', '27': 'Sequent', '28': 'IRIX', '29': 'Solaris', '30': 'SunOS', '31': 'U6000', '32': 'ASERIES', '33': 'HP NonStop OS', '34': 'HP NonStop OSS', '35': 'BS2000', '37': 'Lynx', '38': 'XENIX', '39': 'VM', '40': 'Interactive UNIX', '41': 'BSDUNIX', '42': 'FreeBSD', '43': 'NetBSD', '44': 'GNU Hurd', '45': 'OS9', '46': 'MACH Kernel', '47': 'Inferno', '48': 'QNX', '49': 'EPOC', '50': 'IxWorks', '51': 'VxWorks', '52': 'MiNT', '53': 'BeOS', '54': 'HP MPE', '55': 'NextStep', '56': 'PalmPilot', '57': 'Rhapsody', '59': 'Dedicated', '60': 'OS/390', '61': 'VSE', '62': 'TPF', '64': 'Caldera Open UNIX', '65': 'OpenBSD', '66': 'Not Applicable', '68': 'z/OS', '78': 'FreeBSD 64-Bit', '81': 'Solaris 64-Bit', '86': 'Novell OES', '87': 'Novell Linux Desktop', '88': 'Sun Java Desktop System', '102': 'Other 64-Bit', '104': 'VMware ESXi', '110': 'eComStation 32-bitx', } # end osTypeOther self.osTypeLinux = { '36': 'LINUX', '79': 'RedHat Enterprise Linux', '80': 'RedHat Enterprise Linux 64-Bit', '82': 'SUSE', '83': 'SUSE 64-Bit', '84': 'SLES', '85': 'SLES 64-Bit', '89': 'Mandriva', '90': 'Mandriva 64-Bit', '91': 'TurboLinux', '92': 'TurboLinux 64-Bit', '93': 'Ubuntu', '94': 'Ubuntu 64-Bit', '95': 'Debian', '96': 'Debian 64-Bit', '97': 'Linux 2.4.x', '98': 'Linux 2.4.x 64-Bit', '99': 'Linux 2.6.x', '100': 'Linux 2.6.x 64-Bit', '101': 'Linux 64-Bit', '106': 'CentOS 32-bit', '107': 'CentOS 64-bit', '108': 'Oracle Linux 32-bit', '109': 'Oracle Linux 64-bit', } # end osTypeLinux self.osTypeWindows = { '58': 'Windows 2000', '63': 'Windows (R) Me', '67': 'Windows XP', '69': 'Microsoft Windows Server 2003', '70': 'Microsoft Windows Server 2003 64-Bit', '71': 'Windows XP 64-Bit', '72': 'Windows XP Embedded', '73': 'Windows Vista', '74': 'Windows Vista 64-Bit', '75': 'Windows Embedded for Point of Service', '76': 'Microsoft Windows Server 2008', '77': 'Microsoft Windows Server 2008 64-Bit', '103': 'Microsoft Windows Server 2008 R2', '105': 'Microsoft Windows 7', '111': 'Microsoft Windows Server 2011', '113': 'Microsoft Windows Server 2012', '114': 'Microsoft Windows 8', '115': 'Microsoft Windows 8 64-bit', '116': 'Microsoft Windows Server 2012 R2' } # end osTypeWindows # end __init__() def parse(self): tree = ET.parse(self.file) self.root = tree.getroot() print("parsed file, root element is '{} w/ attributes {}" .format(self.root.tag, self.root.attrib)) self._collect_system_data() self._collect_disk_data() self._collect_nic_data() # end parse() def _nsattr(self, attr, ns=None): ''' returns an attribute name w/ namespace prefix''' if ns is None: return attr else: return '{'+self._ns[ns]+'}'+attr # end _nsattr() def _collect_system_data(self): virtsys = self.root.find('ovf:VirtualSystem', self._ns) self.name = virtsys.find('ovf:Name', self._ns).text virtos = virtsys.find('ovf:OperatingSystemSection', self._ns) self.osid = virtos.get(self._nsattr('id', 'ovf')) if self.osid in self.osTypeLinux: self.licenseType = "LINUX" osname = self.osTypeLinux[self.osid] else: if self.osid in self.osTypeWindows: self.licenseType = "WINDOWS" osname = self.osTypeWindows[self.osid] else: osname = self.osTypeOther[self.osid] print("VM '{}' has {}-type OS '{}'(id:{})" .format(self.name, self.licenseType, osname, self.osid)) virtcpu = virtsys.find('./ovf:VirtualHardwareSection/ovf:Item/[rasd:ResourceType="3"]', self._ns) self.cpus = virtcpu.find('rasd:VirtualQuantity', self._ns).text # !!! VMware also as vmw:CoresPerSocket !!! # we currently exclude this, so there may be cores missing in VM! virtmem = virtsys.find('./ovf:VirtualHardwareSection/ovf:Item/[rasd:ResourceType="4"]', self._ns) # we assume that RAM is specified in MB (or 'byte * 2^20') self.ram = virtmem.find('rasd:VirtualQuantity', self._ns).text print("VM '{}' has {} CPUs and {} MB RAM" .format(self.name, self.cpus, self.ram)) # end _collect_system_data() # get the disks def _collect_disk_data(self): filerefs = self.root.findall('./ovf:References/ovf:File', self._ns) files = dict() for ref in filerefs: name = ref.get(self._nsattr('href', 'ovf')) fileid = ref.get(self._nsattr('id', 'ovf')) files[fileid] = name print("found filerefs {}".format(files)) diskrefs = self.root.findall('./ovf:DiskSection/ovf:Disk', self._ns) disks = dict() for ref in diskrefs: # Note: we assume ovf:capacityAllocationUnits="byte * 2^30" == GiB capacity = ref.get(self._nsattr('capacity', 'ovf')) # reference to file references above fref = ref.get(self._nsattr('fileRef', 'ovf')) # the virt. HW section refers to '/disk/vmdisk1' not 'vmdisk1' diskid = 'ovf:/disk/'+ref.get(self._nsattr('diskId', 'ovf')) # we resolve fref here, we only need the name from now on disks[diskid] = {'capacity': capacity, 'file': files[fref]} print("found disks {}".format(disks)) virtsys = self.root.find('ovf:VirtualSystem', self._ns) virthds = virtsys.findall('./ovf:VirtualHardwareSection/ovf:Item/[rasd:ResourceType="17"]', self._ns) devices = dict() for hdd in virthds: # print("hdd is {}".format(hdd)) diskref = hdd.find('rasd:HostResource', self._ns).text address = hdd.find('rasd:AddressOnParent', self._ns) if address is None: print("no address for sorting found for {}, use InstanceId" .format(diskref)) devNr = hdd.find('rasd:InstanceId', self._ns).text print("disk {} has InstanceId {}".format(diskref, devNr)) else: devNr = address.text print("disk {} has address {}".format(diskref, devNr)) devices[devNr] = disks[diskref] print("devices : {}".format(devices)) self.disks = [devices[dev_no] for dev_no in sorted(devices)] print("disks : {}".format(self.disks)) # end _collect_disk_data() # get the nics def _collect_nic_data(self): # the NetworkSection contains only name and description # maybe that helps for better LAN assignment one day vnets = self.root.findall('./ovf:NetworkSection/ovf:Network', self._ns) lanid = 1 for net in vnets: self.lans[net.get(self._nsattr('name', 'ovf'))] = lanid lanid += 1 print("LANs found: {}".format(self.lans)) virtsys = self.root.find('ovf:VirtualSystem', self._ns) virtnics = virtsys.findall( './ovf:VirtualHardwareSection/ovf:Item/[rasd:ResourceType="10"]', self._ns) devices = dict() for nic in virtnics: # print("nic is {}".format(nic)) nicname = nic.find('rasd:ElementName', self._ns).text connection = nic.find('rasd:Connection', self._ns).text address = nic.find('rasd:AddressOnParent', self._ns) if address is None: print("no address for sorting found for {}, use InstanceId" .format(nicname)) devNr = nic.find('rasd:InstanceId', self._ns).text print("nic '{}' has InstanceId {}".format(nicname, devNr)) else: devNr = address.text print("nic '{}' has address {}".format(nicname, devNr)) devices[devNr] = {'nic': nicname, 'lan': connection, 'lanid': self.lans[connection]} print("devices : {}".format(devices)) self.nics = [devices[dev_no] for dev_no in sorted(devices)] print("nics : {}".format(self.nics)) # end _collect_nic_data() # end class OVFData # -- MAIN -- def main(argv=None): '''Command line options.''' if argv is None: argv = sys.argv else: sys.argv.extend(argv) program_name = os.path.basename(sys.argv[0]) program_version = "v%s" % __version__ program_build_date = str(__updated__) program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date) program_shortdesc = __import__('__main__').__doc__.split("\n")[1] program_license = '''%s Created by Jürgen Buchhammer on %s. Copyright 2016 ProfitBricks GmbH. All rights reserved. Licensed under the Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 Distributed on an "AS IS" basis without warranties or conditions of any kind, either express or implied. USAGE ''' % (program_shortdesc, str(__date__)) try: # Setup argument parser parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('-u', '--user', dest='user', help='the login name') parser.add_argument('-p', '--password', dest='password', help='the login password') parser.add_argument('-L', '--Login', dest='loginfile', default=None, help='the login file to use') parser.add_argument('-t', '--type', dest='metatype', default="OVF", help='type of VM meta data') parser.add_argument('-m', '--metadata', dest='metafile', required=True, default=None, help='meta data file') parser.add_argument('-d', '--datacenterid', dest='datacenterid', default=None, help='datacenter of the new server') parser.add_argument('-D', '--DCname', dest='dcname', default=None, help='new datacenter name') parser.add_argument('-l', '--location', dest='location', default=None, help='location for new datacenter') parser.add_argument('-v', '--verbose', dest="verbose", action="count", default=0, help="set verbosity level [default: %(default)s]") parser.add_argument('-V', '--version', action='version', version=program_version_message) # Process arguments args = parser.parse_args() global verbose verbose = args.verbose if verbose > 0: print("Verbose mode on") print("start {} with args {}".format(program_name, str(args))) (user, password) = getLogin(args.loginfile, args.user, args.password) if user is None or password is None: raise ValueError("user or password resolved to None") pbclient = ProfitBricksService(user, password) if args.metatype == 'OVF': metadata = OFVData(args.metafile) metadata.parse() else: sys.stderr.write("Metadata type '{}' is not supported" .format(args.metatype)) return 1 # we need the DC first to have the location defined dc_id = None if args.datacenterid is None: if args.dcname is None or args.location is None: sys.stderr.write("Either '-d ' or '-D -l ' must be specified") return 1 # else: we will create the DC later after parsing the meta data else: dc_id = args.datacenterid if dc_id is None: location = args.location dc = Datacenter(name=args.dcname, location=location, description="created by pb_importVM") print("create new DC {}".format(str(dc))) response = pbclient.create_datacenter(dc) dc_id = response['id'] result = wait_for_request(pbclient, response['requestId']) print("wait loop returned {}".format(result)) else: dc = pbclient.get_datacenter(dc_id) location = dc['properties']['location'] print("use existing DC {} in location {}" .format(dc['properties']['name'], location)) # check if images exist for disk in metadata.disks: disk_name = disk['file'] images = get_disk_image_by_name(pbclient, location, disk_name) if len(images) == 0: raise ValueError("No HDD image with name '{}' found in location {}" .format(disk_name, location)) if len(images) > 1: raise ValueError("Ambigous image name '{}' in location {}" .format(disk_name, location)) disk['image'] = images[0]['id'] # now we're ready to create the VM # Server server = Server(name=metadata.name, cores=metadata.cpus, ram=metadata.ram) print("create server {}".format(str(Server))) response = pbclient.create_server(dc_id, server) srv_id = response['id'] result = wait_for_request(pbclient, response['requestId']) print("wait loop returned {}".format(str(result))) # NICs (note that createing LANs may be implicit) for nic in metadata.nics: dcnic = NIC(name=nic['nic'], lan=nic['lanid']) print("create NIC {}".format(str(dcnic))) response = pbclient.create_nic(dc_id, srv_id, dcnic) nic_id = response['id'] result = wait_for_request(pbclient, response['requestId']) print("wait loop returned {}".format(str(result))) response = pbclient.get_nic(dc_id, srv_id, nic_id, 2) mac = response['properties']['mac'] print("dcnic has MAC {} for {}".format(mac, nic_id)) # end for(nics) # Volumes (we use the image name as volume name too requests = [] for disk in metadata.disks: dcvol = Volume(name=disk['file'], size=disk['capacity'], image=disk['image'], licence_type=metadata.licenseType) print("create Volume {}".format(str(dcvol))) response = pbclient.create_volume(dc_id, dcvol) requests.append(response['requestId']) disk['volume_id'] = response['id'] # end for(disks) if len(requests) != 0: result = wait_for_requests(pbclient, requests, initial_wait=10, scaleup=15) print("wait loop returned {}".format(str(result))) for disk in metadata.disks: print("attach volume {}".format(disk)) response = pbclient.attach_volume(dc_id, srv_id, disk['volume_id']) result = wait_for_request(pbclient, response['requestId']) print("wait loop returned {}".format(str(result))) # end for(disks) print("import of VM succesfully finished") return 0 except KeyboardInterrupt: # handle keyboard interrupt return 0 except Exception: traceback.print_exc() sys.stderr.write("\n" + program_name + ": for help use --help\n") return 2 # end main() if __name__ == "__main__": sys.exit(main()) profitbricks-sdk-python-3.1.0/examples/pb_snapshotDatacenter.py000066400000000000000000000546121304175001700250230ustar00rootroot00000000000000#!/usr/local/bin/python # encoding: utf-8 ''' pb_snapshotDatacenter is a sample script to make a snapshot of a complete datacenter. pb_snapshotDatacenter - makes a snap shot of each server volume - dumps the datacenter inventory to a file You can use this information to restore or clone a datacenter or use it as a starting point for new data centers. @author: Jürgen Buchhammer @copyright: 2016 ProfitBricks GmbH. All rights reserved. @license: Apache License 2.0 @contact: juergen.buchhammer@profitbricks.com @deffield updated: Updated ''' import sys import os import traceback from argparse import ArgumentParser from argparse import RawDescriptionHelpFormatter from datetime import datetime from time import sleep import json from base64 import b64decode, b64encode from profitbricks.client import ProfitBricksService __all__ = [] __version__ = 0.1 __date__ = '2016-09-02' __updated__ = '2016-09-02' class CLIError(Exception): '''Generic exception to raise and log different fatal errors.''' def __init__(self, msg): super(CLIError).__init__(type(self)) self.msg = "E: %s" % msg def __str__(self): return self.msg def __unicode__(self): return self.msg # end class CLIError def getLogin(filename, user, passwd): ''' write user/passwd to login file or get them from file. This method is not Py3 safe (byte vs. str) ''' if filename is None: return (user, passwd) isPy2 = sys.version_info[0] == 2 if os.path.exists(filename): print("Using file {} for Login".format(filename)) with open(filename, "r") as loginfile: encoded_cred = loginfile.read() print("encoded: {}".format(encoded_cred)) if isPy2: decoded_cred = b64decode(encoded_cred) else: decoded_cred = b64decode(encoded_cred).decode('utf-8') login = decoded_cred.split(':', 1) return (login[0], login[1]) else: if user is None or passwd is None: raise ValueError("user and password must not be None") print("Writing file {} for Login".format(filename)) with open(filename, "wb") as loginfile: creds = user+":"+passwd if isPy2: encoded_cred = b64encode(creds) else: encoded_cred = b64encode(creds.encode('utf-8')) print("encoded: {}".format(encoded_cred)) loginfile.write(encoded_cred) return (user, passwd) # end getLogin() def write_dc_definition(pbclient, dcdef=None, filename=None): with open(filename, 'w') as outfile: json.dump(dcdef, outfile, indent=2) return 0 # end write_dc_definition() def read_dc_definition(pbclient, filename=None): with open(filename) as infile: dcdef = json.load(infile) return dcdef # end read_dc_definition() # --- request status (see pb_createDatacenter.py) def wait_for_request(pbclient, request_id, timeout=0, initial_wait=5, scaleup=10): ''' Waits for a request to finish until timeout. timeout==0 is interpreted as infinite wait time. Returns a tuple (return code, request status, message) where return code 0 : request successful 1 : request failed -1 : timeout exceeded The wait_period is increased every scaleup steps to adjust for long running requests. ''' total_wait = 0 wait_period = initial_wait next_scaleup = scaleup * wait_period wait = True while wait: request_status = pbclient.get_request(request_id, status=True) state = request_status['metadata']['status'] if state == "DONE": return(0, state, request_status['metadata']['message']) if state == 'FAILED': return(1, state, request_status['metadata']['message']) print("Request '{}' is in state '{}'. Sleeping for {} seconds..." .format(request_id, state, wait_period)) sleep(wait_period) total_wait += wait_period if timeout != 0 and total_wait > timeout: wait = False next_scaleup -= wait_period if next_scaleup == 0: wait_period += initial_wait next_scaleup = scaleup * wait_period print("scaling up wait_period to {}, next change in {} seconds" .format(wait_period, next_scaleup)) # end while(wait) return(-1, state, "request not finished before timeout") # end wait_for_request() def wait_for_requests(pbclient, request_ids=[], timeout=0, initial_wait=5, scaleup=10): ''' Waits for a list of requests to finish until timeout. timeout==0 is interpreted as infinite wait time. Returns a dict of request_id -> result. result is a tuple (return code, request status, message) where return code 0 : request successful 1 : request failed -1 : timeout exceeded The wait_period is increased every scaleup steps to adjust for long running requests. ''' done = dict() if len(request_ids) == 0: print("empty request list") return done total_wait = 0 wait_period = initial_wait next_scaleup = scaleup * wait_period wait = True while wait: for request_id in request_ids: if request_id in done: continue request_status = pbclient.get_request(request_id, status=True) state = request_status['metadata']['status'] if state == "DONE": done[request_id] = (0, state, request_status['metadata']['message']) print("Request '{}' is in state '{}'.".format(request_id, state)) if state == 'FAILED': done[request_id] = (1, state, request_status['metadata']['message']) print("Request '{}' is in state '{}'.".format(request_id, state)) # end for(request_ids) if len(done) == len(request_ids): wait = False else: print("{} of {} requests are finished. Sleeping for {} seconds..." .format(len(done), len(request_ids), wait_period)) sleep(wait_period) total_wait += wait_period if timeout != 0 and total_wait > timeout: wait = False next_scaleup -= wait_period if next_scaleup == 0: wait_period += initial_wait next_scaleup = scaleup * wait_period print("scaling up wait_period to {}, next change in {} seconds" .format(wait_period, next_scaleup)) # end if/else(done) # end while(wait) if len(done) != len(request_ids): for request_id in request_ids: if request_id in done: continue done[request_id] = (-1, state, "request not finished before timeout") return done # end wait_for_requests() # ---- server states and control (see pb_controlServerStates.py) def getServerInfo(pbclient=None, dc_id=None): ''' gets info of servers of a data center''' if pbclient is None: raise ValueError("argument 'pbclient' must not be None") if dc_id is None: raise ValueError("argument 'dc_id' must not be None") # list of all found server's info server_info = [] # depth 1 is enough for props/meta servers = pbclient.list_servers(dc_id, 1) for server in servers['items']: props = server['properties'] info = dict(id=server['id'], name=props['name'], state=server['metadata']['state'], vmstate=props['vmState']) server_info.append(info) # end for(servers) return(server_info) # end getServerInfo() def select_where(info=None, select=None, **where): if info is None: raise ValueError("argument 'info' must not be None") if len(info) == 0: return [] if select is None: select = info[0].keys() server_info = [] for old_si in info: w_matches = all(old_si[wk] == wv for (wk, wv) in where.items()) new_si = {k: v for (k, v) in old_si.items() if k in select and w_matches} if len(new_si) > 0: server_info.append(new_si) # end for(info) return(server_info) # end select_where() def getServerStates(pbclient=None, dc_id=None, serverid=None, servername=None): ''' gets states of a server''' if pbclient is None: raise ValueError("argument 'pbclient' must not be None") if dc_id is None: raise ValueError("argument 'dc_id' must not be None") server = None if serverid is None: if servername is None: raise ValueError("one of 'serverid' or 'servername' must be specified") # so, arg.servername is set (to whatever) server_info = select_where(getServerInfo(pbclient, dc_id), ['id', 'name', 'state', 'vmstate'], name=servername) if len(server_info) > 1: raise NameError("ambiguous server name '{}'".format(servername)) if len(server_info) == 1: server = server_info[0] else: # get by ID may also fail if it's removed # in this case, catch exception (message 404) and be quiet for a while # unfortunately this has changed from Py2 to Py3 try: server_info = pbclient.get_server(dc_id, serverid, 1) server = dict(id=server_info['id'], name=server_info['properties']['name'], state=server_info['metadata']['state'], vmstate=server_info['properties']['vmState']) except Exception: ex = sys.exc_info()[1] if ex.args[0] is not None and ex.args[0] == 404: print("Server w/ ID {} not found".format(serverid)) server = None else: raise ex # end try/except # end if/else(serverid) return server # end getServerStates() def wait_for_server(pbclient=None, dc_id=None, serverid=None, indicator='state', state='AVAILABLE', timeout=300): ''' wait for a server/VM to reach a defined state for a specified time indicator := {state|vmstate} specifies if server or VM stat is tested state specifies the status the indicator should have ''' if pbclient is None: raise ValueError("argument 'pbclient' must not be None") if dc_id is None: raise ValueError("argument 'dc_id' must not be None") if serverid is None: raise ValueError("argument 'serverid' must not be None") total_sleep_time = 0 seconds = 5 while total_sleep_time < timeout: sleep(seconds) total_sleep_time += seconds if total_sleep_time == 60: # Increase polling interval after one minute seconds = 10 elif total_sleep_time == 600: # Increase polling interval after 10 minutes seconds = 20 server = getServerStates(pbclient, dc_id, serverid) if server[indicator] == state: break # end while(total_sleep_time) return server # end wait_for_server() def controlServerState(pbclient=None, dc_id=None, serverid=None, servername=None, action=None): server = getServerStates(pbclient, dc_id, serverid, servername) if server is None: raise Exception(1, "specified server not found") print("using server {}(id={}) in state {}, {}" .format(server['name'], server['id'], server['state'], server['vmstate'])) # !!! stop/start/reboot_server() simply return 'True' !!! # this implies, that there's NO response nor requestId to track! if action == 'POWEROFF': if server['state'] == 'INACTIVE': print("server is already powered off") else: # currently use 'forced' poweroff if server['vmstate'] != 'SHUTOFF': print("VM is in state {}, {} may lead to inconsistent state" .format(server['vmstate'], action)) pbclient.stop_server(dc_id, server['id']) server = wait_for_server(pbclient, dc_id, server['id'], state='INACTIVE', timeout=300) elif action == 'POWERON': if server['vmstate'] == 'RUNNING': print("VM is already up and running") else: pbclient.start_server(dc_id, server['id']) server = wait_for_server(pbclient, dc_id, server['id'], indicator='vmstate', state='RUNNING', timeout=300) elif action == 'START': # this is the same as POWERON if server['vmstate'] == 'RUNNING': print("VM is already up and running") else: pbclient.start_server(dc_id, server['id']) server = wait_for_server(pbclient, dc_id, server['id'], indicator='vmstate', state='RUNNING', timeout=300) elif action == 'SHUTOFF': if server['vmstate'] == 'SHUTOFF': print("VM is already shut off") else: print("no command specified for shutdown of VM") # end if/else(action) print("server {}(id={}) now in state {}, {}" .format(server['name'], server['id'], server['state'], server['vmstate'])) # end controlServerState() def main(argv=None): '''Parse command line options and dump a datacenter to snapshots and file.''' if argv is None: argv = sys.argv else: sys.argv.extend(argv) program_name = os.path.basename(sys.argv[0]) program_version = "v%s" % __version__ program_build_date = str(__updated__) program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date) program_shortdesc = __import__('__main__').__doc__.split("\n")[1] program_license = '''%s Created by J. Buchhammer on %s. Copyright 2016 ProfitBricks GmbH. All rights reserved. Licensed under the Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 Distributed on an "AS IS" basis without warranties or conditions of any kind, either express or implied. USAGE ''' % (program_shortdesc, str(__date__)) try: # Setup argument parser parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('-u', '--user', dest='user', help='the login name') parser.add_argument('-p', '--password', dest='password', help='the login password') parser.add_argument('-L', '--Login', dest='loginfile', default=None, help='the login file to use') parser.add_argument('-d', '--datacenterid', dest='dc_id', required=True, default=None, help='datacenter ID of the server') parser.add_argument('-o', '--outfile', dest='outfile', default='dc-def_'+datetime.now().strftime('%Y-%m-%d_%H%M%S'), help='the output file name') parser.add_argument('-S', '--Stopalways', dest='stopalways', action='store_true', help='power off even when VM is running') parser.add_argument('-v', '--verbose', dest="verbose", action="count", default=0, help="set verbosity level [default: %(default)s]") parser.add_argument('-V', '--version', action='version', version=program_version_message) # Process arguments args = parser.parse_args() global verbose verbose = args.verbose if verbose > 0: print("Verbose mode on") print("start {} with args {}".format(program_name, str(args))) outfile = args.outfile if outfile.endswith(".json"): outfile = os.path.splitext(outfile) print("Using output file base name '{}'".format(outfile)) (user, password) = getLogin(args.loginfile, args.user, args.password) if user is None or password is None: raise ValueError("user or password resolved to None") pbclient = ProfitBricksService(user, password) dc_id = args.dc_id # first get all server's VM and OS state to see if we can start srv_info = getServerInfo(pbclient, dc_id) srvon = 0 for server in srv_info: if server['vmstate'] != 'SHUTOFF': print("VM {} is in state {}, but should be SHUTOFF" .format(server['name'], server['vmstate'])) srvon += 1 # end for(srv_info) if srvon > 0 and not args.stopalways: print("shutdown running OS before trying again") return 1 # now power off all VMs before starting the snapshots for server in srv_info: controlServerState(pbclient, dc_id, server['id'], action='POWEROFF') # now let's go dcdef = pbclient.get_datacenter(dc_id, 5) print("starting dump of datacenter {}".format(dcdef['properties']['name'])) dcdef_file = outfile+'_source.json' print("write source dc to {}".format(dcdef_file)) write_dc_definition(pbclient, dcdef, dcdef_file) print("get existing Snapshots") # first get existing snapshots known_snapshots = dict() snapshots = pbclient.list_snapshots() for snap in snapshots['items']: print("SNAP : {}".format(json.dumps(snap))) known_snapshots[snap['properties']['name']] = snap['id'] print("create Snapshots, this may take a while ..") # we do NOT consider dangling volumes, only server-attached ones vol_snapshots = dict() # map volume id==snapshot name snapshot id for server in dcdef['entities']['servers']['items']: print("- server {}".format(server['properties']['name'])) if 'volumes' not in server['entities']: print(" server {} has no volumes" .format(server['properties']['name'])) continue # The volumes are attached by order of creation # Thus we must sort them to keep the order in the clone print("setting volume order by deviceNumber") volumes = server['entities']['volumes']['items'] new_order = sorted(volumes, key=lambda vol: vol['properties']['deviceNumber']) server['entities']['volumes']['items'] = new_order for volume in server['entities']['volumes']['items']: vol_id = volume['id'] # this will be the name too if vol_id in known_snapshots: print("use existing snapshot {} of volume {}" .format(vol_id, volume['properties']['name'])) vol_snapshots[vol_id] = known_snapshots[vol_id] else: print("taking snapshot {} of volume {}" .format(vol_id, volume['properties']['name'])) response = pbclient.create_snapshot(dc_id, vol_id, vol_id, "auto-created by pb_snapshotDatacenter") # response has no request id, need to check metadata state (BUSY, AVAILABLE..) vol_snapshots[vol_id] = response['id'] print("snapshot in progress: {}".format(str(response))) # end for(volume) # end for(server) print("Waiting for snapshots to complete") snapdone = dict() while len(snapdone) != len(vol_snapshots): sleep(10) for snap_id in vol_snapshots.values(): print("looking for {}".format(snap_id)) if snap_id in snapdone: continue snapshot = pbclient.get_snapshot(snap_id) print("snapshot {} is in state {}" .format(snap_id, snapshot['metadata']['state'])) if snapshot['metadata']['state'] == 'AVAILABLE': snapdone[snap_id] = snapshot['metadata']['state'] # end for(vol_snapshots) # end while(snapdone) # now replace the volumes image IDs print("setting snapshot id to volumes") for server in dcdef['entities']['servers']['items']: print("- server {}".format(server['properties']['name'])) if 'volumes' not in server['entities']: print(" server {} has no volumes" .format(server['properties']['name'])) continue for volume in server['entities']['volumes']['items']: vol_id = volume['id'] # this will be the name too volume['properties']['image'] = vol_snapshots[vol_id] # end for(volume) # end for(server) # As it came out, the LAN id is rearranged by order of creation # Thus we must sort the LANs to keep the order in the clone print("setting LAN order by id") lans = dcdef['entities']['lans']['items'] new_order = sorted(lans, key=lambda lan: lan['id']) dcdef['entities']['lans']['items'] = new_order # now sort unordered NICs by MAC and save the dcdef # reason is, that NICs seem to be ordered by MAC, but API response # doesn't guarantee the order, which we need for re-creation print("setting NIC order by MAC") for server in dcdef['entities']['servers']['items']: print("- server {}".format(server['properties']['name'])) if 'nics' not in server['entities']: print(" server {} has no nics" .format(server['properties']['name'])) continue nics = server['entities']['nics']['items'] # print("NICs before {}".format(json.dumps(nics))) new_order = sorted(nics, key=lambda nic: nic['properties']['mac']) # print("NICs after {}".format(json.dumps(new_order))) server['entities']['nics']['items'] = new_order # end for(server) dcdef_file = outfile+'.json' print("write snapshot dc to {}".format(dcdef_file)) write_dc_definition(pbclient, dcdef, dcdef_file) return 0 except KeyboardInterrupt: # handle keyboard interrupt return 0 except Exception: traceback.print_exc() sys.stderr.write("\n" + program_name + ": for help use --help\n") return 2 if __name__ == "__main__": sys.exit(main()) profitbricks-sdk-python-3.1.0/examples/server_example.py000066400000000000000000000173551304175001700235340ustar00rootroot00000000000000"""Create Simple Server """ from profitbricks.client import ProfitBricksService from profitbricks.client import Server server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService( username='username', password='password') i = Server( name='server', ram=4096, cores=4 ) response = client.create_server( datacenter_id=datacenter_id, server=i) """Create Complex Server """ from profitbricks.client import ProfitBricksService # noqa from profitbricks.client import Server, NIC, Volume # noqa server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' image_id = '226ed8c0-a2fe-11e4-b187-5f1f641608c8' client = ProfitBricksService( username='username', password='password') nic1 = NIC( name='nic1', ips=['10.2.2.5'], dhcp='true', lan=1, firewall_active=True, ) nic2 = NIC( name='nic2', ips=['10.2.3.6'], dhcp='true', lan=1, firewall_active=True, ) volume1 = Volume( name='volume6', size=56, image=image_id, bus='VIRTIO' ) volume2 = Volume( name='volume7', size=56, image=image_id, bus='VIRTIO' ) nics = [nic1, nic2] create_volumes = [volume1, volume2] i = Server( name='server11', ram=4096, cores=4, nics=nics, create_volumes=create_volumes ) response = client.create_server( datacenter_id=datacenter_id, server=i) """Create Server with Existing Volume """ from profitbricks.client import ProfitBricksService # noqa from profitbricks.client import Server # noqa server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' volume_id = '700e1cab-99b2-4c30-ba8c-1d273ddba044' client = ProfitBricksService( username='username', password='password') attach_volumes = [volume_id] i = Server( name='server1', ram=4096, cores=4, attach_volumes=attach_volumes ) response = client.create_server( datacenter_id=datacenter_id, server=i) """Create Server with New Volumes """ from profitbricks.client import ProfitBricksService # noqa from profitbricks.client import Server, Volume # noqa server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' volume_id = '700e1cab-99b2-4c30-ba8c-1d273ddba044' datacenter_id = 'c4fd1f8a-65e0-42cb-b8fa-ff7e87c3071b' image_id = '27500669-d81b-11e4-aea4-52540066fee9' client = ProfitBricksService( username='username', password='password') volume1 = Volume( name='volume11', size=56, image=image_id, bus='VIRTIO' ) volume2 = Volume( name='volume21', size=56, image=image_id, bus='VIRTIO' ) create_volumes = [volume1, volume2] i = Server( name='server12', ram=4096, cores=4, create_volumes=create_volumes ) response = client.create_server( datacenter_id=datacenter_id, server=i) """Create Server with NICs Only """ from profitbricks.client import ProfitBricksService # noqa from profitbricks.client import Server, NIC # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService( username='username', password='password') nic1 = NIC( name='nic1', ips=['10.2.2.3'], dhcp='true', lan=1, firewall_active=True, ) nic2 = NIC( name='nic2', ips=['10.2.3.4'], dhcp='true', lan=1, firewall_active=True, ) nics = [nic1, nic2] i = Server( name='server87', ram=4096, cores=4, nics=nics ) response = client.create_server( datacenter_id=datacenter_id, server=i) """Create Server with Two Existing Volumes """ from profitbricks.client import ProfitBricksService # noqa from profitbricks.client import Server # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' volume_id1 = '700e1cab-99b2-4c30-ba8c-1d273ddba023' volume_id2 = '800e1cab-99b2-4c30-ba8c-1d273ddba024' client = ProfitBricksService( username='username', password='password') attach_volumes = [volume_id1, volume_id2] i = Server( name='server1', ram=4096, cores=4, attach_volumes=attach_volumes ) response = client.create_server( datacenter_id=datacenter_id, server=i) """Create Server with Boot Volume """ from profitbricks.client import ProfitBricksService # noqa from profitbricks.client import Server # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' volume_id1 = '700e1cab-99b2-4c30-ba8c-1d273ddba023' volume_id2 = '800e1cab-99b2-4c30-ba8c-1d273ddba024' boot_volume_id = '800e1cab-99b2-4c30-ba8c-1d273ddba024' client = ProfitBricksService( username='username', password='password') i = Server( name='server14', ram=4096, cores=4, boot_volume_id=boot_volume_id ) response = client.create_server( datacenter_id=datacenter_id, server=i) """Create Server with Existing Volumes and NICs """ from profitbricks.client import ProfitBricksService # noqa from profitbricks.client import Server, NIC # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' volume_id1 = '700e1cab-99b2-4c30-ba8c-1d273ddba023' volume_id2 = '800e1cab-99b2-4c30-ba8c-1d273ddba024' boot_volume_id = '800e1cab-99b2-4c30-ba8c-1d273ddba024' client = ProfitBricksService( username='username', password='password') attach_volumes = [volume_id1, volume_id2] nic1 = NIC( name='nic1', ips=['10.2.2.3'], dhcp='true', lan=1, firewall_active=True, ) nic2 = NIC( name='nic2', ips=['10.2.3.4'], dhcp='true', lan=1, firewall_active=True, ) nics = [nic1, nic2] i = Server( name='server1', ram=4096, cores=4, boot_volume_id=boot_volume_id, attach_volumes=attach_volumes, nics=nics ) response = client.create_server( datacenter_id=datacenter_id, server=i) """Start Server """ from profitbricks.client import ProfitBricksService # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' client = ProfitBricksService( username='username', password='password') server = client.start_server( datacenter_id=datacenter_id, server_id=server_id) """Stop Server """ from profitbricks.client import ProfitBricksService # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' client = ProfitBricksService( username='username', password='password') server = client.stop_server( datacenter_id=datacenter_id, server_id=server_id) """Reboot Server """ from profitbricks.client import ProfitBricksService # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' client = ProfitBricksService( username='username', password='password') server = client.reboot_server( datacenter_id=datacenter_id, server_id=server_id) """List Servers """ from profitbricks.client import ProfitBricksService # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService( username='username', password='password') servers = client.list_servers(datacenter_id=datacenter_id) """Delete Server """ from profitbricks.client import ProfitBricksService # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' client = ProfitBricksService( username='username', password='password') server = client.delete_server( datacenter_id=datacenter_id, server_id=server_id) """Update Server """ from profitbricks.client import ProfitBricksService # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' client = ProfitBricksService( username='username', password='password') server = client.update_server( datacenter_id=datacenter_id, server_id=server_id, cores=35, ram=2048) profitbricks-sdk-python-3.1.0/examples/snapshot_examples.py000066400000000000000000000032331304175001700242360ustar00rootroot00000000000000"""List Snapshots """ from __future__ import print_function from profitbricks.client import ProfitBricksService client = ProfitBricksService( username='username', password='password') snapshots = client.list_snapshots() for s in snapshots['items']: print(s['properties']['name']) """Get Snapshot """ from profitbricks.client import ProfitBricksService # noqa snapshot_id = '7df81087-5835-41c6-a10b-3e098593bba4' client = ProfitBricksService( username='username', password='password') snapshot = client.get_snapshot( snapshot_id=snapshot_id) """ Update Snapshot Valid snapshot parameters are: * name (str) * description (str) * licence_type (one of 'LINUX', 'WINDOWS' or 'UNKNOWN') * cpu_hot_plug (bool) * ram_hot_plug (bool) * nic_hot_plug (bool) * nic_hot_unplug (bool) * disc_virtio_hot_plug (bool) * disc_virtio_hot_unplug (bool) * disc_scsi_hot_plug (bool) * disc_scsi_hot_unplug (bool) """ from profitbricks.client import ProfitBricksService # noqa client = ProfitBricksService( username='username', password='password') snapshot_id = 'd084aa0a-f9ab-41d5-9316-18163bc416ef' image = client.update_snapshot( snapshot_id, name='New name', description="Backup of volume XYZ", licence_type='LINUX', cpu_hot_plug=True, ram_hot_plug=True, nic_hot_plug=True, nic_hot_unplug=True, disc_virtio_hot_plug=True, disc_virtio_hot_unplug=True) """Remove Snapshot """ from profitbricks.client import ProfitBricksService # noqa snapshot_id = '7df81087-5835-41c6-a10b-3e098593bba4' client = ProfitBricksService( username='username', password='password') snapshot = client.delete_snapshot( snapshot_id=snapshot_id) profitbricks-sdk-python-3.1.0/examples/volume_example.py000066400000000000000000000033061304175001700235240ustar00rootroot00000000000000"""Create volume """ from profitbricks.client import ProfitBricksService, Volume datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService( username='username', password='password') i = Volume( name='Explicitly created volume', size=56, image='', bus='VIRTIO') response = client.create_volume( datacenter_id=datacenter_id, volume=i) """Create snapshot """ from profitbricks.client import ProfitBricksService # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' volume_id = '700e1cab-99b2-4c30-ba8c-1d273ddba025' client = ProfitBricksService( username='username', password='password') volume = client.create_snapshot( datacenter_id=datacenter_id, volume_id=volume_id, snapshot_name='', snapshot_description='') """Restore Snapshot """ from profitbricks.client import ProfitBricksService # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' volume_id = '700e1cab-99b2-4c30-ba8c-1d273ddba025' snapshot_id = '7df81087-5835-41c6-a10b-3e098593bba4' client = ProfitBricksService( username='username', password='password') response = client.restore_snapshot( datacenter_id=datacenter_id, volume_id=volume_id, snapshot_id=snapshot_id) """Update Volume """ from profitbricks.client import ProfitBricksService # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' volume_id = '700e1cab-99b2-4c30-ba8c-1d273ddba025' client = ProfitBricksService( username='username', password='password') volume = client.update_volume( datacenter_id=datacenter_id, volume_id=volume_id, size=100, name='Resized storage to 100 GB') profitbricks-sdk-python-3.1.0/profitbricks/000077500000000000000000000000001304175001700210115ustar00rootroot00000000000000profitbricks-sdk-python-3.1.0/profitbricks/__init__.py000066400000000000000000000002231304175001700231170ustar00rootroot00000000000000"""ProfitBricks API Client Library for Python""" __version__ = '3.0.0' API_HOST = 'https://api.profitbricks.com/cloudapi/v3' API__VERSION = '3.0' profitbricks-sdk-python-3.1.0/profitbricks/client.py000066400000000000000000002042171304175001700226470ustar00rootroot00000000000000import base64 import json import re import requests import six from six.moves.urllib.parse import urlencode from profitbricks import ( API_HOST, __version__ ) from profitbricks.errors import PBNotAuthorizedError, PBNotFoundError, PBValidationError, PBError # ProfitBricks Object Classes class ProfitBricksService(object): """ ProfitBricksClient Base Class """ def __init__(self, username=None, password=None, host_base=API_HOST, host_cert=None, ssl_verify=True, headers=None): if headers is None: headers = dict() self.username = username self.password = password self.host_base = host_base self.host_cert = host_cert self.verify = ssl_verify self.headers = headers # Datacenter Functions def get_datacenter(self, datacenter_id, depth=1): """ Retrieves a datacenter by its ID. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` """ response = self._perform_request( '/datacenters/%s?depth=%s' % (datacenter_id, str(depth))) return response def list_datacenters(self, depth=1): """ Retrieves a list of all datacenters. """ response = self._perform_request('/datacenters?depth=' + str(depth)) return response def delete_datacenter(self, datacenter_id): """ Removes the server from your Datacenter. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` """ response = self._perform_request( url='/datacenters/%s' % (datacenter_id), type='DELETE') return response def create_datacenter(self, datacenter): """ Creates a Datacenter -- both simple and complex are supported. """ server_items = [] volume_items = [] lan_items = [] loadbalancer_items = [] entities = dict() properties = { "name": datacenter.name, "location": datacenter.location, } # Optional Properties if datacenter.description: properties['description'] = datacenter.description # Servers if len(datacenter.servers) > 0: for server in datacenter.servers: server_items.append(self._create_server_dict(server)) servers = { "items": server_items } server_entities = { "servers": servers } entities.update(server_entities) # Volumes if len(datacenter.volumes) > 0: for volume in datacenter.volumes: volume_items.append(self._create_volume_dict(volume)) volumes = { "items": volume_items } volume_entities = { "volumes": volumes } entities.update(volume_entities) # Load Balancers if len(datacenter.loadbalancers) > 0: for loadbalancer in datacenter.loadbalancers: loadbalancer_items.append( self._create_loadbalancer_dict( loadbalancer ) ) loadbalancers = { "items": loadbalancer_items } loadbalancer_entities = { "loadbalancers": loadbalancers } entities.update(loadbalancer_entities) # LANs if len(datacenter.lans) > 0: for lan in datacenter.lans: lan_items.append( self._create_lan_dict(lan) ) lans = { "items": lan_items } lan_entities = { "lans": lans } entities.update(lan_entities) if len(entities) == 0: raw = { "properties": properties, } else: raw = { "properties": properties, "entities": entities } data = json.dumps(raw) response = self._perform_request( url='/datacenters', type='POST', data=data) return response def update_datacenter(self, datacenter_id, **kwargs): """ Updates a server with the parameters provided. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` """ data = {} for attr in kwargs.keys(): data[self._underscore_to_camelcase(attr)] = kwargs[attr] response = self._perform_request( url='/datacenters/%s' % ( datacenter_id), type='PATCH', data=json.dumps(data)) return response # FirewallRule Functions def get_firewall_rule(self, datacenter_id, server_id, nic_id, firewall_rule_id): """ Retrieves a single FirewallRule by ID. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` :param nic_id: The unique ID of the NIC. :type nic_id: ``str`` :param firewall_rule_id: The unique ID of the FirewallRule. :type firewall_rule_id: ``str`` """ response = self._perform_request( '/datacenters/%s/servers/%s/nics/%s/firewallrules/%s' % ( datacenter_id, server_id, nic_id, firewall_rule_id)) return response def get_firewall_rules(self, datacenter_id, server_id, nic_id, depth=1): """ Retrieves a list of FirewallRules available in the account. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` :param nic_id: The unique ID of the NIC. :type nic_id: ``str`` """ response = self._perform_request( '/datacenters/%s/servers/%s/nics/%s/firewallrules?depth=%s' % ( datacenter_id, server_id, nic_id, str(depth))) return response def delete_firewall_rule(self, datacenter_id, server_id, nic_id, firewall_rule_id): """ Removes a Firewall rule from the NIC. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` :param nic_id: The unique ID of the NIC. :type nic_id: ``str`` :param firewall_rule_id: The unique ID of the FirewallRule. :type firewall_rule_id: ``str`` """ response = self._perform_request( url='/datacenters/%s/servers/%s/nics/%s/firewallrules/%s' % ( datacenter_id, server_id, nic_id, firewall_rule_id), type='DELETE') return response def create_firewall_rule(self, datacenter_id, server_id, nic_id, firewall_rule): """ Creates a firewall rule on the specified NIC and Server. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the Server. :type server_id: ``str`` :param nic_id: The unique ID of the NIC. :type nic_id: ``str`` :param firewall_rule: A FirewallRule dict. :type firewall_rule: ``dict`` """ properties = { "name": firewall_rule.name, "protocol": firewall_rule.protocol, } # Optional Properties if firewall_rule.source_mac: properties['sourceMac'] = firewall_rule.source_mac if firewall_rule.source_ip: properties['sourceIp'] = firewall_rule.source_ip if firewall_rule.target_ip: properties['targetIp'] = firewall_rule.target_ip if firewall_rule.port_range_start: properties['portRangeStart'] = firewall_rule.port_range_start if firewall_rule.port_range_end: properties['portRangeEnd'] = firewall_rule.port_range_end if firewall_rule.icmp_type: properties['icmpType'] = firewall_rule.icmp_type if firewall_rule.icmp_code: properties['icmpCode'] = firewall_rule.icmp_code data = { "properties": properties } response = self._perform_request( url='/datacenters/%s/servers/%s/nics/%s/firewallrules' % ( datacenter_id, server_id, nic_id), type='POST', data=json.dumps(data)) return response def update_firewall_rule(self, datacenter_id, server_id, nic_id, firewall_rule_id, **kwargs): """ Updates a firewall rule. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` :param nic_id: The unique ID of the NIC. :type nic_id: ``str`` :param firewall_rule_id: The unique ID of the firewall. :type firewall_rule_id: ``str`` """ data = {} for attr in kwargs.keys(): data[self._underscore_to_camelcase(attr)] = kwargs[attr] if attr == 'source_mac': data['sourceMac'] = kwargs[attr] elif attr == 'source_ip': data['sourceIp'] = kwargs[attr] elif attr == 'target_ip': data['targetIp'] = kwargs[attr] elif attr == 'port_range_start': data['portRangeStart'] = kwargs[attr] elif attr == 'port_range_end': data['portRangeEnd'] = kwargs[attr] elif attr == 'icmp_type': data['icmpType'] = kwargs[attr] elif attr == 'icmp_code': data['icmpCode'] = kwargs[attr] else: data[self._underscore_to_camelcase(attr)] = kwargs[attr] response = self._perform_request( url='/datacenters/%s/servers/%s/nics/%s/firewallrules/%s' % ( datacenter_id, server_id, nic_id, firewall_rule_id), type='PATCH', data=json.dumps(data)) return response # Image Functions def get_image(self, image_id): """ Retrieves a single image by ID. :param image_id: The unique ID of the image. :type image_id: ``str`` """ response = self._perform_request('/images/%s' % image_id) return response def list_images(self, depth=1): """ Retrieves a list of images available in the datacenter. :param depth: The depth of the response data. :type depth: ``int`` """ response = self._perform_request('/images?depth=' + str(depth)) return response def delete_image(self, image_id): """ Removes only user created images. :param image_id: The unique ID of the image. :type image_id: ``str`` """ response = self._perform_request(url='/images/' + image_id, type='DELETE') return response def update_image(self, image_id, **kwargs): """ Replace all properties of an image. """ data = {} for attr in kwargs.keys(): data[self._underscore_to_camelcase(attr)] = kwargs[attr] response = self._perform_request(url='/images/' + image_id, type='PATCH', data=json.dumps(data)) return response # IPBlock Functions def get_ipblock(self, ipblock_id): """ Retrieves a single IPBlock by ID. :param ipblock_id: The unique ID of the IPBlock. :type ipblock_id: ``str`` """ response = self._perform_request('/ipblocks/%s' % ipblock_id) return response def list_ipblocks(self, depth=1): """ Retrieves a list of IPBlocks available in the account. """ response = self._perform_request('/ipblocks?depth=%s' % str(depth)) return response def delete_ipblock(self, ipblock_id): """ Removes a IPBlock from your account. :param ipblock_id: The unique ID of the IPBlock. :type ipblock_id: ``str`` """ response = self._perform_request( url='/ipblocks/' + ipblock_id, type='DELETE') return response def reserve_ipblock(self, ipblock): """ Reserves an IPBlock within your account. """ properties = { "name": ipblock.name, "location": ipblock.location, "size": str(ipblock.size).lower() } raw = { "properties": properties, } data = self._underscore_to_camelcase(json.dumps(raw)) response = self._perform_request( url='/ipblocks', type='POST', data=data) return response # LAN Functions def get_lan(self, datacenter_id, lan_id, depth=1): """ Retrieves a single LAN by ID. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param lan_id: The unique ID of the LAN. :type lan_id: ``str`` """ response = self._perform_request( '/datacenters/%s/lans/%s?depth=%s' % ( datacenter_id, lan_id, str(depth))) return response def list_lans(self, datacenter_id, depth=1): """ Retrieves a list of LANs available in the account. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` """ response = self._perform_request( '/datacenters/%s/lans?depth=%s' % ( datacenter_id, str(depth))) return response def delete_lan(self, datacenter_id, lan_id): """ Removes a LAN from the Datacenter. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param lan_id: The unique ID of the LAN. :type lan_id: ``str`` """ response = self._perform_request( url='/datacenters/%s/lans/%s' % ( datacenter_id, lan_id), type='DELETE') return response def create_lan(self, datacenter_id, lan): """ Creates a LAN in the Datacenter. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param lan: The LAN object to be created. :type lan: ``dict`` """ data = self._underscore_to_camelcase( json.dumps( self._create_lan_dict(lan) ) ) response = self._perform_request( url='/datacenters/%s/lans' % datacenter_id, type='POST', data=data) return response def update_lan(self, datacenter_id, lan_id, **kwargs): """ Updates a LAN :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param lan_id: The unique ID of the LAN. :type lan_id: ``str`` """ data = {} for attr in kwargs.keys(): data[self._underscore_to_camelcase(attr)] = kwargs[attr] response = self._perform_request( url='/datacenters/%s/lans/%s' % (datacenter_id, lan_id), type='PATCH', data=json.dumps(data)) return response def get_lan_members(self, datacenter_id, lan_id, depth=1): """ Retrieves the list of NICs that are part of the LAN. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param lan_id: The unique ID of the LAN. :type lan_id: ``str`` """ response = self._perform_request( '/datacenters/%s/lans/%s/nics?depth=%s' % ( datacenter_id, lan_id, str(depth))) return response # LoadBalancer Functions def get_loadbalancer(self, datacenter_id, loadbalancer_id): """ Retrieves a single LoadBalancer by ID. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param loadbalancer_id: The unique ID of the LoadBalancer. :type loadbalancer_id: ``str`` """ response = self._perform_request( '/datacenters/%s/loadbalancers/%s' % ( datacenter_id, loadbalancer_id)) return response def list_loadbalancers(self, datacenter_id, depth=1): """ Retrieves a list of LoadBalancers in the Datacenter. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` """ response = self._perform_request( '/datacenters/%s/loadbalancers?depth=%s' % ( datacenter_id, str(depth))) return response def delete_loadbalancer(self, datacenter_id, loadbalancer_id): """ Removes the LoadBalancer from the Datacenter. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param loadbalancer_id: The unique ID of the LoadBalancer. :type loadbalancer_id: ``str`` """ response = self._perform_request( url='/datacenters/%s/loadbalancers/%s' % ( datacenter_id, loadbalancer_id), type='DELETE') return response def create_loadbalancer(self, datacenter_id, loadbalancer): """ Creates a LoadBalancer within the specified DataCenter. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param loadbalancer: The LoadBalancer object to be created. :type loadbalancer: ``dict`` """ data = self._underscore_to_camelcase( json.dumps( self._create_loadbalancer_dict(loadbalancer) ) ) response = self._perform_request( url='/datacenters/%s/loadbalancers' % datacenter_id, type='POST', data=data) return response def update_loadbalancer(self, datacenter_id, loadbalancer_id, **kwargs): """ Updates a LoadBalancer :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param loadbalancer_id: The unique ID of the LoadBalancer. :type loadbalancer_id: ``str`` """ data = {} for attr in kwargs.keys(): data[self._underscore_to_camelcase(attr)] = kwargs[attr] response = self._perform_request( url='/datacenters/%s/loadbalancers/%s' % (datacenter_id, loadbalancer_id), type='PATCH', data=json.dumps(data)) return response def get_loadbalancer_members(self, datacenter_id, loadbalancer_id, depth=1): """ Retrieves the list of NICs that are part of the LAN. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param loadbalancer_id: The unique ID of the LoadBalancer. :type loadbalancer_id: ``str`` """ response = self._perform_request( '/datacenters/%s/loadbalancers/%s/balancednics?depth=%s' % ( datacenter_id, loadbalancer_id, str(depth))) return response def add_loadbalanced_nics(self, datacenter_id, loadbalancer_id, nic_id): """ Associates a NIC with the given LoadBalancer. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param loadbalancer_id: The unique ID of the LoadBalancer. :type loadbalancer_id: ``str`` :param nic_id: The ID of the NIC. :type nic_id: ``str`` """ data = '{ "id": "' + nic_id + '" }' response = self._perform_request( url='/datacenters/%s/loadbalancers/%s/balancednics' % ( datacenter_id, loadbalancer_id), type='POST', data=data) return response def get_loadbalanced_nic(self, datacenter_id, loadbalancer_id, nic_id, depth=1): """ Gets the properties of a balanced NIC. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param loadbalancer_id: The unique ID of the LoadBalancer. :type loadbalancer_id: ``str`` :param nic_id: The unique ID of the NIC. :type nic_id: ``str`` """ response = self._perform_request( '/datacenters/%s/loadbalancers/%s/balancednics/%s?depth=%s' % ( datacenter_id, loadbalancer_id, nic_id, str(depth))) return response def remove_loadbalanced_nic(self, datacenter_id, loadbalancer_id, nic_id): """ Removes a NIC from the loadbalancer. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param loadbalancer_id: The unique ID of the LoadBalancer. :type loadbalancer_id: ``str`` :param nic_id: The unique ID of the NIC. :type nic_id: ``str`` """ response = self._perform_request( url='/datacenters/%s/loadbalancers/%s/balancednics/%s' % ( datacenter_id, loadbalancer_id, nic_id), type='DELETE') return response # Location Functions def get_location(self, location_id): """ Retrieves a single Location by ID. :param location_id: The unique ID of the Location. :type location_id: ``str`` """ response = self._perform_request('/locations/' + location_id) return response def list_locations(self): """ Retrieves a list of Location available in the account. """ response = self._perform_request('/locations') return response # NIC Functions def get_nic(self, datacenter_id, server_id, nic_id, depth=1): """ Retrieves a NIC by its ID. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` :param nic_id: The unique ID of the NIC. :type nic_id: ``str`` """ response = self._perform_request( '/datacenters/%s/servers/%s/nics/%s?depth=%s' % ( datacenter_id, server_id, nic_id, str(depth))) return response def list_nics(self, datacenter_id, server_id, depth=1): """ Retrieves a list of all NICs bound to the specified server. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` """ response = self._perform_request( '/datacenters/%s/servers/%s/nics?depth=%s' % ( datacenter_id, server_id, str(depth))) return response def delete_nic(self, datacenter_id, server_id, nic_id): """ Removes a NIC from the server. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` :param nic_id: The unique ID of the NIC. :type nic_id: ``str`` """ response = self._perform_request( url='/datacenters/%s/servers/%s/nics/%s' % ( datacenter_id, server_id, nic_id), type='DELETE') return response def create_nic(self, datacenter_id, server_id, nic): """ Creates a NIC on the specified server. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the Server. :type server_id: ``str`` :param nic: A NIC dict. :type nic: ``dict`` """ data = json.dumps(self._create_nic_dict(nic)) response = self._perform_request( url='/datacenters/%s/servers/%s/nics' % ( datacenter_id, server_id), type='POST', data=data) return response def update_nic(self, datacenter_id, server_id, nic_id, **kwargs): """ Updates a NIC with the parameters provided. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the Server. :type server_id: ``str`` :param nic_id: The unique ID of the NIC. :type nic_id: ``str`` """ data = {} for attr in kwargs.keys(): data[self._underscore_to_camelcase(attr)] = kwargs[attr] response = self._perform_request( url='/datacenters/%s/servers/%s/nics/%s' % ( datacenter_id, server_id, nic_id), type='PATCH', data=json.dumps(data)) return response # Request Functions def get_request(self, request_id, status=False): """ Retrieves a single request by ID. :param request_id: The unique ID of the request. :type request_id: ``str`` :param status: Retreive the full status of the request. :type status: ``bool`` """ if status: response = self._perform_request( '/requests/' + request_id + '/status') else: response = self._perform_request( '/requests/%s' % request_id) return response def list_requests(self, depth=1): """ Retrieves a list of requests available in the account. """ response = self._perform_request( '/requests?depth=%s' % str(depth)) return response # Server Functions def get_server(self, datacenter_id, server_id, depth=1): """ Retrieves a server by its ID. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` """ response = self._perform_request( '/datacenters/%s/servers/%s?depth=%s' % ( datacenter_id, server_id, str(depth))) return response def list_servers(self, datacenter_id, depth=1): """ Retrieves a list of all servers bound to the specified server. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` """ response = self._perform_request( '/datacenters/%s/servers?depth=%s' % (datacenter_id, str(depth))) return response def delete_server(self, datacenter_id, server_id): """ Removes the server from your Datacenter. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` """ response = self._perform_request( url='/datacenters/%s/servers/%s' % ( datacenter_id, server_id), type='DELETE') return response def create_server(self, datacenter_id, server): """ Creates a server within the Datacenter. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server: A dict of the Server to be created. :type server: ``dict`` """ data = json.dumps(self._create_server_dict(server)) response = self._perform_request( url='/datacenters/%s/servers' % (datacenter_id), type='POST', data=data) return response def update_server(self, datacenter_id, server_id, **kwargs): """ Updates a server with the parameters provided. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` """ data = {} for attr in kwargs.keys(): if attr == 'boot_volume': boot_volume_properties = { "id": kwargs[attr] } boot_volume_entities = { "bootVolume": boot_volume_properties } data.update(boot_volume_entities) else: data[self._underscore_to_camelcase(attr)] = kwargs[attr] response = self._perform_request( url='/datacenters/%s/servers/%s' % ( datacenter_id, server_id), type='PATCH', data=json.dumps(data)) return response def get_attached_volumes(self, datacenter_id, server_id, depth=1): """ Retrieves a list of volumes attached to the server. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` """ response = self._perform_request( '/datacenters/%s/servers/%s/volumes?depth=%s' % ( datacenter_id, server_id, str(depth))) return response def get_attached_volume(self, datacenter_id, server_id, volume_id): """ Retrieves volume information. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` :param volume_id: The unique ID of the volume. :type volume_id: ``str`` """ response = self._perform_request( '/datacenters/%s/servers/%s/volumes/%s' % ( datacenter_id, server_id, volume_id)) return response def attach_volume(self, datacenter_id, server_id, volume_id): """ Attaches a volume to a server. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` :param volume_id: The unique ID of the volume. :type volume_id: ``str`` """ data = '{ "id": "' + volume_id + '" }' response = self._perform_request( url='/datacenters/%s/servers/%s/volumes' % ( datacenter_id, server_id), type='POST', data=data) return response def detach_volume(self, datacenter_id, server_id, volume_id): """ Detaches a volume from a server. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` :param volume_id: The unique ID of the volume. :type volume_id: ``str`` """ response = self._perform_request( url='/datacenters/%s/servers/%s/volumes/%s' % ( datacenter_id, server_id, volume_id), type='DELETE') return response def get_attached_cdroms(self, datacenter_id, server_id, depth=1): """ Retrieves a list of CDROMs attached to the server. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` """ response = self._perform_request( '/datacenters/%s/servers/%s/cdroms?depth=%s' % ( datacenter_id, server_id, str(depth))) return response def get_attached_cdrom(self, datacenter_id, server_id, cdrom_id): """ Retrieves an attached CDROM. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` :param cdrom_id: The unique ID of the CDROM. :type cdrom_id: ``str`` """ response = self._perform_request( '/datacenters/%s/servers/%s/cdroms/%s' % ( datacenter_id, server_id, cdrom_id)) return response def attach_cdrom(self, datacenter_id, server_id, cdrom_id): """ Attaches a CDROM to a server. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` :param cdrom_id: The unique ID of the volume. :type cdrom_id: ``str`` """ data = '{ "id": "' + cdrom_id + '" }' response = self._perform_request( url='/datacenters/%s/servers/%s/cdroms' % ( datacenter_id, server_id), type='POST', data=data) return response def detach_cdrom(self, datacenter_id, server_id, cdrom_id): """ Detaches a volume from a server. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` :param cdrom_id: The unique ID of the CDROM. :type cdrom_id: ``str`` """ response = self._perform_request( url='/datacenters/%s/servers/%s/cdroms/%s' % ( datacenter_id, server_id, cdrom_id), type='DELETE') return response def start_server(self, datacenter_id, server_id): """ Starts the server. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` """ response = self._perform_request( url='/datacenters/%s/servers/%s/start' % ( datacenter_id, server_id), type='POST-ACTION') return response def stop_server(self, datacenter_id, server_id): """ Stops the server. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` """ response = self._perform_request( url='/datacenters/%s/servers/%s/stop' % ( datacenter_id, server_id), type='POST-ACTION') return response def reboot_server(self, datacenter_id, server_id): """ Reboots the server. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param server_id: The unique ID of the server. :type server_id: ``str`` """ response = self._perform_request( url='/datacenters/%s/servers/%s/reboot' % ( datacenter_id, server_id), type='POST-ACTION') return response # Snapshot Functions def get_snapshot(self, snapshot_id): """ Retrieves a single snapshot by ID. :param snapshot_id: The unique ID of the snapshot. :type snapshot_id: ``str`` """ response = self._perform_request('/snapshots/%s' % snapshot_id) return response def list_snapshots(self, depth=1): """ Retrieves a list of snapshots available in the account. """ response = self._perform_request( '/snapshots?depth=%s' % str(depth)) return response def delete_snapshot(self, snapshot_id): """ Removes a snapshot from your account. :param snapshot_id: The unique ID of the snapshot. :type snapshot_id: ``str`` """ response = self._perform_request( url='/snapshots/' + snapshot_id, type='DELETE') return response def update_snapshot(self, snapshot_id, **kwargs): """ Removes a snapshot from your account. :param snapshot_id: The unique ID of the snapshot. :type snapshot_id: ``str`` """ data = {} for attr in kwargs.keys(): data[self._underscore_to_camelcase(attr)] = kwargs[attr] response = self._perform_request( url='/snapshots/' + snapshot_id, type='PATCH', data=json.dumps(data)) return response def create_snapshot(self, datacenter_id, volume_id, name=None, description=None): """ Creates a snapshot of the specified volume. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param volume_id: The unique ID of the volume. :type volume_id: ``str`` """ data = {'name': name, 'description': description} response = self._perform_request( '/datacenters/%s/volumes/%s/create-snapshot' % ( datacenter_id, volume_id), type='POST-ACTION-JSON', data=urlencode(data)) return response def restore_snapshot(self, datacenter_id, volume_id, snapshot_id): """ Restores a snapshot to the specified volume. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param volume_id: The unique ID of the volume. :type volume_id: ``str`` :param snapshot_id: The unique ID of the Snapshot. :type snapshot_id: ``str`` """ data = {'snapshotId': snapshot_id} response = self._perform_request( url='/datacenters/%s/volumes/%s/restore-snapshot' % ( datacenter_id, volume_id), type='POST-ACTION', data=urlencode(data)) return response def remove_snapshot(self, snapshot_id): """ Removes a snapshot. :param snapshot_id: The ID of the Snapshot you wish to remove. :type snapshot_id: ``str`` """ response = self._perform_request( url='/snapshots/' + snapshot_id, type='DELETE') return response # Volume Functions def get_volume(self, datacenter_id, volume_id): """ Retrieves a single volume by ID. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param volume_id: The unique ID of the volume. :type volume_id: ``str`` """ response = self._perform_request( '/datacenters/%s/volumes/%s' % (datacenter_id, volume_id)) return response def list_volumes(self, datacenter_id, depth=1): """ Retrieves a list of Volumes in the datacenter. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` """ response = self._perform_request( '/datacenters/%s/volumes?depth=%s' % (datacenter_id, str(depth))) return response def delete_volume(self, datacenter_id, volume_id): """ Removes a Volume from the Datacenter. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param volume_id: The unique ID of the volume. :type volume_id: ``str`` """ response = self._perform_request( url='/datacenters/%s/volumes/%s' % ( datacenter_id, volume_id), type='DELETE') return response def create_volume(self, datacenter_id, volume): """ Creates a volume within the specified DataCenter. :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param volume: A Volume dict. :type volume: ``dict`` """ data = (json.dumps(self._create_volume_dict(volume))) response = self._perform_request( url='/datacenters/%s/volumes' % datacenter_id, type='POST', data=data) return response def update_volume(self, datacenter_id, volume_id, **kwargs): """ Updates a volume :param datacenter_id: The unique ID of the Datacenter. :type datacenter_id: ``str`` :param volume_id: The unique ID of the volume. :type volume_id: ``str`` """ data = {} for attr in kwargs.keys(): data[self._underscore_to_camelcase(attr)] = kwargs[attr] response = self._perform_request( url='/datacenters/%s/volumes/%s' % ( datacenter_id, volume_id), type='PATCH', data=json.dumps(data)) return response # Private Functions def _wrapped_request(self, method, url, params=None, data=None, headers=None, cookies=None, files=None, auth=None, timeout=None, allow_redirects=True, proxies=None, hooks=None, stream=None): headers.update(self.headers) session = requests.Session() return session.request(method, url, params, data, headers, cookies, files, auth, timeout, allow_redirects, proxies, hooks, stream, self.verify, self.host_cert) def _perform_request(self, url, type='GET', data=None, headers=dict()): headers.update({'Authorization': 'Basic %s' % (base64.b64encode( self._b('%s:%s' % (self.username, self.password))).decode('utf-8'))}) url = self._build_url(url) headers.update({'User-Agent': 'profitbricks-sdk-python/' + __version__}) if type == 'POST' or type == 'PUT': response = self._wrapped_request(type, url, data=data, headers=headers) headers.update({'Content-Type': 'application/json'}) elif type == 'POST-ACTION-JSON' or type == 'POST-ACTION': headers.update({'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'}) response = self._wrapped_request('POST', url, data=data, headers=headers) if response.status_code == 202 and type == 'POST-ACTION': return True elif response.status_code == 401: raise response.raise_for_status() elif type == 'PATCH': headers.update({'Content-Type': 'application/json'}) response = self._wrapped_request(type, url, data=data, headers=headers) else: headers.update({'Content-Type': 'application/json'}) response = self._wrapped_request(type, url, params=data, headers=headers) if type == 'DELETE': if response.status_code == 202: return True try: if not response.ok: err = response.json() code = err['httpStatus'] msg = err['messages'] if response.status_code == 401: raise PBNotAuthorizedError(code, msg, url) if response.status_code == 404: raise PBNotFoundError(code, msg, url) if response.status_code == 422: raise PBValidationError(code, msg, url) else: raise PBError(code, msg, url) except ValueError as e: raise Exception('Failed to parse the response', response.text) json_response = response.json() if 'location' in response.headers: json_response['requestId'] = self._request_id(response.headers) return json_response def _request_id(self, headers): # The request URL has currently the format: # {host_base}/requests/{request ID}/status # Thus search for a UUID. match = re.search('/requests/([-A-Fa-f0-9]+)/', headers['location']) if match: return match.group(1) else: raise Exception("Failed to extract request ID from response " "header 'location': '{location}'".format(location=headers['location'])) def _build_url(self, uri): url = self.host_base + uri return url def _b(self, s, encoding='utf-8'): """ Returns the given string as a string of bytes. That means in Python2 as a str object, and in Python3 as a bytes object. Raises a TypeError, if it cannot be converted. """ if six.PY2: # This is Python2 if isinstance(s, str): return s elif isinstance(s, unicode): # noqa return s.encode(encoding) else: # And this is Python3 if isinstance(s, bytes): return s elif isinstance(s, str): return s.encode(encoding) raise TypeError("Invalid argument %r for _b()" % (s,)) def _underscore_to_camelcase(self, value): """ Convert Python snake case back to mixed case. """ def camelcase(): yield str.lower while True: yield str.capitalize c = camelcase() return "".join(next(c)(x) if x else '_' for x in value.split("_")) def _create_lan_dict(self, lan): items = [] entities = dict() properties = { "name": lan.name } # Optional Properties if lan.public is not None: properties['public'] = str(lan.public).lower() if len(lan.nics) > 0: for nic in lan.nics: nics_properties = { "id": nic } items.append(nics_properties) item_entities = { "items": items } nics_entities = { "nics": item_entities } entities.update(nics_entities) if len(entities) == 0: raw = { "properties": properties, } else: raw = { "properties": properties, "entities": entities } return raw def _create_loadbalancer_dict(self, loadbalancer): items = [] entities = dict() properties = { "name": loadbalancer.name } # Optional Properties if loadbalancer.ip: properties['ip'] = loadbalancer.ip if loadbalancer.dhcp is not None: properties['dhcp'] = str(loadbalancer.dhcp).lower() if len(loadbalancer.balancednics) > 0: for nic in loadbalancer.balancednics: balancednic_properties = { "id": nic } items.append(balancednic_properties) item_entities = { "items": items } balancednics_entities = { "balancednics": item_entities } entities.update(balancednics_entities) if len(loadbalancer.balancednics) == 0: raw = { "properties": properties, } else: raw = { "properties": properties, "entities": entities } return raw def _create_nic_dict(self, nic): items = [] properties = { "name": nic.name, "lan": nic.lan, } # Optional Properties if nic.nat: properties['nat'] = nic.nat if nic.ips: properties['ips'] = nic.ips if nic.dhcp is not None: properties['dhcp'] = nic.dhcp if nic.firewall_active is not None: properties['firewallActive'] = nic.firewall_active if len(nic.firewall_rules) > 0: for rule in nic.firewall_rules: items.append(self._create_firewallrules_dict(rule)) rules = { "items": items } entities = { "firewallrules": rules } if len(nic.firewall_rules) == 0: raw = { "properties": properties, } else: raw = { "properties": properties, "entities": entities } return raw def _create_firewallrules_dict(self, rule): properties = {} if rule.name: properties['name'] = rule.name if rule.protocol: properties['protocol'] = rule.protocol if rule.source_mac: properties['sourceMac'] = rule.source_mac if rule.source_ip: properties['sourceIp'] = rule.source_ip if rule.target_ip: properties['targetIp'] = rule.target_ip if rule.port_range_start: properties['portRangeStart'] = rule.port_range_start if rule.port_range_end: properties['portRangeEnd'] = rule.port_range_end if rule.icmp_type: properties['icmpType'] = rule.icmp_type if rule.icmp_code: properties['icmpCode'] = rule.icmp_code raw = { "properties": properties } return raw def _create_server_dict(self, server): volume_items = [] nic_items = [] entities = dict() properties = { "name": server.name, "ram": server.ram, "cores": server.cores } # Optional Properties if server.availability_zone: properties['availabilityZone'] = server.availability_zone if server.boot_cdrom: properties['bootCdrom'] = server.boot_cdrom if server.boot_volume_id: boot_volume = { "id": server.boot_volume_id } properties['bootVolume'] = boot_volume if server.cpu_family: properties['cpuFamily'] = server.cpu_family if len(server.create_volumes) > 0: for volume in server.create_volumes: volume_items.append(self._create_volume_dict(volume)) volumes = { "items": volume_items } volume_entities = { "volumes": volumes } entities.update(volume_entities) if len(server.nics) > 0: for nic in server.nics: nic_items.append(self._create_nic_dict(nic)) nics = { "items": nic_items } nic_entities = { "nics": nics } entities.update(nic_entities) # Attach Existing Volume(s) if len(server.attach_volumes) > 0: for volume in server.attach_volumes: volume_properties = { "id": volume } volume_items.append(volume_properties) volumes = { "items": volume_items } volume_entities = { "volumes": volumes } entities.update(volume_entities) if len(entities) == 0: raw = { "properties": properties, } else: raw = { "properties": properties, "entities": entities } return raw def _create_volume_dict(self, volume): properties = { "name": volume.name, "size": volume.size } # Optional Properties if volume.availability_zone: properties['availabilityZone'] = volume.availability_zone if volume.image: properties['image'] = volume.image if volume.bus: properties['bus'] = volume.bus if volume.disk_type: properties['type'] = volume.disk_type if volume.image is None: properties['licenceType'] = volume.licence_type # if volume.licence_type: # properties['licenceType'] = volume.licence_type if volume.image_password: properties['imagePassword'] = volume.image_password if volume.ssh_keys: properties['sshKeys'] = volume.ssh_keys raw = { "properties": properties } return raw class Datacenter(ProfitBricksService): def __init__(self, name=None, location=None, description=None, volumes=None, servers=None, lans=None, loadbalancers=None, **kwargs): """ Datacenter class initializer. :param name: The Datacenter name.. :type name: ``str`` :param location: The Datacenter geographical location. :type location: ``str`` :param description: Optional description. :type description: ``str`` :param volumes: List of volume dicts. :type volumes: ``list`` :param servers: List of server dicts. :type servers: ``list`` :param lans: List of LAN dicts. :type lans: ``list`` :param loadbalancers: List of loadbalancer dicts. :type loadbalancers: ``list`` """ if volumes is None: volumes = [] if servers is None: servers = [] if lans is None: lans = [] if loadbalancers is None: loadbalancers = [] self.name = name self.description = description self.location = location self.servers = servers self.volumes = volumes self.lans = lans self.loadbalancers = loadbalancers def __repr__(self): return ((' ...>') % (self.name, self.location, self.description)) class FirewallRule(ProfitBricksService): def __init__(self, name=None, protocol=None, source_mac=None, source_ip=None, target_ip=None, port_range_start=None, port_range_end=None, icmp_type=None, icmp_code=None, **kwargs): """ FirewallRule class initializer. :param name: The name of the FirewallRule. :type name: ``str`` :param protocol: Either TCP or UDP :type protocol: ``str`` :param source_mac: Source MAC you want to restrict. :type source_mac: ``str`` :param source_ip: Source IP you want to restrict. :type source_ip: ``str`` :param target_ip: Target IP you want to restrict. :type target_ip: ``str`` :param port_range_start: Optional port range. :type port_range_start: ``str`` :param port_range_end: Optional port range. :type port_range_end: ``str`` :param icmp_type: Defines the allowed type. :type icmp_type: ``str`` :param icmp_code: Defines the allowed code. :type icmp_code: ``str`` """ self.name = name self.protocol = protocol self.source_mac = source_mac self.source_ip = source_ip self.target_ip = target_ip self.port_range_start = port_range_start self.port_range_end = port_range_end if icmp_type is not None: icmp_type = str(icmp_type) self.icmp_type = icmp_type if icmp_code is not None: icmp_code = str(icmp_code) self.icmp_code = icmp_code def __repr__(self): return ((' ...>') % (self.name, self.protocol, self.source_mac, self.source_ip, self.target_ip, self.port_range_start, self.port_range_end, self.icmp_type, self.icmp_code)) class IPBlock(ProfitBricksService): def __init__(self, name=None, location=None, size=None): """ IPBlock class initializer. :param name: The name of the IP Block. :type name: ``str`` :param location: The location for the IP Block. :type location: ``str`` :param size: The number of IPs in the block. :type size: ``str`` """ self.name = name self.location = location self.size = size def __repr__(self): return (('') % (self.location, self.size)) class LAN(ProfitBricksService): ''' This is the main class for managing LAN resources. ''' def __init__(self, name=None, public=None, nics=None): """ LAN class initializer. :param name: The name of the LAN. :type name: ``str`` :param public: Indicates if the LAN is public. :type public: ``bool`` :param nics: A list of NICs :type nics: ``list`` """ if nics is None: nics = [] self.name = name self.public = public self.nics = nics def __repr__(self): return ((' ...>') % (self.name, str(self.public))) class LoadBalancer(ProfitBricksService): ''' This is the main class for managing LoadBalancer resources. ''' def __init__(self, name=None, ip=None, dhcp=None, balancednics=None, **kwargs): """ LoadBalancer class initializer. :param name: The name of the LoadBalancer. :type name: ``str`` :param ip: The IP for the loadbalancer. :type ip: ``str`` :param dhcp: Indicates if the LoadBalancer uses DHCP or not. :type dhcp: ``bool`` :param balancednics: A list of NICs associated with the LoadBalancer. :type balancednics: ``list`` """ if balancednics is None: balancednics = [] self.name = name self.ip = ip self.dhcp = dhcp self.balancednics = balancednics def __repr__(self): return ((' ...>') % (self.name, self.ip, str(self.dhcp))) class NIC(ProfitBricksService): def __init__(self, name=None, ips=None, dhcp=None, lan=None, firewall_active=None, firewall_rules=None, nat=None, **kwargs): """ NIC class initializer. :param name: The name of the NIC. :type name: ``str`` :param ips: A list of IPs. :type ips: ``list`` :param dhcp: Enable or disable DHCP. Default is enabled. :type dhcp: ``bool`` :param lan: ID of the LAN in which the NIC should reside. :type lan: ``str`` :param nat: Enable or disable NAT. Default is disabled. :type nat: ``bool`` :param firewall_active: Turns the firewall on or not; default is disabled until a rule is added. :type firewall_active: ``bool`` :param firewall_rules: List of Firewall rule dicts. :type firewall_rules: ``list`` """ if firewall_rules is None: firewall_rules = [] self.name = name self.nat = nat self.ips = ips self.dhcp = dhcp self.lan = lan self.firewall_active = firewall_active self.firewall_rules = firewall_rules def __repr__(self): return ((' ...>') % (self.name, self.ips, str(self.dhcp), self.lan, str(self.firewall_active))) class Server(ProfitBricksService): ''' This is the main class for managing server resources. ''' def __init__(self, name=None, cores=None, ram=None, availability_zone=None, boot_volume_id=None, boot_cdrom=None, cpu_family=None, create_volumes=None, attach_volumes=None, nics=None): """ Server class initializer. :param name: The name of your server.. :type name: ``str`` :param cores: The number of cores for the server. :type cores: ``str`` :param ram: The amount of memory for the server. :type ram: ``str`` :param availability_zone: The availability zone for the server. :type availability_zone: ``str`` :param boot_volume_id: The ID of the boot volume. :type boot_volume_id: ``str`` :param boot_cdrom: Attach a CDROM. :type boot_cdrom: ``str`` :param cpu_family: Set the desired CPU type. :type cpu_family: ``str`` :param create_volumes: List of Volume dicts to create. :type create_volumes: ``list`` :param attach_volumes: List of Volume IDs to attach. :type attach_volumes: ``list`` :param nics: List of NIC dicts to create. :type nics: ``list`` """ if create_volumes is None: create_volumes = [] if attach_volumes is None: attach_volumes = [] if nics is None: nics = [] self.name = name self.cores = cores self.ram = ram self.availability_zone = availability_zone self.boot_volume_id = boot_volume_id self.boot_cdrom = boot_cdrom self.cpu_family = cpu_family self.create_volumes = create_volumes self.attach_volumes = attach_volumes self.nics = nics def __repr__(self): return (('') % (self.name, self.cores, self.ram, self.availability_zone, self.boot_volume_id, self.boot_cdrom)) class Volume(ProfitBricksService): def __init__(self, name=None, size=None, bus='VIRTIO', image=None, disk_type='HDD', licence_type='UNKNOWN', image_password=None, ssh_keys=None, availability_zone='AUTO', **kwargs): """ Volume class initializer. :param name: The name of the volume. :type name: ``str`` :param size: The size of the volume. :type size: ``str`` :param bus: The BUS type. Def. VIRTIO. :type bus: ``str`` :param image: The Image ID to use. :type image: ``str`` :param disk_type: The type of storage. Def. HDD :type disk_type: ``str`` :param licence_type: The license type. :type licence_type: ``str`` :param ssh_keys: A list of public SSH keys. :type ssh_keys: ``list`` :param availability_zone: The availability zone for the server. :type availability_zone: ``str`` """ if ssh_keys is None: ssh_keys = [] self.name = name self.availability_zone = availability_zone self.size = int(size) self.image = image self.bus = bus self.disk_type = disk_type self.licence_type = licence_type self.image_password = image_password self.ssh_keys = ssh_keys def __repr__(self): return (('') % (self.name, str(self.size), self.image, self.bus, self.disk_type)) profitbricks-sdk-python-3.1.0/profitbricks/errors.py000066400000000000000000000006701304175001700227020ustar00rootroot00000000000000class PBError(Exception): """Base error for this module.""" def __init__(self, resp, content, uri=None): self.resp = resp self.content = content self.uri = uri class PBNotAuthorizedError(PBError): """HTTP data was invalid or unexpected.""" class PBNotFoundError(PBError): """HTTP data was invalid or unexpected.""" class PBValidationError(PBError): """HTTP data was invalid or unexpected.""" profitbricks-sdk-python-3.1.0/requirements.txt000066400000000000000000000001051304175001700215700ustar00rootroot00000000000000requests>=2.0.0 six>=1.10.0 # Testing requirements pytest responses profitbricks-sdk-python-3.1.0/setup.py000066400000000000000000000051211304175001700200210ustar00rootroot00000000000000""" Setup script for the ProfitBricks API Python client. """ from __future__ import print_function import codecs import os import re import sys from setuptools import setup from setuptools.command.test import test as TestCommand here = os.path.abspath(os.path.dirname(__file__)) def read(*parts): return codecs.open(os.path.join(here, *parts), 'r').read() def find_version(*file_paths): version_file = read(*file_paths) version_match = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]", version_file, re.M) if version_match: return version_match.group(1) raise RuntimeError("Unable to find version string.") if os.path.isfile("README.md"): long_desc = read('README.md') else: long_desc = "ProfitBricks API Client Library for Python" class PyTest(TestCommand): def finalize_options(self): TestCommand.finalize_options(self) self.test_args = ['--strict', '--verbose', '--tb=long', 'tests'] self.test_suite = True def run_tests(self): import pytest errno = pytest.main(self.test_args) sys.exit(errno) setup( name='profitbricks', version=find_version('profitbricks', '__init__.py'), description='ProfitBricks API Client Library for Python', long_description=long_desc, author='Matt Baldwin (stackpointcloud.com)', author_email='baldwin@stackpointcloud.com', url='https://github.com/profitbricks/profitbricks-sdk-python', download_url='https://github.com/profitbricks/profitbricks-sdk-python/tarball/3.0.0', install_requires=['requests>=2.0.0', 'six>=1.10.0'], packages=['profitbricks'], platforms='any', test_suite='profitbricks.test.test_profitbricks', cmdclass={'test': PyTest}, tests_require=['pytest'], license='Apache 2.0', keywords='profitbricks api client cloud', classifiers=['Development Status :: 5 - Production/Stable', 'Natural Language :: English', 'Environment :: Web Environment', 'Intended Audience :: Developers', 'License :: OSI Approved :: Apache Software License', 'Operating System :: POSIX', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 3', 'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: Software Development :: Libraries :: Application Frameworks', 'Topic :: Internet :: WWW/HTTP'], extras_require={ 'testing': ['pytest'], } ) profitbricks-sdk-python-3.1.0/tests/000077500000000000000000000000001304175001700174525ustar00rootroot00000000000000profitbricks-sdk-python-3.1.0/tests/helpers/000077500000000000000000000000001304175001700211145ustar00rootroot00000000000000profitbricks-sdk-python-3.1.0/tests/helpers/__init__.py000066400000000000000000000000001304175001700232130ustar00rootroot00000000000000profitbricks-sdk-python-3.1.0/tests/helpers/configuration.py000066400000000000000000000013271304175001700243400ustar00rootroot00000000000000import os # Default settings for testing. LOCATION = os.getenv('PROFITBRICKS_LOCATION', 'us/las') IMAGE_NAME = 'Ubuntu-16' # Note: Partial image name and case sensitive # Custom HTTP headers # Connection: close - prevents resource warnings in Python 3.4 HEADERS = {'Connection': 'close'} # Import environment variables for credentials. try: os.environ['PROFITBRICKS_USERNAME'] USERNAME = os.getenv('PROFITBRICKS_USERNAME') except KeyError: raise Exception('Please set the environment variable PROFITBRICKS_USERNAME') try: os.environ['PROFITBRICKS_PASSWORD'] PASSWORD = os.getenv('PROFITBRICKS_PASSWORD') except KeyError: raise Exception('Please set the environment variable PROFITBRICKS_PASSWORD') profitbricks-sdk-python-3.1.0/tests/helpers/resources.py000066400000000000000000000063131304175001700235030ustar00rootroot00000000000000import re import time from helpers import configuration def resource(): return { 'locations': ['us/las', 'de/fra', 'de/fkb'], 'vm_states': ['RUNNING', 'SHUTOFF'], 'uuid_match': re.compile( '^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$'), 'mac_match': re.compile( '^([0-9a-f]{2}[:]){5}([0-9a-f]{2})$'), 'datacenter': { 'name': 'Python SDK Test', 'description': 'Python SDK test datacenter', 'location': configuration.LOCATION }, 'server': { 'name': 'Python SDK Test', 'ram': 1024, 'cores': 1 }, 'volume': { 'name': 'Python SDK Test', 'size': 2, 'bus': 'VIRTIO', 'type': 'HDD', 'licence_type': 'UNKNOWN', }, 'volume_failure': { 'name': 'Negative Python SDK Test', 'size': 3, 'bus': 'VIRTIO', 'type': 'HDD', 'licence_type': 'UNKNOWN' }, 'snapshot': { 'name': 'Python SDK Test', 'description': 'Python SDK test snapshot' }, 'nic': { 'name': 'Python SDK Test', 'dhcp': True, 'lan': 1, 'firewall_active': True, 'nat': False }, 'fwrule': { 'name': 'SSH', 'protocol': 'TCP', 'source_mac': '01:23:45:67:89:00', 'source_ip': None, 'target_ip': None, 'port_range_start': 22, 'port_range_end': 22, 'icmp_type': None, 'icmp_code': None, }, 'loadbalancer': { 'name': 'Python SDK Test', 'dhcp': True }, 'lan': { # REST API converts names to lowercase. 'name': 'python sdk test', 'public': True, }, 'ipblock': { # REST API converts names to lowercase. 'name': 'python sdk test', 'location': configuration.LOCATION, 'size': 1 } } def find_image(conn, name): ''' Find image by partial name and location. ''' for item in conn.list_images()['items']: if (item['properties']['location'] == configuration.LOCATION and item['properties']['imageType'] == 'HDD' and name in item['properties']['name']): return item def wait_for_completion(conn, promise, msg, wait_timeout=300): if not promise: return wait_timeout = time.time() + wait_timeout while wait_timeout > time.time(): time.sleep(1) operation_result = conn.get_request( request_id=promise['requestId'], status=True) if operation_result['metadata']['status'] == "DONE": return elif operation_result['metadata']['status'] == "FAILED": raise Exception( 'Request failed to complete'.format( msg, str(promise['requestId'])) ) raise Exception( 'Timed out waiting for async operation {0} msg {1} to ' 'complete'.format( msg, str(promise['requestId'])) ) profitbricks-sdk-python-3.1.0/tests/test_datacenter_live.py000066400000000000000000000073461304175001700242260ustar00rootroot00000000000000import unittest from helpers import configuration from helpers.resources import resource, wait_for_completion from profitbricks.client import Datacenter from profitbricks.client import ProfitBricksService from six import assertRegex class TestDatacenter(unittest.TestCase): @classmethod def setUpClass(self): self.resource = resource() self.client = ProfitBricksService( username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) # Create test datacenter. self.datacenter = self.client.create_datacenter( datacenter=Datacenter(**self.resource['datacenter'])) @classmethod def tearDownClass(self): self.client.delete_datacenter(datacenter_id=self.datacenter['id']) def test_list(self): datacenters = self.client.list_datacenters() self.assertGreater(len(datacenters), 0) self.assertEqual(datacenters['items'][0]['type'], 'datacenter') def test_get(self): datacenter = self.client.get_datacenter( datacenter_id=self.datacenter['id']) assertRegex(self, datacenter['id'], self.resource['uuid_match']) self.assertEqual(datacenter['type'], 'datacenter') self.assertEqual(datacenter['id'], self.datacenter['id']) self.assertEqual(datacenter['properties']['name'], self.resource['datacenter']['name']) self.assertEqual(datacenter['properties']['description'], self.resource['datacenter']['description']) self.assertEqual(datacenter['properties']['location'], self.resource['datacenter']['location']) def test_delete(self): datacenter = self.client.create_datacenter( datacenter=Datacenter(**self.resource['datacenter'])) wait_for_completion(self.client, datacenter, 'create_datacenter') response = self.client.delete_datacenter( datacenter_id=datacenter['id']) self.assertTrue(response) def test_update(self): datacenter = self.client.update_datacenter( datacenter_id=self.datacenter['id'], description=self.resource['datacenter']['name']+' - RENAME') wait_for_completion(self.client, datacenter, 'update_datacenter') datacenter = self.client.get_datacenter(datacenter_id=self.datacenter['id']) assertRegex(self, datacenter['id'], self.resource['uuid_match']) self.assertEqual(datacenter['id'], self.datacenter['id']) self.assertEqual(datacenter['properties']['name'], self.resource['datacenter']['name']) self.assertEqual(datacenter['properties']['description'], self.resource['datacenter']['name']+' - RENAME') self.assertEqual(datacenter['properties']['location'], self.resource['datacenter']['location']) self.assertGreater(datacenter['properties']['version'], 1) def test_create_simple(self): datacenter = self.client.create_datacenter( datacenter=Datacenter(**self.resource['datacenter'])) wait_for_completion(self.client, datacenter, 'create_datacenter') assertRegex(self, datacenter['id'], self.resource['uuid_match']) self.assertEqual(datacenter['properties']['name'], self.resource['datacenter']['name']) self.assertEqual(datacenter['properties']['description'], self.resource['datacenter']['description']) self.assertEqual(datacenter['properties']['location'], self.resource['datacenter']['location']) response = self.client.delete_datacenter( datacenter_id=datacenter['id']) self.assertTrue(response) if __name__ == '__main__': unittest.main() profitbricks-sdk-python-3.1.0/tests/test_errors_live.py000066400000000000000000000035151304175001700234220ustar00rootroot00000000000000import unittest from profitbricks.client import ProfitBricksService, Datacenter, Volume from profitbricks.errors import * from tests.helpers import configuration from tests.helpers.resources import resource class TestErrors(unittest.TestCase): @classmethod def setUpClass(self): self.resource = resource() self.client = ProfitBricksService( username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) self.datacenter = self.client.create_datacenter( datacenter=Datacenter(**self.resource['datacenter'])) @classmethod def tearDownClass(self): self.client.delete_datacenter(datacenter_id=self.datacenter['id']) def test_pb_not_found(self): try: response = self.client.get_datacenter("fake_id") except PBError as err: self.assertTrue(isinstance(err, PBNotFoundError)) def test_pb_unauthorized_error(self): try: self.client = ProfitBricksService( username=configuration.USERNAME + "1", password=configuration.PASSWORD, headers=configuration.HEADERS) response = self.client.list_datacenters() except PBError as err: self.assertTrue(isinstance(err, PBNotAuthorizedError)) def test_pb_validation_error(self): try: i = Volume( name='Explicitly created volume', size=5, disk_type='HDD', image='fake_image_id', bus='VIRTIO') response = self.client.create_volume( datacenter_id=self.datacenter['id'], volume=i) except PBError as err: self.assertTrue(isinstance(err, PBValidationError)) if __name__ == '__main__': unittest.main() profitbricks-sdk-python-3.1.0/tests/test_image_live.py000066400000000000000000000035151304175001700231700ustar00rootroot00000000000000import unittest from helpers import configuration from helpers.resources import resource from profitbricks.client import ProfitBricksService from six import assertRegex class TestImage(unittest.TestCase): @classmethod def setUpClass(self): self.resource = resource() self.client = ProfitBricksService( username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) # Find an Ubuntu image for testing. for item in self.client.list_images()['items']: if (configuration.IMAGE_NAME in item['properties']['name'] and item['properties']['location'] == configuration.LOCATION): self.image = item def test_list_images(self): images = self.client.list_images() assertRegex(self, images['items'][0]['id'], self.resource['uuid_match']) self.assertGreater(len(images), 0) self.assertEqual(images['items'][0]['type'], 'image') self.assertTrue(self, len(images['items']) > 0) def test_get_image(self): image = self.client.get_image(self.image['id']) self.assertEqual(image['type'], 'image') self.assertEqual(image['id'], self.image['id']) self.assertIn(image['properties']['imageType'], ['HDD', 'CDROM']) # A custom image would need to be uploaded and referenced to perform the # following tests. Skipping for now. # def test_delete_image(self): # image = self.client.delete_image(image_id) # self.assertTrue(image) # def test_update_image(self): # image = self.client.update_image( # image_id, # name='New name') # self.assertEqual(image['properties']['name'], 'New name') if __name__ == '__main__': unittest.main() profitbricks-sdk-python-3.1.0/tests/test_ipblock_live.py000066400000000000000000000047341304175001700235350ustar00rootroot00000000000000import unittest from helpers import configuration from helpers.resources import resource from profitbricks.client import IPBlock from profitbricks.client import ProfitBricksService from six import assertRegex class TestIPBlock(unittest.TestCase): @classmethod def setUpClass(self): self.resource = resource() self.client = ProfitBricksService( username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) ipblock1 = IPBlock(**self.resource['ipblock']) self.ipblock1 = self.client.reserve_ipblock(ipblock1) ipblock2 = IPBlock(**self.resource['ipblock']) self.ipblock2 = self.client.reserve_ipblock(ipblock2) @classmethod def tearDownClass(self): self.client.delete_ipblock(self.ipblock1['id']) def test_list_ipblocks(self): ipblocks = self.client.list_ipblocks() assertRegex(self, ipblocks['items'][0]['id'], self.resource['uuid_match']) self.assertGreater(len(ipblocks), 0) assertRegex(self, ipblocks['items'][0]['id'], self.resource['uuid_match']) self.assertGreater(ipblocks['items'][0]['properties']['size'], 0) self.assertIn(ipblocks['items'][0]['properties']['location'], self.resource['locations']) def test_get_ipblock(self): ipblock = self.client.get_ipblock(self.ipblock1['id']) assertRegex(self, ipblock['id'], self.resource['uuid_match']) self.assertEqual(ipblock['id'], self.ipblock1['id']) self.assertEqual(ipblock['properties']['name'], (self.resource['ipblock']['name'])) self.assertEqual(ipblock['properties']['size'], self.resource['ipblock']['size']) self.assertEqual(ipblock['properties']['location'], self.resource['ipblock']['location']) def test_delete_ipblock(self): ipblock = self.client.delete_ipblock(self.ipblock2['id']) self.assertTrue(ipblock) def test_reserve_ipblock(self): ipblock = self.client.reserve_ipblock(IPBlock(**self.resource['ipblock'])) assertRegex(self, ipblock['id'], self.resource['uuid_match']) self.assertEqual(ipblock['properties']['name'], (self.resource['ipblock']['name'])) self.assertEqual(ipblock['properties']['size'], self.resource['ipblock']['size']) self.assertEqual(ipblock['properties']['location'], self.resource['ipblock']['location']) self.client.delete_ipblock(ipblock['id']) if __name__ == '__main__': unittest.main() profitbricks-sdk-python-3.1.0/tests/test_lan_live.py000066400000000000000000000126661304175001700226670ustar00rootroot00000000000000import unittest from helpers import configuration from helpers.resources import resource, wait_for_completion from profitbricks.client import ProfitBricksService from profitbricks.client import Datacenter, Server, LAN, NIC from six import assertRegex class TestLan(unittest.TestCase): @classmethod def setUpClass(self): self.resource = resource() self.client = ProfitBricksService( username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) # Create test datacenter. self.datacenter = self.client.create_datacenter( datacenter=Datacenter(**self.resource['datacenter'])) wait_for_completion(self.client, self.datacenter, 'create_datacenter') # Create test LAN. self.lan = self.client.create_lan( datacenter_id=self.datacenter['id'], lan=LAN(**self.resource['lan'])) wait_for_completion(self.client, self.lan, 'create_lan') # Create test server. self.server = self.client.create_server( datacenter_id=self.datacenter['id'], server=Server(**self.resource['server'])) wait_for_completion(self.client, self.server, 'create_server') # Create test NIC1. nic1 = NIC(**self.resource['nic']) nic1.lan = self.lan['id'] self.nic1 = self.client.create_nic( datacenter_id=self.datacenter['id'], server_id=self.server['id'], nic=nic1) wait_for_completion(self.client, self.nic1, 'create_nic1') # Create test NIC2. nic2 = NIC(**self.resource['nic']) nic2.lan = self.lan['id'] self.nic2 = self.client.create_nic( datacenter_id=self.datacenter['id'], server_id=self.server['id'], nic=nic2) wait_for_completion(self.client, self.nic2, 'create_nic2') @classmethod def tearDownClass(self): self.client.delete_datacenter(datacenter_id=self.datacenter['id']) def test_list_lans(self): lans = self.client.list_lans(datacenter_id=self.datacenter['id']) self.assertGreater(len(lans), 0) self.assertEqual(lans['items'][0]['type'], 'lan') self.assertIn(lans['items'][0]['id'], ('1', '2', '3')) self.assertEqual(lans['items'][0]['properties']['name'], self.resource['lan']['name']) self.assertTrue(lans['items'][0]['properties']['public'], self.resource['lan']['public']) def test_get_lan(self): lan = self.client.get_lan(datacenter_id=self.datacenter['id'], lan_id=self.lan['id']) self.assertEqual(lan['type'], 'lan') self.assertEqual(lan['id'], self.lan['id']) self.assertEqual(lan['properties']['name'], self.resource['lan']['name']) self.assertTrue(lan['properties']['public'], self.resource['lan']['public']) def test_delete_lan(self): lan = self.client.create_lan( datacenter_id=self.datacenter['id'], lan=LAN(**self.resource['lan'])) wait_for_completion(self.client, lan, 'create_lan') lan = self.client.delete_lan(datacenter_id=self.datacenter['id'], lan_id=lan['id']) self.assertTrue(lan) def test_update_lan(self): lan = self.client.update_lan( datacenter_id=self.datacenter['id'], lan_id=self.lan['id'], name=self.resource['lan']['name'] + ' RENAME', public=False) self.assertEqual(lan['type'], 'lan') self.assertEqual(lan['properties']['name'], self.resource['lan']['name'] + ' RENAME') self.assertFalse(lan['properties']['public']) def test_create_lan(self): self.assertEqual(self.lan['id'], '1') self.assertEqual(self.lan['type'], 'lan') self.assertEqual(self.lan['properties']['name'], self.resource['lan']['name']) self.assertEqual(self.lan['properties']['public'], self.resource['lan']['public']) def test_create_complex_lan(self): resource = NIC(**self.resource['nic']) nic1 = self.client.create_nic( datacenter_id=self.datacenter['id'], server_id=self.server['id'], nic=resource) wait_for_completion(self.client, nic1, 'create_nic1') self.assertFalse(nic1['properties']['nat']) self.assertEqual(nic1['properties']['name'], 'Python SDK Test') self.assertTrue(nic1['properties']['dhcp']) self.assertEqual(nic1['properties']['lan'], 1) self.assertTrue(nic1['properties']['firewallActive']) nics = [nic1['id']] lan = LAN(nics=nics, **self.resource['lan']) response = self.client.create_lan( datacenter_id=self.datacenter['id'], lan=lan) wait_for_completion(self.client, response, 'create_lan') self.assertEqual(response['type'], 'lan') self.assertEqual(response['properties']['name'], self.resource['lan']['name']) self.assertTrue(response['properties']['public']) def test_get_lan_members(self): members = self.client.get_lan_members( datacenter_id=self.datacenter['id'], lan_id=self.lan['id']) self.assertGreater(len(members), 0) self.assertEqual(members['items'][0]['type'], 'nic') self.assertEqual(members['items'][0]['properties']['name'], self.resource['nic']['name']) assertRegex(self, members['items'][0]['properties']['mac'], self.resource['mac_match']) if __name__ == '__main__': unittest.main() profitbricks-sdk-python-3.1.0/tests/test_location_live.py000066400000000000000000000017631304175001700237210ustar00rootroot00000000000000import unittest from helpers import configuration from helpers.resources import resource from profitbricks.client import ProfitBricksService class TestLocation(unittest.TestCase): @classmethod def setUpClass(self): self.resource = resource() self.client = ProfitBricksService( username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) def test_list_locations(self): locations = self.client.list_locations() self.assertEqual(len(locations), 4) for location in locations['items']: self.assertEqual(location['type'], 'location') self.assertIn(location['id'], self.resource['locations']) def test_get_location(self): location = self.client.get_location(configuration.LOCATION) self.assertEqual(location['type'], 'location') self.assertEqual(location['id'], configuration.LOCATION) if __name__ == '__main__': unittest.main() profitbricks-sdk-python-3.1.0/tests/test_server_live.py000066400000000000000000000302301304175001700234060ustar00rootroot00000000000000import unittest from helpers import configuration from helpers.resources import resource, wait_for_completion from profitbricks.client import Datacenter, Server, Volume, NIC, FirewallRule from profitbricks.client import ProfitBricksService from six import assertRegex class TestServer(unittest.TestCase): @classmethod def setUpClass(self): self.resource = resource() self.client = ProfitBricksService( username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) # Create test datacenter. self.datacenter = self.client.create_datacenter( datacenter=Datacenter(**self.resource['datacenter'])) wait_for_completion(self.client, self.datacenter, 'create_datacenter') # Create test volume1. self.volume1 = self.client.create_volume( datacenter_id=self.datacenter['id'], volume=Volume(**self.resource['volume'])) wait_for_completion(self.client, self.volume1, 'create_volume') # Create test volume2 (attach volume test). self.volume2 = self.client.create_volume( datacenter_id=self.datacenter['id'], volume=Volume(**self.resource['volume'])) wait_for_completion(self.client, self.volume2, 'create_volume') # Create test server. server = Server(**self.resource['server']) server.attach_volumes = [self.volume1['id']] self.server = self.client.create_server( datacenter_id=self.datacenter['id'], server=server) wait_for_completion(self.client, self.server, 'create_server') # Create test NIC. self.nic = self.client.create_nic( datacenter_id=self.datacenter['id'], server_id=self.server['id'], nic=NIC(**self.resource['nic'])) wait_for_completion(self.client, self.nic, 'create_nic') # Find an Ubuntu image for testing. for item in self.client.list_images()['items']: if (configuration.IMAGE_NAME in item['properties']['name'] and item['properties']['location'] == configuration.LOCATION): self.image = item @classmethod def tearDownClass(self): self.client.delete_datacenter(datacenter_id=self.datacenter['id']) def test_list(self): servers = self.client.list_servers(datacenter_id=self.datacenter['id']) self.assertGreater(len(servers), 0) self.assertEqual(servers['items'][0]['type'], 'server') self.assertTrue(self, len(servers['items']) > 0) assertRegex(self, servers['items'][0]['id'], self.resource['uuid_match']) def test_get(self): server = self.client.get_server( datacenter_id=self.datacenter['id'], server_id=self.server['id'] ) self.assertEqual(server['type'], 'server') self.assertEqual(server['id'], self.server['id']) self.assertEqual(server['properties']['name'], self.resource['server']['name']) self.assertEqual(server['properties']['cores'], self.resource['server']['cores']) self.assertEqual(server['properties']['ram'], self.resource['server']['ram']) def test_delete(self): server = self.client.create_server( datacenter_id=self.datacenter['id'], server=Server(**self.resource['server']) ) wait_for_completion(self.client, server, 'create_server') response = self.client.delete_server( datacenter_id=self.datacenter['id'], server_id=server['id'] ) self.assertTrue(response) def test_update(self): server = self.client.update_server( datacenter_id=self.datacenter['id'], server_id=self.server['id'], name=self.resource['server']['name'] + ' RENAME') wait_for_completion(self.client, server, 'update_server') server = self.client.get_server( datacenter_id=self.datacenter['id'], server_id=self.server['id'] ) self.assertEqual(server['id'], self.server['id']) self.assertEqual(server['properties']['name'], self.resource['server']['name'] + ' RENAME') self.assertEqual(server['properties']['cores'], self.resource['server']['cores']) self.assertEqual(server['properties']['ram'], self.resource['server']['ram']) def test_create_simple(self): # Use server created dring server test setup assertRegex(self, self.server['id'], self.resource['uuid_match']) self.assertEqual(self.server['type'], 'server') self.assertEqual(self.server['properties']['name'], self.resource['server']['name']) self.assertEqual(self.server['properties']['cores'], self.resource['server']['cores']) self.assertEqual(self.server['properties']['ram'], self.resource['server']['ram']) self.assertIsNone(self.server['properties']['availabilityZone']) self.assertIsNone(self.server['properties']['vmState']) def test_create_complex(self): fwrule = FirewallRule(**self.resource['fwrule']) nic = NIC(firewall_rules=[fwrule], **self.resource['nic']) volume = Volume(image=self.image['id'], image_password='secretpassword123', ssh_keys=['ssh-rsa AAAAB3NzaC1'], **self.resource['volume']) server = Server( nics=[nic], create_volumes=[volume], **self.resource['server']) composite_server = self.client.create_server( datacenter_id=self.datacenter['id'], server=server) wait_for_completion(self.client, composite_server, 'create_server', wait_timeout=600) composite_server = self.client.get_server( datacenter_id=self.datacenter['id'], server_id=composite_server['id']) assertRegex(self, composite_server['id'], self.resource['uuid_match']) self.assertEqual(composite_server['properties']['name'], self.resource['server']['name']) self.assertEqual(composite_server['properties']['cores'], self.resource['server']['cores']) self.assertEqual(composite_server['properties']['ram'], self.resource['server']['ram']) self.assertEqual(composite_server['properties']['availabilityZone'], 'AUTO') self.assertIn(composite_server['properties']['vmState'], self.resource['vm_states']) def test_start_server(self): server = self.client.start_server( datacenter_id=self.datacenter['id'], server_id=self.server['id']) self.assertTrue(server) def test_stop_server(self): server = self.client.stop_server( datacenter_id=self.datacenter['id'], server_id=self.server['id']) self.assertTrue(server) def test_reboot_server(self): server = self.client.reboot_server( datacenter_id=self.datacenter['id'], server_id=self.server['id']) self.assertTrue(server) def test_get_attached_volumes(self): servers = self.client.get_attached_volumes( datacenter_id=self.datacenter['id'], server_id=self.server['id']) self.assertGreater(len(servers), 0) self.assertEqual(servers['items'][0]['id'], self.volume1['id']) self.assertEqual(servers['items'][0]['properties']['name'], self.resource['volume']['name']) self.assertEqual(servers['items'][0]['properties']['size'], self.resource['volume']['size']) self.assertEqual(servers['items'][0]['properties']['bus'], self.resource['volume']['bus']) self.assertEqual(servers['items'][0]['properties']['type'], self.resource['volume']['type']) self.assertEqual(servers['items'][0]['properties']['licenceType'], 'UNKNOWN') self.assertIsNone(servers['items'][0]['properties']['image']) self.assertIsNone(servers['items'][0]['properties']['imagePassword']) self.assertFalse(servers['items'][0]['properties']['cpuHotPlug']) self.assertFalse(servers['items'][0]['properties']['cpuHotUnplug']) self.assertFalse(servers['items'][0]['properties']['ramHotPlug']) self.assertFalse(servers['items'][0]['properties']['ramHotUnplug']) self.assertFalse(servers['items'][0]['properties']['nicHotPlug']) self.assertFalse(servers['items'][0]['properties']['nicHotUnplug']) self.assertFalse(servers['items'][0]['properties']['discVirtioHotPlug']) self.assertFalse(servers['items'][0]['properties']['discVirtioHotUnplug']) self.assertFalse(servers['items'][0]['properties']['discScsiHotPlug']) self.assertFalse(servers['items'][0]['properties']['discScsiHotUnplug']) def test_get_attached_volume(self): server = self.client.get_attached_volume( datacenter_id=self.datacenter['id'], server_id=self.server['id'], volume_id=self.volume1['id']) self.assertEqual(server['id'], self.volume1['id']) self.assertEqual(server['properties']['name'], self.resource['volume']['name']) self.assertEqual(server['properties']['size'], self.resource['volume']['size']) self.assertEqual(server['properties']['bus'], self.resource['volume']['bus']) self.assertEqual(server['properties']['type'], self.resource['volume']['type']) self.assertEqual(server['properties']['licenceType'], self.resource['volume']['licence_type']) self.assertIsNone(server['properties']['image']) self.assertIsNone(server['properties']['imagePassword']) self.assertFalse(server['properties']['cpuHotPlug']) self.assertFalse(server['properties']['cpuHotUnplug']) self.assertFalse(server['properties']['ramHotPlug']) self.assertFalse(server['properties']['ramHotUnplug']) self.assertFalse(server['properties']['nicHotPlug']) self.assertFalse(server['properties']['nicHotUnplug']) self.assertFalse(server['properties']['discVirtioHotPlug']) self.assertFalse(server['properties']['discVirtioHotUnplug']) self.assertFalse(server['properties']['discScsiHotPlug']) self.assertFalse(server['properties']['discScsiHotUnplug']) def test_attach_volume(self): volume = self.client.attach_volume( datacenter_id=self.datacenter['id'], server_id=self.server['id'], volume_id=self.volume2['id']) wait_for_completion(self.client, volume, 'attach_volume') self.assertEqual(volume['id'], self.volume2['id']) self.assertEqual(volume['properties']['name'], self.resource['volume']['name']) self.assertEqual(volume['properties']['size'], self.resource['volume']['size']) self.assertEqual(volume['properties']['type'], self.resource['volume']['type']) self.assertEqual(volume['properties']['licenceType'], self.resource['volume']['licence_type']) self.assertIsNone(volume['properties']['bus']) self.assertIsNone(volume['properties']['image']) self.assertIsNone(volume['properties']['imagePassword']) self.assertFalse(volume['properties']['cpuHotPlug']) self.assertFalse(volume['properties']['cpuHotUnplug']) self.assertFalse(volume['properties']['ramHotPlug']) self.assertFalse(volume['properties']['ramHotUnplug']) self.assertFalse(volume['properties']['nicHotPlug']) self.assertFalse(volume['properties']['nicHotUnplug']) self.assertFalse(volume['properties']['discVirtioHotPlug']) self.assertFalse(volume['properties']['discVirtioHotUnplug']) self.assertFalse(volume['properties']['discScsiHotPlug']) self.assertFalse(volume['properties']['discScsiHotUnplug']) self.client.detach_volume( datacenter_id=self.datacenter['id'], server_id=self.server['id'], volume_id=self.volume2['id']) def test_detach_volume(self): volume = self.client.detach_volume( datacenter_id=self.datacenter['id'], server_id=self.server['id'], volume_id=self.volume1['id']) self.assertTrue(volume) if __name__ == '__main__': unittest.main() profitbricks-sdk-python-3.1.0/tests/test_volume_live.py000066400000000000000000000221551304175001700234160ustar00rootroot00000000000000import unittest from helpers import configuration from helpers.resources import resource, wait_for_completion, find_image from profitbricks.client import Datacenter, Volume from profitbricks.client import ProfitBricksService from six import assertRegex class TestVolume(unittest.TestCase): @classmethod def setUpClass(self): self.resource = resource() self.client = ProfitBricksService( username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) # Create test datacenter self.datacenter = self.client.create_datacenter( datacenter=Datacenter(**self.resource['datacenter'])) wait_for_completion(self.client, self.datacenter, 'create_datacenter') # Create test volume self.volume = self.client.create_volume( datacenter_id=self.datacenter['id'], volume=Volume(**self.resource['volume'])) wait_for_completion(self.client, self.volume, 'create_volume') # Create snapshot1 self.snapshot1 = self.client.create_snapshot( datacenter_id=self.datacenter['id'], volume_id=self.volume['id'], name=self.resource['snapshot']['name'], description=self.resource['snapshot']['description']) wait_for_completion(self.client, self.snapshot1, 'create_snapshot1', wait_timeout=600) self.image = find_image(self.client, configuration.IMAGE_NAME) @classmethod def tearDownClass(self): self.client.delete_datacenter(datacenter_id=self.datacenter['id']) def test_list_volumes(self): volumes = self.client.list_volumes( datacenter_id=self.datacenter['id']) self.assertGreater(len(volumes), 0) assertRegex(self, volumes['items'][0]['id'], self.resource['uuid_match']) self.assertEqual(volumes['items'][0]['type'], 'volume') self.assertEqual(volumes['items'][0]['properties']['name'], self.resource['volume']['name']) self.assertEqual(volumes['items'][0]['properties']['size'], self.resource['volume']['size']) self.assertEqual(volumes['items'][0]['properties']['licenceType'], self.resource['volume']['licence_type']) self.assertEqual(volumes['items'][0]['properties']['type'], self.resource['volume']['type']) self.assertFalse(volumes['items'][0]['properties']['cpuHotPlug']) self.assertFalse(volumes['items'][0]['properties']['cpuHotUnplug']) self.assertFalse(volumes['items'][0]['properties']['ramHotPlug']) self.assertFalse(volumes['items'][0]['properties']['ramHotUnplug']) self.assertFalse(volumes['items'][0]['properties']['nicHotPlug']) self.assertFalse(volumes['items'][0]['properties']['nicHotUnplug']) self.assertFalse(volumes['items'][0]['properties']['discVirtioHotPlug']) self.assertFalse(volumes['items'][0]['properties']['discVirtioHotUnplug']) self.assertFalse(volumes['items'][0]['properties']['discScsiHotPlug']) self.assertFalse(volumes['items'][0]['properties']['discScsiHotUnplug']) self.assertIsNone(volumes['items'][0]['properties']['bus']) def test_get_volume(self): volume = self.client.get_volume( datacenter_id=self.datacenter['id'], volume_id=self.volume['id']) self.assertEqual(volume['id'], self.volume['id']) self.assertEqual(volume['type'], 'volume') self.assertEqual(volume['properties']['name'], self.resource['volume']['name']) self.assertEqual(volume['properties']['size'], self.resource['volume']['size']) self.assertEqual(volume['properties']['licenceType'], self.resource['volume']['licence_type']) self.assertEqual(volume['properties']['type'], self.resource['volume']['type']) self.assertFalse(volume['properties']['cpuHotPlug']) self.assertFalse(volume['properties']['cpuHotUnplug']) self.assertFalse(volume['properties']['ramHotPlug']) self.assertFalse(volume['properties']['ramHotUnplug']) self.assertFalse(volume['properties']['nicHotPlug']) self.assertFalse(volume['properties']['nicHotUnplug']) self.assertFalse(volume['properties']['discVirtioHotPlug']) self.assertFalse(volume['properties']['discVirtioHotUnplug']) self.assertFalse(volume['properties']['discScsiHotPlug']) self.assertFalse(volume['properties']['discScsiHotUnplug']) self.assertIsNone(volume['properties']['bus']) def test_delete_volume(self): volume = self.client.create_volume( datacenter_id=self.datacenter['id'], volume=Volume(**self.resource['volume'])) wait_for_completion(self.client, volume, 'create_volume') volume = self.client.delete_volume( datacenter_id=self.datacenter['id'], volume_id=volume['id']) self.assertTrue(volume) def test_update_volume(self): volume = self.client.update_volume( datacenter_id=self.datacenter['id'], volume_id=self.volume['id'], size=6, name=self.resource['volume']['name'] + ' RENAME') wait_for_completion(self.client, volume, 'update_volume') volume = self.client.get_volume( datacenter_id=self.datacenter['id'], volume_id=self.volume['id']) self.assertEqual(volume['id'], self.volume['id']) self.assertEqual(volume['properties']['name'], self.resource['volume']['name'] + ' RENAME') self.assertEqual(volume['properties']['size'], 6) def test_create_volume(self): # Use volume created during volume test setup. self.assertEqual(self.volume['properties']['name'], self.resource['volume']['name']) self.assertEqual(self.volume['properties']['bus'], self.resource['volume']['bus']) self.assertEqual(self.volume['properties']['type'], self.resource['volume']['type']) self.assertEqual(self.volume['properties']['size'], self.resource['volume']['size']) self.assertEqual(self.volume['properties']['licenceType'], self.resource['volume']['licence_type']) self.assertFalse(self.volume['properties']['cpuHotPlug']) self.assertFalse(self.volume['properties']['cpuHotUnplug']) self.assertFalse(self.volume['properties']['ramHotPlug']) self.assertFalse(self.volume['properties']['ramHotUnplug']) self.assertFalse(self.volume['properties']['nicHotPlug']) self.assertFalse(self.volume['properties']['nicHotUnplug']) self.assertFalse(self.volume['properties']['discVirtioHotPlug']) self.assertFalse(self.volume['properties']['discVirtioHotUnplug']) self.assertFalse(self.volume['properties']['discScsiHotPlug']) self.assertFalse(self.volume['properties']['discScsiHotUnplug']) def test_create_snapshot(self): # Use snapshot created during volume test setup. self.assertEqual(self.snapshot1['type'], 'snapshot') self.assertEqual(self.snapshot1['properties']['name'], self.resource['snapshot']['name']) self.assertEqual(self.snapshot1['properties']['description'], self.resource['snapshot']['description']) self.assertEqual(self.snapshot1['properties']['location'], configuration.LOCATION) self.assertFalse(self.snapshot1['properties']['cpuHotPlug']) self.assertFalse(self.snapshot1['properties']['cpuHotUnplug']) self.assertFalse(self.snapshot1['properties']['ramHotPlug']) self.assertFalse(self.snapshot1['properties']['ramHotUnplug']) self.assertFalse(self.snapshot1['properties']['nicHotPlug']) self.assertFalse(self.snapshot1['properties']['nicHotUnplug']) self.assertFalse(self.snapshot1['properties']['discVirtioHotPlug']) self.assertFalse(self.snapshot1['properties']['discVirtioHotUnplug']) self.assertFalse(self.snapshot1['properties']['discScsiHotPlug']) self.assertFalse(self.snapshot1['properties']['discScsiHotUnplug']) self.assertIsNone(self.snapshot1['properties']['size']) self.assertIsNone(self.snapshot1['properties']['licenceType']) def test_restore_snapshot(self): response = self.client.restore_snapshot( datacenter_id=self.datacenter['id'], volume_id=self.volume['id'], snapshot_id=self.snapshot1['id']) self.assertTrue(response) def test_remove_snapshot(self): volume = self.client.remove_snapshot(snapshot_id=self.snapshot1['id']) self.assertTrue(volume) def test_create_volume_failure(self): with self.assertRaises(Exception) as context: self.client.create_volume( datacenter_id=self.datacenter['id'], volume=Volume(image=self.image['id'], **self.resource['volume_failure'])) exception = ('Passwords/SSH Keys ' 'are mandatory for public ProfitBricks Images.') self.assertIn(exception, str(context.exception)) if __name__ == '__main__': unittest.main() profitbricks-sdk-python-3.1.0/tox.ini000066400000000000000000000010121304175001700176150ustar00rootroot00000000000000# Tox (http://tox.testrun.org/) is a tool for running tests # in multiple virtualenvs. This configuration file will run the # test suite on all supported python versions. To use it, "pip install tox" # and then run "tox" from this directory. # # tox.ini is also used for local default parameters for pepe8 and flake8 # [tox] envlist = py27, py34 [testenv] commands = {envpython} setup.py test deps = requests [pep8] max-line-length = 99 exclude = build,debian [flake8] max-line-length = 99 exclude = build,debian