Example usage for com.amazonaws.services.cloudformation.model DescribeStackEventsRequest DescribeStackEventsRequest

Introduction

In this page you can find the example usage for com.amazonaws.services.cloudformation.model DescribeStackEventsRequest DescribeStackEventsRequest.

Prototype

DescribeStackEventsRequest

Source Link

Usage

From source file:br.com.ingenieux.mojo.cloudformation.cmd.WaitForStackCommand.java

License:Apache License

public void execute() throws Exception {
    Set<StackEvent> events = new TreeSet<>((o1, o2) -> {
        return o1.getEventId().compareTo(o2.getEventId());
    });/*from  www  . j  a  va  2s  .c  o m*/

    boolean done = false;

    Date timeoutsAt = new Date(System.currentTimeMillis() + 60000L * ctx.getTimeoutMins());

    do {
        boolean timedOut = !timeoutsAt.after(new Date(System.currentTimeMillis()));

        if (timedOut)
            throw new IllegalStateException("Timed Out");

        {
            final DescribeStackEventsRequest req = new DescribeStackEventsRequest()
                    .withStackName(ctx.getStackId());
            String nextToken = null;

            do {
                req.withNextToken(nextToken);

                Optional<DescribeStackEventsResult> stackEvents = getDescribeStackEventsResult(req);

                if (!stackEvents.isPresent()) {
                    return;
                } else {
                    for (StackEvent e : stackEvents.get().getStackEvents()) {
                        if (!events.contains(e)) {
                            ctx.getNotifier().info("" + e);

                            events.add(e);
                        }
                    }
                }

            } while (null != nextToken);
        }

        {
            final DescribeStacksResult stacks = ctx.getClient()
                    .describeStacks(new DescribeStacksRequest().withStackName(ctx.getStackId()));

            Optional<Stack> foundStack = stacks.getStacks().stream().filter(
                    stack -> ctx.getStatusesToMatch().contains(StackStatus.fromValue(stack.getStackStatus())))
                    .findFirst();

            done = foundStack.isPresent();
        }

        if (!done) {
            Thread.sleep(15000);
        }

    } while (!done);
}

---

From source file:com.carrotgarden.maven.aws.cfn.CarrotCloudForm.java

License:BSD License

private void printStackEvents() {

    final DescribeStackEventsRequest request = new DescribeStackEventsRequest();

    request.withStackName(name);/*w  w  w.j  a  v a  2 s  .  c  om*/

    final DescribeStackEventsResult describeStackEvents = amazonClient.describeStackEvents(request);

    final List<StackEvent> stackEvents = describeStackEvents.getStackEvents();

    Collections.reverse(stackEvents);

    logger.info("stack events:");

    for (final StackEvent event : stackEvents) {

        final StringBuilder text = new StringBuilder(128);

        text.append("\n\t");
        text.append("time=");
        text.append(event.getTimestamp());

        text.append("\n\t");
        text.append("id=");
        text.append(event.getEventId());

        text.append("\n\t");
        text.append("type=");
        text.append(event.getResourceType());

        text.append("\n\t");
        text.append("status=");
        text.append(event.getResourceStatus());

        text.append("\n\t");
        text.append("reason=");
        text.append(event.getResourceStatusReason());

        logger.info("event {}", text);

    }

}

---

From source file:com.deploymentio.cfnstacker.CloudFormationClient.java

License:Apache License

/**
 * Gets all non-progress events for stack that were generated after a
 * certain time. This method will ignore any "throttling" error from AWS and
 * return empty results.//w  w w .ja  v a  2  s.com
 * 
 * @param stackId unique ID for the stack
 * @param startDate only events after this time are considered
 * @return a list of stack events
 */
