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):
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(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
self.image = find_image(self.client, configuration.IMAGE_NAME)
# Create test volume
vol = Volume(**self.resource['volume2'])
vol.image = self.image['id']
self.volume = self.client.create_volume(
datacenter_id=self.datacenter['id'],
volume=vol)
self.client.wait_for_completion(self.volume)
# Create snapshot1
self.snapshot1 = self.client.create_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
name=self.resource['snapshot']['name'],
description=self.resource['snapshot']['description'])
self.client.wait_for_completion(self.snapshot1, timeout=600)
def setUpClass(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(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
wait_for_completion(self.client, self.datacenter, 'create_datacenter')
# Create test volume
self.volume = self.client.create_volume(
datacenter_id=self.datacenter['id'],
volume=Volume(**self.resource['volume']))
wait_for_completion(self.client, self.volume, 'create_volume')
# Create snapshot1
self.snapshot1 = self.client.create_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
name=self.resource['snapshot']['name'],
description=self.resource['snapshot']['description'])
wait_for_completion(self.client, self.snapshot1, 'create_snapshot1',
wait_timeout=600)
self.image = find_image(self.client, configuration.IMAGE_NAME)
def 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 setUpClass(cls):
cls.resource = resource()
cls.client = IonosEnterpriseService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
cls.requests = cls.client.list_requests()
cls.request = cls.requests['items'][0]
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)
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
self.requests = self.client.list_requests()
self.request = self.requests['items'][0]
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.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(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Find an Ubuntu image for testing.
for item in self.client.list_images()['items']:
if 'Ubuntu-15' in item['properties']['name'] and item['properties']['location'] == configuration.LOCATION:
self.image = item
def setUpClass(cls):
cls.resource = resource()
cls.client = IonosEnterpriseService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Find an Ubuntu image for testing.
for item in cls.client.list_images()['items']:
if (configuration.IMAGE_NAME in item['properties']['name'] and
item['properties']['location'] == configuration.LOCATION):
cls.image = item
def setUpClass(cls):
cls.resource = resource()
cls.client = IonosEnterpriseService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
pccModel1 = PrivateCrossConnect(name="TEST NAME 1", description="TEST DESCRIPTION 1")
cls.pcc1 = cls.client.create_pcc(pccModel1)
pccModel2 = PrivateCrossConnect(name="TEST NAME 2", description="TEST DESCRIPTION 2")
cls.pcc2 = cls.client.create_pcc(pccModel2)
def setUpClass(cls):
cls.resource = resource()
cls.client = IonosEnterpriseService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
backupunitModel1 = BackupUnit("TEST 1", password="******", email="*****@*****.**")
cls.backupunit1 = cls.client.create_backupunit(backupunitModel1)
backupunitModel2 = BackupUnit("TEST 2", password="******", email="*****@*****.**")
cls.backupunit2 = cls.client.create_backupunit(backupunitModel2)
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
ipblock1 = IPBlock(**self.resource['ipblock'])
ipblock1.size = 2
self.ipblock1 = self.client.reserve_ipblock(ipblock1)
ipblock2 = IPBlock(**self.resource['ipblock'])
self.ipblock2 = self.client.reserve_ipblock(ipblock2)
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.
group_object = Group(**cls.resource['group'])
cls.group = cls.client.create_group(group_object)
def setUpClass(cls):
cls.resource = resource()
cls.client = IonosEnterpriseService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
ipblock1 = IPBlock(**cls.resource['ipblock'])
ipblock1.size = 2
cls.ipblock1 = cls.client.reserve_ipblock(ipblock1)
ipblock2 = IPBlock(**cls.resource['ipblock'])
cls.ipblock2 = cls.client.reserve_ipblock(ipblock2)
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
ipblock1 = IPBlock(**self.resource['ipblock'])
self.ipblock1 = self.client.reserve_ipblock(ipblock1)
ipblock2 = IPBlock(**self.resource['ipblock'])
self.ipblock2 = self.client.reserve_ipblock(ipblock2)
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):
warnings.filterwarnings("ignore", category=ResourceWarning,
message="unclosed.*<ssl.SSLSocket.*>")
cls.resource = resource()
cls.client = IonosEnterpriseService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
pccModel1 = PrivateCrossConnect(name="TEST NAME 1", description="TEST DESCRIPTION 1")
cls.pcc1 = cls.client.create_pcc(pccModel1)
pccModel2 = PrivateCrossConnect(name="TEST NAME 2", description="TEST DESCRIPTION 2")
cls.pcc2 = cls.client.create_pcc(pccModel2)
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 setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
# Create test LAN.
self.lan = self.client.create_lan(datacenter_id=self.datacenter['id'],
lan=LAN(**self.resource['lan']))
self.client.wait_for_completion(self.lan)
# Create test server.
self.server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=Server(**self.resource['server']))
self.client.wait_for_completion(self.server)
# Create test NIC1.
nic1 = NIC(**self.resource['nic'])
nic1.lan = self.lan['id']
self.nic1 = self.client.create_nic(datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic1)
self.client.wait_for_completion(self.nic1)
# Create test Firewall Rule
fwrule = FirewallRule(**self.resource['fwrule'])
self.fwrule = self.client.create_firewall_rule(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic_id=self.nic1['id'],
firewall_rule=fwrule)
self.client.wait_for_completion(self.fwrule)
# Create test Firewall Rule 2
fwrule2 = FirewallRule(**self.resource['fwrule'])
fwrule2.port_range_start = 8080
fwrule2.port_range_end = 8080
fwrule2.name = "8080"
self.fwrule2 = self.client.create_firewall_rule(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic_id=self.nic1['id'],
firewall_rule=fwrule2)
self.client.wait_for_completion(self.fwrule2)
def setUpClass(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)
# Find an Ubuntu image for testing.
for item in cls.client.list_images()['items']:
if (configuration.IMAGE_NAME in item['properties']['name'] and
item['properties']['location'] == configuration.LOCATION):
cls.image = item
def setUpClass(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 setUpClass(cls):
cls.resource = resource()
cls.client = IonosEnterpriseService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
user = User(firstname="TEST FIRST NAME",
lastname="TEST FIRST NAME",
email="*****@*****.**" % uuid.uuid1(),
password="******")
# Create user
cls.user = cls.client.create_user(user)
cls.client.wait_for_completion(cls.user)
# Create test s3keys.
cls.s3key1 = cls.client.create_s3key(cls.user['id'])
cls.s3key2 = cls.client.create_s3key(cls.user['id'])
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)
backupunitModel1 = BackupUnit("TEST 1",
password="******",
email="*****@*****.**")
cls.backupunit1 = cls.client.create_backupunit(backupunitModel1)
backupunitModel2 = BackupUnit("TEST 2",
password="******",
email="*****@*****.**")
cls.backupunit2 = cls.client.create_backupunit(backupunitModel2)
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(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
wait_for_completion(self.client, self.datacenter, 'create_datacenter')
# Create test volume1.
self.volume1 = self.client.create_volume(
datacenter_id=self.datacenter['id'],
volume=Volume(**self.resource['volume']))
wait_for_completion(self.client, self.volume1, 'create_volume')
# Create test volume2 (attach volume test).
self.volume2 = self.client.create_volume(
datacenter_id=self.datacenter['id'],
volume=Volume(**self.resource['volume']))
wait_for_completion(self.client, self.volume2, 'create_volume')
# Create test server.
server = Server(**self.resource['server'])
server.attach_volumes = [self.volume1['id']]
self.server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=server)
wait_for_completion(self.client, self.server, 'create_server')
# Create test NIC.
self.nic = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=NIC(**self.resource['nic']))
wait_for_completion(self.client, self.nic, 'create_nic')
# Find an Ubuntu image for testing.
for item in self.client.list_images()['items']:
if 'Ubuntu-15' in item['properties']['name'] and item['properties']['location'] == configuration.LOCATION:
self.image = item
def setUpClass(cls):
warnings.filterwarnings("ignore",
category=ResourceWarning,
message="unclosed.*<ssl.SSLSocket.*>")
cls.resource = resource()
cls.client = IonosEnterpriseService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
user = User(firstname="TEST FIRST NAME",
lastname="TEST FIRST NAME",
email="*****@*****.**" % uuid.uuid1(),
password="******")
# Create user
cls.user = cls.client.create_user(user)
cls.client.wait_for_completion(cls.user)
# Create test s3keys.
cls.s3key1 = cls.client.create_s3key(cls.user['id'])
cls.s3key2 = cls.client.create_s3key(cls.user['id'])
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
# Create test LAN.
self.lan = self.client.create_lan(
datacenter_id=self.datacenter['id'],
lan=LAN(name=self.resource['lan']['name'], public=False))
self.client.wait_for_completion(self.lan)
# Create test server.
self.server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=Server(**self.resource['server']))
self.client.wait_for_completion(self.server)
# Create test NIC1.
nic1 = NIC(**self.resource['nic'])
nic1.lan = self.lan['id']
self.ips = ['10.0.0.1']
nic1.ips = self.ips
self.nic1 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic1)
self.client.wait_for_completion(self.nic1)
# Create test NIC2.
nic2 = NIC(**self.resource['nic'])
nic2.lan = self.lan['id']
self.nic2 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic2)
self.client.wait_for_completion(self.nic2)
def setUpClass(self):
self.resource = resource()
self.client = ProfitBricksService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(datacenter=Datacenter(
**self.resource['datacenter']))
self.client.wait_for_completion(self.datacenter)
# Create test volume
volume = Volume(**self.resource['volume'])
self.volume = self.client.create_volume(
datacenter_id=self.datacenter['id'], volume=volume)
self.client.wait_for_completion(self.volume)
# Create test volume1
volume1 = Volume(**self.resource['volume'])
self.volume1 = self.client.create_volume(
datacenter_id=self.datacenter['id'], volume=volume1)
self.client.wait_for_completion(self.volume1)
# Create test snapshot
snapshot = Snapshot(**self.resource['snapshot'])
self.snapshot1 = self.client.create_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
name=snapshot.name,
description=snapshot.description)
self.client.wait_for_completion(self.snapshot1)
# Create test snapshot2
self.snapshot2 = self.client.create_snapshot(
datacenter_id=self.datacenter['id'],
volume_id=self.volume['id'],
name="python sdk test snapshot",
description="snapshot test description")
self.client.wait_for_completion(self.snapshot2)
def setUpClass(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(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
# Create test datacenter.
self.datacenter = self.client.create_datacenter(
datacenter=Datacenter(**self.resource['datacenter']))
wait_for_completion(self.client, self.datacenter, 'create_datacenter')
# Create test LAN.
self.lan = self.client.create_lan(
datacenter_id=self.datacenter['id'],
lan=LAN(**self.resource['lan']))
wait_for_completion(self.client, self.lan, 'create_lan')
# Create test server.
self.server = self.client.create_server(
datacenter_id=self.datacenter['id'],
server=Server(**self.resource['server']))
wait_for_completion(self.client, self.server, 'create_server')
# Create test NIC1.
nic1 = NIC(**self.resource['nic'])
nic1.lan = self.lan['id']
self.nic1 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic1)
wait_for_completion(self.client, self.nic1, 'create_nic1')
# Create test NIC2.
nic2 = NIC(**self.resource['nic'])
nic2.lan = self.lan['id']
self.nic2 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=nic2)
wait_for_completion(self.client, self.nic2, 'create_nic2')
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(self):
self.resource = resource()
self.client = ProfitBricksService(
username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS
)
