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
