def main(argv=None):
'''Command line options.'''
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
program_name = os.path.basename(sys.argv[0])
program_version = "v%s" % __version__
program_build_date = str(__updated__)
program_version_message = '%%(prog)s %s (%s)' % (program_version,
program_build_date)
program_shortdesc = __import__('__main__').__doc__.split("\n")[1]
program_license = '''%s
Created by J. Buchhammer on %s.
Copyright 2016 ProfitBricks GmbH. All rights reserved.
Licensed under the Apache License 2.0
http://www.apache.org/licenses/LICENSE-2.0
Distributed on an "AS IS" basis without warranties
or conditions of any kind, either express or implied.
USAGE
''' % (program_shortdesc, str(__date__))
try:
# Setup argument parser
parser = ArgumentParser(description=program_license,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('-u', '--user', dest='user', help='the login name')
parser.add_argument('-p',
'--password',
dest='password',
help='the login password')
parser.add_argument('-L',
'--Login',
dest='loginfile',
default=None,
help='the login file to use')
parser.add_argument('-d',
'--datacenterid',
dest='dc_id',
required=True,
default=None,
help='datacenter of the server')
parser.add_argument('-s',
'--serverid',
dest='serverid',
default=None,
help='ID of the server')
parser.add_argument('-n',
'--name',
dest='servername',
default=None,
help='name of the server')
parser.add_argument('-C',
'--command',
dest='command',
default=None,
help='remote shell command to use for shutdown')
parser.add_argument('-v',
'--verbose',
dest="verbose",
action="count",
help="set verbosity level [default: %(default)s]")
parser.add_argument('-V',
'--version',
action='version',
version=program_version_message)
# Process arguments
args = parser.parse_args()
global verbose
verbose = args.verbose
dc_id = args.dc_id
if verbose > 0:
print("Verbose mode on")
if args.serverid is None and args.servername is None:
parser.error("one of 'serverid' or 'name' must be specified")
(user, password) = getLogin(args.loginfile, args.user, args.password)
if user is None or password is None:
raise ValueError("user or password resolved to None")
pbclient = ProfitBricksService(user, password)
server = getServerStates(pbclient, dc_id, args.serverid,
args.servername)
if server is None:
raise Exception(1, "specified server not found")
print("using server {}(id={}) in state {}, {}".format(
server['name'], server['id'], server['state'], server['vmstate']))
# ! stop/start/reboot_server() simply return 'True' !
# this implies, that there's NO response nor requestId to track!
if server['vmstate'] == 'SHUTOFF':
print("VM is already shut off")
else:
if args.command is None:
print("no command specified for shutdown of VM")
else:
print("executing {}".format(args.command))
cmdrc = call(args.command, shell=True)
print("executing {} returned {}".format(args.command, cmdrc))
server = wait_for_server(pbclient,
dc_id,
server['id'],
indicator='vmstate',
state='SHUTOFF',
timeout=300)
# first we have to delete all attached volumes
volumes = pbclient.get_attached_volumes(dc_id, server['id'], 0)
for vol in volumes['items']:
print("deleting volume {} of server {}".format(
vol['id'], server['name']))
pbclient.delete_volume(dc_id, vol['id'])
pbclient.delete_server(dc_id, server['id'])
wait_for_datacenter(pbclient, dc_id)
except KeyboardInterrupt:
# handle keyboard interrupt #
pass
except Exception:
traceback.print_exc()
sys.stderr.write("\n" + program_name + ": for help use --help\n")
return 2
return 0
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 main(argv=None):
'''Command line options.'''
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
program_name = os.path.basename(sys.argv[0])
program_version = "v%s" % __version__
program_build_date = str(__updated__)
program_version_message = '%%(prog)s %s (%s)' % (program_version,
program_build_date)
program_shortdesc = __import__('__main__').__doc__.split("\n")[1]
program_license = '''%s
Created by J. Buchhammer on %s.
Copyright 2016 ProfitBricks GmbH. All rights reserved.
Licensed under the Apache License 2.0
http://www.apache.org/licenses/LICENSE-2.0
Distributed on an "AS IS" basis without warranties
or conditions of any kind, either express or implied.
USAGE
''' % (program_shortdesc, str(__date__))
try:
# Setup argument parser
parser = ArgumentParser(description=program_license,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('-u', '--user', dest='user', help='the login name')
parser.add_argument('-p', '--password', dest='password',
help='the login password')
parser.add_argument('-L', '--Login', dest='loginfile', default=None,
help='the login file to use')
parser.add_argument('-d', '--datacenterid', dest='dc_id',
required=True, default=None,
help='datacenter of the server')
parser.add_argument('-s', '--serverid', dest='serverid', default=None,
help='ID of the server')
parser.add_argument('-n', '--name', dest='servername', default=None,
help='name of the server')
parser.add_argument('-C', '--command', dest='command', default=None,
help='remote shell command to use for shutdown')
parser.add_argument('-v', '--verbose', dest="verbose", action="count",
help="set verbosity level [default: %(default)s]")
parser.add_argument('-V', '--version', action='version',
version=program_version_message)
# Process arguments
args = parser.parse_args()
global verbose
verbose = args.verbose
dc_id = args.dc_id
if verbose > 0:
print("Verbose mode on")
if args.serverid is None and args.servername is None:
parser.error("one of 'serverid' or 'name' must be specified")
(user, password) = getLogin(args.loginfile, args.user, args.password)
if user is None or password is None:
raise ValueError("user or password resolved to None")
pbclient = ProfitBricksService(user, password)
server = getServerStates(pbclient, dc_id, args.serverid,
args.servername)
if server is None:
raise Exception(1, "specified server not found")
print("using server {}(id={}) in state {}, {}"
.format(server['name'], server['id'], server['state'],
server['vmstate']))
# ! stop/start/reboot_server() simply return 'True' !
# this implies, that there's NO response nor requestId to track!
if server['vmstate'] == 'SHUTOFF':
print("VM is already shut off")
else:
if args.command is None:
print("no command specified for shutdown of VM")
else:
print("executing {}".format(args.command))
cmdrc = call(args.command, shell=True)
print("executing {} returned {}".format(args.command, cmdrc))
server = wait_for_server(pbclient, dc_id, server['id'],
indicator='vmstate', state='SHUTOFF',
timeout=300)
# first we have to delete all attached volumes
volumes = pbclient.get_attached_volumes(dc_id, server['id'], 0)
for vol in volumes['items']:
print("deleting volume {} of server {}"
.format(vol['id'], server['name']))
pbclient.delete_volume(dc_id, vol['id'])
pbclient.delete_server(dc_id, server['id'])
wait_for_datacenter(pbclient, dc_id)
except KeyboardInterrupt:
# handle keyboard interrupt #
return 0
except Exception:
traceback.print_exc()
sys.stderr.write("\n" + program_name + ": for help use --help\n")
return 2
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']))
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)
@classmethod
def tearDownClass(self):
self.client.delete_datacenter(datacenter_id=self.datacenter['id'])
def test_list_volumes(self):
volumes = self.client.list_volumes(
datacenter_id=self.datacenter['id'])
self.assertGreater(len(volumes), 0)
assertRegex(self, volumes['items'][0]['id'], self.resource['uuid_match'])
self.assertEqual(volumes['items'][0]['type'], 'volume')
self.assertEqual(volumes['items'][0]['properties']['name'],
self.resource['volume2']['name'])
self.assertEqual(volumes['items'][0]['properties']['size'],
self.resource['volume2']['size'])
self.assertEqual(volumes['items'][0]['properties']['type'],
self.resource['volume2']['disk_type'])
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['volume2']['name'])
self.assertEqual(volume['properties']['size'], self.resource['volume2']['size'])
self.assertEqual(volume['properties']['licenceType'],
self.image['properties']['licenceType'])
self.assertEqual(volume['properties']['type'], self.resource['volume2']['disk_type'])
self.assertIsNone(volume['properties']['bus'])
self.assertEqual(volume['properties']['availabilityZone'],
self.resource['volume2']['availability_zone'])
def test_delete_volume(self):
volume = self.client.create_volume(
datacenter_id=self.datacenter['id'],
volume=Volume(**self.resource['volume']))
self.client.wait_for_completion(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['volume2']['name'] + ' - RENAME')
self.client.wait_for_completion(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['volume2']['name'] + ' - RENAME')
self.assertEqual(volume['properties']['size'], 6)
def test_create_volume(self):
# Use volume created during volume test setup.
assertRegex(self, self.volume['id'], self.resource['uuid_match'])
self.assertEqual(self.volume['properties']['name'], self.resource['volume2']['name'])
self.assertEqual(self.volume['properties']['bus'], self.resource['volume2']['bus'])
self.assertEqual(self.volume['properties']['type'], self.resource['volume2']['disk_type'])
self.assertEqual(self.volume['properties']['size'], self.resource['volume2']['size'])
self.assertEqual(self.volume['properties']['sshKeys'],
self.resource['volume2']['ssh_keys'])
self.assertEqual(self.volume['properties']['availabilityZone'],
self.resource['volume2']['availability_zone'])
def test_create_snapshot(self):
# Use snapshot created during volume test setup.
self.assertEqual(self.snapshot1['type'], 'snapshot')
self.assertEqual(self.snapshot1['properties']['name'], self.resource['snapshot']['name'])
self.assertEqual(self.snapshot1['properties']['description'],
self.resource['snapshot']['description'])
self.assertEqual(self.snapshot1['properties']['location'], configuration.LOCATION)
self.assertIsNone(self.snapshot1['properties']['size'])
self.assertIsNone(self.snapshot1['properties']['licenceType'])
def test_restore_snapshot(self):
response = self.client.restore_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
snapshot_id=self.snapshot1['id'])
self.assertTrue(response)
def test_remove_snapshot(self):
volume = self.client.remove_snapshot(snapshot_id=self.snapshot1['id'])
self.assertTrue(volume)
def test_get_failure(self):
try:
self.client.get_volume(
datacenter_id=self.datacenter['id'],
volume_id='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:
volume = Volume(name=self.resource['volume2']['name'])
self.client.create_volume(datacenter_id=self.datacenter['id'], volume=volume)
except PBError as e:
self.assertIn(self.resource['missing_attribute_error'] % 'size',
e.content[0]['message'])
class TestVolume(unittest.TestCase):
def setUp(self):
self.volume = ProfitBricksService(
username='******', password='******')
def test_list_volumes(self):
volumes = self.volume.list_volumes(
datacenter_id=datacenter_id)
self.assertEqual(len(volumes), 4)
self.assertEqual(volumes['items'][0]['id'], volume_id)
self.assertEqual(volumes['items'][0]['properties']['name'], 'my boot volume for server 1')
self.assertEqual(volumes['items'][0]['properties']['size'], 80)
self.assertEqual(volumes['items'][0]['properties']['licenceType'], 'WINDOWS')
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.assertEqual(volumes['items'][0]['properties']['bus'], 'VIRTIO')
self.assertEqual(volumes['items'][0]['properties']['type'], 'HDD')
def test_get_volume(self):
volume = self.volume.get_volume(
datacenter_id=datacenter_id,
volume_id=volume_id)
self.assertEqual(volume['properties']['name'], 'my boot volume for server 1')
self.assertEqual(volume['properties']['size'], 80)
self.assertEqual(volume['properties']['licenceType'], 'WINDOWS')
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.assertEqual(volume['properties']['bus'], 'VIRTIO')
self.assertEqual(volume['properties']['type'], 'HDD')
def test_delete_volume(self):
volume = self.volume.delete_volume(
datacenter_id=datacenter_id,
volume_id=volume_id)
self.assertTrue(volume)
def test_update_volume(self):
volume = self.volume.update_volume(
datacenter_id=datacenter_id,
volume_id=volume_id,
size=100,
name='Resized storage to 100 GB',
cpu_hot_unplug=True)
self.assertEqual(
volume['properties']['name'], 'Resized storage to 100 GB')
self.assertEqual(volume['properties']['size'], 100)
def test_create_volume(self):
i = Volume(
name='Explicitly created volume',
size=56,
image='<IMAGE/SNAPSHOT-ID>',
bus='VIRTIO')
response = self.volume.create_volume(
datacenter_id=datacenter_id, volume=i)
self.assertEqual(
response['properties']['name'], 'my boot volume for server 1')
self.assertEqual(response['properties']['size'], 80)
self.assertEqual(response['properties']['licenceType'], 'WINDOWS')
self.assertFalse(response['properties']['cpuHotPlug'])
self.assertFalse(response['properties']['cpuHotUnplug'])
self.assertFalse(response['properties']['ramHotPlug'])
self.assertFalse(response['properties']['ramHotUnplug'])
self.assertFalse(response['properties']['nicHotPlug'])
self.assertFalse(response['properties']['nicHotUnplug'])
self.assertFalse(response['properties']['discVirtioHotPlug'])
self.assertFalse(response['properties']['discVirtioHotUnplug'])
self.assertFalse(response['properties']['discScsiHotPlug'])
self.assertFalse(response['properties']['discScsiHotUnplug'])
self.assertEqual(response['properties']['bus'], 'VIRTIO')
self.assertEqual(response['properties']['type'], 'HDD')
def test_create_optional_value(self):
i = Volume(
name='Explicitly created volume',
size=56,
image='<IMAGE/SNAPSHOT-ID>',
bus='VIRTIO',
ram_hot_plug=True,
cpu_hot_unplug=True)
response = self.volume.create_volume(
datacenter_id=datacenter_id, volume=i)
self.assertEqual(
response['properties']['name'], 'my boot volume for server 1')
self.assertEqual(response['properties']['size'], 80)
self.assertEqual(response['properties']['licenceType'], 'WINDOWS')
self.assertFalse(response['properties']['cpuHotPlug'])
self.assertFalse(response['properties']['cpuHotUnplug'])
self.assertFalse(response['properties']['ramHotPlug'])
self.assertFalse(response['properties']['ramHotUnplug'])
self.assertFalse(response['properties']['nicHotPlug'])
self.assertFalse(response['properties']['nicHotUnplug'])
self.assertFalse(response['properties']['discVirtioHotPlug'])
self.assertFalse(response['properties']['discVirtioHotUnplug'])
self.assertFalse(response['properties']['discScsiHotPlug'])
self.assertFalse(response['properties']['discScsiHotUnplug'])
self.assertEqual(response['properties']['bus'], 'VIRTIO')
self.assertEqual(response['properties']['type'], 'HDD')
def test_create_snapshot(self):
volume = self.volume.create_snapshot(
datacenter_id=datacenter_id,
volume_id=volume_id,
name='<URLENCODED_SNAPSHOT_NAME>',
description='<URLENCODED_SNAPSHOT_DESCRIPTION>')
self.assertEqual(volume['id'], snapshot_id)
self.assertEqual(
volume['properties']['name'],
'Snapshot of storage X on 12.12.12 12:12:12 - updated')
self.assertEqual(volume['properties']['description'],
'description of a snapshot - updated')
self.assertEqual(volume['properties']['location'], 'de/fkb')
self.assertEqual(volume['properties']['size'], 28)
self.assertEqual(volume['properties']['licenceType'], 'WINDOWS')
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'])
def test_restore_snapshot(self):
response = self.volume.restore_snapshot(
datacenter_id=datacenter_id,
volume_id=volume_id,
snapshot_id=snapshot_id)
self.assertTrue(response)
def test_remove_snapshot(self):
volume = self.volume.remove_snapshot(snapshot_id=snapshot_id)
self.assertTrue(volume)
