def setUpClass(cls):
cls.resource = resource()
cls.client = IonosEnterpriseService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
cls.datacenter = cls.client.create_datacenter(datacenter=Datacenter(
**cls.resource['datacenter']))
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 setUpClass(cls):
warnings\
.filterwarnings("ignore", category=ResourceWarning,
message="unclosed.*<ssl.SSLSocket.*>")
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(**cls.resource['datacenter']))
cls.client.wait_for_completion(cls.datacenter)
# Create test server.
cls.server = cls.client.create_server(cls.datacenter['id'],
Server(**cls.resource['server']))
cls.client.wait_for_completion(cls.server)
# Use an image ID for CDROM
images = cls.client.list_images()['items']
images = list(
filter(
lambda v: v['properties']['location'] == cls.resource[
'datacenter']['location'] and v['properties']['imageType']
!= 'HDD', images))
cls.image_id = images[0]['id']
cls.attached_cdrom = cls.client.attach_cdrom(cls.datacenter['id'],
cls.server['id'],
cls.image_id)
cls.client.wait_for_completion(cls.attached_cdrom)
def setUpClass(cls):
warnings.filterwarnings("ignore",
category=ResourceWarning,
message="unclosed.*<ssl.SSLSocket.*>")
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['k8s_datacenter']))
# Wait for datacenter to be active
cls.client.wait_for_completion(cls.datacenter)
# Create test k8s cluster
cls.k8s_cluster = cls.client.create_k8s_cluster(
**cls.resource['k8s_cluster'])
# Create test k8s cluster for delete test
cls.k8s_cluster_for_delete_test = cls.client.create_k8s_cluster(
**cls.resource['k8s_cluster'])
# Wait for k8s cluster to be active
cls.client.wait_for(
fn_request=lambda: cls.client.list_k8s_clusters(),
fn_check=lambda r: list(
filter(lambda e: e['id'] == cls.k8s_cluster['id'], r['items'])
)[0]['metadata']['state'] == 'ACTIVE',
scaleup=10000)
# get cluster config
cls.k8s_config = cls.client.get_k8s_config(cls.k8s_cluster['id'])
def test_create_failure(self):
try:
datacenter = Datacenter(name=self.resource['datacenter']['name'])
self.client.create_datacenter(datacenter)
except ICError as e:
self.assertIn(
self.resource['missing_attribute_error'] % 'location',
e.content[0]['message'])
def getDatacenterObject(defdict=None):
if not defdict or not isinstance(defdict, dict):
raise ValueError("argument 'defdict' must be non-empty dict")
props = dict()
for k, v in defdict['properties'].items():
# no renaming needed here, but this accounts for optional props too
props[k] = v
apiobj = Datacenter(**props)
return apiobj
def test_remove_datacenter(self):
datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
self.client.wait_for_completion(datacenter)
response = self.client.delete_datacenter(
datacenter_id=datacenter['id'])
self.assertTrue(response)
assertRegex(self, response['requestId'], self.resource['uuid_match'])
def setUpClass(cls):
warnings.filterwarnings("ignore", category=ResourceWarning,
message="unclosed.*<ssl.SSLSocket.*>")
cls.resource = resource()
cls.client = IonosEnterpriseService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
cls.datacenter = cls.client.create_datacenter(
datacenter=Datacenter(**cls.resource['datacenter']))
def setUpClass(cls):
warnings.filterwarnings("ignore", category=ResourceWarning,
message="unclosed.*<ssl.SSLSocket.*>")
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 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 Firewall Rule
fwrule = FirewallRule(**cls.resource['fwrule'])
cls.fwrule = cls.client.create_firewall_rule(
datacenter_id=cls.datacenter['id'],
server_id=cls.server['id'],
nic_id=cls.nic1['id'],
firewall_rule=fwrule)
cls.client.wait_for_completion(cls.fwrule)
# Create test Firewall Rule 2
fwrule2 = FirewallRule(**cls.resource['fwrule'])
fwrule2.port_range_start = 8080
fwrule2.port_range_end = 8080
fwrule2.name = "8080"
cls.fwrule2 = cls.client.create_firewall_rule(
datacenter_id=cls.datacenter['id'],
server_id=cls.server['id'],
nic_id=cls.nic1['id'],
firewall_rule=fwrule2)
cls.client.wait_for_completion(cls.fwrule2)
def setUpClass(cls):
warnings.filterwarnings("ignore", category=ResourceWarning,
message="unclosed.*<ssl.SSLSocket.*>")
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 pcc.
pcc = PrivateCrossConnect(name="TEST NAME - %s" % uuid.uuid1(),
description="TEST DESCRIPTION 1")
cls.pcc = cls.client.create_pcc(pcc)
cls.client.wait_for_completion(cls.pcc)
# Create test LAN.
lan_properties = cls.resource['lan']
lan_properties['pcc_id'] = cls.pcc['id']
cls.lan = cls.client.create_lan(
datacenter_id=cls.datacenter['id'],
lan=LAN(**lan_properties))
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 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['k8s_datacenter'])
)
print(cls.datacenter)
# Wait for datacenter to be active
cls.client.wait_for_completion(cls.datacenter)
# Create test k8s cluster
cls.k8s_cluster = cls.client.create_k8s_cluster(**cls.resource['k8s_cluster'])
print(cls.k8s_cluster)
# Wait for k8s cluster to be active
cls.client.wait_for(
fn_request=lambda: cls.client.list_k8s_clusters(),
fn_check=lambda r: list(filter(
lambda e: e['properties']['name'] == cls.resource['k8s_cluster']['name'],
r['items']
))[0]['metadata']['state'] == 'ACTIVE',
scaleup=10000
)
# get cluster config
cls.k8s_config = cls.client.get_k8s_config(cls.k8s_cluster['id'])
print(cls.k8s_config)
# Create test k8s nodepool
cls.k8s_nodepool = cls.client.create_k8s_cluster_nodepool(
cls.k8s_cluster['id'],
datacenter_id=cls.datacenter['id'],
**cls.resource['k8s_nodepool']
)
print(cls.k8s_nodepool)
# Wait for k8s nodepool to be active
cls.client.wait_for(
fn_request=lambda: cls.client.list_k8s_cluster_nodepools(cls.k8s_cluster['id']),
fn_check=lambda r: list(filter(
lambda e: e['properties']['name'] == cls.resource['k8s_nodepool']['name'],
r['items']
))[0]['metadata']['state'] == 'ACTIVE',
scaleup=10000
)
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 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_simple(self):
datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
self.client.wait_for_completion(datacenter)
self.assertEqual(datacenter['type'], 'datacenter')
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)
def setUpClass(cls):
warnings.filterwarnings("ignore",
category=ResourceWarning,
message="unclosed.*<ssl.SSLSocket.*>")
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 LAN.
cls.lan = cls.client.create_lan(datacenter_id=cls.datacenter['id'],
lan=LAN(
name=cls.resource['lan']['name'],
public=False))
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.ips = ['10.0.0.1']
nic1.ips = cls.ips
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 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 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 setUpClass(cls):
warnings.filterwarnings("ignore",
category=ResourceWarning,
message="unclosed.*<ssl.SSLSocket.*>")
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 group.
cls.group = cls.client.create_group(Group(**cls.resource['group']))
cls.client.wait_for_completion(cls.group)
cls.share_1 = cls.client.add_share(cls.group['id'],
cls.datacenter['id'])
cls.client.wait_for_completion(cls.share_1)
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 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)
# Create test LoadBalancer
loadbalancer = LoadBalancer(**cls.resource['loadbalancer'])
loadbalancer.balancednics = [cls.nic1['id']]
cls.loadbalancer = cls.client.create_loadbalancer(
datacenter_id=cls.datacenter['id'],
loadbalancer=loadbalancer
)
cls.client.wait_for_completion(cls.loadbalancer)
# Create test LoadBalancer2
loadbalancer2 = LoadBalancer(**cls.resource['loadbalancer'])
loadbalancer2.name = "Python SDK Test 2"
cls.loadbalancer2 = cls.client.create_loadbalancer(
datacenter_id=cls.datacenter['id'],
loadbalancer=loadbalancer2
)
cls.client.wait_for_completion(cls.loadbalancer2)
# Create test LoadBalancer3
loadbalancer3 = LoadBalancer(**cls.resource['loadbalancer'])
loadbalancer3.balancednics = [cls.nic1['id']]
loadbalancer3.name = "Python SDK Test 3"
cls.loadbalancer3 = cls.client.create_loadbalancer(
datacenter_id=cls.datacenter['id'],
loadbalancer=loadbalancer3
)
cls.client.wait_for_completion(cls.loadbalancer3)
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
}
# ************* END CONFIG used for test **************
username = os.getenv('IONOS_USERNAME', 'my_username')
password = os.getenv('IONOS_PASSWORD', 'my_password')
client = IonosEnterpriseService(
username=username,
password=password,
)
print('Creating datacenter named: %s in location: %s' %
(datacenter_name, datacenter_location))
datacenter_props = {'name': datacenter_name, 'location': datacenter_location}
datacenter = client.create_datacenter(datacenter=Datacenter(
**datacenter_props))
print('Request completed!')
print('Waiting for the datacenter to be active!')
datacenters = client.wait_for(
fn_request=client.list_datacenters(),
fn_check=lambda r: list(
filter(lambda e: e['properties']['name'] == datacenter_name, r['items']
))[0]['metadata']['state'] == 'AVAILABLE',
console_print='.',
scaleup=10000)
print('Datacenter active!')
datacenter_id = datacenter['id']
print('Using datacenter with ID: %s' % datacenter_id)
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)
break
"""Get Datacenter
"""
from ionosenterprise.client import IonosEnterpriseService # noqa
datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022'
client = IonosEnterpriseService(username='******', password='******')
datacenter = client.get_datacenter(datacenter_id=datacenter_id)
"""Create Simple Datacenter
"""
from ionosenterprise.client import IonosEnterpriseService # noqa
from ionosenterprise.client import Datacenter, Volume, Server # noqa
i = Datacenter(name='dc1', description='My New Datacenter', location='de/fkb')
response = client.create_datacenter(datacenter=i)
"""Create Complex Datacenter
"""
from ionosenterprise.client import IonosEnterpriseService # noqa
from ionosenterprise.client import Datacenter, LAN, NIC, LoadBalancer, FirewallRule # noqa
image_id = 'df8382a1-0f40-11e6-ab6b-52540005ab80'
fwrule1 = FirewallRule(name='Open SSH port',
protocol='TCP',
source_mac='01:23:45:67:89:00',
port_range_start=22,
port_range_end=22)
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)
