/*
* Copyright (c) 2016 ingenieux Labs
*
* Licensed 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 br.com.ingenieux.mojo.beanstalk.env;
import com.google.common.base.Predicate;
import com.amazonaws.services.elasticbeanstalk.model.CheckDNSAvailabilityRequest;
import com.amazonaws.services.elasticbeanstalk.model.ConfigurationOptionSetting;
import com.amazonaws.services.elasticbeanstalk.model.CreateEnvironmentResult;
import com.amazonaws.services.elasticbeanstalk.model.DescribeConfigurationSettingsRequest;
import com.amazonaws.services.elasticbeanstalk.model.DescribeConfigurationSettingsResult;
import com.amazonaws.services.elasticbeanstalk.model.EnvironmentDescription;
import org.apache.commons.lang.StringUtils;
import org.apache.maven.plugin.AbstractMojoExecutionException;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.ListIterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import br.com.ingenieux.mojo.aws.util.CredentialsUtil;
import br.com.ingenieux.mojo.beanstalk.cmd.dns.BindDomainsCommand;
import br.com.ingenieux.mojo.beanstalk.cmd.dns.BindDomainsContext;
import br.com.ingenieux.mojo.beanstalk.cmd.dns.BindDomainsContextBuilder;
import br.com.ingenieux.mojo.beanstalk.cmd.env.swap.SwapCNamesCommand;
import br.com.ingenieux.mojo.beanstalk.cmd.env.swap.SwapCNamesContext;
import br.com.ingenieux.mojo.beanstalk.cmd.env.swap.SwapCNamesContextBuilder;
import br.com.ingenieux.mojo.beanstalk.cmd.env.terminate.TerminateEnvironmentCommand;
import br.com.ingenieux.mojo.beanstalk.cmd.env.terminate.TerminateEnvironmentContext;
import br.com.ingenieux.mojo.beanstalk.cmd.env.terminate.TerminateEnvironmentContextBuilder;
import br.com.ingenieux.mojo.beanstalk.cmd.env.waitfor.WaitForEnvironmentCommand;
import br.com.ingenieux.mojo.beanstalk.cmd.env.waitfor.WaitForEnvironmentContext;
import br.com.ingenieux.mojo.beanstalk.cmd.env.waitfor.WaitForEnvironmentContextBuilder;
import br.com.ingenieux.mojo.beanstalk.util.EnvironmentHostnameUtil;
import static java.lang.String.format;
import static org.apache.commons.lang.StringUtils.isNotBlank;
/**
* Launches a new environment and, when done, replace with the existing, terminating when needed. It
* combines both create-environment, wait-for-environment, swap-environment-cnames, and
* terminate-environment
*
* @since 0.2.0
*/
@Mojo(name = "replace-environment")
// Best Guess Evar
public class ReplaceEnvironmentMojo extends CreateEnvironmentMojo {
/**
* Pattern for Increasing in Replace Environment
*/
private static final Pattern PATTERN_NUMBERED = Pattern.compile("^(.*)-(\\d+)$");
/**
* Max Environment Name Length
*/
private static final int MAX_ENVNAME_LEN = 40;
/**
* Minutes until timeout
*/
@Parameter(property = "beanstalk.timeoutMins", defaultValue = "20")
Integer timeoutMins;
/**
* Skips if Same Version?
*/
@Parameter(property = "beanstalk.skipIfSameVersion", defaultValue = "true")
boolean skipIfSameVersion = true;
/**
* Max Number of Attempts (for cnameSwap in Particular)
*/
@Parameter(property = "beanstalk.maxAttempts", defaultValue = "15")
Integer maxAttempts = 15;
/**
* Do a 'Mock' Terminate Environment Call (useful for Debugging)
*/
@Parameter(property = "beanstalk.mockTerminateEnvironment", defaultValue = "false")
boolean mockTerminateEnvironment = false;
/**
* Allows one Red (broken) environment to replace another Red (broken) environment.
*/
@Parameter(property = "beanstalk.redToRedOkay", defaultValue = "true")
boolean redToRedOkay = true;
/**
* Retry Interval, in Seconds
*/
@Parameter(property = "beanstalk.attemptRetryInterval", defaultValue = "60")
int attemptRetryInterval = 60;
/**
* <p>List of R53 Domains</p> <p/> <p>Could be set as either:</p> <ul> <li>fqdn:hostedZoneId
* (e.g. "services.modafocas.org:Z3DJ4DL0DIEEJA")</li> <li>hosted zone name - will be set to
* root. (e.g., "modafocas.org")</li> </ul>
*/
@Parameter(property = "beanstalk.domains")
String[] domains;
/**
* Whether or not to copy option settings from old environment when replacing
*/
@Parameter(property = "beanstalk.copyOptionSettings", defaultValue = "true")
boolean copyOptionSettings = true;
/**
* Whether or not to keep the Elastic Beanstalk platform (aka solutionStack) from the old
* environment when replacing
*/
@Parameter(property = "beanstalk.copySolutionStack", defaultValue = "true")
boolean copySolutionStack = true;
@Override
protected EnvironmentDescription handleResults(Collection<EnvironmentDescription> environments) throws MojoExecutionException {
// Don't care - We're an exception to the rule, you know.
return null;
}
@Override
protected Object executeInternal() throws Exception {
solutionStack = lookupSolutionStack(solutionStack);
/*
* Is the desired cname not being used by other environments? If so,
* just launch the environment
*/
if (!hasEnvironmentFor(applicationName, cnamePrefix)) {
if (getLog().isInfoEnabled()) {
getLog().info("Just launching a new environment.");
}
return super.executeInternal();
}
/*
* Gets the current environment using this cname
*/
EnvironmentDescription curEnv = getEnvironmentFor(applicationName, cnamePrefix);
if (curEnv.getVersionLabel().equals(versionLabel) && skipIfSameVersion) {
getLog().warn(format("Environment is running version %s and skipIfSameVersion is true. Returning", versionLabel));
return null;
}
/*
* Decides on a environmentRef, and launches a new environment
*/
String cnamePrefixToCreate = getCNamePrefixToCreate();
/* TODO: Revise Suffix Dynamics */
if (getLog().isInfoEnabled()) {
getLog().info("Creating a new environment on " + cnamePrefixToCreate + ".elasticbeanstalk.com");
}
if (copyOptionSettings) {
copyOptionSettings(curEnv);
}
if (!solutionStack.equals(curEnv.getSolutionStackName()) && copySolutionStack) {
if (getLog().isWarnEnabled()) {
getLog()
.warn(
format(
"(btw, we're launching with solutionStack/ set to '%s' based on the existing env instead of the "
+ "default ('%s'). If this is not the desired behavior please set the copySolutionStack property to"
+ " false.",
curEnv.getSolutionStackName(),
solutionStack));
}
solutionStack = curEnv.getSolutionStackName();
}
/**
* TODO: Spend a comfy Saturday Afternoon in a Coffee Shop trying to figure out this nice boolean logic with Karnaugh Maps sponsored by Allogy
*/
boolean userWantsHealthyExitStatus = mustBeHealthy;
final boolean currentEnvironmentIsRed = "Red".equals(curEnv.getHealth());
if (redToRedOkay) {
//Side-effect: must be before createEnvironment() and waitForEnvironment() to effect superclass behavior.
mustBeHealthy = !currentEnvironmentIsRed;
}
/**
* // I really meant it.
*/
String newEnvironmentName = getNewEnvironmentName(StringUtils.defaultString(this.environmentName, curEnv.getEnvironmentName()));
if (getLog().isInfoEnabled()) {
getLog().info("And it'll be named " + newEnvironmentName);
getLog().info("And it will replace a '" + curEnv.getHealth() + "' enviroment");
}
CreateEnvironmentResult createEnvResult = createEnvironment(cnamePrefixToCreate, newEnvironmentName);
/*
* Waits for completion
*/
EnvironmentDescription newEnvDesc = null;
try {
newEnvDesc = waitForEnvironment(createEnvResult.getEnvironmentId());
} catch (Exception exc) {
/*
* Terminates the failed launched environment
*/
terminateEnvironment(createEnvResult.getEnvironmentId());
handleException(exc);
return null;
}
/*
* Swaps. Due to beanstalker-25, we're doing some extra logic we
* actually woudln't want to.
*/
{
boolean swapped = false;
for (int i = 1; i <= maxAttempts; i++) {
try {
swapEnvironmentCNames(newEnvDesc.getEnvironmentId(), curEnv.getEnvironmentId(), cnamePrefix, newEnvDesc);
swapped = true;
break;
} catch (Throwable exc) {
if (exc instanceof MojoFailureException) {
exc = Throwable.class.cast(MojoFailureException.class.cast(exc).getCause());
}
getLog().warn(format("Attempt #%d/%d failed. Sleeping and retrying. Reason: %s (type: %s)", i, maxAttempts, exc.getMessage(), exc.getClass()));
sleepInterval(attemptRetryInterval);
}
}
if (!swapped) {
getLog().info("Failed to properly Replace Environment. Finishing the new one. And throwing you a failure");
terminateEnvironment(newEnvDesc.getEnvironmentId());
String message = "Unable to swap cnames. btw, see https://github.com/ingenieux/beanstalker/issues/25 and help us improve beanstalker";
getLog().warn(message);
throw new MojoFailureException(message);
}
}
/*
* Terminates the previous environment
*/
terminateEnvironment(curEnv.getEnvironmentId());
/**
* TODO: I really need a Saturday Afternoon in order to understand this ffs.
*/
if (currentEnvironmentIsRed && userWantsHealthyExitStatus) {
final String newHealth = newEnvDesc.getHealth();
if (newHealth.equals("Green")) {
getLog().info("Previous environment was 'Red', new environment is 'Green' (for the moment)");
} else {
getLog().warn(format("Previous environment was 'Red', replacement environment is currently '%s'", newHealth));
//NB: we have already switched from one broken service to another, so this is more for the build status indicator...
newEnvDesc = waitForGreenEnvironment(createEnvResult.getEnvironmentId());
}
}
return createEnvResult;
}
public void sleepInterval(int pollInterval) {
getLog().info(format("Sleeping for %d seconds (and until %s)", pollInterval, new Date(System.currentTimeMillis() + 1000 * pollInterval)));
try {
Thread.sleep(1000 * pollInterval);
} catch (InterruptedException e) {
}
}
/**
* Prior to Launching a New Environment, lets look and copy the most we can
*
* @param curEnv current environment
*/
private void copyOptionSettings(EnvironmentDescription curEnv) throws Exception {
/**
* Skip if we don't have anything
*/
if (null != this.optionSettings && this.optionSettings.length > 0) {
return;
}
DescribeConfigurationSettingsResult configSettings =
getService()
.describeConfigurationSettings(
new DescribeConfigurationSettingsRequest().withApplicationName(applicationName).withEnvironmentName(curEnv.getEnvironmentName()));
List<ConfigurationOptionSetting> newOptionSettings =
new ArrayList<ConfigurationOptionSetting>(configSettings.getConfigurationSettings().get(0).getOptionSettings());
ListIterator<ConfigurationOptionSetting> listIterator = newOptionSettings.listIterator();
while (listIterator.hasNext()) {
ConfigurationOptionSetting curOptionSetting = listIterator.next();
boolean bInvalid = harmfulOptionSettingP(curEnv.getEnvironmentId(), curOptionSetting);
if (bInvalid) {
getLog()
.info(
format(
"Excluding Option Setting: %s:%s['%s']",
curOptionSetting.getNamespace(),
curOptionSetting.getOptionName(),
CredentialsUtil.redact(curOptionSetting.getValue())));
listIterator.remove();
} else {
getLog()
.info(
format(
"Including Option Setting: %s:%s['%s']",
curOptionSetting.getNamespace(),
curOptionSetting.getOptionName(),
CredentialsUtil.redact(curOptionSetting.getValue())));
}
}
Object __secGroups = project.getProperties().get("beanstalk.securityGroups");
if (null != __secGroups) {
String securityGroups = StringUtils.defaultString(__secGroups.toString());
if (!StringUtils.isBlank(securityGroups)) {
ConfigurationOptionSetting newOptionSetting = new ConfigurationOptionSetting("aws:autoscaling:launchconfiguration", "SecurityGroups", securityGroups);
newOptionSettings.add(newOptionSetting);
getLog()
.info(
format(
"Including Option Setting: %s:%s['%s']", newOptionSetting.getNamespace(), newOptionSetting.getOptionName(), newOptionSetting.getValue()));
}
}
/*
* Then copy it back
*/
this.optionSettings = newOptionSettings.toArray(new ConfigurationOptionSetting[newOptionSettings.size()]);
}
/**
* Swaps environment cnames
*
* @param newEnvironmentId environment id
* @param curEnvironmentId environment id
*/
protected void swapEnvironmentCNames(String newEnvironmentId, String curEnvironmentId, String cnamePrefix, EnvironmentDescription newEnv)
throws AbstractMojoExecutionException {
getLog().info("Swapping environment cnames " + newEnvironmentId + " and " + curEnvironmentId);
{
SwapCNamesContext context =
SwapCNamesContextBuilder.swapCNamesContext() //
.withSourceEnvironmentId(newEnvironmentId) //
.withDestinationEnvironmentId(curEnvironmentId) //
.build();
SwapCNamesCommand command = new SwapCNamesCommand(this);
command.execute(context);
}
/*
* Changes in Route53 as well.
*/
if (null != domains) {
List<String> domainsToUse = new ArrayList<String>();
for (String s : domains) {
if (isNotBlank(s)) {
domainsToUse.add(s.trim());
}
}
if (!domainsToUse.isEmpty()) {
final BindDomainsContext ctx = new BindDomainsContextBuilder().withCurEnv(newEnv).withDomains(domainsToUse).build();
new BindDomainsCommand(this).execute(ctx);
} else {
getLog().info("Skipping r53 domain binding");
}
}
{
WaitForEnvironmentContext context =
new WaitForEnvironmentContextBuilder()
.withApplicationName(applicationName) //
.withStatusToWaitFor("Ready") //
.withEnvironmentRef(newEnvironmentId) //
.withTimeoutMins(timeoutMins) //
.build();
WaitForEnvironmentCommand command = new WaitForEnvironmentCommand(this);
command.execute(context);
}
}
/**
* Terminates and waits for an environment
*
* @param environmentId environment id to terminate
*/
protected void terminateEnvironment(String environmentId) throws AbstractMojoExecutionException {
if (mockTerminateEnvironment) {
getLog().info(format("We're ignoring the termination of environment id '%s' (see mockTerminateEnvironment)", environmentId));
return;
}
Exception lastException = null;
for (int i = 1; i <= maxAttempts; i++) {
getLog().info(format("Terminating environmentId=%s (attempt %d/%d)", environmentId, i, maxAttempts));
try {
TerminateEnvironmentContext terminatecontext =
new TerminateEnvironmentContextBuilder().withEnvironmentId(environmentId).withTerminateResources(true).build();
TerminateEnvironmentCommand command = new TerminateEnvironmentCommand(this);
command.execute(terminatecontext);
return;
} catch (Exception exc) {
lastException = exc;
}
}
throw new MojoFailureException("Unable to terminate environment " + environmentId, lastException);
}
/**
* Waits for an environment to get ready. Throws an exception either if this environment
* couldn't get into Ready state or there was a timeout
*
* @param environmentId environmentId to wait for
* @return EnvironmentDescription in Ready state
*/
protected EnvironmentDescription waitForEnvironment(String environmentId) throws AbstractMojoExecutionException {
getLog().info("Waiting for environmentId " + environmentId + " to get into Ready state");
WaitForEnvironmentContext context =
new WaitForEnvironmentContextBuilder() //
.withApplicationName(applicationName) //
.withStatusToWaitFor("Ready")
.withEnvironmentRef(environmentId) //
.withHealth((mustBeHealthy ? "Green" : null)) //
.withTimeoutMins(timeoutMins)
.build();
WaitForEnvironmentCommand command = new WaitForEnvironmentCommand(this);
return command.execute(context);
}
/**
* TODO: What is Coffee anyway?
*
* Waits for an environment to become green. Throws an exception either if this environment
* couldn't get into a green state, or there was a timeout.
*
* @param environmentId environmentId to wait for
* @return EnvironmentDescription in Ready state
*/
protected EnvironmentDescription waitForGreenEnvironment(String environmentId) throws AbstractMojoExecutionException {
getLog().info("Waiting for environmentId " + environmentId + " to become 'Green'");
WaitForEnvironmentContext context =
new WaitForEnvironmentContextBuilder()
.withApplicationName(applicationName)
.withStatusToWaitFor("Ready")
.withEnvironmentRef(environmentId)
.withHealth("Green")
.withTimeoutMins(timeoutMins)
.build();
WaitForEnvironmentCommand command = new WaitForEnvironmentCommand(this);
return command.execute(context);
}
/**
* Creates a cname prefix if needed, or returns the desired one
*
* @return cname prefix to launch environment into
*/
protected String getCNamePrefixToCreate() {
String cnamePrefixToReturn = cnamePrefix;
int i = 0;
while (hasEnvironmentFor(applicationName, cnamePrefixToReturn) || isNamedEnvironmentUnavailable(cnamePrefixToReturn)) {
// TODO: Environment Length Restrictions
cnamePrefixToReturn = String.format("%s-%d", cnamePrefix, i++);
}
return cnamePrefixToReturn;
}
/**
* Boolean predicate for environment existence
*
* @param applicationName application name
* @param cnamePrefix cname prefix
* @return true if the application name has this cname prefix
*/
protected boolean hasEnvironmentFor(String applicationName, String cnamePrefix) {
return null != getEnvironmentFor(applicationName, cnamePrefix);
}
/**
* Returns the environment description matching applicationName and environmentRef
*
* @param applicationName application name
* @param cnamePrefix cname prefix
* @return environment description
*/
protected EnvironmentDescription getEnvironmentFor(String applicationName, String cnamePrefix) {
Collection<EnvironmentDescription> environments = getEnvironmentsFor(applicationName);
Predicate<EnvironmentDescription> pred = EnvironmentHostnameUtil.getHostnamePredicate(getRegion(), cnamePrefix);
/*
* Finds a matching environment
*/
for (EnvironmentDescription envDesc : environments) {
if (pred.apply(envDesc)) {
return envDesc;
}
}
return null;
}
private String getNewEnvironmentName(String newEnvironmentName) {
String result = newEnvironmentName;
String environmentRadical = result;
int i = 0;
{
Matcher matcher = PATTERN_NUMBERED.matcher(newEnvironmentName);
if (matcher.matches()) {
environmentRadical = matcher.group(1);
i = 1 + Integer.valueOf(matcher.group(2));
}
}
while (containsNamedEnvironment(result) || isNamedEnvironmentUnavailable(result)) {
result = formatAndTruncate("%s-%d", MAX_ENVNAME_LEN, environmentRadical, i++);
}
return result;
}
private boolean isNamedEnvironmentUnavailable(String cnamePrefix) {
return !getService().checkDNSAvailability(new CheckDNSAvailabilityRequest(cnamePrefix)).isAvailable();
}
/**
* Elastic Beanstalk Contains a Max EnvironmentName Limit. Lets truncate it, shall we?
*
* @param mask String.format Mask
* @param maxLen Maximum Length
* @param args String.format args
* @return formatted String, or maxLen rightmost characters
*/
protected String formatAndTruncate(String mask, int maxLen, Object... args) {
String result = String.format(mask, args);
if (result.length() > maxLen) {
result = result.substring(result.length() - maxLen, result.length());
}
return result;
}
/**
* Boolean predicate for named environment
*
* @param environmentName environment name
* @return true if environment name exists
*/
protected boolean containsNamedEnvironment(String environmentName) {
for (EnvironmentDescription envDesc : getEnvironmentsFor(applicationName)) {
if (envDesc.getEnvironmentName().equals(environmentName)) {
return true;
}
}
return false;
}
}