public List<StackEvent> getStackEvents(String stackId, Date startDate, OperationTracker tracker,
        int checkIntervalSeconds) {

    ArrayList<StackEvent> events = new ArrayList<StackEvent>();
    DescribeStackEventsResult result = null;
    String nextToken = null;

    doLoop: do {
        try {
            result = client.describeStackEvents(new DescribeStackEventsRequest().withStackName(stackId));
        } catch (AmazonServiceException ase) {
            if ("Throttling".equals(ase.getErrorCode())) {
                logger.warn("Got a throttling error from AWS while calling describeStackEvents()");
                break;
            } else {
                throw ase;
            }
        }
        nextToken = result.getNextToken();

        for (StackEvent evt : result.getStackEvents()) {

            // break out if we start seeing events older than our start date
            if (!evt.getTimestamp().after(startDate)) {
                if (logger.isTraceEnabled()) {
                    logger.trace(createStackEventLogMessage(evt, startDate, "Saw event older than startdate"));
                }
                break doLoop;
            }

            // mark that an event was generated
            if (tracker != null) {
                tracker.markEventsGenerated(stackId);
            }

            // ignore IN_PROGRESS events
            if (!evt.getResourceStatus().endsWith("_IN_PROGRESS")) {
                if (logger.isTraceEnabled()) {
                    logger.trace(createStackEventLogMessage(evt, startDate, "Adding event"));
                }
                events.add(evt);
            } else {
                if (logger.isTraceEnabled()) {
                    logger.trace(createStackEventLogMessage(evt, startDate, "Ignorning event"));
                }
            }

            // start tracking a sub-stack if we come across one
            if (tracker != null && evt.getResourceType().equals("AWS::CloudFormation::Stack")
                    && !evt.getPhysicalResourceId().equals(stackId)) {
                tracker.track(this, evt.getLogicalResourceId(), evt.getPhysicalResourceId(),
                        checkIntervalSeconds);
            }
        }

    } while (!StringUtils.isEmpty(nextToken));

    // sort the events
    Collections.sort(events, new Comparator<StackEvent>() {
        @Override
        public int compare(StackEvent e1, StackEvent e2) {
            return e1.getTimestamp().compareTo(e2.getTimestamp());
        }
    });

    return events;
}

---

From source file:com.mweagle.tereus.aws.CloudFormation.java

License:Open Source License

protected List<StackEvent> getStackEvents(final AmazonCloudFormationAsyncClient awsClient,
        final String stackName, Logger logger) throws Exception {
    List<StackEvent> events = new ArrayList<StackEvent>();
    Optional<String> token = Optional.empty();

    final DescribeStackEventsRequest describeRequest = new DescribeStackEventsRequest();
    describeRequest.setStackName(stackName);
    do {//from w ww.j a  va  2 s  .c  o  m
        if (token.isPresent()) {
            describeRequest.setNextToken(token.get());
        }
        final Future<DescribeStackEventsResult> stackEvents = awsClient
                .describeStackEventsAsync(describeRequest);
        DescribeStackEventsResult eventResult = stackEvents.get();
        events.addAll(eventResult.getStackEvents());
        token = Optional.ofNullable(eventResult.getNextToken());
    } while (token.isPresent());
    return events;
}

---

From source file:com.mweagle.tereus.aws.CloudFormation.java

License:Open Source License

protected Optional<DescribeStacksResult> waitForStackComplete(final AmazonCloudFormationAsyncClient awsClient,
        final String stackName, List<StackEvent> priorEvents, Logger logger) throws Exception {
    Map<String, StackEvent> eventHistory = new HashMap<>();
    for (StackEvent eachEvent : priorEvents) {
        eventHistory.put(eachEvent.getEventId(), eachEvent);
    }//from  w w  w .  j  av  a2  s  . co  m
    Optional<StackEvent> terminationEvent = Optional.empty();

    final Predicate<StackEvent> isNewEvent = event -> {
        return !eventHistory.containsKey(event.getEventId());
    };

    final Predicate<StackEvent> isTerminalEvent = stackEvent -> {
        return (CloudFormation.TERMINAL_EVENTS.contains(stackEvent.getResourceStatus())
                && stackEvent.getResourceType().equals("AWS::CloudFormation::Stack"));
    };

    // Query for events
    final DescribeStackEventsRequest describeRequest = new DescribeStackEventsRequest();
    describeRequest.setStackName(stackName);
    while (!terminationEvent.isPresent()) {
        logger.debug("Waiting for StackEvents");
        Thread.sleep(20 * 1000);

        final List<StackEvent> events = getStackEvents(awsClient, stackName, logger);

        // Get all the events we haven't seen, log and mark them
        events.stream().filter(isNewEvent).forEach(item -> {
            logger.info(item.toString());
            eventHistory.put(item.getEventId(), item);
        });

        // Find the first terminal event
        terminationEvent = events.stream().filter(isTerminalEvent).findFirst();
    }

    // Don't ever delete anything, unless the initial event set length was empty, implying
    // a creation event
    if (priorEvents.size() <= 0 && terminationEvent.get().getResourceStatus().contains("_FAILED")) {
        logger.warn("Stack creation . Deleting stack.");
        final DeleteStackRequest deleteStackRequest = new DeleteStackRequest();
        deleteStackRequest.setStackName(stackName);
        awsClient.deleteStack(deleteStackRequest);
        return Optional.empty();
    } else {
        // Looks good, let's get the final output for the stack...
        return describeStack(awsClient, stackName, logger);
    }
}

