def setUpClass(cls):
cls.resource = resource()
cls.client = IonosEnterpriseService(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)
cls.image = find_image(cls.client, configuration.IMAGE_NAME)
# Create test volume
vol = Volume(**cls.resource['volume2'])
vol.image = cls.image['id']
cls.volume = cls.client.create_volume(
datacenter_id=cls.datacenter['id'], volume=vol)
cls.client.wait_for_completion(cls.volume)
# Create snapshot1
cls.snapshot1 = cls.client.create_snapshot(
datacenter_id=cls.datacenter['id'],
volume_id=cls.volume['id'],
name=cls.resource['snapshot']['name'],
description=cls.resource['snapshot']['description'])
cls.client.wait_for_completion(cls.snapshot1, timeout=600)
def test_create_composite(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'])
volume.availability_zone = 'ZONE_3'
server = Server(
nics=[nic],
create_volumes=[volume],
**self.resource['server'])
composite_server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=server)
self.client.wait_for_completion(composite_server, 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'], 'ZONE_1')
self.assertIn(composite_server['properties']['vmState'], self.resource['vm_states'])
self.assertGreater(len(composite_server['entities']['volumes']['items']), 0)
self.assertGreater(len(composite_server['entities']['nics']['items']), 0)
def setUpClass(cls):
cls.resource = resource()
cls.client = IonosEnterpriseService(
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 volume
volume = Volume(**cls.resource['volume'])
cls.volume = cls.client.create_volume(
datacenter_id=cls.datacenter['id'],
volume=volume
)
cls.client.wait_for_completion(cls.volume)
# Create test volume1
volume1 = Volume(**cls.resource['volume'])
cls.volume1 = cls.client.create_volume(
datacenter_id=cls.datacenter['id'],
volume=volume1
)
cls.client.wait_for_completion(cls.volume1)
# Create test snapshot
snapshot = Snapshot(**cls.resource['snapshot'])
cls.snapshot1 = cls.client.create_snapshot(
datacenter_id=cls.datacenter['id'],
volume_id=cls.volume['id'],
name=snapshot.name,
description=snapshot.description)
cls.client.wait_for_completion(cls.snapshot1)
# Create test snapshot2
cls.snapshot2 = cls.client.create_snapshot(
datacenter_id=cls.datacenter['id'],
volume_id=cls.volume['id'],
name="python sdk test snapshot",
description="snapshot test description")
cls.client.wait_for_completion(cls.snapshot2)
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 ICError as e:
self.assertIn(self.resource['missing_attribute_error'] % 'size',
e.content[0]['message'])
def test_ic_validation_error(self):
try:
i = Volume(name='Explicitly created volume',
size=5,
disk_type='HDD',
image='fake_image_id',
bus='VIRTIO')
self.client.create_volume(datacenter_id=self.datacenter['id'],
volume=i)
except ICError as err:
self.assertTrue(isinstance(err, ICValidationError))
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)
assertRegex(self, volume['requestId'], self.resource['uuid_match'])
def test_create_composite(self):
datacenter_resource = Datacenter(
**self.resource['datacenter_composite'])
datacenter_resource.servers = [Server(**self.resource['server'])]
datacenter_resource.volumes = [Volume(**self.resource['volume'])]
datacenter = self.client.create_datacenter(
datacenter=datacenter_resource)
self.client.wait_for_completion(datacenter)
self.assertEqual(datacenter['type'], 'datacenter')
self.assertEqual(datacenter['properties']['name'],
self.resource['datacenter_composite']['name'])
self.assertEqual(datacenter['properties']['description'],
self.resource['datacenter_composite']['description'])
self.assertEqual(datacenter['properties']['location'],
self.resource['datacenter_composite']['location'])
self.assertGreater(len(datacenter['entities']['servers']), 0)
self.assertGreater(len(datacenter['entities']['volumes']), 0)
response = self.client.delete_datacenter(
datacenter_id=datacenter['id'])
self.assertTrue(response)
def getVolumeObject(defdict=None):
if not defdict or not isinstance(defdict, dict):
raise ValueError("argument 'defdict' must be non-empty dict")
# TODO: can we set deviceNumber too? Nope, not supported in Volume()
# AARGH! some of Volume's fields have different names -> need to convert
# so make a copy and let source as is
props = dict()
for k, v in defdict['properties'].items():
if k == 'type':
props['disk_type'] = v
continue
if k == 'imagePassword':
props['image_password'] = v
continue
if k == 'licenceType':
props['licence_type'] = v
continue
if k == 'sshKeys':
props['ssh_keys'] = v
continue
props[k] = v
# end for(defdict)
apiobj = Volume(**props)
return apiobj
# pylint: disable=reimported,wrong-import-position
"""Create volume
"""
from ionosenterprise.client import IonosEnterpriseService, Volume
datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022'
client = IonosEnterpriseService(
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 ionosenterprise.client import IonosEnterpriseService # noqa
datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022'
volume_id = '700e1cab-99b2-4c30-ba8c-1d273ddba025'
client = IonosEnterpriseService(
def main(argv=None):
'''Command line options.'''
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
program_name = os.path.basename(sys.argv[0])
program_version = "v%s" % __version__
program_build_date = str(__updated__)
program_version_message = '%%(prog)s %s (%s)' % (program_version,
program_build_date)
program_shortdesc = __import__('__main__').__doc__.split("\n")[1]
program_license = '''%s
Created by Jürgen Buchhammer on %s.
Copyright 2016 IONOS. All rights reserved.
Licensed under the Apache License 2.0
http://www.apache.org/licenses/LICENSE-2.0
Distributed on an "AS IS" basis without warranties
or conditions of any kind, either express or implied.
USAGE
''' % (program_shortdesc, str(__date__))
try:
# Setup argument parser
parser = ArgumentParser(description=program_license,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('-u', '--user', dest='user', help='the login name')
parser.add_argument('-p',
'--password',
dest='password',
help='the login password')
parser.add_argument('-L',
'--Login',
dest='loginfile',
default=None,
help='the login file to use')
parser.add_argument('-t',
'--type',
dest='metatype',
default="OVF",
help='type of VM meta data')
parser.add_argument('-m',
'--metadata',
dest='metafile',
required=True,
default=None,
help='meta data file')
parser.add_argument('-d',
'--datacenterid',
dest='datacenterid',
default=None,
help='datacenter of the new server')
parser.add_argument('-D',
'--DCname',
dest='dcname',
default=None,
help='new datacenter name')
parser.add_argument('-l',
'--location',
dest='location',
default=None,
help='location for new datacenter')
parser.add_argument('-v',
'--verbose',
dest="verbose",
action="count",
default=0,
help="set verbosity level [default: %(default)s]")
parser.add_argument('-V',
'--version',
action='version',
version=program_version_message)
# Process arguments
args = parser.parse_args()
global verbose
verbose = args.verbose
if verbose > 0:
print("Verbose mode on")
print("start {} with args {}".format(program_name, str(args)))
(user, password) = getLogin(args.loginfile, args.user, args.password)
if user is None or password is None:
raise ValueError("user or password resolved to None")
pbclient = IonosEnterpriseService(user, password)
if args.metatype == 'OVF':
metadata = OFVData(args.metafile)
metadata.parse()
else:
sys.stderr.write("Metadata type '{}' is not supported".format(
args.metatype))
return 1
# we need the DC first to have the location defined
dc_id = None
if args.datacenterid is None:
if args.dcname is None or args.location is None:
sys.stderr.write(
"Either '-d <id>' or '-D <name> -l <loc>' must be specified"
)
return 1
# else: we will create the DC later after parsing the meta data
else:
dc_id = args.datacenterid
if dc_id is None:
location = args.location
dc = Datacenter(name=args.dcname,
location=location,
description="created by pb_importVM")
print("create new DC {}".format(str(dc)))
response = pbclient.create_datacenter(dc)
dc_id = response['id']
result = wait_for_request(pbclient, response['requestId'])
print("wait loop returned {}".format(result))
else:
dc = pbclient.get_datacenter(dc_id)
location = dc['properties']['location']
print("use existing DC {} in location {}".format(
dc['properties']['name'], location))
# check if images exist
for disk in metadata.disks:
disk_name = disk['file']
images = get_disk_image_by_name(pbclient, location, disk_name)
if not images:
raise ValueError(
"No HDD image with name '{}' found in location {}".format(
disk_name, location))
if len(images) > 1:
raise ValueError(
"Ambigous image name '{}' in location {}".format(
disk_name, location))
disk['image'] = images[0]['id']
# now we're ready to create the VM
# Server
server = Server(name=metadata.name,
cores=metadata.cpus,
ram=metadata.ram)
print("create server {}".format(str(Server)))
response = pbclient.create_server(dc_id, server)
srv_id = response['id']
result = wait_for_request(pbclient, response['requestId'])
print("wait loop returned {}".format(str(result)))
# NICs (note that createing LANs may be implicit)
for nic in metadata.nics:
dcnic = NIC(name=nic['nic'], lan=nic['lanid'])
print("create NIC {}".format(str(dcnic)))
response = pbclient.create_nic(dc_id, srv_id, dcnic)
nic_id = response['id']
result = wait_for_request(pbclient, response['requestId'])
print("wait loop returned {}".format(str(result)))
response = pbclient.get_nic(dc_id, srv_id, nic_id, 2)
mac = response['properties']['mac']
print("dcnic has MAC {} for {}".format(mac, nic_id))
# end for(nics)
# Volumes (we use the image name as volume name too
requests = []
for disk in metadata.disks:
dcvol = Volume(name=disk['file'],
size=disk['capacity'],
image=disk['image'],
licence_type=metadata.licenseType)
print("create Volume {}".format(str(dcvol)))
response = pbclient.create_volume(dc_id, dcvol)
requests.append(response['requestId'])
disk['volume_id'] = response['id']
# end for(disks)
if requests:
result = wait_for_requests(pbclient,
requests,
initial_wait=10,
scaleup=15)
print("wait loop returned {}".format(str(result)))
for disk in metadata.disks:
print("attach volume {}".format(disk))
response = pbclient.attach_volume(dc_id, srv_id, disk['volume_id'])
result = wait_for_request(pbclient, response['requestId'])
print("wait loop returned {}".format(str(result)))
# end for(disks)
print("import of VM succesfully finished")
return 0
except KeyboardInterrupt:
# handle keyboard interrupt
return 0
except Exception:
traceback.print_exc()
sys.stderr.write("\n" + program_name + ": for help use --help\n")
return 2
def setUpClass(cls):
cls.resource = resource()
cls.client = IonosEnterpriseService(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 volume1.
cls.volume1 = cls.client.create_volume(
datacenter_id=cls.datacenter['id'],
volume=Volume(**cls.resource['volume']))
cls.client.wait_for_completion(cls.volume1)
# Create test volume2 (attach volume test).
cls.volume2 = cls.client.create_volume(
datacenter_id=cls.datacenter['id'],
volume=Volume(**cls.resource['volume']))
cls.client.wait_for_completion(cls.volume2)
# Create test server.
server = Server(**cls.resource['server'])
server.attach_volumes = [cls.volume1['id']]
cls.server = cls.client.create_server(
datacenter_id=cls.datacenter['id'], server=server)
cls.client.wait_for_completion(cls.server)
# Create test NIC.
cls.nic = cls.client.create_nic(datacenter_id=cls.datacenter['id'],
server_id=cls.server['id'],
nic=NIC(**cls.resource['nic']))
cls.client.wait_for_completion(cls.nic)
# 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
# Find a cdrom image
images = cls.client.list_images(depth=5)
usedIndex = 0
for index, image in enumerate(images['items']):
if (image['metadata']['state'] == "AVAILABLE"
and image['properties']['public'] is True
and image['properties']['imageType'] == "CDROM" and
image['properties']['location'] == configuration.LOCATION
and image['properties']['licenceType'] == "LINUX"):
if usedIndex == 0:
cls.test_image1 = image
usedIndex = index
else:
cls.test_image2 = image
break
# Create test cdrom
cls.cdrom = cls.client.attach_cdrom(datacenter_id=cls.datacenter['id'],
server_id=cls.server['id'],
cdrom_id=cls.test_image1['id'])
cls.client.wait_for_completion(cls.cdrom)
lan=1,
firewall_active=True,
firewall_rules=fw_rules)
nic2 = NIC(name='nic2',
ips=['10.2.3.4'],
dhcp='true',
lan=1,
firewall_active=True,
firewall_rules=fw_rules)
nics = [nic1, nic2]
volume1 = Volume(name='volume1',
size=56,
image=image_id,
bus='VIRTIO',
image_password="******")
volume2 = Volume(name='volume2',
size=56,
image=image_id,
bus='VIRTIO',
image_password="******")
volumes = [volume2]
server1 = Server(name='My New Server1',
ram=4096,
cores=4,
nics=nics,
def main(argv=None):
'''Parse command line options and create a server/volume composite.'''
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
program_name = os.path.basename(sys.argv[0])
program_version = "v%s" % __version__
program_build_date = str(__updated__)
program_version_message = '%%(prog)s %s (%s)' % (program_version,
program_build_date)
program_shortdesc = __import__('__main__').__doc__.split("\n")[1]
program_license = '''%s
Created by J. Buchhammer on %s.
Copyright 2016 IONOS. All rights reserved.
Licensed under the Apache License 2.0
http://www.apache.org/licenses/LICENSE-2.0
Distributed on an "AS IS" basis without warranties
or conditions of any kind, either express or implied.
USAGE
''' % (program_shortdesc, str(__date__))
try:
# Setup argument parser
parser = ArgumentParser(description=program_license,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('-u', '--user', dest='user', help='the login name')
parser.add_argument('-p', '--password', dest='password',
help='the login password')
parser.add_argument('-L', '--Login', dest='loginfile', default=None,
help='the login file to use')
parser.add_argument('-d', '--datacenterid', dest='datacenterid',
required=True, default=None,
help='datacenter of the new server')
parser.add_argument('-l', '--lanid', dest='lanid', required=True,
default=None, help='LAN of the new server')
parser.add_argument('-n', '--name', dest='servername',
default="SRV_"+datetime.now().isoformat(),
help='name of the new server')
parser.add_argument('-c', '--cores', dest='cores', type=int,
default=2, help='CPU cores')
parser.add_argument('-r', '--ram', dest='ram', type=int, default=4,
help='RAM in GB')
parser.add_argument('-s', '--storage', dest='storage', type=int,
default=4, help='storage in GB')
parser.add_argument('-b', '--boot', dest='bootdevice', default="HDD",
help='boot device')
parser.add_argument('-i', '--imageid', dest='imageid', default=None,
help='installation image')
parser.add_argument('-P', '--imagepassword', dest='imgpassword',
default=None, help='the image password')
parser.add_argument('-v', '--verbose', dest="verbose", action="count",
help="set verbosity level [default: %(default)s]")
parser.add_argument('-V', '--version', action='version',
version=program_version_message)
# Process arguments
args = parser.parse_args()
global verbose
verbose = args.verbose
dc_id = args.datacenterid
lan_id = args.lanid
servername = args.servername
if verbose > 0:
print("Verbose mode on")
print("start {} with args {}".format(program_name, str(args)))
# Test images (location de/fra)
# CDROM: 7fc885b3-c9a6-11e5-aa10-52540005ab80 # debian-8.3.0-amd64-netinst.iso
# HDD: 28007a6d-c88a-11e5-aa10-52540005ab80 # CentOS-7-server-2016-02-01
hdimage = args.imageid
cdimage = None
if args.bootdevice == "CDROM":
hdimage = None
cdimage = args.imageid
print("using boot device {} with image {}"
.format(args.bootdevice, args.imageid))
(user, password) = getLogin(args.loginfile, args.user, args.password)
if user is None or password is None:
raise ValueError("user or password resolved to None")
pbclient = IonosEnterpriseService(user, password)
first_nic = NIC(name="local", ips=[], dhcp=True, lan=lan_id)
volume = Volume(name=servername+"-Disk", size=args.storage,
image=hdimage, image_password=args.imgpassword)
server = Server(name=servername, cores=args.cores, ram=args.ram*1024,
create_volumes=[volume], nics=[first_nic],
boot_cdrom=cdimage)
print("creating server..")
if verbose > 0:
print("SERVER: {}".format(str(server)))
response = pbclient.create_server(dc_id, server)
print("wait for provisioning..")
wait_for_request(pbclient, response["requestId"])
server_id = response['id']
print("Server provisioned with ID {}".format(server_id))
nics = pbclient.list_nics(dc_id, server_id, 1)
# server should have exactly one nic, but we only test empty nic list
if not nics['items']:
raise CLIError("No NICs found for newly created server {}"
.format(server_id))
nic0 = nics['items'][0]
if verbose > 0:
print("NIC0: {}".format(str(nic0)))
(nic_id, nic_mac) = (nic0['id'], nic0['properties']['mac'])
print("NIC of new Server has ID {} and MAC {}".format(nic_id, nic_mac))
print("{} finished w/o errors".format(program_name))
return 0
except KeyboardInterrupt:
# handle keyboard interrupt #
return 0
except Exception:
traceback.print_exc()
sys.stderr.write("\n" + program_name + ": for help use --help\n")
return 2
def setUpClass(cls):
cls.resource = resource()
cls.client = IonosEnterpriseService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create datacenter resource
cls.datacenter = cls.client.create_datacenter(datacenter=Datacenter(
**cls.resource['datacenter']))
cls.client.wait_for_completion(cls.datacenter)
# Create volume resource
volume = Volume(**cls.resource['volume'])
cls.volume = cls.client.create_volume(
datacenter_id=cls.datacenter['id'], volume=volume)
cls.client.wait_for_completion(cls.volume)
cls.image = find_image(cls.client, configuration.IMAGE_NAME)
# Create snapshot resource
cls.snapshot = cls.client.create_snapshot(
datacenter_id=cls.datacenter['id'],
volume_id=cls.volume['id'],
name=cls.resource['snapshot']['name'])
cls.client.wait_for_completion(cls.snapshot)
# Reserve IP block resource
cls.ipblock = cls.client.reserve_ipblock(
IPBlock(**cls.resource['ipblock']))
# Create User 1
cls.user_dict1 = User(
firstname='John',
lastname='Doe',
email='*****@*****.**' % randint(0, 9999999999999),
password='******' % randint(0, 99999999),
administrator=True,
force_sec_auth=False)
cls.user1 = cls.client.create_user(user=cls.user_dict1)
# Create User 2
cls.user_dict2 = User(
firstname='John',
lastname='Doe',
email='*****@*****.**' % randint(0, 9999999999999),
password='******' % randint(0, 99999999))
cls.user2 = cls.client.create_user(user=cls.user_dict2)
# Create User 3
cls.user_dict3 = User(
firstname='John',
lastname='Doe',
email='*****@*****.**' % randint(0, 9999999999999),
password='******' % randint(0, 99999999))
cls.user3 = cls.client.create_user(user=cls.user_dict3)
# Create Group 1
group = Group(**cls.resource['group'])
cls.group1 = cls.client.create_group(group)
# Create Group 2
group.name = cls.resource['group']['name'] + ' 2'
cls.group2 = cls.client.create_group(group)
# Create Group 3
group.name = cls.resource['group']['name'] + ' 3'
cls.group3 = cls.client.create_group(group)
# Create Share 1
cls.share1 = cls.client.add_share(group_id=cls.group3['id'],
resource_id=cls.datacenter['id'],
edit_privilege=True,
share_privilege=True)
name='nic1',
ips=['10.2.2.5'],
dhcp='true',
lan=1,
firewall_active=True,
)
nic2 = NIC(
name='nic2',
ips=['10.2.3.6'],
dhcp='true',
lan=1,
firewall_active=True,
)
volume1 = Volume(name='volume6', size=56, image=image_id, bus='VIRTIO')
volume2 = Volume(name='volume7', size=56, image=image_id, bus='VIRTIO')
nics = [nic1, nic2]
create_volumes = [volume1, volume2]
i = Server(name='server11',
ram=4096,
cores=4,
nics=nics,
create_volumes=create_volumes)
response = client.create_server(datacenter_id=datacenter_id, server=i)
"""Create Server with Existing Volume
"""
