def deploy_chef(self, args): """ Deploys and configures a Chef Server """ compute = self._context.getComputeService() try: name = self.__config.get("deploy-chef", "template") log.info("Loading template...") options = self._template_options(compute, "deploy-chef") template = compute.templateBuilder() \ .imageNameMatches(name) \ .options(options.blockOnPort(4000, 90)) \ .build() log.info("Deploying %s..." % template.getImage().getName()) node = Iterables.getOnlyElement( compute.createNodesInGroup("kahuna-chef", 1, template)) cookbooks = self.__config.get("deploy-chef", "cookbooks") with open(self.__scriptdir + "/configure-chef.sh", "r") as f: script = f.read() % {'cookbooks': cookbooks} log.info("Configuring node with cookbooks: %s..." % cookbooks) compute.runScriptOnNode(node.getId(), script) log.info("Chef Server configured!") log.info("You can access the admin console at: http://%s:4040" % Iterables.getOnlyElement(node.getPrivateAddresses())) log.info("These are the certificates to access the API:") self._print_node_file(self._context, node, "/etc/chef/validation.pem") self._print_node_file(self._context, node, "/etc/chef/webui.pem") except RunNodesException, ex: self._print_node_errors(ex)
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 deploy_chef(self, args): """ Deploys and configures a Chef Server """ compute = self._context.getComputeService() try: name = self.__config.get("deploy-chef", "template") log.info("Loading template...") vdc, options = self._template_options(compute, "deploy-chef") 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("kahuna-chef-%s" % identity, 1, template)) log.info("Created %s at %s" % (node.getName(), Iterables.getOnlyElement(node.getPublicAddresses()))) cookbooks = self.__config.get("deploy-chef", "cookbooks") with open("%s/configure-chef.sh" % self.__scriptdir, "r") as f: script = f.read() % {'cookbooks': cookbooks} log.info("Configuring node with cookbooks: %s..." % cookbooks) compute.runScriptOnNode(node.getId(), script) log.info("Done! You can access the admin console at: " "http://%s:4040" % Iterables.getOnlyElement(node.getPublicAddresses())) log.info("These are the certificates to access the API:") webui = ssh.get(self._context, node, "/etc/chef/webui.pem") log.info("webui.pem: %s", webui) validator = ssh.get(self._context, node, "/etc/chef/validation.pem") log.info("validation.pem: %s" % validator) except RunNodesException, ex: self._print_node_errors(ex)
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...") options = self._template_options(compute, config_section) template = compute.templateBuilder() \ .imageNameMatches(name) \ .options(options) \ .build() log.info("Deploying %s..." % template.getImage().getName()) node = Iterables.getOnlyElement( compute.createNodesInGroup(vapp_name, 1, template)) # 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") # abiquo-aim.ini self._complete_file("abiquo-aim.ini", {'redishost': redishost, 'redisport': redisport, 'nfsto': nfsto}) self._upload_file_node(self._context, node, "/etc/", "abiquo-aim.ini") # configure-aim-node.sh with open(self.__scriptdir + "/configure-aim-node.sh", "r") as f: script = f.read() % {'nfsfrom': nfsfrom, 'nfsto': nfsto} log.info("Configuring node...") compute.runScriptOnNode(node.getId(), script) log.info("Node configured!") log.info("You can access it at: ssh://%s" % Iterables.getOnlyElement(node.getPrivateAddresses())) except RunNodesException, ex: self._print_node_errors(ex)
def applyAmbiguities(cls, originalRule, ambiguitiesByOriginalForm, model): """ generated source for method applyAmbiguities """ rules = Lists.newArrayList(originalRule) # Each literal can potentially multiply the number of rules we have, so # we apply each literal separately to the entire list of rules so far. for literal in Iterables.concat(ImmutableSet.of(originalRule.getHead()), originalRule.getBody()): for rule in rules: Preconditions.checkArgument(originalRule.arity() == rule.arity()) newRules.addAll(applyAmbiguitiesForLiteral(literal, rule, ambiguitiesByOriginalForm, model)) rules = newRules return rules
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') (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...") template_options = self._template_options(compute, "deploy-abiquo") template = compute.templateBuilder() \ .imageId(options.template) \ .options(template_options) \ .build() log.info("Deploying %s..." % template.getImage().getName()) node = Iterables.getOnlyElement( compute.createNodesInGroup("kahuna-abiquo", 1, template)) self._upload_file_node(self._context, node, "/opt/abiquo/config", options.props, True) log.info("Restarting Abiquo Tomcat...") compute.runScriptOnNode(node.getId(), "service abiquo-tomcat restart") log.info("Abiquo configured at: %s" % Iterables.getOnlyElement(node.getPrivateAddresses())) except RunNodesException, ex: self._print_node_errors(ex)
def mergeStrata(cls, toMerge, toAdd, strataDependencyGraph): """ generated source for method mergeStrata """ newStratum = ImmutableSet.copyOf(Iterables.concat(toMerge)) for oldStratum in toMerge: toAdd.remove(oldStratum) toAdd.add(newStratum) # Change the keys for oldStratum in toMerge: strataDependencyGraph.putAll(newStratum, parents) strataDependencyGraph.removeAll(oldStratum) # Change the values for entry in ImmutableList.copyOf(strataDependencyGraph.entries()): if toMerge.contains(entry.getValue()): strataDependencyGraph.remove(entry.getKey(), entry.getValue()) strataDependencyGraph.put(entry.getKey(), newStratum)
def removeUnreachableBasesAndInputs(cls, pn, basesTrueByInit): """ generated source for method removeUnreachableBasesAndInputs """ reachability = Maps.newHashMap() numTrueInputs = HashMultiset.create() numFalseInputs = HashMultiset.create() toAdd = Stack() legalsToInputs = Maps.newHashMap() for legalProp in Iterables.concat(pn.getLegalPropositions().values()): if inputProp != None: legalsToInputs.put(legalProp, inputProp) for c in pn.getComponents(): ConcurrencyUtils.checkForInterruption() if isinstance(c, (Constant, )): if c.getValue(): toAdd.add(Pair.of(c, cls.Type.TRUE)) else: toAdd.add(Pair.of(c, cls.Type.FALSE)) for p in pn.getInputPropositions().values(): toAdd.add(Pair.of(p, cls.Type.FALSE)) for baseProp in pn.getBasePropositions().values(): if basesTrueByInit.contains(baseProp): toAdd.add(Pair.of(baseProp, cls.Type.TRUE)) else: toAdd.add(Pair.of(baseProp, cls.Type.FALSE)) initProposition = pn.getInitProposition() toAdd.add(Pair.of(initProposition, cls.Type.BOTH)) while not toAdd.isEmpty(): ConcurrencyUtils.checkForInterruption() if oldType == None: oldType = cls.Type.NEITHER if isinstance(curComp, (Proposition, )): typeToAdd = newInputType elif isinstance(curComp, (Transition, )): typeToAdd = newInputType elif isinstance(curComp, (Constant, )): typeToAdd = newInputType elif isinstance(curComp, (Not, )): typeToAdd = newInputType.opposite() elif isinstance(curComp, (And, )): if newInputType.hasTrue: numTrueInputs.add(curComp) if numTrueInputs.count(curComp) == curComp.getInputs().size(): typeToAdd = cls.Type.TRUE if newInputType.hasFalse: typeToAdd = typeToAdd.with_(cls.Type.FALSE) elif isinstance(curComp, (Or, )): if newInputType.hasFalse: numFalseInputs.add(curComp) if numFalseInputs.count(curComp) == curComp.getInputs().size(): typeToAdd = cls.Type.FALSE if newInputType.hasTrue: typeToAdd = typeToAdd.with_(cls.Type.TRUE) else: raise RuntimeException("Unhandled component type " + curComp.__class__) if oldType.includes(typeToAdd): continue reachability.put(curComp, typeToAdd.with_(oldType)) typeToAdd = typeToAdd.minus(oldType) if typeToAdd == cls.Type.NEITHER: raise RuntimeException("Something's messed up here") for output in curComp.getOutputs(): toAdd.add(Pair.of(output, typeToAdd)) if legalsToInputs.containsKey(curComp): if inputProp == None: raise IllegalStateException() toAdd.add(Pair.of(inputProp, typeToAdd)) trueConst = Constant(True) falseConst = Constant(False) pn.addComponent(trueConst) pn.addComponent(falseConst) for entry in reachability.entrySet(): if type_ == cls.Type.TRUE or type_ == cls.Type.FALSE: if isinstance(c, (Constant, )): continue for input in c.getInputs(): input.removeOutput(c) c.removeAllInputs() if type_ == cls.Type.TRUE ^ (isinstance(c, (Not, ))): c.addInput(trueConst) trueConst.addOutput(c) else: c.addInput(falseConst) falseConst.addOutput(c) cls.optimizeAwayTrueAndFalse(pn, trueConst, falseConst)
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)
def getSentences(cls, rule, includeHead): """ generated source for method getSentences """ if includeHead == cls.VarDomainOpts.INCLUDE_HEAD: return Iterables.concat(ImmutableList.of(rule.getHead()), rule.getBody()) else: return rule.getBody()
def getRules(cls, description): """ generated source for method getRules """ return Iterables.transform(Iterables.filter(description, Predicate()), Function())
def getPositiveConjuncts(cls, body): """ generated source for method getPositiveConjuncts """ return Iterables.transform(Iterables.filter(body, Predicate()), Function())