| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.jclouds.examples.chef.basics; |
| |
| import static com.google.common.base.Charsets.UTF_8; |
| import static com.google.common.base.Preconditions.checkArgument; |
| import static com.google.common.base.Predicates.not; |
| import static com.google.common.collect.Iterables.concat; |
| import static com.google.common.collect.Iterables.contains; |
| import static com.google.common.collect.Iterables.getOnlyElement; |
| import static org.jclouds.compute.config.ComputeServiceProperties.TIMEOUT_SCRIPT_COMPLETE; |
| import static org.jclouds.compute.options.TemplateOptions.Builder.overrideLoginCredentials; |
| import static org.jclouds.compute.options.TemplateOptions.Builder.runScript; |
| import static org.jclouds.compute.predicates.NodePredicates.TERMINATED; |
| import static org.jclouds.compute.predicates.NodePredicates.inGroup; |
| |
| import java.io.File; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.Properties; |
| import java.util.Set; |
| import java.util.concurrent.TimeUnit; |
| |
| import org.jclouds.ContextBuilder; |
| import org.jclouds.apis.ApiMetadata; |
| import org.jclouds.apis.Apis; |
| import org.jclouds.chef.ChefApiMetadata; |
| import org.jclouds.chef.ChefContext; |
| import org.jclouds.chef.ChefService; |
| import org.jclouds.chef.config.ChefProperties; |
| import org.jclouds.chef.domain.BootstrapConfig; |
| import org.jclouds.chef.util.RunListBuilder; |
| import org.jclouds.compute.ComputeService; |
| import org.jclouds.compute.ComputeServiceContext; |
| import org.jclouds.compute.RunNodesException; |
| import org.jclouds.compute.RunScriptOnNodesException; |
| import org.jclouds.compute.domain.ExecResponse; |
| import org.jclouds.compute.domain.NodeMetadata; |
| import org.jclouds.compute.domain.OsFamily; |
| import org.jclouds.compute.domain.TemplateBuilder; |
| import org.jclouds.domain.LoginCredentials; |
| import org.jclouds.enterprise.config.EnterpriseConfigurationModule; |
| import org.jclouds.logging.slf4j.config.SLF4JLoggingModule; |
| import org.jclouds.providers.ProviderMetadata; |
| import org.jclouds.providers.Providers; |
| import org.jclouds.scriptbuilder.domain.Statement; |
| import org.jclouds.scriptbuilder.domain.StatementList; |
| import org.jclouds.scriptbuilder.domain.chef.RunList; |
| import org.jclouds.scriptbuilder.statements.chef.ChefSolo; |
| import org.jclouds.scriptbuilder.statements.chef.InstallChefUsingOmnibus; |
| import org.jclouds.scriptbuilder.statements.git.CloneGitRepo; |
| import org.jclouds.scriptbuilder.statements.git.InstallGit; |
| import org.jclouds.scriptbuilder.statements.login.AdminAccess; |
| import org.jclouds.sshj.config.SshjSshClientModule; |
| |
| import com.google.common.base.Predicates; |
| import com.google.common.base.Splitter; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.Maps; |
| import com.google.common.io.Files; |
| import com.google.inject.Module; |
| |
| /** |
| * Demonstrates the use of {@link ComputeService}. |
| * <p/> |
| * Usage is: {@code java MainApp provider identity credential groupName (add|chef|destroy)} if |
| * {@code chef} is used, the following parameter is a list of recipes to be installed in the node |
| * separated by commas. |
| */ |
| public class MainApp { |
| |
| public static enum Action { |
| ADD, CHEF, SOLO, DESTROY; |
| } |
| |
| public static final Map<String, ApiMetadata> allApis = Maps.uniqueIndex( |
| Apis.viewableAs(ComputeServiceContext.class), Apis.idFunction()); |
| |
| public static final Map<String, ProviderMetadata> appProviders = Maps.uniqueIndex( |
| Providers.viewableAs(ComputeServiceContext.class), Providers.idFunction()); |
| |
| public static final Set<String> allKeys = ImmutableSet.copyOf(Iterables.concat( |
| appProviders.keySet(), allApis.keySet())); |
| |
| public static int PARAMETERS = 5; |
| |
| public static String INVALID_SYNTAX = |
| "Invalid number of parameters. Syntax is: provider identity credential groupName (add|chef|solo|destroy)"; |
| |
| public static void main(final String[] args) { |
| if (args.length < PARAMETERS) { |
| throw new IllegalArgumentException(INVALID_SYNTAX); |
| } |
| |
| String provider = args[0]; |
| String identity = args[1]; |
| String credential = args[2]; |
| String groupName = args[3]; |
| Action action = Action.valueOf(args[4].toUpperCase()); |
| if ((action == Action.CHEF || action == Action.SOLO) && args.length < PARAMETERS + 1) { |
| throw new IllegalArgumentException("please provide the list of recipes to install, separated by commas"); |
| } |
| String recipes = action == Action.CHEF || action == Action.SOLO ? args[5] : "apache2"; |
| |
| String minRam = System.getProperty("minRam"); |
| |
| // note that you can check if a provider is present ahead of time |
| checkArgument(contains(allKeys, provider), "provider %s not in supported list: %s", |
| provider, allKeys); |
| |
| LoginCredentials login = |
| action != Action.DESTROY ? getLoginForCommandExecution(action) : null; |
| |
| ComputeService compute = initComputeService(provider, identity, credential); |
| |
| try { |
| switch (action) { |
| case ADD: |
| System.out.printf(">> adding node to group %s%n", groupName); |
| |
| // Default template chooses the smallest size on an operating |
| // system that tested to work with java |
| TemplateBuilder templateBuilder = compute.templateBuilder(); |
| templateBuilder.osFamily(OsFamily.UBUNTU); |
| |
| // If you want to up the ram and leave everything default, you |
| // can just tweak minRam |
| if (minRam != null) { |
| templateBuilder.minRam(Integer.parseInt(minRam)); |
| } |
| |
| // note this will create a user with the same name as you on the |
| // node. ex. you can connect via ssh publicip |
| Statement bootInstructions = AdminAccess.standard(); |
| |
| // to run commands as root, we use the runScript option in the |
| // template. |
| templateBuilder.options(runScript(bootInstructions)); |
| |
| NodeMetadata node = |
| getOnlyElement(compute.createNodesInGroup(groupName, 1, |
| templateBuilder.build())); |
| System.out.printf("<< node %s: %s%n", node.getId(), |
| concat(node.getPrivateAddresses(), node.getPublicAddresses())); |
| |
| case SOLO: |
| System.out.printf(">> installing [%s] on group %s as %s%n", recipes, groupName, |
| login.identity); |
| |
| Iterable<String> recipeList = Splitter.on(',').split(recipes); |
| ImmutableList.Builder<Statement> bootstrapBuilder = ImmutableList.builder(); |
| bootstrapBuilder.add(new InstallGit()); |
| |
| // Clone community cookbooks into the node |
| for (String recipe : recipeList) { |
| bootstrapBuilder.add(CloneGitRepo.builder() |
| .repository("git://github.com/opscode-cookbooks/" + recipe + ".git") |
| .directory("/var/chef/cookbooks/" + recipe) // |
| .build()); |
| } |
| |
| // Configure Chef Solo to bootstrap the selected recipes |
| bootstrapBuilder.add(new InstallChefUsingOmnibus()); |
| bootstrapBuilder.add(ChefSolo.builder() // |
| .cookbookPath("/var/chef/cookbooks") // |
| .runlist(RunList.builder().recipes(recipeList).build()) // |
| .build()); |
| |
| // Build the statement that will perform all the operations above |
| StatementList bootstrap = new StatementList(bootstrapBuilder.build()); |
| |
| // Run the script in the nodes of the group |
| runScriptOnGroup(compute, login, groupName, bootstrap); |
| break; |
| case CHEF: |
| // Create the connection to the Chef server |
| ChefService chef = |
| initChefService(System.getProperty("chef.client"), |
| System.getProperty("chef.validator")); |
| |
| // Build the runlist for the deployed nodes |
| System.out.println("Configuring node runlist in the Chef server..."); |
| List<String> runlist = |
| new RunListBuilder().addRecipes(recipes.split(",")).build(); |
| BootstrapConfig config = BootstrapConfig.builder().runList(runlist).build(); |
| chef.updateBootstrapConfigForGroup(groupName, config); |
| Statement chefServerBootstrap = chef.createBootstrapScriptForGroup(groupName); |
| |
| // Run the script in the nodes of the group |
| System.out.printf(">> installing [%s] on group %s as %s%n", recipes, groupName, |
| login.identity); |
| runScriptOnGroup(compute, login, groupName, chefServerBootstrap); |
| break; |
| case DESTROY: |
| System.out.printf(">> destroying nodes in group %s%n", groupName); |
| // you can use predicates to select which nodes you wish to |
| // destroy. |
| Set<? extends NodeMetadata> destroyed = compute.destroyNodesMatching(// |
| Predicates.<NodeMetadata>and(not(TERMINATED), inGroup(groupName))); |
| System.out.printf("<< destroyed nodes %s%n", destroyed); |
| break; |
| } |
| } catch (RunNodesException e) { |
| System.err.println("error adding node to group " + groupName + ": " + e.getMessage()); |
| error = 1; |
| } catch (RunScriptOnNodesException e) { |
| System.err.println("error installing " + recipes + " on group " + groupName + ": " |
| + e.getMessage()); |
| error = 1; |
| } catch (Exception e) { |
| System.err.println("error: " + e.getMessage()); |
| error = 1; |
| } finally { |
| compute.getContext().close(); |
| System.exit(error); |
| } |
| } |
| |
| static int error = 0; |
| |
| private static void runScriptOnGroup(final ComputeService compute, |
| final LoginCredentials login, final String groupName, final Statement command) |
| throws RunScriptOnNodesException { |
| // when you run commands, you can pass options to decide whether |
| // to run it as root, supply or own credentials vs from cache, |
| // and wrap in an init script vs directly invoke |
| Map<? extends NodeMetadata, ExecResponse> execResponses = |
| compute.runScriptOnNodesMatching(// |
| inGroup(groupName), // predicate used to select nodes |
| command, // what you actually intend to run |
| overrideLoginCredentials(login)); // use the local user & ssh key |
| |
| for (Entry<? extends NodeMetadata, ExecResponse> response : execResponses.entrySet()) { |
| System.out.printf( |
| "<< node %s: %s%n", |
| response.getKey().getId(), |
| concat(response.getKey().getPrivateAddresses(), response.getKey() |
| .getPublicAddresses()) |
| ); |
| System.out.printf("<< %s%n", response.getValue()); |
| } |
| } |
| |
| private static ComputeService initComputeService(final String provider, final String identity, |
| final String credential) { |
| // example of specific properties, in this case optimizing image list to |
| // only amazon supplied |
| Properties properties = new Properties(); |
| long scriptTimeout = TimeUnit.MILLISECONDS.convert(20, TimeUnit.MINUTES); |
| properties.setProperty(TIMEOUT_SCRIPT_COMPLETE, scriptTimeout + ""); |
| |
| // example of injecting a ssh implementation |
| Iterable<Module> modules = |
| ImmutableSet.<Module>of(new SshjSshClientModule(), new SLF4JLoggingModule(), |
| new EnterpriseConfigurationModule()); |
| |
| ContextBuilder builder = |
| ContextBuilder.newBuilder(provider).credentials(identity, credential).modules(modules) |
| .overrides(properties); |
| |
| System.out.printf(">> initializing %s%n", builder.getApiMetadata()); |
| |
| return builder.buildView(ComputeServiceContext.class).getComputeService(); |
| } |
| |
| private static ChefService initChefService(final String client, final String validator) { |
| try { |
| Properties chefConfig = new Properties(); |
| chefConfig.put(ChefProperties.CHEF_VALIDATOR_NAME, validator); |
| chefConfig |
| .put(ChefProperties.CHEF_VALIDATOR_CREDENTIAL, credentialForClient(validator)); |
| |
| ContextBuilder builder = ContextBuilder.newBuilder(new ChefApiMetadata()) // |
| .credentials(client, credentialForClient(client)) // |
| .modules(ImmutableSet.<Module>of(new SLF4JLoggingModule())) // |
| .overrides(chefConfig); // |
| |
| System.out.printf(">> initializing %s%n", builder.getApiMetadata()); |
| |
| ChefContext context = builder.buildView(ChefContext.class); |
| return context.getChefService(); |
| } catch (Exception e) { |
| System.err.println("error reading private key " + e.getMessage()); |
| System.exit(1); |
| return null; |
| } |
| } |
| |
| private static LoginCredentials getLoginForCommandExecution(final Action action) { |
| try { |
| String user = System.getProperty("user.name"); |
| String privateKey = |
| Files.toString(new File(System.getProperty("user.home") + "/.ssh/id_rsa"), UTF_8); |
| return LoginCredentials.builder().user(user).privateKey(privateKey) |
| .authenticateSudo(true).build(); |
| } catch (Exception e) { |
| System.err.println("error reading ssh key " + e.getMessage()); |
| System.exit(1); |
| return null; |
| } |
| } |
| |
| private static String credentialForClient(final String client) throws Exception { |
| String pemFile = System.getProperty("user.home") + "/.chef/" + client + ".pem"; |
| return Files.toString(new File(pemFile), UTF_8); |
| } |
| |
| } |
