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
