def test_create_complex_lan(self):
resource = NIC(**self.resource['nic'])
nic1 = self.client.create_nic(
datacenter_id=self.datacenter['id'],
server_id=self.server['id'],
nic=resource)
self.client.wait_for_completion(nic1)
self.assertFalse(nic1['properties']['nat'])
self.assertEqual(nic1['properties']['name'], 'Python SDK Test')
self.assertTrue(nic1['properties']['dhcp'])
self.assertEqual(nic1['properties']['lan'], 1)
self.assertTrue(nic1['properties']['firewallActive'])
nics = [nic1['id']]
lan = LAN(nics=nics, **self.resource['lan'])
response = self.client.create_lan(
datacenter_id=self.datacenter['id'],
lan=lan)
self.client.wait_for_completion(response)
self.assertEqual(response['type'], 'lan')
self.assertEqual(response['properties']['name'], self.resource['lan']['name'])
self.assertTrue(response['properties']['public'])
def getLANObject(defdict=None):
if defdict is None or not type(defdict) is dict or len(defdict.keys()) == 0:
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
# end for(defdict)
apiobj = LAN(**props)
return(apiobj)
def getLANObject(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
# end for(defdict)
apiobj = LAN(**props)
return apiobj
def test_remove_lan(self):
lan = self.client.create_lan(
datacenter_id=self.datacenter['id'],
lan=LAN(**self.resource['lan']))
self.client.wait_for_completion(lan)
lan = self.client.delete_lan(datacenter_id=self.datacenter['id'], lan_id=lan['id'])
self.assertTrue(lan)
def setUpClass(cls):
cls.resource = resource()
cls.client = ProfitBricksService(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 create_lan(module, profitbricks):
"""
Creates a LAN.
module : AnsibleModule object
profitbricks: authenticated profitbricks object.
Returns:
The LAN instance
"""
datacenter = module.params.get('datacenter')
name = module.params.get('name')
public = module.params.get('public')
wait = module.params.get('wait')
wait_timeout = module.params.get('wait_timeout')
# Locate UUID for virtual datacenter
datacenter_list = profitbricks.list_datacenters()
datacenter_id = _get_resource_id(datacenter_list, datacenter, module,
"Data center")
lan_list = profitbricks.list_lans(datacenter_id)
lan = None
for i in lan_list['items']:
if name == i['properties']['name']:
lan = i
break
should_change = lan is None
if module.check_mode:
module.exit_json(changed=should_change)
if not should_change:
return {'changed': should_change, 'lan': lan}
try:
lan = LAN(name=name, public=public)
lan_response = profitbricks.create_lan(datacenter_id, lan)
if wait:
_wait_for_completion(profitbricks, lan_response, wait_timeout,
"create_lan")
return {'failed': False, 'changed': True, 'lan': lan_response}
except Exception as e:
module.fail_json(msg="failed to create the LAN: %s" % to_native(e))
def set_public_lan(lan_id):
"""
Enables public Internet access for the specified public_lan. If no public
LAN is available, then a new public LAN is created.
"""
conn = get_conn()
datacenter_id = get_datacenter_id()
try:
lan = conn.get_lan(datacenter_id=datacenter_id, lan_id=lan_id)
if not lan["properties"]["public"]:
conn.update_lan(datacenter_id=datacenter_id, lan_id=lan_id, public=True)
return lan["id"]
except Exception: # pylint: disable=broad-except
lan = conn.create_lan(datacenter_id, LAN(public=True, name="Public LAN"))
return lan["id"]
def setUpClass(cls):
cls.resource = resource()
cls.client = ProfitBricksService(
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 set_public_lan(lan_id):
'''
Enables public Internet access for the specified public_lan. If no public
LAN is available, then a new public LAN is created.
'''
conn = get_conn()
datacenter_id = get_datacenter_id()
try:
lan = conn.get_lan(datacenter_id=datacenter_id, lan_id=lan_id)
if not lan['properties']['public']:
conn.update_lan(datacenter_id=datacenter_id,
lan_id=lan_id,
public=True)
return lan['id']
except Exception:
lan = conn.create_lan(datacenter_id, LAN(public=True,
name='Public LAN'))
return lan['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(**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 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 test_create_failure(self):
try:
self.client.create_lan(
datacenter_id='00000000-0000-0000-0000-000000000000', lan=LAN())
except PBNotFoundError as e:
self.assertIn(self.resource['not_found_error'], e.content[0]['message'])
size=56,
image=image_id,
bus='VIRTIO',
image_password="******")
volumes = [volume2]
server1 = Server(name='My New Server1',
ram=4096,
cores=4,
nics=nics,
create_volumes=[volume1])
servers = [server1]
lan1 = LAN(name='public Lan 4', public=True)
lan2 = LAN(name='public Lan 5', public=True)
lans = [lan1, lan2]
loadbalancer1 = LoadBalancer(name='LB01', ip='10.2.2.5', dhcp=False)
loadbalancers = [loadbalancer1]
d = Datacenter(name='My New Datacenter',
description='Production environment',
location='de/fkb',
servers=servers,
volumes=volumes,
lans=lans,
def _create_machine(module, profitbricks, datacenter, name):
cores = module.params.get('cores')
ram = module.params.get('ram')
cpu_family = module.params.get('cpu_family')
volume_size = module.params.get('volume_size')
disk_type = module.params.get('disk_type')
availability_zone = module.params.get('availability_zone')
volume_availability_zone = module.params.get('volume_availability_zone')
image_password = module.params.get('image_password')
ssh_keys = module.params.get('ssh_keys')
bus = module.params.get('bus')
lan = module.params.get('lan')
nat = module.params.get('nat')
image = module.params.get('image')
assign_public_ip = module.boolean(module.params.get('assign_public_ip'))
wait = module.params.get('wait')
wait_timeout = module.params.get('wait_timeout')
nics = []
if assign_public_ip:
public_lan = _get_lan_by_id_or_properties(
profitbricks.list_lans(datacenter)['items'], public=True)
public_ip_lan_id = public_lan['id'] if public_lan is not None else None
if public_ip_lan_id is None:
i = LAN(name='public', public=True)
lan_response = profitbricks.create_lan(datacenter, i)
_wait_for_completion(profitbricks, lan_response, wait_timeout,
"_create_machine")
public_ip_lan_id = lan_response['id']
nics.append(
NIC(name=str(uuid4()).replace('-', '')[:10],
nat=nat,
lan=int(public_ip_lan_id)))
if lan is not None:
matching_lan = _get_lan_by_id_or_properties(
profitbricks.list_lans(datacenter)['items'], lan, name=lan)
nics.append(
NIC(name=str(uuid4()).replace('-', '')[:10],
nat=nat,
lan=int(matching_lan['id'])))
v = Volume(name=str(uuid4()).replace('-', '')[:10],
size=volume_size,
image_password=image_password,
ssh_keys=ssh_keys,
disk_type=disk_type,
availability_zone=volume_availability_zone,
bus=bus)
try:
UUID(image)
except Exception:
v.image_alias = image
else:
v.image = image
s = Server(
name=name,
ram=ram,
cores=cores,
cpu_family=cpu_family,
availability_zone=availability_zone,
create_volumes=[v],
nics=nics,
)
try:
create_server_response = profitbricks.create_server(
datacenter_id=datacenter, server=s)
_wait_for_completion(profitbricks, create_server_response,
wait_timeout, "create_virtual_machine")
server_response = profitbricks.get_server(
datacenter_id=datacenter,
server_id=create_server_response['id'],
depth=3)
except Exception as e:
module.fail_json(msg="failed to create the new server: %s" %
to_native(e))
else:
server_response['nic'] = server_response['entities']['nics']['items'][
0]
return server_response
def _create_machine(module, profitbricks, datacenter, name):
image = module.params.get('image')
cores = module.params.get('cores')
ram = module.params.get('ram')
volume_size = module.params.get('volume_size')
bus = module.params.get('bus')
lan = module.params.get('lan')
assign_public_ip = module.params.get('assign_public_ip')
subscription_user = module.params.get('subscription_user')
subscription_password = module.params.get('subscription_password')
location = module.params.get('location')
image = module.params.get('image')
assign_public_ip = module.boolean(module.params.get('assign_public_ip'))
wait = module.params.get('wait')
wait_timeout = module.params.get('wait_timeout')
try:
# Generate name, but grab first 10 chars so we don't
# screw up the uuid match routine.
v = Volume(
name=str(uuid.uuid4()).replace('-','')[:10],
size=volume_size,
image=image,
bus=bus)
volume_response = profitbricks.create_volume(
datacenter_id=datacenter, volume=v)
# We're forced to wait on the volume creation since
# server create relies upon this existing.
_wait_for_completion(profitbricks, volume_response,
wait_timeout, "create_volume")
except Exception as e:
module.fail_json(msg="failed to create the new volume: %s" % str(e))
if assign_public_ip:
public_found = False
lans = profitbricks.list_lans(datacenter)
for lan in lans['items']:
if lan['properties']['public']:
public_found = True
lan = lan['id']
if not public_found:
i = LAN(
name='public',
public=True)
lan_response = profitbricks.create_lan(datacenter, i)
lan = lan_response['id']
_wait_for_completion(profitbricks, lan_response,
wait_timeout, "_create_machine")
try:
n = NIC(
lan=int(lan)
)
nics = [n]
s = Server(
name=name,
ram=ram,
cores=cores,
nics=nics,
boot_volume_id=volume_response['id']
)
server_response = profitbricks.create_server(
datacenter_id=datacenter, server=s)
if wait:
_wait_for_completion(profitbricks, server_response,
wait_timeout, "create_virtual_machine")
return (server_response)
except Exception as e:
module.fail_json(msg="failed to create the new server: %s" % str(e))
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 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)
# Create test LoadBalancer
loadbalancer = LoadBalancer(**self.resource['loadbalancer'])
loadbalancer.balancednics = [self.nic1['id']]
self.loadbalancer = self.client.create_loadbalancer(
datacenter_id=self.datacenter['id'], loadbalancer=loadbalancer)
self.client.wait_for_completion(self.loadbalancer)
# Create test LoadBalancer2
loadbalancer2 = LoadBalancer(**self.resource['loadbalancer'])
loadbalancer2.name = "Python SDK Test 2"
self.loadbalancer2 = self.client.create_loadbalancer(
datacenter_id=self.datacenter['id'], loadbalancer=loadbalancer2)
self.client.wait_for_completion(self.loadbalancer2)
# Create test LoadBalancer3
loadbalancer3 = LoadBalancer(**self.resource['loadbalancer'])
loadbalancer3.balancednics = [self.nic1['id']]
loadbalancer3.name = "Python SDK Test 3"
self.loadbalancer3 = self.client.create_loadbalancer(
datacenter_id=self.datacenter['id'], loadbalancer=loadbalancer3)
self.client.wait_for_completion(self.loadbalancer3)
def _create_machine(module, profitbricks, datacenter, name):
cores = module.params.get('cores')
ram = module.params.get('ram')
cpu_family = module.params.get('cpu_family')
volume_size = module.params.get('volume_size')
disk_type = module.params.get('disk_type')
availability_zone = module.params.get('availability_zone')
volume_availability_zone = module.params.get('volume_availability_zone')
image_password = module.params.get('image_password')
ssh_keys = module.params.get('ssh_keys')
bus = module.params.get('bus')
lan = module.params.get('lan')
nat = module.params.get('nat')
assign_public_ip = module.params.get('assign_public_ip')
subscription_user = module.params.get('subscription_user')
subscription_password = module.params.get('subscription_password')
location = module.params.get('location')
image = module.params.get('image')
assign_public_ip = module.boolean(module.params.get('assign_public_ip'))
wait = module.params.get('wait')
wait_timeout = module.params.get('wait_timeout')
if assign_public_ip:
public_found = False
lans = profitbricks.list_lans(datacenter)
for lan in lans['items']:
if lan['properties']['public']:
public_found = True
lan = lan['id']
if not public_found:
i = LAN(name='public', public=True)
lan_response = profitbricks.create_lan(datacenter, i)
_wait_for_completion(profitbricks, lan_response, wait_timeout,
"_create_machine")
lan = lan_response['id']
v = Volume(name=str(uuid.uuid4()).replace('-', '')[:10],
size=volume_size,
image=image,
image_password=image_password,
ssh_keys=ssh_keys,
disk_type=disk_type,
availability_zone=volume_availability_zone,
bus=bus)
n = NIC(name=str(uuid.uuid4()).replace('-', '')[:10],
nat=nat,
lan=int(lan))
s = Server(
name=name,
ram=ram,
cores=cores,
cpu_family=cpu_family,
availability_zone=availability_zone,
create_volumes=[v],
nics=[n],
)
try:
create_server_response = profitbricks.create_server(
datacenter_id=datacenter, server=s)
_wait_for_completion(profitbricks, create_server_response,
wait_timeout, "create_virtual_machine")
server_response = profitbricks.get_server(
datacenter_id=datacenter,
server_id=create_server_response['id'],
depth=3)
except Exception as e:
module.fail_json(msg="failed to create the new server: %s" % str(e))
else:
server_response['nic'] = server_response['entities']['nics']['items'][
0]
return server_response
lans = client.list_lans(datacenter_id=datacenter_id) print(lans) """Create Complex LAN """ from profitbricks.client import ProfitBricksService, LAN # noqa lan_id = '4' datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService(username='******', password='******') nics = ['<NIC-ID-1>', '<NIC-ID-2>'] i = LAN(name='public Lan 4', public=True, nics=nics) response = client.create_lan(datacenter_id=datacenter_id, lan=i) """Create LAN """ from profitbricks.client import ProfitBricksService, LAN # noqa lan_id = '4' datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService(username='******', password='******') i = LAN(name='public Lan 4', public=True) response = client.create_lan(datacenter_id=datacenter_id, lan=i) """Get LAN Members