---

From source file:com.netflix.spinnaker.clouddriver.aws.provider.agent.AmazonCloudFormationCachingAgent.java

License:Apache License

@Override
public CacheResult loadData(ProviderCache providerCache) {
    log.info("Describing items in {}", getAgentType());
    AmazonCloudFormation cloudformation = amazonClientProvider.getAmazonCloudFormation(account, region);

    Collection<CacheData> stackCacheData = new ArrayList<>();

    try {//from   w  ww.  ja v a  2 s  . co m
        List<Stack> stacks = cloudformation.describeStacks().getStacks();

        for (Stack stack : stacks) {
            Map<String, Object> stackAttributes = new HashMap<>();
            stackAttributes.put("stackId", stack.getStackId());
            stackAttributes.put("tags",
                    stack.getTags().stream().collect(Collectors.toMap(Tag::getKey, Tag::getValue)));
            stackAttributes.put("outputs", stack.getOutputs().stream()
                    .collect(Collectors.toMap(Output::getOutputKey, Output::getOutputValue)));
            stackAttributes.put("stackName", stack.getStackName());
            stackAttributes.put("region", region);
            stackAttributes.put("accountName", account.getName());
            stackAttributes.put("accountId", account.getAccountId());
            stackAttributes.put("stackStatus", stack.getStackStatus());
            stackAttributes.put("creationTime", stack.getCreationTime());

            if (stack.getStackStatus().equals("ROLLBACK_COMPLETE")) {
                DescribeStackEventsRequest request = new DescribeStackEventsRequest()
                        .withStackName(stack.getStackName());
                cloudformation.describeStackEvents(request).getStackEvents().stream()
                        .filter(e -> e.getResourceStatus().equals("CREATE_FAILED")).findFirst()
                        .map(StackEvent::getResourceStatusReason)
                        .map(statusReason -> stackAttributes.put("stackStatusReason", statusReason));
            }
            String stackCacheKey = Keys.getCloudFormationKey(stack.getStackId(), region, account.getName());
            Map<String, Collection<String>> relationships = new HashMap<>();
            relationships.put(STACKS.getNs(), Collections.singletonList(stackCacheKey));
            stackCacheData.add(new DefaultCacheData(stackCacheKey, stackAttributes, relationships));
        }
    } catch (AmazonCloudFormationException e) {
        log.error("Error retrieving stacks", e);
    }

    log.info("Caching {} items in {}", stackCacheData.size(), getAgentType());
    HashMap<String, Collection<CacheData>> result = new HashMap<>();
    result.put(STACKS.getNs(), stackCacheData);
    return new DefaultCacheResult(result);
}

---

From source file:com.nike.cerberus.service.CloudFormationService.java

License:Apache License

/**
 * Returns the events for a named stack.
 *
 * @param stackId Stack ID.//from  ww w  .  j av a 2s .  co  m
 * @return Collection of events
 */
public List<StackEvent> getStackEvents(final String stackId) {
    final DescribeStackEventsRequest request = new DescribeStackEventsRequest().withStackName(stackId);

    try {
        final DescribeStackEventsResult result = cloudFormationClient.describeStackEvents(request);
        return result.getStackEvents();
    } catch (final AmazonServiceException ase) {
        // Stack doesn't exist, just return with no status
        if (ase.getStatusCode() != 400) {
            throw ase;
        }
    }

    return Collections.emptyList();
}

