def _deploy_aim(self, config_section, vapp_name):
""" Deploys and configures an AIM based hypervisor """
compute = self._context.getComputeService()
try:
name = self.__config.get(config_section, "template")
log.info("Loading template...")
vdc, options = self._template_options(compute, config_section)
template = compute.templateBuilder() \
.imageNameMatches(name) \
.locationId(vdc.getId()) \
.options(options) \
.build()
log.info("Deploying %s to %s..." % (template.getImage().getName(),
vdc.getDescription()))
identity = self._context.getApiContext().getIdentity()
node = Iterables.getOnlyElement(
compute.createNodesInGroup("%s-%s" % (vapp_name, identity),
1, template))
log.info("Created %s at %s" % (node.getName(),
Iterables.getOnlyElement(node.getPublicAddresses())))
# Configuration values
redishost = self.__config.get(config_section, "redis_host")
redisport = self.__config.get(config_section, "redis_port")
nfsto = self.__config.get(config_section, "nfs_to")
nfsfrom = self.__config.get(config_section, "nfs_from")
bootstrap = []
with open("%s/abiquo-aim.ini" % self.__scriptdir, "r") as f:
aim_config = f.read() % {'redishost': redishost,
'redisport': redisport, 'nfsto': nfsto}
bootstrap.append(Statements.createOrOverwriteFile(
"/etc/abiquo-aim.ini", [aim_config]))
with open("%s/configure-aim-node.sh" % self.__scriptdir, "r") as f:
script = f.read() % {'nfsfrom': nfsfrom, 'nfsto': nfsto}
bootstrap.append(Statements.exec(script))
log.info("Configuring node...")
compute.runScriptOnNode(node.getId(), StatementList(bootstrap))
log.info("Done! You can access it at: %s" %
Iterables.getOnlyElement(node.getPublicAddresses()))
except RunNodesException, ex:
self._print_node_errors(ex)
def reset_datanode(self, args):
""" Resets the datanode (database, redis and rabbitmq) """
parser = OptionParser(usage="scalability reset-datanode <options>")
parser.add_option('-j', '--jenkins-version',
help='Download the database from the given version '
'from Jenkins', action='store', dest='jenkins')
parser.add_option('-d', '--datanode',
help='Ip address of the data node (with rabbit, '
'redis and zookeper)', action='store', dest='datanode')
parser.add_option('-u', '--login-user',
help='Username used to access the datanode',
action='store', dest='user')
parser.add_option('-p', '--login-password',
help='Password used to access the datanode',
action='store', dest='password')
(options, args) = parser.parse_args(args)
if not options.datanode or not options.jenkins \
or not options.user or not options.password:
parser.print_help()
return
compute = self._context.getComputeService()
license = self.__config.get("reset-datanode", "license")
predicate = NodeHasIp(options.datanode)
try:
script = []
script.append(jenkins._download_database(options.jenkins))
script.append(Statements.exec(
"mysql -u %s kinton </tmp/kinton-schema-%s.sql" %
(options.user, options.jenkins)))
script.append(Statements.exec(
'mysql -u %s kinton -e "'
'insert into license (data, version_c) values (\'%s\', 1)"' %
(options.user, license)))
script.append(redis.run("flushall"))
script.extend(rabbitmq.reset())
print "Cleaning database for datanode at: %s" % options.datanode
options = RunScriptOptions.Builder \
.overrideLoginUser(options.user) \
.overrideLoginPassword(options.password)
compute.runScriptOnNodesMatching(predicate,
StatementList(script), options)
except RunNodesException, ex:
self._print_node_errors(ex)
def deploy_rs(self, args):
""" Deploys and configures custom Abiquo Remote Services """
parser = OptionParser(usage="scalability deploy-rs <options>")
parser.add_option('-j', '--jenkins-version',
help='Download the given version of the wars from Jenkins',
action='store', dest='jenkins')
parser.add_option('-r', '--rabbit', help='The RabbitMQ host',
action='store', dest='rabbit')
parser.add_option('-n', '--nfs', help='The NFS to mount',
action='store', dest='nfs')
parser.add_option('-c', '--count', type="int", default=1,
help='Number of nodes to deploy (default 1)',
action='store', dest='count')
parser.add_option('-s', '--hypervisor-sessions', type="int", default=2,
help='Number of concurrent hypervisor sessions (default 2)',
action='store', dest='hypervisorsessions')
parser.add_option('-l', '--list', help='Upload only those wars (default all rs)',
default='rs', action='store', dest='wars')
(options, args) = parser.parse_args(args)
if not options.jenkins or not options.nfs or not options.rabbit:
parser.print_help()
return
compute = self._context.getComputeService()
try:
name = self.__config.get("deploy-rs", "template")
log.info("Loading template...")
vdc, template_options = self._template_options(compute,
"deploy-rs")
template_options.overrideCores(
self.__config.getint("deploy-rs", "template_cores"))
template_options.overrideRam(
self.__config.getint("deploy-rs", "template_ram"))
template = compute.templateBuilder() \
.imageNameMatches(name) \
.locationId(vdc.getId()) \
.options(template_options) \
.build()
java_opts = self.__config.get("deploy-rs", "tomcat_opts")
boundary_org = self.__config.get("deploy-rs", "boundary_org")
boundary_key = self.__config.get("deploy-rs", "boundary_key")
newrelic_key = self.__config.get("deploy-rs", "newrelic_key")
tomcat = TomcatScripts(boundary_org, boundary_key, newrelic_key)
log.info("Deploying %s %s nodes to %s..." % (options.count,
template.getImage().getName(), vdc.getDescription()))
# Due to the IpPoolManagement concurrency issue, we need to deploy
# the nodes one by one
nodes = []
responses = []
for i in xrange(options.count):
node = Iterables.getOnlyElement(
compute.createNodesInGroup("kahuna-rs", 1, template))
log.info("Created node %s at %s" % (node.getName(),
Iterables.getOnlyElement(node.getPublicAddresses())))
nodes.append(node)
log.info("Cooking %s with Chef in the background..." %
node.getName())
tomcat_config = {
"rabbit": options.rabbit,
"datacenter": node.getName(),
"nfs": options.nfs,
"nfs-mount": True,
"java-opts": java_opts,
"hypervisor-sessions": options.hypervisorsessions
}
install_tomcat = tomcat.install_and_configure(node,
tomcat_config, self._install_jenkins_wars(options.jenkins, options.wars))
bootstrap = hostname.configure(node) + \
[ntp.install()] + redis.install("2.6.4") + install_tomcat
responses.append(compute.submitScriptOnNode(node.getId(),
StatementList(bootstrap), RunScriptOptions.NONE))
log.info("Waiting until all nodes are configured...")
for i, future in enumerate(responses):
result = future.get()
log.info("%s node at %s -> %s" % (nodes[i].getName(),
Iterables.getOnlyElement(nodes[i].getPublicAddresses()),
"OK" if result.getExitStatus() == 0 else "FAILED"))
log.info("Done!")
except (AbiquoException, AuthorizationException), ex:
print "Error: %s" % ex.getMessage()
def deploy_api(self, args):
""" Deploys and configures custom Abiquo APIs """
parser = OptionParser(usage="scalability deploy-api <options>")
parser.add_option('-f', '--file',
help='Path to a local api file to deploy',
action='store', dest='file')
parser.add_option('-j', '--jenkins-version',
help='Download the api from the given version from Jenkins',
action='store', dest='jenkins')
parser.add_option('-d', '--datanode',
help='Ip address of the data node (with rabbit, '
'redis and zookeper)',
action='store', dest='datanode')
parser.add_option('-b', '--balancer',
help='Ip address of the load balancer node',
action='store', dest='balancer')
parser.add_option('-c', '--count', type="int", default=1,
help='Number of nodes to deploy (default 1)',
action='store', dest='count')
(options, args) = parser.parse_args(args)
if options.file and options.jenkins:
print "Cannot use -f and -j together"
parser.print_help()
return
if not options.file and not options.jenkins \
or not options.datanode or not options.balancer:
parser.print_help()
return
compute = self._context.getComputeService()
try:
name = self.__config.get("deploy-api", "template")
log.info("Loading template...")
vdc, template_options = self._template_options(compute,
"deploy-api")
template_options.overrideCores(
self.__config.getint("deploy-api", "template_cores"))
template_options.overrideRam(
self.__config.getint("deploy-api", "template_ram"))
template = compute.templateBuilder() \
.imageNameMatches(name) \
.locationId(vdc.getId()) \
.options(template_options) \
.build()
java_opts = self.__config.get("deploy-api", "tomcat_opts")
boundary_org = self.__config.get("deploy-api", "boundary_org")
boundary_key = self.__config.get("deploy-api", "boundary_key")
newrelic_key = self.__config.get("deploy-api", "newrelic_key")
tomcat = TomcatScripts(boundary_org, boundary_key, newrelic_key)
log.info("Deploying %s %s nodes to %s..." % (options.count,
template.getImage().getName(), vdc.getDescription()))
# Due to the IpPoolManagement concurrency issue, we need to deploy
# the nodes one by one
nodes = []
responses = []
for i in xrange(options.count):
node = Iterables.getOnlyElement(
compute.createNodesInGroup("kahuna-api", 1, template))
log.info("Created node %s at %s" % (node.getName(),
Iterables.getOnlyElement(node.getPublicAddresses())))
if options.file:
ssh.upload(self._context, node, "/tmp", options.file)
nodes.append(node)
log.info("Cooking %s with Chef in the background..." %
node.getName())
tomcat_config = {
"rabbit": options.datanode,
"redis": options.datanode,
"zookeeper": options.datanode,
"module": "api",
"db-host": options.datanode,
#"syslog": options.balancer,
"ajp_port": 10000 + i,
"java-opts": java_opts
}
bootstrap = []
bootstrap.extend(hostname.configure(node))
bootstrap.append(ntp.install())
if options.jenkins:
bootstrap.extend(jenkins._download_war(
options.jenkins, "api"))
bootstrap.extend(tomcat.install_and_configure(node,
tomcat_config, self._install_local_wars))
responses.append(compute.submitScriptOnNode(node.getId(),
StatementList(bootstrap), RunScriptOptions.NONE))
log.info("Waiting until all nodes are configured...")
for i, future in enumerate(responses):
result = future.get()
log.info("%s node at %s -> %s" % (nodes[i].getName(),
Iterables.getOnlyElement(nodes[i].getPublicAddresses()),
"OK" if result.getExitStatus() == 0 else "FAILED"))
log.info("Done!")
except (AbiquoException, AuthorizationException), ex:
print "Error: %s" % ex.getMessage()
def deploy_abiquo(self, args):
""" Deploys and configures an Abiquo platform """
parser = OptionParser(usage="mothership deploy-abiquo <options>")
parser.add_option('-t', '--template-id',
help='The id of the template to deploy',
action='store', dest='template')
parser.add_option('-p', '--properties',
help='Path to the abiquo.properties file to use',
action='store', dest='props')
parser.add_option('-j', '--jenkins-version',
help='Download the given version of the wars from Jenkins',
action='store', dest='jenkins')
(options, args) = parser.parse_args(args)
if not options.template or not options.props:
parser.print_help()
return
compute = self._context.getComputeService()
try:
log.info("Loading template...")
vdc, template_options = self._template_options(compute,
"deploy-abiquo")
template = compute.templateBuilder() \
.imageId(options.template) \
.locationId(vdc.getId()) \
.options(template_options) \
.build()
log.info("Deploying %s to %s..." % (template.getImage().getName(),
vdc.getDescription()))
node = Iterables.getOnlyElement(
compute.createNodesInGroup("kahuna-abiquo", 1, template))
log.info("Created %s at %s" % (node.getName(),
Iterables.getOnlyElement(node.getPublicAddresses())))
# Generate the bootstrap script
bootstrap = []
bootstrap.append(Statements.exec("service abiquo-tomcat stop"))
with open(options.props, "r") as f:
bootstrap.append(Statements.createOrOverwriteFile(
"/opt/abiquo/config/abiquo.properties", [f.read()]))
with open("%s/configure-abiquo.sh" % self.__scriptdir, "r") as f:
bootstrap.append(Statements.exec(f.read()))
if options.jenkins:
with open("%s/configure-from-jenkins.sh" %
self.__scriptdir, "r") as f:
jenkins_script = f.read() % {'version': options.jenkins}
bootstrap.append(Statements.exec(jenkins_script))
bootstrap.append(Statements.exec("service abiquo-tomcat start"))
log.info("Configuring node with the given properties...")
compute.runScriptOnNode(node.getId(), StatementList(bootstrap))
log.info("Done! Abiquo configured at: %s" %
Iterables.getOnlyElement(node.getPublicAddresses()))
except RunNodesException, ex:
self._print_node_errors(ex)