from profitbricks.client import ProfitBricksService # noqa
client = ProfitBricksService(
username='******', password='******')
snapshot_id = 'd084aa0a-f9ab-41d5-9316-18163bc416ef'
image = client.update_snapshot(
snapshot_id,
name='New name',
description="Backup of volume XYZ",
licence_type='LINUX',
cpu_hot_plug=True,
ram_hot_plug=True,
nic_hot_plug=True,
nic_hot_unplug=True,
disc_virtio_hot_plug=True,
disc_virtio_hot_unplug=True)
"""Remove Snapshot
"""
from profitbricks.client import ProfitBricksService # noqa
snapshot_id = '7df81087-5835-41c6-a10b-3e098593bba4'
client = ProfitBricksService(
username='******', password='******')
snapshot = client.delete_snapshot(
snapshot_id=snapshot_id)
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'])
class TestUserManagement(unittest.TestCase):
@classmethod
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create datacenter resource
self.datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
# Create volume resource
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)
self.image = find_image(self.client, configuration.IMAGE_NAME)
# Create snapshot resource
self.snapshot = self.client.create_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
name=self.resource['snapshot']['name'])
self.client.wait_for_completion(self.snapshot)
# Reserve IP block resource
self.ipblock = self.client.reserve_ipblock(
IPBlock(**self.resource['ipblock']))
# Create User 1
self.user_dict1 = User(
firstname='John',
lastname='Doe',
email='*****@*****.**' % randint(0, 9999999999999),
password='******' % randint(0, 99999999),
administrator=True,
force_sec_auth=False)
self.user1 = self.client.create_user(user=self.user_dict1)
# Create User 2
self.user_dict2 = User(
firstname='John',
lastname='Doe',
email='*****@*****.**' % randint(0, 9999999999999),
password='******' % randint(0, 99999999))
self.user2 = self.client.create_user(user=self.user_dict2)
# Create User 3
self.user_dict3 = User(
firstname='John',
lastname='Doe',
email='*****@*****.**' % randint(0, 9999999999999),
password='******' % randint(0, 99999999))
self.user3 = self.client.create_user(user=self.user_dict3)
# Create Group 1
group = Group(**self.resource['group'])
self.group1 = self.client.create_group(group)
# Create Group 2
group.name = self.resource['group']['name'] + ' 2'
self.group2 = self.client.create_group(group)
# Create Group 3
group.name = self.resource['group']['name'] + ' 3'
self.group3 = self.client.create_group(group)
# Create Share 1
self.share1 = self.client.add_share(group_id=self.group3['id'],
resource_id=self.datacenter['id'],
edit_privilege=True,
share_privilege=True)
@classmethod
def tearDownClass(self):
self.client.delete_share(group_id=self.group3['id'],
resource_id=self.datacenter['id'])
self.client.delete_snapshot(snapshot_id=self.snapshot['id'])
self.client.delete_user(user_id=self.user1['id'])
self.client.delete_user(user_id=self.user3['id'])
self.client.delete_group(group_id=self.group1['id'])
self.client.delete_group(group_id=self.group3['id'])
self.client.delete_ipblock(ipblock_id=self.ipblock['id'])
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_create_user(self):
self.assertEqual(self.user1['type'], 'user')
self.assertEqual(self.user1['properties']['firstname'],
self.user_dict1.firstname)
self.assertEqual(self.user1['properties']['lastname'],
self.user_dict1.lastname)
self.assertEqual(self.user1['properties']['email'],
self.user_dict1.email)
self.assertEqual(self.user1['properties']['administrator'],
self.user_dict1.administrator)
self.assertEqual(self.user1['properties']['forceSecAuth'],
self.user_dict1.force_sec_auth)
def test_list_users(self):
users = self.client.list_users()
self.assertGreater(len(users['items']), 0)
self.assertEqual(users['items'][0]['type'], 'user')
def test_get_user(self):
user = self.client.get_user(user_id=self.user1['id'])
self.assertEqual(user['type'], 'user')
self.assertEqual(user['id'], self.user1['id'])
self.assertEqual(user['properties']['firstname'],
self.user1['properties']['firstname'])
self.assertEqual(user['properties']['lastname'],
self.user1['properties']['lastname'])
self.assertEqual(user['properties']['email'],
self.user1['properties']['email'])
self.assertEqual(user['properties']['administrator'],
self.user1['properties']['administrator'])
self.assertEqual(user['properties']['forceSecAuth'],
self.user1['properties']['forceSecAuth'])
self.assertFalse(user['properties']['secAuthActive'])
def test_delete_user(self):
user = self.client.delete_user(user_id=self.user2['id'])
self.assertTrue(user)
def test_update_user(self):
user = self.client.update_user(
user_id=self.user1['id'],
firstname=self.user1['properties']['firstname'],
lastname=self.user1['properties']['lastname'],
email=self.user1['properties']['email'],
administrator=False,
force_sec_auth=self.user1['properties']['forceSecAuth'])
self.assertEqual(user['type'], 'user')
self.assertEqual(user['id'], self.user1['id'])
self.assertEqual(user['properties']['firstname'],
self.user1['properties']['firstname'])
self.assertEqual(user['properties']['lastname'],
self.user1['properties']['lastname'])
self.assertEqual(user['properties']['email'],
self.user1['properties']['email'])
self.assertFalse(user['properties']['administrator'])
self.assertEqual(user['properties']['forceSecAuth'],
self.user1['properties']['forceSecAuth'])
def test_create_user_failure(self):
try:
user = User(firstname='John',
lastname='Doe',
password='******')
self.client.create_user(user)
except PBError as e:
self.assertIn(self.resource['missing_attribute_error'] % 'email',
e.content[0]['message'])
def test_get_user_failure(self):
try:
self.client.get_user('00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_create_group(self):
self.assertEqual(self.group1['type'], 'group')
self.assertEqual(self.group1['properties']['name'],
self.resource['group']['name'])
self.assertEqual(self.group1['properties']['createDataCenter'],
self.resource['group']['create_datacenter'])
self.assertEqual(self.group1['properties']['createSnapshot'],
self.resource['group']['create_snapshot'])
self.assertEqual(self.group1['properties']['reserveIp'],
self.resource['group']['reserve_ip'])
self.assertEqual(self.group1['properties']['accessActivityLog'],
self.resource['group']['access_activity_log'])
def test_list_groups(self):
groups = self.client.list_groups()
self.assertGreater(len(groups['items']), 0)
self.assertEqual(groups['items'][0]['type'], 'group')
def test_get_group(self):
group = self.client.get_group(group_id=self.group1['id'])
self.assertEqual(group['type'], 'group')
self.assertEqual(group['id'], self.group1['id'])
self.assertEqual(group['properties']['name'],
self.group1['properties']['name'])
self.assertEqual(group['properties']['createDataCenter'],
self.group1['properties']['createDataCenter'])
self.assertEqual(group['properties']['createSnapshot'],
self.group1['properties']['createSnapshot'])
self.assertEqual(group['properties']['reserveIp'],
self.group1['properties']['reserveIp'])
self.assertEqual(group['properties']['accessActivityLog'],
self.group1['properties']['accessActivityLog'])
def test_update_group(self):
group = self.client.update_group(group_id=self.group1['id'],
name=self.resource['group']['name'] +
' - RENAME',
create_datacenter=False)
self.assertEqual(group['type'], 'group')
self.assertEqual(group['id'], self.group1['id'])
self.assertEqual(group['properties']['name'],
self.resource['group']['name'] + ' - RENAME')
self.assertFalse(group['properties']['createDataCenter'])
def test_delete_group(self):
group = self.client.delete_group(group_id=self.group2['id'])
self.assertTrue(group)
def test_create_group_failure(self):
try:
self.client.create_group(Group(create_datacenter=True))
except PBError as e:
self.assertIn(self.resource['missing_attribute_error'] % 'name',
e.content[0]['message'])
def test_get_group_failure(self):
try:
self.client.get_group('00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_add_share(self):
self.assertEqual(self.share1['type'], 'resource')
self.assertTrue(self.share1['properties']['editPrivilege'])
self.assertTrue(self.share1['properties']['sharePrivilege'])
def test_list_shares(self):
shares = self.client.list_shares(group_id=self.group3['id'])
self.assertGreater(len(shares['items']), 0)
self.assertEqual(shares['items'][0]['type'], 'resource')
def test_get_share(self):
share = self.client.get_share(group_id=self.group3['id'],
resource_id=self.datacenter['id'])
self.assertEqual(share['id'], self.datacenter['id'])
self.assertEqual(share['type'], 'resource')
self.assertTrue(share['properties']['editPrivilege'])
self.assertTrue(share['properties']['sharePrivilege'])
def test_update_share(self):
share = self.client.update_share(group_id=self.group3['id'],
resource_id=self.datacenter['id'],
share_privilege=False)
self.assertEqual(share['id'], self.datacenter['id'])
self.assertEqual(share['type'], 'resource')
self.assertFalse(share['properties']['sharePrivilege'])
def test_get_share_failure(self):
try:
self.client.get_share(
group_id=self.group3['id'],
resource_id='00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_create_share_failure(self):
try:
self.client.add_share(
group_id=self.group3['id'],
resource_id='00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_list_group_users(self):
users = self.client.list_group_users(group_id=self.group3['id'])
self.assertGreater(len(users['items']), 0)
self.assertEqual(users['items'][0]['type'], 'user')
def test_add_group_user(self):
user = self.client.add_group_user(group_id=self.group3['id'],
user_id=self.user3['id'])
self.assertEqual(user['id'], self.user3['id'])
self.assertEqual(user['type'], 'user')
def test_remove_group_user(self):
user = self.client.remove_group_user(group_id=self.group3['id'],
user_id=self.user3['id'])
self.assertTrue(user)
def test_list_resources(self):
resources = self.client.list_resources()
self.assertGreater(len(resources['items']), 0)
self.assertEqual(resources['id'], 'resources')
self.assertEqual(resources['type'], 'collection')
def test_list_datacenter_resources(self):
resources = self.client.list_resources(resource_type='datacenter')
self.assertGreater(len(resources['items']), 0)
self.assertEqual(resources['id'], 'resources')
self.assertEqual(resources['items'][0]['type'], 'datacenter')
def test_list_image_resources(self):
resources = self.client.list_resources(resource_type='image')
self.assertGreater(len(resources['items']), 0)
self.assertEqual(resources['id'], 'resources')
self.assertEqual(resources['items'][0]['type'], 'image')
def test_list_snapshot_resources(self):
resources = self.client.list_resources(resource_type='snapshot')
self.assertGreater(len(resources['items']), 0)
self.assertEqual(resources['id'], 'resources')
self.assertEqual(resources['items'][0]['type'], 'snapshot')
def test_list_ipblock_resources(self):
resources = self.client.list_resources(resource_type='ipblock')
self.assertGreater(len(resources['items']), 0)
self.assertEqual(resources['id'], 'resources')
self.assertEqual(resources['items'][0]['type'], 'ipblock')
def test_list_resources_failure(self):
try:
self.client.list_resources(resource_type='unknown')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
def test_get_datacenter_resource(self):
resource = self.client.get_resource(resource_type='datacenter',
resource_id=self.datacenter['id'])
self.assertEqual(resource['id'], self.datacenter['id'])
self.assertEqual(resource['type'], 'datacenter')
def test_get_image_resource(self):
resource = self.client.get_resource(resource_type='image',
resource_id=self.image['id'])
self.assertEqual(resource['id'], self.image['id'])
self.assertEqual(resource['type'], 'image')
def test_get_snapshot_resource(self):
resource = self.client.get_resource(resource_type='snapshot',
resource_id=self.snapshot['id'])
self.assertEqual(resource['id'], self.snapshot['id'])
self.assertEqual(resource['type'], 'snapshot')
def test_list_ipblock_resources2(self):
resource = self.client.get_resource(resource_type='ipblock',
resource_id=self.ipblock['id'])
self.assertEqual(resource['id'], self.ipblock['id'])
self.assertEqual(resource['type'], 'ipblock')
def test_get_resource_failure(self):
try:
self.client.get_resource(
resource_type='datacenter',
resource_id='00000000-0000-0000-0000-000000000000')
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'],
e.content[0]['message'])
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)
print("creating snapshot: {}".format(snapshot_name))
pb.create_snapshot(datacenter_id, volume_id, snapshot_name)
sleep(sleep_seconds)
# delete old snapshots
snapshots = pb.list_snapshots()
for snapshot_item in snapshots['items']:
snapshot_id = snapshot_item['id']
snapshot = pb.get_snapshot(snapshot_id)
snapshot_name = snapshot['properties']['name']
if not snapshot_name.startswith(snapshot_prefix):
continue
snapshot_created = snapshot['metadata']['createdDate']
snapshot_date = datetime.strptime(snapshot_created, "%Y-%m-%dT%H:%M:%SZ")
if snapshot_date < now - timedelta(days=retention_time):
print("deleting snapshot: {} (created: {})".format(
snapshot_name, snapshot_created))
pb.delete_snapshot(snapshot_id)
sleep(sleep_seconds)
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)
print("creating snapshot: {}".format(snapshot_name))
pb.create_snapshot(datacenter_id, volume_id, snapshot_name)
sleep(sleep_seconds)
# delete old snapshots
snapshots = pb.list_snapshots()
for snapshot_item in snapshots['items']:
snapshot_id = snapshot_item['id']
snapshot = pb.get_snapshot(snapshot_id)
snapshot_name = snapshot['properties']['name']
if not snapshot_name.startswith(snapshot_prefix):
continue
snapshot_created = snapshot['metadata']['createdDate']
snapshot_date = datetime.strptime(snapshot_created, "%Y-%m-%dT%H:%M:%SZ")
if snapshot_date < now - timedelta(days=retention_time):
print("deleting snapshot: {} (created: {})".format(snapshot_name, snapshot_created))
pb.delete_snapshot(snapshot_id)
sleep(sleep_seconds)
class TestServer(unittest.TestCase):
def setUp(self):
self.snapshot = ProfitBricksService(
username='******', password='******')
def test_list_snapshots(self):
snapshots = self.snapshot.list_snapshots()
self.assertEqual(len(snapshots), 4)
self.assertEqual(snapshots['items'][0]['id'], snapshot_id)
self.assertEqual(
snapshots['items'][0]['properties']['name'],
'Snapshot of storage X on 12.12.12 12:12:12')
self.assertEqual(
snapshots['items'][0]['properties']['description'],
'description of a snapshot')
self.assertEqual(
snapshots['items'][0]['properties']['location'], 'de/fkb')
self.assertEqual(
snapshots['items'][0]['properties']['size'], 28)
def test_get_snapshot(self):
snapshot = self.snapshot.get_snapshot(
snapshot_id=snapshot_id)
self.assertEqual(snapshot['id'], snapshot_id)
self.assertEqual(
snapshot['properties']['name'],
'Snapshot of storage X on 12.12.12 12:12:12')
self.assertEqual(
snapshot['properties']['description'],
'description of a snapshot')
self.assertEqual(
snapshot['properties']['location'], 'de/fkb')
self.assertEqual(
snapshot['properties']['size'], 28)
def test_delete_snapshot(self):
snapshot = self.snapshot.delete_snapshot(
snapshot_id=snapshot_id)
self.assertTrue(snapshot)
def test_update_snapshot(self):
snapshot = self.snapshot.update_snapshot(
snapshot_id='7df81087-5835-41c6-a10b-3e098593bbd2',
name='New name')
self.assertEqual(snapshot['id'], '7df81087-5835-41c6-a10b-3e098593bbd2')
self.assertEqual(snapshot['properties']['name'], 'New name')
self.assertEqual(
snapshot['properties']['description'],
'description of a snapshot - updated')
self.assertEqual(
snapshot['properties']['location'], 'de/fkb')
self.assertEqual(
snapshot['properties']['size'], 28)
"""
from profitbricks.client import ProfitBricksService
client = ProfitBricksService(username="******", password="******")
snapshot_id = "d084aa0a-f9ab-41d5-9316-18163bc416ef"
image = client.update_snapshot(
snapshot_id,
name="New name",
description="Backup of volume XYZ",
licence_type="LINUX",
cpu_hot_plug=True,
ram_hot_plug=True,
nic_hot_plug=True,
nic_hot_unplug=True,
disc_virtio_hot_plug=True,
disc_virtio_hot_unplug=True,
)
"""Remove Snapshot
"""
from profitbricks.client import ProfitBricksService
snapshot_id = "7df81087-5835-41c6-a10b-3e098593bba4"
client = ProfitBricksService(username="******", password="******")
snapshot = client.delete_snapshot(snapshot_id=snapshot_id)