---

From source file:de.taimos.pipeline.aws.cloudformation.EventPrinter.java

License:Apache License

private void waitAndPrintEvents(String stack, long pollIntervalMillis,
        BasicFuture<AmazonWebServiceRequest> waitResult) throws ExecutionException {
    Date startDate = new Date();
    String lastEventId = null;//from w w  w  .  j  a  v a2  s .c  om
    this.printLine();
    this.printStackName(stack);
    this.printLine();

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    if (pollIntervalMillis > 0) {
        while (!waitResult.isDone()) {
            try {
                DescribeStackEventsResult result = this.client
                        .describeStackEvents(new DescribeStackEventsRequest().withStackName(stack));
                List<StackEvent> stackEvents = new ArrayList<>();
                for (StackEvent event : result.getStackEvents()) {
                    if (event.getEventId().equals(lastEventId) || event.getTimestamp().before(startDate)) {
                        break;
                    }
                    stackEvents.add(event);
                }
                if (!stackEvents.isEmpty()) {
                    Collections.reverse(stackEvents);
                    for (StackEvent event : stackEvents) {
                        this.printEvent(sdf, event);
                        this.printLine();
                    }
                    lastEventId = stackEvents.get(stackEvents.size() - 1).getEventId();
                }
            } catch (AmazonCloudFormationException e) {
                // suppress and continue
            }
            try {
                Thread.sleep(pollIntervalMillis);
            } catch (InterruptedException e) {
                // suppress and continue
            }
        }
    }

    try {
        waitResult.get();
    } catch (InterruptedException e) {
        this.listener.getLogger().format("Failed to wait for CFN action to complete: %s", e.getMessage());
    }
}

---

From source file:io.konig.maven.CreateCloudFormationStackAction.java

License:Apache License

private List<Output> getOutputForRequest(String stackName, AmazonCloudFormation client)
        throws InterruptedException, StackCreationException {
    int tried = 0;
    String maxTime = System.getProperty("stackMaxTime");
    while (tried < (maxTime == null ? 1800 : Integer.parseInt(maxTime))) {
        DescribeStacksRequest describeStacksRequest = new DescribeStacksRequest();
        describeStacksRequest.withStackName(stackName);
        Stack resultStack = client.describeStacks(describeStacksRequest).getStacks().get(0);
        StackStatus stackStatus = StackStatus.valueOf(resultStack.getStackStatus());
        if (("CREATE_COMPLETE").equals(stackStatus.toString())) {
            return resultStack.getOutputs();
        } else if (stackStatus.toString().endsWith("IN_PROGRESS")) {
            Thread.sleep(10000);//from w w w. j a  v  a2s . c o  m
        } else {
            DescribeStackEventsRequest describeStackEventsRequest = new DescribeStackEventsRequest();
            describeStackEventsRequest.withStackName(stackName);
            List<StackEvent> stackEvents = client.describeStackEvents(describeStackEventsRequest)
                    .getStackEvents();
            List<StackEvent> errorEvents = new ArrayList<StackEvent>();
            for (StackEvent stackEvent : stackEvents) {
                if (stackEvent.getResourceStatus().equals("CREATE_FAILED")) {
                    errorEvents.add(stackEvent);
                }
            }
            throw new StackCreationException(errorEvents.toString());
        }
        tried++;
    }
    throw new RuntimeException("stack creation/deletion timed out");
}

---

From source file:jetbrains.buildServer.runner.cloudformation.AWSClient.java

License:Apache License

public List<String> describeStackEvents(AmazonCloudFormationClient stackbuilder, String stackName,
        String ACTION) {/* w ww . j a  va2s .com*/
    List<String> output = new ArrayList<String>();
    DescribeStackEventsRequest request = new DescribeStackEventsRequest();
    request.setStackName(stackName);
    DescribeStackEventsResult results = stackbuilder.describeStackEvents(request);
    for (StackEvent event : results.getStackEvents()) {
        if (event.getEventId().contains(ACTION)) {

            output.add(event.getEventId());
            // myListener.debugLog(event.toString());
        }
    }
    return output;
}

---

• «
• 1
• 2
• »