def main(): module = AnsibleModule(argument_spec=dict( name=dict(type='str'), location=dict(type='str', choices=LOCATIONS, default='us/las'), size=dict(type='int', default=1), api_url=dict(type='str', default=None), username=dict(type='str', required=True, aliases=['subscription_user'], fallback=(env_fallback, ['PROFITBRICKS_USERNAME'])), password=dict(type='str', required=True, aliases=['subscription_password'], fallback=(env_fallback, ['PROFITBRICKS_PASSWORD']), no_log=True), wait=dict(type='bool', default=True), wait_timeout=dict(type='int', default=600), state=dict(type='str', default='present'), ), supports_check_mode=True) if not HAS_PB_SDK: module.fail_json( msg= 'profitbricks is required for this module, run `pip install profitbricks`' ) username = module.params.get('username') password = module.params.get('password') api_url = module.params.get('api_url') if not api_url: profitbricks = ProfitBricksService(username=username, password=password) else: profitbricks = ProfitBricksService(username=username, password=password, host_base=api_url) user_agent = 'profitbricks-sdk-python/%s Ansible/%s' % (sdk_version, __version__) profitbricks.headers = {'User-Agent': user_agent} state = module.params.get('state') if state == 'absent': try: (changed) = delete_ipblock(module, profitbricks) module.exit_json(changed=changed) except Exception as e: module.fail_json(msg='failed to set IPBlock state: %s' % to_native(e)) elif state == 'present': try: (ipblock_dict) = reserve_ipblock(module, profitbricks) module.exit_json(**ipblock_dict) except Exception as e: module.fail_json(msg='failed to set IPBlocks state: %s' % to_native(e))
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) def test_get_failure(self): try: self.client.get_location( location_id='00000000-0000-0000-0000-000000000000') except PBNotFoundError as e: self.assertIn(self.resource['not_found_error'], e.content[0]['message'])
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 'Ubuntu-15' in item['properties']['name'] and item['properties']['location'] == configuration.LOCATION: self.image = item def test_list_images(self): images = self.client.list_images() self.assertGreater(len(images), 0) self.assertEqual(images['items'][0]['type'], 'image') assertRegex(self, images['items'][0]['id'], self.resource['uuid_match']) 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'])
def __init__(self): ''' Main execution path ''' self.data = {} self.inventory = {} # Ansible Inventory self.vars = {} # Defaults, if not found in the settings file self.cache_path = '.' self.cache_max_age = 0 # # Read settings, environment variables, and CLI arguments self.read_cli_args() self.read_settings() self.read_environment() if not getattr(self, 'subscription_password', None) and getattr( self, 'subscription_password_file', None): self.subscription_password = read_password_file( self.subscription_password_file) self.cache_filename = self.cache_path + "/ansible-profitbricks.cache" # Verify credentials and create client if hasattr(self, 'subscription_user') and hasattr( self, 'subscription_password'): base_url = API_HOST if hasattr(self, 'api_url'): base_url = self.api_url user_agent = 'profitbricks-sdk-python/%s - Ansible' % (sdk_version) headers = {'User-Agent': user_agent} self.client = ProfitBricksService( username=self.subscription_user, password=self.subscription_password, host_base=base_url, headers=headers) else: sys.stderr.write( 'ERROR: ProfitBricks credentials cannot be found.\n') sys.exit(1) if self.cache_max_age > 0: if not self.is_cache_valid() or self.args.refresh: self.data = self.fetch_resources('all') self.build_inventory() self.write_to_cache() else: self.load_from_cache() print_data = self.get_from_local_source() else: print_data = self.get_from_api_source() print( json.dumps(print_data, sort_keys=False, indent=2, separators=(',', ': ')))
class TestImage(unittest.TestCase): def setUp(self): self.image = ProfitBricksService( username='******', password='******') def test_list_images(self): images = self.image.list_images() self.assertEqual(len(images), 4) self.assertEqual( images['items'][0]['id'], '7df81087-5835-41c6-a10b-3e098593bbd2') def test_get_image(self): image_id = '7df81087-5835-41c6-a10b-3e098593bbd2' image = self.image.get_image(image_id) self.assertEqual(image['properties']['name'], 'Ubuntu 14.04') def test_delete_image(self): image_id = '7df81087-5835-41c6-a10b-3e098593bbd2' image = self.image.delete_image(image_id) self.assertTrue(image) def test_update_image(self): image_id = '7df81087-5835-41c6-a10b-3e098593bbd2' image = self.image.update_image( image_id, name='New name') self.assertEqual(image['properties']['name'], 'New name')
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'])) self.client.wait_for_completion(self.datacenter) self.image = find_image(self.client, configuration.IMAGE_NAME) # Create test volume vol = Volume(**self.resource['volume2']) vol.image = self.image['id'] self.volume = self.client.create_volume( datacenter_id=self.datacenter['id'], volume=vol) self.client.wait_for_completion(self.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']) self.client.wait_for_completion(self.snapshot1, timeout=600)
def setUpClass(self): self.resource = resource() self.client = ProfitBricksService(username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) self.requests = self.client.list_requests() self.request = self.requests['items'][0]
def main(): module = AnsibleModule(argument_spec=dict( datacenter=dict(type='str'), server=dict(type='str'), volume=dict(type='str'), subscription_user=dict( type='str', default=os.environ.get('PROFITBRICKS_USERNAME')), subscription_password=dict( type='str', default=os.environ.get('PROFITBRICKS_PASSWORD')), wait=dict(type='bool', default=True), wait_timeout=dict(type='int', default=600), state=dict(type='str', default='present'), )) if not HAS_PB_SDK: module.fail_json(msg='profitbricks required for this module') if not module.params.get('subscription_user'): module.fail_json( msg='subscription_user parameter or ' + 'PROFITBRICKS_USERNAME environment variable is required.') if not module.params.get('subscription_password'): module.fail_json( msg='subscription_password parameter or ' + 'PROFITBRICKS_PASSWORD environment variable is required.') if not module.params.get('datacenter'): module.fail_json(msg='datacenter parameter is required') if not module.params.get('server'): module.fail_json(msg='server parameter is required') if not module.params.get('volume'): module.fail_json(msg='volume parameter is required') subscription_user = module.params.get('subscription_user') subscription_password = module.params.get('subscription_password') profitbricks = ProfitBricksService(username=subscription_user, password=subscription_password) user_agent = 'profitbricks-sdk-ruby/%s Ansible/%s' % (sdk_version, __version__) profitbricks.headers = {'User-Agent': user_agent} state = module.params.get('state') if state == 'absent': try: (changed) = detach_volume(module, profitbricks) module.exit_json(changed=changed) except Exception as e: module.fail_json(msg='failed to set volume_attach state: %s' % str(e)) elif state == 'present': try: attach_volume(module, profitbricks) module.exit_json() except Exception as e: module.fail_json(msg='failed to set volume_attach state: %s' % str(e))
def main(): module = AnsibleModule( argument_spec=dict( datacenter=dict(type='str', required=True), server=dict(type='str', required=True), nic=dict(type='str', required=True), name=dict(type='str', required=True), protocol=dict(type='str', choices=PROTOCOLS, required=False), source_mac=dict(type='str', default=None), source_ip=dict(type='str', default=None), target_ip=dict(type='str', default=None), port_range_start=dict(type='int', default=None), port_range_end=dict(type='int', default=None), icmp_type=dict(type='int', default=None), icmp_code=dict(type='int', default=None), subscription_user=dict(type='str', default=os.environ.get('PROFITBRICKS_USERNAME')), subscription_password=dict(type='str', default=os.environ.get('PROFITBRICKS_PASSWORD')), wait=dict(type='bool', default=True), wait_timeout=dict(type='int', default=600), state=dict(type='str', default='present'), ) ) if not HAS_PB_SDK: module.fail_json(msg='profitbricks required for this module') if not module.params.get('subscription_user'): module.fail_json(msg='subscription_user parameter or ' + 'PROFITBRICKS_USERNAME environment variable is required.') if not module.params.get('subscription_password'): module.fail_json(msg='subscription_password parameter or ' + 'PROFITBRICKS_PASSWORD environment variable is required.') subscription_user = module.params.get('subscription_user') subscription_password = module.params.get('subscription_password') profitbricks = ProfitBricksService( username=subscription_user, password=subscription_password) user_agent = 'profitbricks-sdk-ruby/%s Ansible/%s' % (sdk_version, __version__) profitbricks.headers = {'User-Agent': user_agent} state = module.params.get('state') if state == 'absent': try: (changed) = delete_firewall_rule(module, profitbricks) module.exit_json(changed=changed) except Exception as e: module.fail_json(msg='failed to set firewall rule state: %s' % str(e)) elif state == 'present': try: (firewall_rule_dict) = create_firewall_rule(module, profitbricks) module.exit_json(**firewall_rule_dict) except Exception as e: module.fail_json(msg='failed to set firewall rules state: %s' % str(e))
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']))
def setUpClass(self): self.resource = resource() self.client = ProfitBricksService(username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) ipblock1 = IPBlock(**self.resource['ipblock']) ipblock1.size = 2 self.ipblock1 = self.client.reserve_ipblock(ipblock1) ipblock2 = IPBlock(**self.resource['ipblock']) self.ipblock2 = self.client.reserve_ipblock(ipblock2)
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'])
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'])) self.client.wait_for_completion(self.datacenter) # Create test LAN. self.lan = self.client.create_lan(datacenter_id=self.datacenter['id'], lan=LAN(**self.resource['lan'])) self.client.wait_for_completion(self.lan) # Create test server. self.server = self.client.create_server( datacenter_id=self.datacenter['id'], server=Server(**self.resource['server'])) self.client.wait_for_completion(self.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) self.client.wait_for_completion(self.nic1) # Create test Firewall Rule fwrule = FirewallRule(**self.resource['fwrule']) self.fwrule = self.client.create_firewall_rule( datacenter_id=self.datacenter['id'], server_id=self.server['id'], nic_id=self.nic1['id'], firewall_rule=fwrule) self.client.wait_for_completion(self.fwrule) # Create test Firewall Rule 2 fwrule2 = FirewallRule(**self.resource['fwrule']) fwrule2.port_range_start = 8080 fwrule2.port_range_end = 8080 fwrule2.name = "8080" self.fwrule2 = self.client.create_firewall_rule( datacenter_id=self.datacenter['id'], server_id=self.server['id'], nic_id=self.nic1['id'], firewall_rule=fwrule2) self.client.wait_for_completion(self.fwrule2)
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)
def main(): module = AnsibleModule(argument_spec=dict( datacenter=dict(), server=dict(), name=dict(), size=dict(type='int', default=10), bus=dict(choices=['VIRTIO', 'IDE'], default='VIRTIO'), image=dict(), image_password=dict(default=None), ssh_keys=dict(type='list', default=[]), disk_type=dict(choices=['HDD', 'SSD'], default='HDD'), licence_type=dict(default='UNKNOWN'), count=dict(type='int', default=1), auto_increment=dict(type='bool', default=True), instance_ids=dict(type='list', default=[]), subscription_user=dict(), subscription_password=dict(), wait=dict(type='bool', default=True), wait_timeout=dict(type='int', default=600), state=dict(default='present'), )) if not module.params.get('subscription_user'): module.fail_json(msg='subscription_user parameter is required') if not module.params.get('subscription_password'): module.fail_json(msg='subscription_password parameter is required') subscription_user = module.params.get('subscription_user') subscription_password = module.params.get('subscription_password') profitbricks = ProfitBricksService(username=subscription_user, password=subscription_password) state = module.params.get('state') if state == 'absent': if not module.params.get('datacenter'): module.fail_json( msg= 'datacenter parameter is required for running or stopping machines.' ) try: (changed) = delete_volume(module, profitbricks) module.exit_json(changed=changed) except Exception as e: module.fail_json(msg='failed to set volume state: %s' % str(e)) elif state == 'present': if not module.params.get('datacenter'): module.fail_json( msg='datacenter parameter is required for new instance') if not module.params.get('name'): module.fail_json(msg='name parameter is required for new instance') try: (volume_dict_array) = create_volume(module, profitbricks) module.exit_json(**volume_dict_array) except Exception as e: module.fail_json(msg='failed to set volume state: %s' % str(e))
def main(): module = AnsibleModule( argument_spec=dict( datacenter=dict(), server=dict(), name=dict(default=str(uuid.uuid4()).replace('-','')[:10]), lan=dict(), subscription_user=dict(), subscription_password=dict(no_log=True), wait=dict(type='bool', default=True), wait_timeout=dict(type='int', default=600), state=dict(default='present'), ) ) if not HAS_PB_SDK: module.fail_json(msg='profitbricks required for this module') if not module.params.get('subscription_user'): module.fail_json(msg='subscription_user parameter is required') if not module.params.get('subscription_password'): module.fail_json(msg='subscription_password parameter is required') if not module.params.get('datacenter'): module.fail_json(msg='datacenter parameter is required') if not module.params.get('server'): module.fail_json(msg='server parameter is required') subscription_user = module.params.get('subscription_user') subscription_password = module.params.get('subscription_password') profitbricks = ProfitBricksService( username=subscription_user, password=subscription_password) state = module.params.get('state') if state == 'absent': if not module.params.get('name'): module.fail_json(msg='name parameter is required') try: (changed) = delete_nic(module, profitbricks) module.exit_json(changed=changed) except Exception as e: module.fail_json(msg='failed to set nic state: %s' % str(e)) elif state == 'present': if not module.params.get('lan'): module.fail_json(msg='lan parameter is required') try: (nic_dict) = create_nic(module, profitbricks) module.exit_json(nics=nic_dict) except Exception as e: module.fail_json(msg='failed to set nic state: %s' % str(e))
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'])) self.client.wait_for_completion(self.datacenter) # Create test volume volume = Volume(**self.resource['volume']) self.volume = self.client.create_volume( datacenter_id=self.datacenter['id'], volume=volume) self.client.wait_for_completion(self.volume) # Create test volume1 volume1 = Volume(**self.resource['volume']) self.volume1 = self.client.create_volume( datacenter_id=self.datacenter['id'], volume=volume1) self.client.wait_for_completion(self.volume1) # Create test snapshot snapshot = Snapshot(**self.resource['snapshot']) self.snapshot1 = self.client.create_snapshot( datacenter_id=self.datacenter['id'], volume_id=self.volume['id'], name=snapshot.name, description=snapshot.description) self.client.wait_for_completion(self.snapshot1) # Create test snapshot2 self.snapshot2 = self.client.create_snapshot( datacenter_id=self.datacenter['id'], volume_id=self.volume['id'], name="python sdk test snapshot", description="snapshot test description") self.client.wait_for_completion(self.snapshot2)
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'])) self.client.wait_for_completion(self.datacenter) # Create test LAN. self.lan = self.client.create_lan( datacenter_id=self.datacenter['id'], lan=LAN(name=self.resource['lan']['name'], public=False)) self.client.wait_for_completion(self.lan) # Create test server. self.server = self.client.create_server( datacenter_id=self.datacenter['id'], server=Server(**self.resource['server'])) self.client.wait_for_completion(self.server) # Create test NIC1. nic1 = NIC(**self.resource['nic']) nic1.lan = self.lan['id'] self.ips = ['10.0.0.1'] nic1.ips = self.ips self.nic1 = self.client.create_nic( datacenter_id=self.datacenter['id'], server_id=self.server['id'], nic=nic1) self.client.wait_for_completion(self.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) self.client.wait_for_completion(self.nic2)
class TestLocation(unittest.TestCase): def setUp(self): self.location = ProfitBricksService( username='******', password='******') def test_list_locations(self): locations = self.location.list_locations() self.assertEqual(len(locations), 4) self.assertEqual(locations['items'][0]['id'], 'de/fra') self.assertEqual( locations['items'][0]['properties']['name'], 'Europe / Germany / Frankfurt') def test_get_location(self): location = self.location.get_location(location_id) self.assertEqual(location['id'], 'de/fra') self.assertEqual( location['properties']['name'], 'Europe / Germany / Frankfurt')
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']))
def setUpClass(cls): cls.resource = resource() cls.client = ProfitBricksService(username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) # Find an Ubuntu image for testing. for item in cls.client.list_images()['items']: if (configuration.IMAGE_NAME in item['properties']['name'] and item['properties']['location'] == configuration.LOCATION): cls.image = item
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 'Ubuntu-15' in item['properties']['name'] and item['properties']['location'] == configuration.LOCATION: self.image = item
def get_conn(): """ Return a conn object for the passed VM data """ return ProfitBricksService( username=config.get_cloud_config_value( "username", get_configured_provider(), __opts__, search_global=False ), password=config.get_cloud_config_value( "password", get_configured_provider(), __opts__, search_global=False ), )
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)
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)
class TestProvisioningRequest(unittest.TestCase): def setUp(self): self.provisioning_request = ProfitBricksService(username="******", password="******") def test_list_requests(self): prov_requests = self.provisioning_request.list_requests() self.assertEqual(len(prov_requests), 4) self.assertEqual(prov_requests["items"][0]["id"], "59359eae-cdcd-406f-900b-58b3ad9d8de9") def test_get_request(self): request_id = "59359eae-cdcd-406f-900b-58b3ad9d8de9" prov_request = self.provisioning_request.get_request(request_id) self.assertEqual(prov_request["metadata"]["createdBy"], "User X") def test_get_request_with_status(self): request_id = "59359eae-cdcd-406f-900b-58b3ad9d8de9" prov_request = self.provisioning_request.get_request(request_id, status=True) self.assertEqual(prov_request["metadata"]["requestStatus"], "RUNNING")
class TestContractResources(unittest.TestCase): @classmethod def setUpClass(self): self.client = ProfitBricksService(username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) def test_list_contract_resources(self): contracts = self.client.list_contracts() self.assertEqual(contracts['type'], 'contract') self.assertIsInstance(contracts['properties']['contractNumber'], int)
def main(): module = AnsibleModule(argument_spec=dict( name=dict(), description=dict(), location=dict(choices=LOCATIONS, default='us/las'), subscription_user=dict(), subscription_password=dict(), wait=dict(type='bool', default=True), wait_timeout=dict(default=600), state=dict(default='present'), )) if not HAS_PB_SDK: module.fail_json(msg='profitbricks required for this module') if not module.params.get('subscription_user'): module.fail_json(msg='subscription_user parameter is required') if not module.params.get('subscription_password'): module.fail_json(msg='subscription_password parameter is required') subscription_user = module.params.get('subscription_user') subscription_password = module.params.get('subscription_password') profitbricks = ProfitBricksService(username=subscription_user, password=subscription_password) state = module.params.get('state') if state == 'absent': if not module.params.get('name'): module.fail_json( msg='name parameter is required deleting a virtual datacenter.' ) try: (changed) = remove_datacenter(module, profitbricks) module.exit_json(changed=changed) except Exception as e: module.fail_json(msg='failed to set datacenter state: %s' % str(e)) elif state == 'present': if not module.params.get('name'): module.fail_json( msg='name parameter is required for a new datacenter') if not module.params.get('location'): module.fail_json( msg='location parameter is required for a new datacenter') try: (datacenter_dict_array) = create_datacenter(module, profitbricks) module.exit_json(**datacenter_dict_array) except Exception as e: module.fail_json(msg='failed to set datacenter state: %s' % str(e))
def setUpClass(cls): cls.resource = resource() cls.client = ProfitBricksService( username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) ipblock1 = IPBlock(**cls.resource['ipblock']) ipblock1.size = 2 cls.ipblock1 = cls.client.reserve_ipblock(ipblock1) ipblock2 = IPBlock(**cls.resource['ipblock']) cls.ipblock2 = cls.client.reserve_ipblock(ipblock2)
def get_conn(): ''' Return a conn object for the passed VM data ''' return ProfitBricksService( username=config.get_cloud_config_value('username', get_configured_provider(), __opts__, search_global=False), password=config.get_cloud_config_value('password', get_configured_provider(), __opts__, search_global=False))
def main(): module = AnsibleModule( argument_spec=dict( datacenter=dict(), server=dict(), volume=dict(), subscription_user=dict(), subscription_password=dict(), wait=dict(type='bool', default=True), wait_timeout=dict(type='int', default=600), state=dict(default='present'), ) ) if not HAS_PB_SDK: module.fail_json(msg='profitbricks required for this module') if not module.params.get('subscription_user'): module.fail_json(msg='subscription_user parameter is required') if not module.params.get('subscription_password'): module.fail_json(msg='subscription_password parameter is required') if not module.params.get('datacenter'): module.fail_json(msg='datacenter parameter is required') if not module.params.get('server'): module.fail_json(msg='server parameter is required') if not module.params.get('volume'): module.fail_json(msg='volume parameter is required') subscription_user = module.params.get('subscription_user') subscription_password = module.params.get('subscription_password') profitbricks = ProfitBricksService( username=subscription_user, password=subscription_password) state = module.params.get('state') if state == 'absent': try: (changed) = detach_volume(module, profitbricks) module.exit_json(changed=changed) except Exception as e: module.fail_json(msg='failed to set volume_attach state: %s' % str(e)) elif state == 'present': try: attach_volume(module, profitbricks) module.exit_json() except Exception as e: module.fail_json(msg='failed to set volume_attach state: %s' % str(e))
class TestIPBlock(unittest.TestCase): def setUp(self): self.ipblock = ProfitBricksService( username='******', password='******') def test_list_ipblocks(self): ipblocks = self.ipblock.list_ipblocks() self.assertEqual(len(ipblocks), 4) self.assertEqual(ipblocks['items'][0]['id'], ipblock_id) self.assertEqual( ipblocks['items'][0]['properties']['size'], 5) self.assertEqual( ipblocks['items'][0]['properties']['location'], 'de/fra') def test_get_ipblock(self): ipblock = self.ipblock.get_ipblock(ipblock_id) self.assertEqual(ipblock['id'], ipblock_id) self.assertEqual(ipblock['properties']['size'], 5) self.assertEqual( ipblock['properties']['location'], 'de/fra') def test_delete_ipblock(self): ipblock = self.ipblock.delete_ipblock(ipblock_id) self.assertTrue(ipblock) def test_reserve_ipblock(self): i = IPBlock(location='de/fra', size=5) ipblock = self.ipblock.reserve_ipblock(i) self.assertEqual(ipblock['id'], ipblock_id) self.assertEqual(ipblock['properties']['size'], 5) self.assertEqual( ipblock['properties']['location'], 'de/fra')
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 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 'Ubuntu-15' in item['properties']['name'] and item['properties']['location'] == configuration.LOCATION: self.image = item
def setUpClass(cls): cls.resource = resource() cls.client = ProfitBricksService( username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) # Create test datacenter. cls.datacenter = cls.client.create_datacenter( datacenter=Datacenter(**cls.resource['datacenter'])) cls.client.wait_for_completion(cls.datacenter) # Create test LAN. cls.lan = cls.client.create_lan( datacenter_id=cls.datacenter['id'], lan=LAN(**cls.resource['lan'])) cls.client.wait_for_completion(cls.lan) # Create test server. cls.server = cls.client.create_server( datacenter_id=cls.datacenter['id'], server=Server(**cls.resource['server'])) cls.client.wait_for_completion(cls.server) # Create test NIC1. nic1 = NIC(**cls.resource['nic']) nic1.lan = cls.lan['id'] cls.nic1 = cls.client.create_nic( datacenter_id=cls.datacenter['id'], server_id=cls.server['id'], nic=nic1) cls.client.wait_for_completion(cls.nic1) # Create test NIC2. nic2 = NIC(**cls.resource['nic']) nic2.lan = cls.lan['id'] cls.nic2 = cls.client.create_nic( datacenter_id=cls.datacenter['id'], server_id=cls.server['id'], nic=nic2) cls.client.wait_for_completion(cls.nic2)
def main(): module = AnsibleModule(argument_spec=dict( datacenter=dict(required=True), server=dict(required=True), name=dict(), lan=dict(), subscription_user=dict(required=True), subscription_password=dict(required=True, no_log=True), wait=dict(type='bool', default=True), wait_timeout=dict(type='int', default=600), state=dict(default='present'), ), required_if=( ('state', 'absent', ['name']), ('state', 'present', ['lan']), )) if not HAS_PB_SDK: module.fail_json(msg='profitbricks required for this module') subscription_user = module.params.get('subscription_user') subscription_password = module.params.get('subscription_password') profitbricks = ProfitBricksService(username=subscription_user, password=subscription_password) state = module.params.get('state') if state == 'absent': try: (changed) = delete_nic(module, profitbricks) module.exit_json(changed=changed) except Exception as e: module.fail_json(msg='failed to set nic state: %s' % str(e)) elif state == 'present': try: (nic_dict) = create_nic(module, profitbricks) module.exit_json(nics=nic_dict) # @FIXME changed not calculated? except Exception as e: module.fail_json(msg='failed to set nic state: %s' % str(e))
class TestRequest(unittest.TestCase): @classmethod def setUpClass(self): self.resource = resource() self.client = ProfitBricksService(username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) self.requests = self.client.list_requests() self.request = self.requests['items'][0] def test_list_requests(self): requests = self.client.list_requests() self.assertGreater(len(requests), 0) self.assertEqual(requests['items'][0]['type'], 'request') def test_get_request(self): request = self.client.get_request(request_id=self.request['id'], status=False) self.assertEqual(request['type'], 'request') self.assertEqual(request['id'], self.request['id']) self.assertEqual(request['href'], self.request['href']) def test_get_request_status(self): request = self.client.get_request(request_id=self.request['id'], status=True) self.assertEqual(request['type'], 'request-status') self.assertEqual(request['id'], self.request['id'] + '/status') self.assertEqual(request['href'], self.request['href'] + '/status') def test_get_failure(self): try: self.client.get_request( request_id='00000000-0000-0000-0000-000000000000', status=False) except PBNotFoundError as e: self.assertIn(self.resource['not_found_error'], e.content[0]['message'])
class TestSnapshot(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'])) self.client.wait_for_completion(self.datacenter) # Create test volume volume = Volume(**self.resource['volume']) self.volume = self.client.create_volume( datacenter_id=self.datacenter['id'], volume=volume) self.client.wait_for_completion(self.volume) # Create test volume1 volume1 = Volume(**self.resource['volume']) self.volume1 = self.client.create_volume( datacenter_id=self.datacenter['id'], volume=volume1) self.client.wait_for_completion(self.volume1) # Create test snapshot snapshot = Snapshot(**self.resource['snapshot']) self.snapshot1 = self.client.create_snapshot( datacenter_id=self.datacenter['id'], volume_id=self.volume['id'], name=snapshot.name, description=snapshot.description) self.client.wait_for_completion(self.snapshot1) # Create test snapshot2 self.snapshot2 = self.client.create_snapshot( datacenter_id=self.datacenter['id'], volume_id=self.volume['id'], name="python sdk test snapshot", description="snapshot test description") self.client.wait_for_completion(self.snapshot2) @classmethod def tearDownClass(self): self.client.delete_snapshot(snapshot_id=self.snapshot1['id']) self.client.delete_datacenter(datacenter_id=self.datacenter['id']) def test_list_snapshots(self): snapshots = self.client.list_snapshots() self.assertGreater(len(snapshots['items']), 0) self.assertEqual(snapshots['items'][0]['type'], 'snapshot') def test_get_snapshot(self): snapshot = self.client.get_snapshot(snapshot_id=self.snapshot1['id']) self.assertEqual(snapshot['type'], 'snapshot') self.assertEqual(snapshot['id'], self.snapshot1['id']) self.assertEqual(snapshot['properties']['name'], self.resource['snapshot']['name']) self.assertTrue(snapshot['properties']['description'], self.resource['snapshot']['description']) self.assertEqual(snapshot['properties']['location'], configuration.LOCATION) self.assertEqual(snapshot['properties']['size'], self.volume['properties']['size']) self.assertEqual(snapshot['properties']['cpuHotPlug'], self.volume['properties']['cpuHotPlug']) self.assertEqual(snapshot['properties']['cpuHotUnplug'], self.volume['properties']['cpuHotUnplug']) self.assertEqual(snapshot['properties']['ramHotPlug'], self.volume['properties']['ramHotPlug']) self.assertEqual(snapshot['properties']['ramHotUnplug'], self.volume['properties']['ramHotUnplug']) self.assertEqual(snapshot['properties']['nicHotPlug'], self.volume['properties']['nicHotPlug']) self.assertEqual(snapshot['properties']['nicHotUnplug'], self.volume['properties']['nicHotUnplug']) self.assertEqual(snapshot['properties']['discVirtioHotPlug'], self.volume['properties']['discVirtioHotPlug']) self.assertEqual(snapshot['properties']['discVirtioHotUnplug'], self.volume['properties']['discVirtioHotUnplug']) self.assertEqual(snapshot['properties']['discScsiHotPlug'], self.volume['properties']['discScsiHotPlug']) self.assertEqual(snapshot['properties']['discScsiHotUnplug'], self.volume['properties']['discScsiHotUnplug']) self.assertEqual(snapshot['properties']['licenceType'], self.volume['properties']['licenceType']) def test_delete_snapshot(self): snapshot = self.client.delete_snapshot( snapshot_id=self.snapshot2['id']) self.assertTrue(snapshot) def test_update_snapshot(self): snapshot = self.client.update_snapshot( snapshot_id=self.snapshot1['id'], name=self.resource['snapshot']['name'] + ' - RENAME', description=self.resource['snapshot']['description'] + ' - RENAME') self.client.wait_for_completion(snapshot) self.assertEqual(snapshot['type'], 'snapshot') self.assertEqual(snapshot['properties']['name'], self.resource['snapshot']['name'] + ' - RENAME') self.assertEqual( snapshot['properties']['description'], self.resource['snapshot']['description'] + ' - RENAME') def test_create_snapshot(self): 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']) def test_get_failure(self): try: self.client.get_snapshot('00000000-0000-0000-0000-000000000000') except PBNotFoundError as e: self.assertIn(self.resource['not_found_error'], e.content[0]['message']) def test_create_failure(self): try: self.client.create_snapshot( datacenter_id='00000000-0000-0000-0000-000000000000', volume_id=self.volume['id'], name=self.resource['snapshot']['name']) except PBNotFoundError as e: self.assertIn(self.resource['not_found_error'], e.content[0]['message'])
def setUp(self): self.datacenter = ProfitBricksService(username="******", password="******")
class TestDatacenter(unittest.TestCase): def setUp(self): self.datacenter = ProfitBricksService(username="******", password="******") def test_get_all(self): datacenters = self.datacenter.list_datacenters() self.assertEqual(len(datacenters), 4) self.assertEqual(datacenters["items"][0]["id"], datacenter_id) # self.assertEqual( # datacenters['items'][0]['properties']['name'], 'datacenter1') # self.assertEqual( # datacenters['items'][0]['properties']['description'], 'Description of my DC') # self.assertEqual( # datacenters['items'][0]['properties']['location'], 'de/fkb') # self.assertEqual( # datacenters['items'][0]['properties']['version'], 4) def test_get(self): datacenter = self.datacenter.get_datacenter(datacenter_id=datacenter_id) self.assertEqual(datacenter["id"], datacenter_id) self.assertEqual(datacenter["properties"]["name"], "datacenter1") self.assertEqual(datacenter["properties"]["description"], "Description of my DC") self.assertEqual(datacenter["properties"]["version"], 4) self.assertEqual(datacenter["properties"]["location"], "de/fkb") def test_delete(self): datacenter = self.datacenter.delete_datacenter(datacenter_id=datacenter_id) self.assertTrue(datacenter) def test_update(self): datacenter = self.datacenter.update_datacenter( datacenter_id=datacenter_id, name="Partially updated datacenter name" ) self.assertEqual(datacenter["id"], datacenter_id) self.assertEqual(datacenter["properties"]["name"], "datacenter1") self.assertEqual(datacenter["properties"]["description"], "Description of my DC") self.assertEqual(datacenter["properties"]["version"], 4) self.assertEqual(datacenter["properties"]["location"], "de/fkb") def test_create_simple(self): i = Datacenter(name="datacenter1", description="My New Datacenter", location="de/fkb") response = self.datacenter.create_datacenter(datacenter=i) self.assertEqual(response["id"], datacenter_id) self.assertEqual(response["properties"]["name"], "datacenter1") self.assertEqual(response["properties"]["description"], "My New Datacenter") self.assertEqual(response["properties"]["version"], 4) self.assertEqual(response["properties"]["location"], "de/fkb") def test_create_complex(self): """ Creates a complex Datacenter in a single request. """ 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="<IMAGE/SNAPSHOT-ID>", bus="VIRTIO") volume2 = Volume(name="volume2", size=56, image="<IMAGE/SNAPSHOT-ID>", bus="VIRTIO") volumes = [volume2] server1 = Server(name="server1", ram=4096, cores=4, nics=nics, create_volumes=[volume1]) servers = [server1] balancednics = ["<NIC-ID-1>", "<NIC-ID-2>"] 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 = self.datacenter.create_datacenter(datacenter=d) print(response) self.assertEqual(response["id"], datacenter_id) self.assertEqual(response["properties"]["name"], "My New Datacenter") self.assertEqual(response["properties"]["description"], "Production environment") self.assertEqual(response["properties"]["version"], 4) self.assertEqual(response["properties"]["location"], "de/fkb")
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) # Create snapshot2 (used in delete test) self.snapshot2 = 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.snapshot2, 'create_snapshop2', wait_timeout=600) self.image = find_image(self.client, configuration.IMAGE_NAME) @classmethod def tearDownClass(self): self.client.remove_snapshot(snapshot_id=self.snapshot1['id']) 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. assertRegex(self, self.snapshot1['id'], self.resource['uuid_match']) 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.snapshot2['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 = ('(422, u\'[(root).properties.image] Passwords/SSH Keys ' 'are mandatory for public ProfitBricks Images.\')') self.assertIn(exception, str(context.exception))
def setUp(self): self.loadbalancer = ProfitBricksService(username="******", password="******")
class TestFirewall(unittest.TestCase): def setUp(self): self.firewall = ProfitBricksService(username='******', password='******') def test_get_all(self): firewalls = self.firewall.get_firewall_rules( datacenter_id=datacenter_id, server_id=server_id, nic_id=nic_id) self.assertEqual(len(firewalls), 4) self.assertEqual(firewalls['items'][0]['id'], firewall_rule_id) self.assertEqual(firewalls['items'][0]['properties']['name'], 'Open SSH port') self.assertEqual(firewalls['items'][0]['properties']['portRangeStart'], 22) def test_get(self): firewall = self.firewall.get_firewall_rule( datacenter_id=datacenter_id, server_id=server_id, nic_id=nic_id, firewall_rule_id=firewall_rule_id) self.assertEqual(firewall['id'], firewall_rule_id) self.assertEqual(firewall['properties']['name'], 'Open SSH port') self.assertEqual(firewall['properties']['portRangeStart'], 22) def test_delete(self): firewall = self.firewall.delete_firewall_rule( datacenter_id=datacenter_id, server_id=server_id, nic_id=nic_id, firewall_rule_id=firewall_rule_id) self.assertTrue(firewall) def test_update(self): firewall = self.firewall.update_firewall_rule( datacenter_id=datacenter_id, server_id=server_id, nic_id=nic_id, firewall_rule_id=firewall_rule_id, source_mac='01:98:22:22:44:22', target_ip='123.100.101.102') self.assertEqual(firewall['id'], firewall_rule_id) self.assertEqual(firewall['properties']['name'], 'Open SSH port') self.assertEqual(firewall['properties']['portRangeStart'], 22) self.assertEqual( firewall['properties']['sourceMac'], '01:98:22:22:44:22') self.assertEqual( firewall['properties']['targetIp'], '123.100.101.102') def test_create(self): i = FirewallRule( name='Open SSH port', protocol='TCP' ) response = self.firewall.create_firewall_rule( datacenter_id=datacenter_id, server_id=server_id, nic_id=nic_id, firewall_rule=i) self.assertEqual(response['id'], firewall_rule_id) self.assertEqual(response['properties']['name'], 'Open SSH port') self.assertEqual(response['properties']['portRangeStart'], 22) self.assertEqual(response['properties']['protocol'], 'TCP') self.assertEqual( response['properties']['sourceMac'], '01:23:45:67:89:00') def test_create_optional_value(self): i = FirewallRule( name='Open SSH port', protocol='TCP', source_mac='01:23:45:67:89:00', source_ip='12.2.11.22', port_range_start=22, port_range_end=1000 ) response = self.firewall.create_firewall_rule( datacenter_id=datacenter_id, server_id=server_id, nic_id=nic_id, firewall_rule=i) self.assertEqual(response['id'], firewall_rule_id) self.assertEqual(response['properties']['name'], 'Open SSH port') self.assertEqual(response['properties']['portRangeStart'], 22) self.assertEqual(response['properties']['protocol'], 'TCP')
# 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. """Create volume """ from profitbricks.client import ProfitBricksService, Volume datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService( username='******', password='******') i = Volume( name='Explicitly created volume', size=56, image='<IMAGE/SNAPSHOT-ID>', bus='VIRTIO') response = client.create_volume( datacenter_id=datacenter_id, volume=i) """Create snapshot """ from profitbricks.client import ProfitBricksService # noqa
class TestServer(unittest.TestCase): def setUp(self): self.server = ProfitBricksService( username='******', password='******') def test_list_servers(self): servers = self.server.list_servers(datacenter_id=datacenter_id) self.assertEqual(len(servers), 4) self.assertEqual(servers['items'][0]['id'], server_id) self.assertEqual(servers['items'][0]['properties']['name'], 'New Server') self.assertEqual(servers['items'][0]['properties']['cores'], '4') self.assertEqual(servers['items'][0]['properties']['ram'], '4096') self.assertEqual(servers['items'][0]['properties']['availabilityZone'], 'ZONE_1') self.assertEqual(servers['items'][0]['properties']['vmState'], 'SHUTOFF') self.assertEqual(servers['items'][0]['properties']['bootVolume'], None) self.assertEqual(servers['items'][0]['properties']['bootCdrom'], None) def test_get_server(self): server = self.server.get_server( datacenter_id=datacenter_id, server_id=server_id) self.assertEqual(server['id'], server_id) self.assertEqual(server['properties']['name'], 'New Server') self.assertEqual(server['properties']['cores'], '4') self.assertEqual(server['properties']['ram'], '4096') self.assertEqual(server['properties']['availabilityZone'], 'ZONE_1') self.assertEqual(server['properties']['vmState'], 'SHUTOFF') self.assertEqual(server['properties']['bootVolume'], None) self.assertEqual(server['properties']['bootCdrom'], None) def test_delete_server(self): server = self.server.delete_server( datacenter_id=datacenter_id, server_id=server_id) self.assertTrue(server) def test_update_server(self): server = self.server.update_server( datacenter_id=datacenter_id, server_id=server_id, cores=16) self.assertEqual(server['id'], server_id) self.assertEqual(server['properties']['name'], 'server1 - updated') self.assertEqual(server['properties']['cores'], '16') self.assertEqual(server['properties']['ram'], '4096') self.assertEqual(server['properties']['availabilityZone'], 'ZONE_1') self.assertEqual(server['properties']['bootVolume']['id'], '<ID-OF-ANOTHER-STORAGE>') self.assertEqual(server['properties']['bootCdrom'], None) def test_create_complex(self): 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, ) volume1 = Volume( name='volume1', size=56, image='<IMAGE/SNAPSHOT-ID>', bus='VIRTIO' ) volume2 = Volume( name='volume2', size=56, image='<IMAGE/SNAPSHOT-ID>', bus='VIRTIO' ) nics = [nic1, nic2] create_volumes = [volume1, volume2] i = Server( name='server1', ram=4096, cores=4, nics=nics, create_volumes=create_volumes ) response = self.server.create_server( datacenter_id=datacenter_id, server=i) self.assertEqual(response['id'], server_id) self.assertEqual(response['properties']['name'], 'New Server') self.assertEqual(response['properties']['cores'], '4') self.assertEqual(response['properties']['ram'], '4096') self.assertEqual( response['properties']['availabilityZone'], 'ZONE_1') self.assertEqual(response['properties']['vmState'], 'SHUTOFF') def test_create_with_existing_volume(self): volume_id = '<NEW-STORAGE-ID>' attach_volumes = [volume_id] i = Server( name='server1', ram=4096, cores=4, attach_volumes=attach_volumes ) response = self.server.create_server( datacenter_id=datacenter_id, server=i) self.assertEqual(response['id'], server_id) self.assertEqual(response['properties']['name'], 'New Server') self.assertEqual(response['properties']['cores'], '4') self.assertEqual(response['properties']['ram'], '4096') self.assertEqual( response['properties']['availabilityZone'], 'ZONE_1') self.assertEqual(response['properties']['vmState'], 'SHUTOFF') def test_create_with_volumes_only(self): volume1 = Volume( name='volume1', size=56, image='<IMAGE/SNAPSHOT-ID>', bus='VIRTIO' ) volume2 = Volume( name='volume2', size=56, image='<IMAGE/SNAPSHOT-ID>', bus='VIRTIO' ) create_volumes = [volume1, volume2] i = Server( name='server1', ram=4096, cores=4, create_volumes=create_volumes ) response = self.server.create_server( datacenter_id=datacenter_id, server=i) self.assertEqual(response['id'], server_id) self.assertEqual(response['properties']['name'], 'New Server') self.assertEqual(response['properties']['cores'], '4') self.assertEqual(response['properties']['ram'], '4096') self.assertEqual(response['properties']['availabilityZone'], 'ZONE_1') self.assertEqual(response['properties']['vmState'], 'SHUTOFF') def test_create_with_nics_only(self): 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, nics=nics ) response = self.server.create_server( datacenter_id=datacenter_id, server=i) self.assertEqual(response['id'], server_id) self.assertEqual(response['properties']['name'], 'New Server') self.assertEqual(response['properties']['cores'], '4') self.assertEqual(response['properties']['ram'], '4096') self.assertEqual(response['properties']['availabilityZone'], 'ZONE_1') self.assertEqual(response['properties']['vmState'], 'SHUTOFF') def test_create_simple(self): i = Server( name='server1', ram=4096, cores=4 ) response = self.server.create_server( datacenter_id=datacenter_id, server=i) self.assertEqual(response['id'], server_id) self.assertEqual(response['properties']['name'], 'New Server') self.assertEqual(response['properties']['cores'], '4') self.assertEqual(response['properties']['ram'], '4096') self.assertEqual(response['properties']['availabilityZone'], 'ZONE_1') self.assertEqual(response['properties']['vmState'], 'SHUTOFF') def test_create_with_two_existing_volumes(self): volume_id1 = '700e1cab-99b2-4c30-ba8c-1d273ddba023' volume_id2 = '800e1cab-99b2-4c30-ba8c-1d273ddba024' attach_volumes = [volume_id1, volume_id2] i = Server( name='server1', ram=4096, cores=4, attach_volumes=attach_volumes ) response = self.server.create_server( datacenter_id=datacenter_id, server=i) self.assertEqual(response['id'], server_id) self.assertEqual(response['properties']['name'], 'New Server') self.assertEqual(response['properties']['cores'], '4') self.assertEqual(response['properties']['ram'], '4096') self.assertEqual(response['properties']['availabilityZone'], 'ZONE_1') self.assertEqual(response['properties']['vmState'], 'SHUTOFF') def test_create_with_boot_volume(self): volume_id1 = '700e1cab-99b2-4c30-ba8c-1d273ddba023' volume_id2 = '800e1cab-99b2-4c30-ba8c-1d273ddba024' boot_volume_id = '800e1cab-99b2-4c30-ba8c-1d273ddba024' attach_volumes = [volume_id1, volume_id2] i = Server( name='server1', ram=4096, cores=4, boot_volume_id=boot_volume_id, attach_volumes=attach_volumes ) response = self.server.create_server( datacenter_id=datacenter_id, server=i) self.assertEqual(response['id'], server_id) self.assertEqual(response['properties']['name'], 'New Server') self.assertEqual(response['properties']['cores'], '4') self.assertEqual(response['properties']['ram'], '4096') self.assertEqual(response['properties']['availabilityZone'], 'ZONE_1') self.assertEqual(response['properties']['vmState'], 'SHUTOFF') def test_create_with_nics_and_existing_volume(self): volume_id1 = '700e1cab-99b2-4c30-ba8c-1d273ddba023' volume_id2 = '800e1cab-99b2-4c30-ba8c-1d273ddba024' boot_volume_id = '800e1cab-99b2-4c30-ba8c-1d273ddba024' 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 = self.server.create_server( datacenter_id=datacenter_id, server=i) self.assertEqual(response['id'], server_id) self.assertEqual(response['properties']['name'], 'New Server') self.assertEqual(response['properties']['cores'], '4') self.assertEqual(response['properties']['ram'], '4096') self.assertEqual(response['properties']['availabilityZone'], 'ZONE_1') self.assertEqual(response['properties']['vmState'], 'SHUTOFF') def test_get_attached_volumes(self): servers = self.server.get_attached_volumes( datacenter_id=datacenter_id, server_id=server_id) self.assertEqual(len(servers), 4) self.assertEqual(servers['items'][0]['id'], '700e1cab-99b2-4c30-ba8c-1d273ddba025') self.assertEqual(servers['items'][0]['properties']['name'], 'my boot volume for server 1') self.assertEqual(servers['items'][0]['properties']['size'], 80) self.assertEqual(servers['items'][0]['properties']['bus'], 'VIRTIO') self.assertEqual(servers['items'][0]['properties']['image'], None) self.assertEqual(servers['items'][0]['properties']['imagePassword'], None) self.assertEqual(servers['items'][0]['properties']['type'], 'HDD') self.assertEqual(servers['items'][0]['properties']['licenceType'], 'WINDOWS') 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): volume_id = '700e1cab-99b2-4c30-ba8c-1d273ddba025' server = self.server.get_attached_volume( datacenter_id=datacenter_id, server_id=server_id, volume_id=volume_id) self.assertEqual(server['id'], volume_id) self.assertEqual(server['properties']['name'], 'my boot volume for server 1') self.assertEqual(server['properties']['size'], 80) self.assertEqual(server['properties']['bus'], 'VIRTIO') self.assertEqual(server['properties']['image'], None) self.assertEqual(server['properties']['imagePassword'], None) self.assertEqual(server['properties']['type'], 'HDD') self.assertEqual(server['properties']['licenceType'], 'WINDOWS') 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_detach_volume(self): volume_id = '700e1cab-99b2-4c30-ba8c-1d273ddba025' server = self.server.detach_volume( datacenter_id=datacenter_id, server_id=server_id, volume_id=volume_id) self.assertTrue(server) def test_attach_volume(self): volume_id = '700e1cab-99b2-4c30-ba8c-1d273ddba025' server = self.server.attach_volume( datacenter_id=datacenter_id, server_id=server_id, volume_id=volume_id) self.assertEqual(server['id'], volume_id) self.assertEqual(server['properties']['name'], 'my boot volume for server 1') self.assertEqual(server['properties']['size'], 80) self.assertEqual(server['properties']['bus'], 'VIRTIO') self.assertEqual(server['properties']['image'], None) self.assertEqual(server['properties']['imagePassword'], None) self.assertEqual(server['properties']['type'], 'HDD') self.assertEqual(server['properties']['licenceType'], 'WINDOWS') 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_get_attached_cdroms(self): servers = self.server.get_attached_cdroms( datacenter_id=datacenter_id, server_id=server_id) self.assertEqual(len(servers), 4) self.assertEqual(servers['items'][0]['id'], '7df81087-5835-41c6-a10b-3e098593bbd2') self.assertEqual(servers['items'][0]['properties']['name'], 'Ubuntu 14.04') self.assertEqual(servers['items'][0]['properties']['size'], 28) self.assertEqual(servers['items'][0]['properties']['description'], 'Ubuntu image description') self.assertEqual(servers['items'][0]['properties']['location'], 'de/fkb') self.assertEqual(servers['items'][0]['properties']['imageType'], 'CDROM') self.assertEqual(servers['items'][0]['properties']['licenceType'], 'UNKNOWN') self.assertFalse(servers['items'][0]['properties']['public']) 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_cdrom(self): cdrom_id = '7df81087-5835-41c6-a10b-3e098593bbd2' server = self.server.get_attached_cdrom( datacenter_id=datacenter_id, server_id=server_id, cdrom_id=cdrom_id) self.assertEqual(server['id'], cdrom_id) self.assertEqual(server['properties']['name'], 'Ubuntu 14.04') self.assertEqual(server['properties']['size'], 28) self.assertEqual(server['properties']['description'], 'Ubuntu image description') self.assertEqual(server['properties']['location'], 'de/fkb') self.assertEqual(server['properties']['imageType'], 'CDROM') self.assertEqual(server['properties']['licenceType'], 'UNKNOWN') self.assertFalse(server['properties']['public']) 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_detach_cdrom(self): cdrom_id = '7df81087-5835-41c6-a10b-3e098593bbd2' server = self.server.detach_cdrom( datacenter_id=datacenter_id, server_id=server_id, cdrom_id=cdrom_id) self.assertTrue(server) def test_attach_cdrom(self): cdrom_id = '7df81087-5835-41c6-a10b-3e098593bbd2' server = self.server.attach_cdrom( datacenter_id=datacenter_id, server_id=server_id, cdrom_id=cdrom_id) self.assertEqual(server['id'], cdrom_id) self.assertEqual(server['properties']['name'], 'Ubuntu 14.04') self.assertEqual(server['properties']['size'], 28) self.assertEqual(server['properties']['description'], 'Ubuntu image description') self.assertEqual(server['properties']['location'], 'de/fkb') self.assertEqual(server['properties']['imageType'], 'CDROM') self.assertEqual(server['properties']['licenceType'], 'UNKNOWN') self.assertFalse(server['properties']['public']) 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_start_server(self): server = self.server.start_server( datacenter_id=datacenter_id, server_id=server_id) self.assertTrue(server) def test_stop_server(self): server = self.server.stop_server( datacenter_id=datacenter_id, server_id=server_id) self.assertTrue(server) def test_reboot_server(self): server = self.server.reboot_server( datacenter_id=datacenter_id, server_id=server_id) self.assertTrue(server)
def setUp(self): self.server = ProfitBricksService( username='******', password='******')
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
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)
from datetime import datetime, timedelta from profitbricks.client import ProfitBricksService from time import sleep # read config config = ConfigParser() config.read('settings.cfg') datacenter_id = config.get('snapshots', 'datacenter_id') snapshot_prefix = config.get('snapshots', 'snapshot_prefix') retention_time = config.getint('snapshots', 'retention_time') sleep_seconds = config.getint('snapshots', 'sleep_seconds') pb = ProfitBricksService( username=config.get('credentials', 'username'), password=config.get('credentials', 'password'), ) # timestamp for creating and deleting now = datetime.now() # create new snapshots from list of volumes in datacenter volumes = pb.list_volumes(datacenter_id=datacenter_id) for volume_item in volumes['items']: volume_id = volume_item['id'] volume = pb.get_volume(datacenter_id, volume_id) volume_name = volume['properties']['name'] snapshot_name = "{}-{}-{}".format(snapshot_prefix, now.strftime("%Y%m%d"), volume_name)
# 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. # pylint: disable=reimported,wrong-import-position """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='******', 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='******', password='******')
def main(): module = AnsibleModule(argument_spec=dict( datacenter=dict(), name=dict(), image=dict(), cores=dict(type='int', default=2), ram=dict(type='int', default=2048), cpu_family=dict(choices=['AMD_OPTERON', 'INTEL_XEON'], default='AMD_OPTERON'), volume_size=dict(type='int', default=10), disk_type=dict(choices=['HDD', 'SSD'], default='HDD'), image_password=dict(default=None, no_log=True), ssh_keys=dict(type='list', elements='str', default=[], no_log=False), bus=dict(choices=['VIRTIO', 'IDE'], default='VIRTIO'), lan=dict(type='int', default=1), count=dict(type='int', default=1), auto_increment=dict(type='bool', default=True), instance_ids=dict(type='list', elements='str', default=[]), subscription_user=dict(), subscription_password=dict(no_log=True), location=dict(choices=LOCATIONS, default='us/las'), assign_public_ip=dict(type='bool', default=False), wait=dict(type='bool', default=True), wait_timeout=dict(type='int', default=600), remove_boot_volume=dict(type='bool', default=True), state=dict(default='present'), )) if not HAS_PB_SDK: module.fail_json(msg='profitbricks required for this module') subscription_user = module.params.get('subscription_user') subscription_password = module.params.get('subscription_password') profitbricks = ProfitBricksService(username=subscription_user, password=subscription_password) state = module.params.get('state') if state == 'absent': if not module.params.get('datacenter'): module.fail_json(msg='datacenter parameter is required ' + 'for running or stopping machines.') try: (changed) = remove_virtual_machine(module, profitbricks) module.exit_json(changed=changed) except Exception as e: module.fail_json(msg='failed to set instance state: %s' % to_native(e), exception=traceback.format_exc()) elif state in ('running', 'stopped'): if not module.params.get('datacenter'): module.fail_json(msg='datacenter parameter is required for ' + 'running or stopping machines.') try: (changed) = startstop_machine(module, profitbricks, state) module.exit_json(changed=changed) except Exception as e: module.fail_json(msg='failed to set instance state: %s' % to_native(e), exception=traceback.format_exc()) elif state == 'present': if not module.params.get('name'): module.fail_json(msg='name parameter is required for new instance') if not module.params.get('image'): module.fail_json( msg='image parameter is required for new instance') if not module.params.get('subscription_user'): module.fail_json(msg='subscription_user parameter is ' + 'required for new instance') if not module.params.get('subscription_password'): module.fail_json(msg='subscription_password parameter is ' + 'required for new instance') try: (machine_dict_array) = create_virtual_machine(module, profitbricks) module.exit_json(**machine_dict_array) except Exception as e: module.fail_json(msg='failed to set instance state: %s' % to_native(e), exception=traceback.format_exc())
def main(): module = AnsibleModule(argument_spec=dict( datacenter=dict(type='str'), name=dict(type='str'), image=dict(type='str'), cores=dict(type='int', default=2), ram=dict(type='int', default=2048), cpu_family=dict( type='str', choices=CPU_FAMILIES, default='AMD_OPTERON'), volume_size=dict(type='int', default=10), disk_type=dict(type='str', choices=DISK_TYPES, default='HDD'), availability_zone=dict( type='str', choices=AVAILABILITY_ZONES, default='AUTO'), volume_availability_zone=dict( type='str', choices=AVAILABILITY_ZONES, default=None), image_password=dict(type='str', default=None), ssh_keys=dict(type='list', default=[]), bus=dict(type='str', choices=BUS_TYPES, default='VIRTIO'), lan=dict(type='int', default=1), nat=dict(type='bool', default=None), count=dict(type='int', default=1), auto_increment=dict(type='bool', default=True), instance_ids=dict(type='list', default=[]), subscription_user=dict( type='str', default=os.environ.get('PROFITBRICKS_USERNAME')), subscription_password=dict( type='str', default=os.environ.get('PROFITBRICKS_PASSWORD')), location=dict(type='str', choices=LOCATIONS, default='us/las'), assign_public_ip=dict(type='bool', default=False), wait=dict(type='bool', default=True), wait_timeout=dict(type='int', default=600), remove_boot_volume=dict(type='bool', default=True), state=dict(type='str', default='present'), )) if not HAS_PB_SDK: module.fail_json(msg='profitbricks required for this module') if not module.params.get('subscription_user'): module.fail_json( msg='subscription_user parameter or ' + 'PROFITBRICKS_USERNAME environment variable is required.') if not module.params.get('subscription_password'): module.fail_json( msg='subscription_password parameter or ' + 'PROFITBRICKS_PASSWORD environment variable is required.') subscription_user = module.params.get('subscription_user') subscription_password = module.params.get('subscription_password') wait = module.params.get('wait') wait_timeout = module.params.get('wait_timeout') profitbricks = ProfitBricksService(username=subscription_user, password=subscription_password) user_agent = 'profitbricks-sdk-ruby/%s Ansible/%s' % (sdk_version, __version__) profitbricks.headers = {'User-Agent': user_agent} state = module.params.get('state') if state == 'absent': if not module.params.get('datacenter'): module.fail_json(msg='datacenter parameter is required ' + 'for running or stopping machines.') try: (changed) = remove_virtual_machine(module, profitbricks) module.exit_json(changed=changed) except Exception as e: module.fail_json(msg='failed to set instance state: %s' % str(e)) elif state in ('running', 'stopped'): if not module.params.get('datacenter'): module.fail_json(msg='datacenter parameter is required for ' + 'running or stopping machines.') try: (changed) = startstop_machine(module, profitbricks, state) module.exit_json(changed=changed) except Exception as e: module.fail_json(msg='failed to set instance state: %s' % str(e)) elif state == 'present': if not module.params.get('name'): module.fail_json(msg='name parameter is required for new instance') datacenter_list = profitbricks.list_datacenters() datacenter_id = _get_datacenter_id(datacenter_list, module.params.get('datacenter')) server_list = profitbricks.list_servers(datacenter_id) if not _get_server_id(server_list, module.params.get('name')): # create if not module.params.get('image'): module.fail_json( msg='image parameter is required for new instance') try: (machine_dict_array) = create_virtual_machine( module, profitbricks) module.exit_json(**machine_dict_array) except Exception as e: module.fail_json(msg='failed to set instance state: %s' % str(e)) else: # update try: (machine_dict_array) = update_virtual_machine( module, profitbricks) module.exit_json(**machine_dict_array) except Exception as e: module.fail_json(msg='failed to set instance state: %s' % str(e))
def setUp(self): self.firewall = ProfitBricksService(username='******', password='******')
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
class TestLoadBalancer(unittest.TestCase): def setUp(self): self.loadbalancer = ProfitBricksService(username="******", password="******") def test_get_all(self): loadbalancers = self.loadbalancer.list_loadbalancers(datacenter_id=datacenter_id) self.assertEqual(len(loadbalancers), 4) self.assertEqual(loadbalancers["items"][0]["id"], loadbalancer_id) self.assertEqual(loadbalancers["items"][0]["properties"]["name"], "My LB") def test_get_loadbalancer(self): loadbalancer = self.loadbalancer.get_loadbalancer(datacenter_id=datacenter_id, loadbalancer_id=loadbalancer_id) self.assertEqual(loadbalancer["properties"]["name"], "My LB") self.assertEqual(loadbalancer["properties"]["ip"], "10.2.2.3") self.assertTrue(loadbalancer["properties"]["dhcp"]) def test_delete_loadbalancer(self): loadbalancer = self.loadbalancer.delete_loadbalancer( datacenter_id=datacenter_id, loadbalancer_id=loadbalancer_id ) self.assertTrue(loadbalancer) def test_update_loadbalancer(self): loadbalancer = self.loadbalancer.update_loadbalancer( datacenter_id=datacenter_id, loadbalancer_id=loadbalancer_id, ip="10.2.2.4" ) self.assertEqual(loadbalancer["properties"]["name"], "My LB") self.assertEqual(loadbalancer["properties"]["ip"], "10.2.2.4") self.assertTrue(loadbalancer["properties"]["dhcp"]) def test_create_loadbalancer(self): i = LoadBalancer(name="My LB") response = self.loadbalancer.create_loadbalancer(datacenter_id=datacenter_id, loadbalancer=i) self.assertEqual(response["properties"]["name"], "My LB") self.assertEqual(response["properties"]["ip"], "10.2.2.3") self.assertTrue(response["properties"]["dhcp"]) def test_create_with_balancednics(self): balancednics = ["<NIC-ID-1>", "<NIC-ID-2>"] i = LoadBalancer(name="My LB", balancednics=balancednics) response = self.loadbalancer.create_loadbalancer(datacenter_id=datacenter_id, loadbalancer=i) self.assertEqual(response["properties"]["name"], "My LB") self.assertEqual(response["properties"]["ip"], "10.2.2.3") self.assertTrue(response["properties"]["dhcp"]) def test_create_optional_value(self): i = LoadBalancer(name="My LB", ip="10.2.2.3", dhcp=True) response = self.loadbalancer.create_loadbalancer(datacenter_id=datacenter_id, loadbalancer=i) self.assertEqual(response["properties"]["name"], "My LB") self.assertEqual(response["properties"]["ip"], "10.2.2.3") self.assertTrue(response["properties"]["dhcp"]) def test_get_loadbalancer_members(self): members = self.loadbalancer.get_loadbalancer_members( datacenter_id=datacenter_id, loadbalancer_id=loadbalancer_id ) self.assertEqual(len(members), 4) self.assertEqual(members["items"][0]["id"], "<NIC-ID>") self.assertEqual(members["items"][0]["properties"]["name"], "nic1") self.assertEqual(members["items"][0]["properties"]["mac"], "AB:21:23:09:78:C2") def test_add_loadbalanced_nic(self): nic = "<NIC-ID-1" response = self.loadbalancer.add_loadbalanced_nics( datacenter_id=datacenter_id, loadbalancer_id=loadbalancer_id, nic_id=nic ) self.assertEqual(response["properties"]["name"], "nic1") self.assertEqual(response["properties"]["mac"], "AB:21:23:09:78:C2") self.assertTrue(response["properties"]["dhcp"]) def test_get_balanced_nic(self): response = self.loadbalancer.get_loadbalanced_nic( datacenter_id=datacenter_id, loadbalancer_id=loadbalancer_id, nic_id=nic_id ) self.assertEqual(response["properties"]["name"], "nic1") self.assertEqual(response["properties"]["mac"], "AB:21:23:09:78:C2") self.assertTrue(response["properties"]["dhcp"]) def test_remove_balanced_nic(self): loadbalancer = self.loadbalancer.remove_loadbalanced_nic( datacenter_id=datacenter_id, loadbalancer_id=loadbalancer_id, nic_id=nic_id ) self.assertTrue(loadbalancer)
"""List Images """ from profitbricks.client import ProfitBricksService client = ProfitBricksService( username='******', 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
"""List NICs """ from profitbricks.client import ProfitBricksService datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' client = ProfitBricksService( username='******', 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 datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' server_id = '700e1cab-99b2-4c30-ba8c-1d273ddba023' client = ProfitBricksService( username='******', password='******') i = NIC( name='nic1', ips=['10.2.2.3', '10.2.3.4'], dhcp='true',
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 'Ubuntu-15' 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') 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='******', 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']) response = 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)
def main(): module = AnsibleModule(argument_spec=dict( datacenter=dict(type='str'), server=dict(type='str'), name=dict(type='str', default=str(uuid4()).replace('-', '')[:10]), lan=dict(type='int', default=None), dhcp=dict(type='bool', default=None), nat=dict(type='bool', default=None), firewall_active=dict(type='bool', default=None), ips=dict(type='list', default=None), api_url=dict(type='str', default=None), username=dict(type='str', required=True, aliases=['subscription_user'], fallback=(env_fallback, ['PROFITBRICKS_USERNAME'])), password=dict(type='str', required=True, aliases=['subscription_password'], fallback=(env_fallback, ['PROFITBRICKS_PASSWORD']), no_log=True), wait=dict(type='bool', default=True), wait_timeout=dict(type='int', default=600), state=dict(type='str', default='present'), ), supports_check_mode=True) if not HAS_PB_SDK: module.fail_json( msg= 'profitbricks is required for this module, run `pip install profitbricks`' ) if not module.params.get('datacenter'): module.fail_json(msg='datacenter parameter is required') if not module.params.get('server'): module.fail_json(msg='server parameter is required') username = module.params.get('username') password = module.params.get('password') api_url = module.params.get('api_url') if not api_url: profitbricks = ProfitBricksService(username=username, password=password) else: profitbricks = ProfitBricksService(username=username, password=password, host_base=api_url) user_agent = 'profitbricks-sdk-python/%s Ansible/%s' % (sdk_version, __version__) profitbricks.headers = {'User-Agent': user_agent} state = module.params.get('state') if state == 'absent': if not module.params.get('name'): module.fail_json(msg='name parameter is required') try: (changed) = delete_nic(module, profitbricks) module.exit_json(changed=changed) except Exception as e: module.fail_json(msg='failed to set nic state: %s' % to_native(e)) elif state == 'present': if not module.params.get('lan'): module.fail_json(msg='lan parameter is required') try: (nic_dict) = create_nic(module, profitbricks) module.exit_json(**nic_dict) except Exception as e: module.fail_json(msg='failed to set nic state: %s' % to_native(e)) elif state == 'update': try: (nic_dict) = update_nic(module, profitbricks) module.exit_json(**nic_dict) except Exception as e: module.fail_json(msg='failed to update nic: %s' % to_native(e))
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