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))