def main():
module = AnsibleModule(argument_spec=dict(
name=dict(type='str'),
location=dict(type='str', choices=LOCATIONS, default='us/las'),
size=dict(type='int', default=1),
api_url=dict(type='str', default=None),
username=dict(type='str',
required=True,
aliases=['subscription_user'],
fallback=(env_fallback, ['PROFITBRICKS_USERNAME'])),
password=dict(type='str',
required=True,
aliases=['subscription_password'],
fallback=(env_fallback, ['PROFITBRICKS_PASSWORD']),
no_log=True),
wait=dict(type='bool', default=True),
wait_timeout=dict(type='int', default=600),
state=dict(type='str', default='present'),
),
supports_check_mode=True)
if not HAS_SDK:
module.fail_json(
msg=
'ionosenterprise is required for this module, run `pip install ionosenterprise`'
)
username = module.params.get('username')
password = module.params.get('password')
api_url = module.params.get('api_url')
if not api_url:
ionosenterprise = IonosEnterpriseService(username=username,
password=password)
else:
ionosenterprise = IonosEnterpriseService(username=username,
password=password,
host_base=api_url)
user_agent = 'profitbricks-sdk-python/%s Ansible/%s' % (sdk_version,
__version__)
ionosenterprise.headers = {'User-Agent': user_agent}
state = module.params.get('state')
if state == 'absent':
try:
(changed) = delete_ipblock(module, ionosenterprise)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set IPBlock state: %s' %
to_native(e))
elif state == 'present':
try:
(ipblock_dict) = reserve_ipblock(module, ionosenterprise)
module.exit_json(**ipblock_dict)
except Exception as e:
module.fail_json(msg='failed to set IPBlocks state: %s' %
to_native(e))
def test_ic_unauthorized_error(self):
try:
self.client = IonosEnterpriseService(
username=configuration.USERNAME + "1",
password=configuration.PASSWORD,
headers=configuration.HEADERS)
self.client.list_datacenters()
except ICError as err:
self.assertTrue(isinstance(err, ICNotAuthorizedError))
def main():
module = AnsibleModule(argument_spec=dict(
k8s_cluster_id=dict(type='str'),
config_file=dict(type='str'),
api_url=dict(type='str', default=None),
username=dict(type='str',
required=True,
aliases=['subscription_user'],
fallback=(env_fallback, ['PROFITBRICKS_USERNAME'])),
password=dict(type='str',
required=True,
aliases=['subscription_password'],
fallback=(env_fallback, ['PROFITBRICKS_PASSWORD']),
no_log=True),
wait=dict(type='bool', default=True),
wait_timeout=dict(type='int', default=600),
state=dict(type='str', default='present'),
),
supports_check_mode=True)
if not HAS_SDK:
module.fail_json(
msg=
'ionosenterprise is required for this module, run `pip install ionosenterprise`'
)
username = module.params.get('username')
password = module.params.get('password')
api_url = module.params.get('api_url')
if not api_url:
ionosenterprise = IonosEnterpriseService(username=username,
password=password)
else:
ionosenterprise = IonosEnterpriseService(username=username,
password=password,
host_base=api_url)
user_agent = 'profitbricks-sdk-python/%s Ansible/%s' % (sdk_version,
__version__)
ionosenterprise.headers = {'User-Agent': user_agent}
state = module.params.get('state')
if state == 'present':
try:
(response) = get_config(module, ionosenterprise)
module.exit_json(response=response)
except Exception as e:
module.fail_json(msg='failed to get the k8s cluster config: %s' %
to_native(e))
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):
warnings.filterwarnings("ignore",
category=ResourceWarning,
message="unclosed.*<ssl.SSLSocket.*>")
cls.client = IonosEnterpriseService(username=configuration.USERNAME,
password=configuration.PASSWORD,
headers=configuration.HEADERS)
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):
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):
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.requests = cls.client.list_requests()
cls.request = cls.requests['items'][0]
class TestErrors(unittest.TestCase):
@classmethod
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']))
@classmethod
def tearDownClass(cls):
cls.client.delete_datacenter(datacenter_id=cls.datacenter['id'])
def test_ic_not_found(self):
try:
self.client.get_datacenter("fake_id")
except ICError as err:
self.assertTrue(isinstance(err, ICNotFoundError))
def test_ic_unauthorized_error(self):
try:
self.client = IonosEnterpriseService(
username=configuration.USERNAME + "1",
password=configuration.PASSWORD,
headers=configuration.HEADERS)
self.client.list_datacenters()
except ICError as err:
self.assertTrue(isinstance(err, ICNotAuthorizedError))
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 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):
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(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']))
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(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(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(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(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 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
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# 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
def main():
module = AnsibleModule(
argument_spec=dict(
pcc_id=dict(type='str'),
name=dict(type='str'),
description=dict(type='str'),
api_url=dict(type='str', default=None),
username=dict(
type='str',
required=True,
aliases=['subscription_user'],
fallback=(env_fallback, ['PROFITBRICKS_USERNAME'])
),
password=dict(
type='str',
required=True,
aliases=['subscription_password'],
fallback=(env_fallback, ['PROFITBRICKS_PASSWORD']),
no_log=True
),
wait=dict(type='bool', default=True),
wait_timeout=dict(type='int', default=600),
state=dict(type='str', default='present'),
),
supports_check_mode=True
)
if not HAS_SDK:
module.fail_json(msg='ionosenterprise is required for this module, run `pip install ionosenterprise`')
username = module.params.get('username')
password = module.params.get('password')
api_url = module.params.get('api_url')
if not api_url:
ionosenterprise = IonosEnterpriseService(username=username, password=password)
else:
ionosenterprise = IonosEnterpriseService(
username=username,
password=password,
host_base=api_url
)
user_agent = 'profitbricks-sdk-python/%s Ansible/%s' % (sdk_version, __version__)
ionosenterprise.headers = {'User-Agent': user_agent}
state = module.params.get('state')
if state == 'present':
pass
if not module.params.get('name'):
module.fail_json(msg='name parameter is required for a new pcc')
if not module.params.get('description'):
module.fail_json(msg='description parameter is required for a new pcc')
try:
(pcc_dict_array) = create_pcc(module, ionosenterprise)
module.exit_json(**pcc_dict_array)
except Exception as e:
module.fail_json(msg='failed to set user state: %s' % to_native(e))
elif state == 'absent':
if not module.params.get('pcc_id'):
module.fail_json(msg='pcc_id parameter is required for deleting a pcc.')
try:
(changed) = delete_pcc(module, ionosenterprise)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg='failed to set pcc state: %s' % to_native(e))
elif state == 'update':
if not module.params.get('pcc_id'):
module.fail_json(msg='pcc_id parameter is required for updating a pcc.')
try:
(changed) = update_pcc(module, ionosenterprise)
module.exit_json(
changed=changed)
except Exception as e:
module.fail_json(msg='failed to set pcc state: %s' % to_native(e))
