def create_datacenter(module, profitbricks): """ Creates a Datacenter This will create a new Datacenter in the specified location. module : AnsibleModule object profitbricks: authenticated profitbricks object. Returns: True if a new datacenter was created, false otherwise """ name = module.params.get('name') location = module.params.get('location') description = module.params.get('description') wait = module.params.get('wait') wait_timeout = int(module.params.get('wait_timeout')) virtual_datacenters = [] i = Datacenter(name=name, location=location, description=description) try: datacenter_response = profitbricks.create_datacenter(datacenter=i) if wait: _wait_for_completion(profitbricks, datacenter_response, wait_timeout, "_create_datacenter") results = {'datacenter_id': datacenter_response['id']} return results except Exception as e: module.fail_json(msg="failed to create the new datacenter: %s" % str(e))
def create_datacenter(call=None, kwargs=None): ''' Creates a virtual datacenter based on supplied parameters. CLI Example: .. code-block:: bash salt-cloud -f create_datacenter profitbricks name=mydatacenter location=us/las description="my description" ''' if call != 'function': raise SaltCloudSystemExit( 'The create_address function must be called with -f or --function.' ) if kwargs is None: kwargs = {} if kwargs.get('name') is None: raise SaltCloudExecutionFailure('The "name" parameter is required') if kwargs.get('location') is None: raise SaltCloudExecutionFailure('The "location" parameter is required') conn = get_conn() datacenter = Datacenter(name=kwargs['name'], location=kwargs['location'], description=kwargs.get('description')) response = conn.create_datacenter(datacenter) _wait_for_completion(conn, response, 60, 'create_datacenter') return response
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) 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 test_create_failure(self): try: datacenter = Datacenter(name=self.resource['datacenter']['name']) self.client.create_datacenter(datacenter) except PBError as e: self.assertIn( self.resource['missing_attribute_error'] % 'location', e.content[0]['message'])
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']))
def getDatacenterObject(defdict=None): if not defdict or not isinstance(defdict, dict): raise ValueError("argument 'defdict' must be non-empty dict") props = dict() for k, v in defdict['properties'].items(): # no renaming needed here, but this accounts for optional props too props[k] = v apiobj = Datacenter(**props) return apiobj
def test_remove_datacenter(self): datacenter = self.client.create_datacenter(datacenter=Datacenter( **self.resource['datacenter'])) self.client.wait_for_completion(datacenter) response = self.client.delete_datacenter( datacenter_id=datacenter['id']) self.assertTrue(response)
def getDatacenterObject(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 apiobj = Datacenter(**props) return(apiobj)
def describe_datacenter(client): """ Creates a detailed description of the Datacenter according to the requirements""" # Define a public NIC public_nic = NIC(name=PUBLIC_NIC_NAME, dhcp=True, lan=1, nat=False) # Define a private NIC private_nic = NIC(name=PRIVATE_NIC_NAME, dhcp=True, lan=2) # get existing image with specific name images = find_images(client=client, name=UBUNTU_IMAGE_NAME, location=LOCATION) if images: ubuntu_image = images[0] else: raise Exception("There are no existing Ubuntu images") # Define a volume for backend backend_volume = Volume(name='Backend Volume', size=20, image=ubuntu_image['id'], image_password='******', ssh_keys=[get_public_key()], availability_zone='ZONE_3') # Define volume for frontend frontend_volume = Volume(name='Data Volume 1', size=20, image=ubuntu_image['id'], image_password='******', ssh_keys=[get_public_key()], availability_zone='ZONE_3') # Define a server with associated NICs and volumes backend_server = Server(name=BACKEND_NAME, ram=DEFAULT_RAM_VALUE, cores=DEFAULT_CORES_VALUES, cpu_family='INTEL_XEON', nics=[private_nic], create_volumes=[backend_volume]) # Define a server with associated NICs and volumes frontend_server = Server(name=FRONTEND_NAME, ram=DEFAULT_RAM_VALUE, cores=DEFAULT_CORES_VALUES, cpu_family='INTEL_XEON', nics=[public_nic, private_nic], create_volumes=[frontend_volume]) # Define a data center with the server datacenter = Datacenter(name=DATACENTER_NAME, description="Yulia's test assignment datacenter", location=LOCATION, servers=[frontend_server, backend_server]) return datacenter
def test_remove_datacenter(self): datacenter = self.client.create_datacenter(datacenter=Datacenter( **self.resource['datacenter'])) self.client.wait_for_completion(datacenter) response = self.client.delete_datacenter( datacenter_id=datacenter['id']) self.assertTrue(response) assertRegex(self, response['requestId'], self.resource['uuid_match'])
def test_create_composite(self): datacenter_resource = Datacenter( **self.resource['datacenter_composite']) datacenter_resource.servers = [Server(**self.resource['server'])] datacenter_resource.volumes = [Volume(**self.resource['volume'])] datacenter = self.client.create_datacenter( datacenter=datacenter_resource) self.client.wait_for_completion(datacenter) self.assertEqual(datacenter['type'], 'datacenter') self.assertEqual(datacenter['properties']['name'], self.resource['datacenter_composite']['name']) self.assertEqual(datacenter['properties']['description'], self.resource['datacenter_composite']['description']) self.assertEqual(datacenter['properties']['location'], self.resource['datacenter_composite']['location']) self.assertGreater(len(datacenter['entities']['servers']), 0) self.assertGreater(len(datacenter['entities']['volumes']), 0) response = self.client.delete_datacenter( datacenter_id=datacenter['id']) self.assertTrue(response)
def setUpClass(cls): cls.resource = resource() cls.client = 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_datacenter(module, profitbricks): datacenter = module.params.get('datacenter') location = module.params.get('location') wait_timeout = module.params.get('wait_timeout') i = Datacenter(name=datacenter, location=location) try: datacenter_response = profitbricks.create_datacenter(datacenter=i) _wait_for_completion(profitbricks, datacenter_response, wait_timeout, "_create_datacenter") return datacenter_response except Exception as e: module.fail_json(msg="failed to create the new server(s): %s" % str(e))
def test_create_simple(self): datacenter = self.client.create_datacenter(datacenter=Datacenter( **self.resource['datacenter'])) self.client.wait_for_completion(datacenter) self.assertEqual(datacenter['type'], 'datacenter') self.assertEqual(datacenter['properties']['name'], self.resource['datacenter']['name']) self.assertEqual(datacenter['properties']['description'], self.resource['datacenter']['description']) self.assertEqual(datacenter['properties']['location'], self.resource['datacenter']['location']) response = self.client.delete_datacenter( datacenter_id=datacenter['id']) self.assertTrue(response)
def setUpClass(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 = 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 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 create_datacenter(module, profitbricks): """ Creates a Datacenter This will create a new Datacenter in the specified location. module : AnsibleModule object profitbricks: authenticated profitbricks object. Returns: The datacenter ID if a new datacenter was created. """ name = module.params.get('name') location = module.params.get('location') description = module.params.get('description') wait = module.params.get('wait') wait_timeout = int(module.params.get('wait_timeout')) datacenters = profitbricks.list_datacenters() for dc in datacenters['items']: if name == dc['properties']['name']: return {'datacenter_id': dc['id'], 'changed': False} i = Datacenter(name=name, location=location, description=description) try: datacenter_response = profitbricks.create_datacenter(datacenter=i) if wait: _wait_for_completion(profitbricks, datacenter_response, wait_timeout, "_create_datacenter") results = {'datacenter_id': datacenter_response['id'], 'changed': True} return results except Exception as e: module.fail_json(msg="failed to create the new datacenter: %s" % to_native(e))
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 ProfitBricks GmbH. 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 = ProfitBricksService(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 len(images) == 0: 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 len(requests) != 0: 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
break """Get Datacenter """ from profitbricks.client import ProfitBricksService # noqa datacenter_id = '700e1cab-99b2-4c30-ba8c-1d273ddba022' client = ProfitBricksService(username='******', password='******') datacenter = client.get_datacenter(datacenter_id=datacenter_id) """Create Simple Datacenter """ from profitbricks.client import ProfitBricksService # noqa from profitbricks.client import Datacenter, Volume, Server # noqa i = Datacenter(name='dc1', description='My New Datacenter', location='de/fkb') response = client.create_datacenter(datacenter=i) """Create Complex Datacenter """ from profitbricks.client import ProfitBricksService # noqa from profitbricks.client import Datacenter, LAN, NIC, LoadBalancer, FirewallRule # noqa image_id = 'df8382a1-0f40-11e6-ab6b-52540005ab80' fwrule1 = FirewallRule(name='Open SSH port', protocol='TCP', source_mac='01:23:45:67:89:00', port_range_start=22, port_range_end=22)
def setUpClass(self): self.resource = resource() self.client = ProfitBricksService(username=configuration.USERNAME, password=configuration.PASSWORD, headers=configuration.HEADERS) # Create datacenter resource self.datacenter = self.client.create_datacenter(datacenter=Datacenter( **self.resource['datacenter'])) self.client.wait_for_completion(self.datacenter) # Create volume resource 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) self.image = find_image(self.client, configuration.IMAGE_NAME) # Create snapshot resource self.snapshot = self.client.create_snapshot( datacenter_id=self.datacenter['id'], volume_id=self.volume['id'], name=self.resource['snapshot']['name']) self.client.wait_for_completion(self.snapshot) # Reserve IP block resource self.ipblock = self.client.reserve_ipblock( IPBlock(**self.resource['ipblock'])) # Create User 1 self.user_dict1 = User( firstname='John', lastname='Doe', email='*****@*****.**' % randint(0, 9999999999999), password='******' % randint(0, 99999999), administrator=True, force_sec_auth=False) self.user1 = self.client.create_user(user=self.user_dict1) # Create User 2 self.user_dict2 = User( firstname='John', lastname='Doe', email='*****@*****.**' % randint(0, 9999999999999), password='******' % randint(0, 99999999)) self.user2 = self.client.create_user(user=self.user_dict2) # Create User 3 self.user_dict3 = User( firstname='John', lastname='Doe', email='*****@*****.**' % randint(0, 9999999999999), password='******' % randint(0, 99999999)) self.user3 = self.client.create_user(user=self.user_dict3) # Create Group 1 group = Group(**self.resource['group']) self.group1 = self.client.create_group(group) # Create Group 2 group.name = self.resource['group']['name'] + ' 2' self.group2 = self.client.create_group(group) # Create Group 3 group.name = self.resource['group']['name'] + ' 3' self.group3 = self.client.create_group(group) # Create Share 1 self.share1 = self.client.add_share(group_id=self.group3['id'], resource_id=self.datacenter['id'], edit_privilege=True, share_privilege=True)
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 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 volume1. cls.volume1 = cls.client.create_volume( datacenter_id=cls.datacenter['id'], volume=Volume(**cls.resource['volume'])) cls.client.wait_for_completion(cls.volume1) # Create test volume2 (attach volume test). cls.volume2 = cls.client.create_volume( datacenter_id=cls.datacenter['id'], volume=Volume(**cls.resource['volume'])) cls.client.wait_for_completion(cls.volume2) # Create test server. server = Server(**cls.resource['server']) server.attach_volumes = [cls.volume1['id']] cls.server = cls.client.create_server( datacenter_id=cls.datacenter['id'], server=server) cls.client.wait_for_completion(cls.server) # Create test NIC. cls.nic = cls.client.create_nic(datacenter_id=cls.datacenter['id'], server_id=cls.server['id'], nic=NIC(**cls.resource['nic'])) cls.client.wait_for_completion(cls.nic) # Find an Ubuntu image for testing. for item in cls.client.list_images()['items']: if (configuration.IMAGE_NAME in item['properties']['name'] and item['properties']['location'] == configuration.LOCATION): cls.image = item # Find a cdrom image images = cls.client.list_images(depth=5) usedIndex = 0 for index, image in enumerate(images['items']): if (image['metadata']['state'] == "AVAILABLE" and image['properties']['public'] is True and image['properties']['imageType'] == "CDROM" and image['properties']['location'] == configuration.LOCATION and image['properties']['licenceType'] == "LINUX"): if usedIndex == 0: cls.test_image1 = image usedIndex = index else: cls.test_image2 = image break # Create test cdrom cls.cdrom = cls.client.attach_cdrom(datacenter_id=cls.datacenter['id'], server_id=cls.server['id'], cdrom_id=cls.test_image1['id']) cls.client.wait_for_completion(cls.cdrom)