def create_backup(self): """Create the backup and watch it until it completes.""" self.backup = self.cdbinst.create_backup(self.bu_name, description=self.bu_desc) print("Creating backup for DB '%s'" % self.dbName) self.refresh_info() utils.wait_for_build(self.backup, "status", ['COMPLETED', 'FAILED'], interval=5, attempts=0, verbose=True) return
def test_wait_for_build(self): sav = utils.wait_until utils.wait_until = Mock() obj = fakes.FakeEntity() att = utils.random_name() desired = utils.random_name() callback = utils.random_name() interval = utils.random_name() attempts = utils.random_name() verbose = utils.random_name() verbose_atts = utils.random_name() utils.wait_for_build(obj, att, desired, callback, interval, attempts, verbose, verbose_atts) utils.wait_until.assert_called_once_with(obj, att, desired, callback=callback, interval=interval, attempts=attempts, verbose=verbose, verbose_atts=verbose_atts) utils.wait_until = sav
def test_wait_for_build(self): sav = utils.wait_until utils.wait_until = Mock() obj = fakes.FakeEntity() att = utils.random_unicode() desired = utils.random_unicode() callback = utils.random_unicode() interval = utils.random_unicode() attempts = utils.random_unicode() verbose = utils.random_unicode() verbose_atts = utils.random_unicode() utils.wait_for_build(obj, att, desired, callback, interval, attempts, verbose, verbose_atts) utils.wait_until.assert_called_once_with(obj, att, desired, callback=callback, interval=interval, attempts=attempts, verbose=verbose, verbose_atts=verbose_atts) utils.wait_until = sav
def build(self, image, flavor, **kwargs): """Builds a server and runs the requested script on it. image and flavor are values that will be recognized by the novaclient library as references to an image and a flavor to use to boot the server with. Optionally, other kewword arguments can be passed and will be passed allong to the novaclient.boot method to enable other things such as more metadata, disk configuration options, network interfaces, etc... """ logger.debug("Generating new SSH key") name = "serverondemand-%s" % str(time.time()).replace('.', '-') key = RSAKey.generate(2048) personality = { "/root/.ssh/authorized_keys": "ssh-rsa %s serverondemand generated key\n" % key.get_base64(), } meta = { 'origin': 'serverondemand', } if kwargs.get('meta', None): meta.update(kwargs.pop('meta')) if kwargs.get('files', None): personality.update(kwargs.pop('files')) logger.info("Building server") server = self.api.servers.create(name, image, flavor, meta = meta, files = personality, **kwargs) server = wait_for_build(server, verbose = self.debug) self.server = server self.key = key logger.info("Uploading bootstrap") self.bootstrap() logger.info("Executing scripts") self.run_script()
rs_region = "ORD" hp_region = "region-a.geo-1" rs_compute = rs.get_client("compute", rs_region) rs_obj = rs.get_client("object_store", rs_region, public=False) rs_image = rs.get_client("image", rs_region) hp_compute = hp.get_client("compute", hp_region) hp_obj = hp.get_client("object_store", hp_region) hp_image = hp.get_client("image", hp_region) rs_cont_name = "export_images" hp_cont_name = "upload_images" instance = rs_compute.servers.find(name="glue_server") # Create the snapshot of the server snap = instance.create_image(instance, "glue_snap") logit("Snapshot created; id =", snap.id) utils.wait_for_build(snap, verbose=True) # Export it task = rs_image.export_task(snap, rs_cont_name) logit("Export Task created; id =", task.id) utils.wait_for_build(task, verbose=True, desired=["success", "failure"]) # Transfer it to HP obj_name = "%s.vhd" % snap.id start = time.time() dlo_parts = rs_obj.dlo_fetch(rs_cont_name, obj_name) logit("Number of DLO parts:", len(dlo_parts)) dlo_upload(hp, hp_region, hp_cont_name, dlo_parts, obj_name) end = time.time() elapsed = end - start logit("It took %8.2f seconds to transfer the image." % elapsed)
except IOError: pass try: cleanup[svc].append(reso.id) except (KeyError, AttributeError): cleanup[svc] = [reso.id] with open(filename, "w") as ff: json.dump(cleanup, ff) # Create the database instance # NOTE: The flavor ID and size are hardcoded # for demo purposes. print print "Creating the database instance..." db_instance = cdb.create("PyTexas_DB", flavor=1, volume=2) utils.wait_for_build(db_instance, verbose=True) db = db_instance.create_database("demodb") add_to_cleanup("CDB", db_instance) db_user = db_instance.create_user("demouser", "topsecret", db) db_host = db_instance.hostname print "Database instance created; hostname:", db_host # Create the isolated network print print "Creating the isolated network" new_network_name = "PyTexas_NW" new_network_cidr = "192.168.0.0/24" new_net = cnw.create(new_network_name, cidr=new_network_cidr) add_to_cleanup("CNW", new_net)
flavor = [flav for flav in flavors if flav.ram == 1024 and flav.disk == 20][0] # Store the public key keyfile = os.path.expanduser("~/.ssh/id_rsa.pub") with open(keyfile, "r") as kf: pub = kf.read() key = cs.keypairs.create("scale_key", pub) add_to_cleanup("CSK", key) # Create two servers with only ServiceNet networks = [{"net-id": cnw.SERVICE_NET_ID}] server1 = cs.servers.create("scale12x_Srv1", image=IMAGE_ID, flavor=flavor, key_name="scale_key", nics=networks) server2 = cs.servers.create("scale12x_Srv2", image=IMAGE_ID, flavor=flavor, key_name="scale_key", nics=networks) add_to_cleanup("CS", server1) add_to_cleanup("CS", server2) utils.wait_for_build(server1, verbose=True) utils.wait_for_build(server2, verbose=True) print "App servers created." print "Server 1:", server1.name, server1.addresses print "Server 2:", server2.name, server2.addresses # Get the server IPs print print "Creating the nodes" ip1 = server1.addresses["private"][0]["addr"] ip2 = server2.addresses["private"][0]["addr"] # Define the nodes node1 = clb.Node(address=ip1, port=80, weight=1, condition="ENABLED") node2 = clb.Node(address=ip2, port=80, weight=1, condition="ENABLED") print "Node 1 created:", node1 print "Node 2 created:", node2
pass try: cleanup[svc].append(reso.id) except (KeyError, AttributeError): cleanup[svc] = [reso.id] with open(filename, "w") as ff: json.dump(cleanup, ff) # Create the database instance # NOTE: The flavor ID and size are hardcoded # for demo purposes. print print "Creating the database instance..." db_instance = cdb.create("PyTexas_DB", flavor=1, volume=2) utils.wait_for_build(db_instance, verbose=True) db = db_instance.create_database("demodb") add_to_cleanup("CDB", db_instance) db_user = db_instance.create_user("demouser", "topsecret", db) db_host = db_instance.hostname print "Database instance created; hostname:", db_host # Create the isolated network print print "Creating the isolated network" new_network_name = "PyTexas_NW" new_network_cidr = "192.168.0.0/24" new_net = cnw.create(new_network_name, cidr=new_network_cidr) add_to_cleanup("CNW", new_net) print "Network created:", new_net
cleanup[svc] = [reso.id] with open(filename, "w") as ff: json.dump(cleanup, ff) # Get the available flavors flavors = cdb.list_flavors() # Select the 512MB flavor flavor = [flav for flav in flavors if flav.ram == 512][0] # Create the database instance print print "Creating the database instance..." db_instance = cdb.create("scale12x_DB", flavor=flavor, volume=2) utils.wait_for_build(db_instance, verbose=True) # Create a database on this instance db = db_instance.create_database("demodb") add_to_cleanup("CDB", db_instance) # Create a user, giving them access to the database. db_user = db_instance.create_user("demouser", "topsecret", db) db_host = db_instance.hostname print "Database instance created; hostname:", db_host # Define a Node for this database print print "Creating the node" node = clb.Node(address=db_host, port=3306, condition="ENABLED") print "Node created:", node