@Bean
public AmazonCloudFormation amazonCloudFormationClient(final AWSCredentialsProvider awsCredentialsProvider,final ClientConfiguration awsClientConfig,final Region awsRegion) {
    return AmazonCloudFormationClientBuilder.standard()
        .withCredentials(awsCredentialsProvider)
        .withClientConfiguration(awsClientConfig)
        .withRegion(awsRegion.getName())
        .build();
}

private void createAmazonapiclients() {
       cfnClient = AmazonCloudFormationClientBuilder.defaultClient();
       ec2Client = AmazonEC2ClientBuilder.defaultClient();
       snsClient = AmazonSNSClientBuilder.defaultClient();
       sqsClient = AmazonSQSClientBuilder.defaultClient();
       elbClient = AmazonElasticLoadBalancingClientBuilder.defaultClient();
       s3Client = AmazonS3ClientBuilder.defaultClient();
       rdsClient = AmazonRDSClientBuilder.defaultClient();
       iamClient = AmazonIdentityManagementClientBuilder.defaultClient();
}

public DeployService(SamConfig config) {
    this(config,config.getAwsClientFactory().create(AmazonCloudFormationClientBuilder.standard()));
}

public static AmazonCloudFormation createCFNClient() {
       return AmazonCloudFormationClientBuilder.defaultClient();
}

public CloudFrontLogEventHandler(AmazonCloudFormationClient cloudFormationClient,AmazonS3Client amazonS3Client,AWSWAF awsWaf) {

    cloudFormationClient.setRegion(Region.getRegion(Regions.US_WEST_2));
    this.amazonS3Client = amazonS3Client;
    objectMapper = new ObjectMapper();
    objectMapper.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);

    // New processors would need there own ip sets as there is a hard limit of 1000 ips and the
    // RateLimitingProcessor truncates the set and removes any ips from the set that it doesn't kNow about
    // see CloudFormationDefinedParams
    logEventProcessors.add(new RateLimitingProcessor(objectMapper,awsWaf,amazonS3Client));
    logEventProcessors.add(new GoogleAnalyticsKPIProcessor());
    logEventProcessors.add(new TlsverificationProcessor());
}

@Inject
public CreateCloudFrontSecurityGroupUpdaterLambdaOperation(final CloudFormationService cloudFormationService,final EnvironmentMetadata environmentMetadata,@Named(CF_OBJECT_MAPPER) final ObjectMapper cloudformationObjectMapper,AWSLambda awsLambda,AmazonS3 amazonS3) {

    this.cloudFormationService = cloudFormationService;
    this.cloudformationObjectMapper = cloudformationObjectMapper;
    this.environmentMetadata = environmentMetadata;
    this.awsLambda = awsLambda;
    this.amazonS3 = amazonS3;

    final Region region = Region.getRegion(Regions.US_EAST_1);
    AmazonCloudFormation amazonCloudFormation = new AmazonCloudFormationClient();
    amazonCloudFormation.setRegion(region);
    amazonSNS = new AmazonSNSClient();
    amazonSNS.setRegion(region);
}

public CfSignalResourceBundle() {
  cloudFormationsupplier = (cfSignalResourceConfig) -> {
    AmazonCloudFormation amazonCloudFormation = internalCloudFormation.get();

    if (amazonCloudFormation != null) {
      return amazonCloudFormation;
    }

    return internalCloudFormation.updateAndGet((unused) -> {

      AmazonCloudFormationClient amazonCloudFormationClient = new AmazonCloudFormationClient();

      String awsRegion = cfSignalResourceConfig.getAwsRegion();
      Region region;
      if (Strings.isNullOrEmpty(awsRegion)) {
        region = Regions.getCurrentRegion();
      }
      else {
        region = Region.getRegion(Regions.fromName(awsRegion));
      }
      amazonCloudFormationClient.setRegion(region);

      return amazonCloudFormationClient;
    });
  };
}

@Test
public void parseInternal_stackConfigurationWithExternallyConfiguredCloudFormationClient_returnsConfiguredStackWithExternallyConfiguredClient() throws Exception {
    //Arrange
    DefaultListablebeanfactory beanfactory = new DefaultListablebeanfactory();
    XmlBeanDeFinitionReader reader = new XmlBeanDeFinitionReader(beanfactory);

    reader.loadBeanDeFinitions(new ClassPathResource(getClass().getSimpleName() + "-withCustomCloudFormationClient.xml",getClass()));

    AmazonCloudFormation amazonCloudFormationMock = beanfactory.getBean(AmazonCloudFormation.class);
    when(amazonCloudFormationMock.listStackResources(new ListStackResourcesRequest().withStackName("test"))).
            thenReturn(new ListStackResourcesResult().withStackResourceSummaries(new StackResourceSummary()));
    when(amazonCloudFormationMock.describeStacks(new DescribeStacksRequest().withStackName("test"))).
            thenReturn(new DescribeStacksResult().withStacks(new Stack()));


    //Act
    StackResourceRegistry stackResourceRegistry = beanfactory.getBean(StackResourceRegistry.class);

    //Assert
    assertNotNull(stackResourceRegistry);
    assertFalse(beanfactory.containsBeanDeFinition(getBeanName(AmazonCloudFormationClient.class.getName())));
    verify(amazonCloudFormationMock,times(1)).listStackResources(new ListStackResourcesRequest().withStackName("test"));
    beanfactory.getBean("customStackTags");
    verify(amazonCloudFormationMock,times(1)).describeStacks(new DescribeStacksRequest().withStackName("test"));
}

private List<CloudResource> getCloudResources(AuthenticatedContext ac,CloudStack stack,String cFStackName,AmazonCloudFormationClient client,AmazonEC2Client amazonEC2Client,AmazonAutoScalingClient amazonASClient,boolean mapPublicIpOnLaunch) {
    List<CloudResource> cloudResources = new ArrayList<>();
    AmazonCloudFormationClient cloudFormationClient = awsClient.createCloudFormationClient(new AwsCredentialView(ac.getCloudCredential()),ac.getCloudContext().getLocation().getRegion().value());
    scheduleStatusChecks(stack,ac,cloudFormationClient);
    suspendAutoScaling(ac,stack);
    if (mapPublicIpOnLaunch) {
        Map<String,String> eipAllocationIds = getElasticIpAllocationIds(cFStackName,client);
        List<Group> gateways = getGatewayGroups(stack.getGroups());
        for (Group gateway : gateways) {
            List<String> eips = getEipsForGatewayGroup(eipAllocationIds,gateway);
            List<String> instanceIds = getInstancesForGroup(ac,amazonASClient,client,gateway);
            associateElasticIpsToInstances(amazonEC2Client,eips,instanceIds);
        }
    }
    return cloudResources;
}

private void scheduleStatusChecks(CloudStack stack,AuthenticatedContext ac,AmazonCloudFormationClient cloudFormationClient) {
    for (Group group : stack.getGroups()) {
        String asGroupName = cfStackUtil.getAutoscalingGroupName(ac,cloudFormationClient,group.getName());
        LOGGER.info("Polling Auto Scaling group until new instances are ready. [stack: {},asGroup: {}]",ac.getCloudContext().getId(),asGroupName);
        PollTask<Boolean> task = awsPollTaskFactory.newASGroupStatusCheckerTask(ac,asGroupName,group.getInstancesSize(),awsClient,cfStackUtil);
        try {
            Boolean statePollerResult = task.call();
            if (!task.completed(statePollerResult)) {
                syncPollingScheduler.schedule(task);
            }
        } catch (Exception e) {
            throw new CloudConnectorException(e.getMessage(),e);
        }
    }
}

@Override
public List<CloudVmMetaDataStatus> collect(AuthenticatedContext ac,List<CloudResource> resources,List<CloudInstance> vms) {
    List<CloudVmMetaDataStatus> cloudVmMetaDataStatuses = new ArrayList<>();
    try {
        String region = ac.getCloudContext().getLocation().getRegion().value();
        AmazonCloudFormationClient amazonCFClient =
                awsClient.createCloudFormationClient(new AwsCredentialView(ac.getCloudCredential()),region);
        AmazonAutoScalingClient amazonASClient =
                awsClient.createAutoScalingClient(new AwsCredentialView(ac.getCloudCredential()),region);
        AmazonEC2Client amazonEC2Client =
                awsClient.createAccess(new AwsCredentialView(ac.getCloudCredential()),region);

        //contains all instances
        ListMultimap<String,CloudInstance> groupByInstanceGroup = groupByInstanceGroup(vms);

        for (String key : groupByInstanceGroup.keySet()) {
            List<CloudInstance> cloudInstances = groupByInstanceGroup.get(key);
            cloudVmMetaDataStatuses.addAll(collectGroupMetaData(ac,amazonEC2Client,amazonCFClient,key,cloudInstances));
        }

        return cloudVmMetaDataStatuses;
    } catch (RuntimeException e) {
        throw new CloudConnectorException(e.getMessage(),e);
    }
}

private List<Output> getoutputForRequest(String vpcStackName,AmazonCloudFormationClient client) {
    int tried = 0;
    while (tried < MAX_TRY) {
        LOGGER.info("checking vpc stack creation result,tried: " + tried + '/' + MAX_TRY);
        DescribeStacksRequest describeStacksRequest = new DescribeStacksRequest();
        describeStacksRequest.withStackName(vpcStackName);
        Stack resultStack = client.describeStacks(describeStacksRequest).getStacks().get(0);
        StackStatus stackStatus = StackStatus.valueOf(resultStack.getStackStatus());
        if (Failed_STATUSES.contains(stackStatus)) {
            LOGGER.error("stack creation Failed: ",stackStatus);
            throw new RuntimeException();
        } else if (CREATE_COMPLETE.equals(stackStatus)) {
            return resultStack.getoutputs();
        }
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            LOGGER.error("thread sleep interrupted",e);
        }
        tried++;
    }
    throw new RuntimeException("vpc creation timed out");
}

/**
 * Binds all the Amazon services used.
 */
@Override
protected void configure() {
    final Region region = Region.getRegion(Regions.fromName(regionName));
    bind(AmazonEC2.class).toInstance(createAmazonClientInstance(AmazonEC2Client.class,region));
    bind(AmazonCloudFormation.class).toInstance(createAmazonClientInstance(AmazonCloudFormationClient.class,region));
    bind(AmazonIdentityManagement.class).toInstance(createAmazonClientInstance(AmazonIdentityManagementClient.class,region));
    bind(AWSKMS.class).toInstance(createAmazonClientInstance(AWSKMSClient.class,region));
    bind(AmazonS3.class).toInstance(createAmazonClientInstance(AmazonS3Client.class,region));
    bind(AmazonAutoScaling.class).toInstance(createAmazonClientInstance(AmazonAutoScalingClient.class,region));
    bind(AWSSecurityTokenService.class).toInstance(createAmazonClientInstance(AWSSecurityTokenServiceClient.class,region));
    bind(AWSLambda.class).toInstance(createAmazonClientInstance(AWSLambdaClient.class,region));
    bind(AmazonSNS.class).toInstance(createAmazonClientInstance(AmazonSNSClient.class,region));
}

protected AmazonCloudFormationClient getCloudFormationClient() {
    if (null != cloudformationClient) {
        return cloudformationClient;
    }

    return cloudformationClient = new AmazonCloudFormationClient(getAWSCredentialsProvideChain()).withRegion(Region.getRegion(Regions.fromName(deployment.getRegion())));
}

@Test
public void parseInternal_withCustomregion_shouldConfigureDefaultClientWithCustomregion() throws Exception {
    //Arrange
    DefaultListablebeanfactory registry = new DefaultListablebeanfactory();
    XmlBeanDeFinitionReader reader = new XmlBeanDeFinitionReader(registry);

    //Act
    reader.loadBeanDeFinitions(new ClassPathResource(getClass().getSimpleName() + "-custom-region.xml",getClass()));

    // Assert
    AmazonCloudFormationClient amazonCloudFormation = registry.getBean(AmazonCloudFormationClient.class);
    assertEquals("https://" + Region.getRegion(Regions.SA_EAST_1).getServiceEndpoint("cloudformation"),ReflectionTestUtils.getField(amazonCloudFormation,"endpoint").toString());
}

@Test
public void parseInternal_withCustomregionProvider_shouldConfigureDefaultClientWithCustomregionReturnedByProvider() throws Exception {
    //Arrange
    DefaultListablebeanfactory registry = new DefaultListablebeanfactory();
    XmlBeanDeFinitionReader reader = new XmlBeanDeFinitionReader(registry);

    //Act
    reader.loadBeanDeFinitions(new ClassPathResource(getClass().getSimpleName() + "-custom-region-provider.xml",getClass()));

    // Assert
    AmazonCloudFormationClient amazonCloudFormation = registry.getBean(AmazonCloudFormationClient.class);
    assertEquals("https://" + Region.getRegion(Regions.AP_SOUTHEAST_2).getServiceEndpoint("cloudformation"),"endpoint").toString());
}

public void execute() {
    checkParams();
    AmazonCloudFormationClient client = getorCreateClient(AmazonCloudFormationClient.class);
    UpdateStackRequest request = new UpdateStackRequest()
            .withStackName(stackName).withStackPolicyBody(stackPolicyBody)
            .withStackPolicyURL(stackPolicyURL)
            .withTemplateBody(templateBody).withTemplateURL(templateURL)
            .withStackPolicyDuringUpdateBody(stackPolicyDuringUpdateBody)
            .withStackPolicyDuringUpdateURL(stackPolicyDuringUpdateURL)
            .withUsePrevIoUstemplate(usePrevIoUstemplate);

    if (capabilities.size() > 0) {
        request.setCapabilities(capabilities);
    }
    if (parameters.size() > 0) {
        request.setParameters(parameters);
    }
    if (notificationArns.size() > 0) {
        request.setNotificationARNs(notificationArns);
    }

    try {
        client.updateStack(request);
        System.out.println("Update stack " + stackName
                + " request submitted.");
    } catch (Exception e) {
        throw new BuildException("Could not update stack: "
                + e.getMessage(),e);
    }
}

public void execute() {
    checkParams();
    AmazonCloudFormationClient client = getorCreateClient(AmazonCloudFormationClient.class);
    CreateStackRequest createStackRequest = new CreateStackRequest()
            .withdisableRollback(disableRollback).withOnFailure(onFailure)
            .withStackName(stackName).withStackPolicyBody(stackPolicyBody)
            .withStackPolicyURL(stackPolicyURL)
            .withTemplateBody(templateBody).withTemplateURL(templateURL)
            .withTimeoutInMinutes(timeoutInMinutes);

    if (capabilities.size() > 0) {
        createStackRequest.setCapabilities(capabilities);
    }
    if (parameters.size() > 0) {
        createStackRequest.setParameters(parameters);
    }
    if (tags.size() > 0) {
        createStackRequest.setTags(tags);
    }
    try {
        client.createStack(createStackRequest);
        System.out.println("Create stack " + stackName
                + " request submitted.");
        if(waitForCreation) {
            WaitForStackToReachStateTask.waitForCloudFormationStackToReachStatus(client,stackName,CREATE_COMPLETE);
        }
    } catch (Exception e) {
        throw new BuildException(
                "Could not create stack " + e.getMessage(),e);
    }
}

public void execute() {
    checkParams();
    AmazonCloudFormationClient client = getorCreateClient(AmazonCloudFormationClient.class);
    SetStackPolicyRequest setStackPolicyRequest = new SetStackPolicyRequest()
            .withStackName(stackName).withStackPolicyBody(stackPolicyBody)
            .withStackPolicyURL(stackPolicyURL);
    try {
        client.setStackPolicy(setStackPolicyRequest);
        System.out.println("Successfully set stack policy");
    } catch (Exception e) {
        throw new BuildException("Could not set the stack policy "
                + e.getMessage(),e);
    }
}

public void execute() {
    checkParams();
    AmazonCloudFormationClient client = getorCreateClient(AmazonCloudFormationClient.class);
    if (!waitForCloudFormationStackToReachStatus(client,status)) {
        throw new BuildException("The stack update or creation Failed");
    }
}

public static boolean waitForCloudFormationStackToReachStatus(
        AmazonCloudFormationClient client,String stackName,String status) {
    int count = 0;
    while (true) {
        if (count++ == 100) {
            System.out
                    .println(stackName + " never reached state " + status);
            return false;
        }
        try {
            Thread.sleep(1000 * 30);
        } catch (InterruptedException e) {
            System.out.println(e.getMessage());
            return false;
        }
        String stackStatus = client
                .describeStacks(
                        new DescribeStacksRequest()
                                .withStackName(stackName)).getStacks()
                .get(0).getStackStatus();
        if (stackStatus.equals(status)) {
            return true;
        } else if (stackStatus.contains(Failed)) {
            System.out.println("The process Failed with status " + stackStatus);
            return false;
        }
        System.out.println(stackName + " is in status " + stackStatus);
    }
}

@BeforeClass
public static void setUp() {
    client = new AmazonCloudFormationClient();
    project = new Project();
    SetUpCloudFormationTestsTask setUpTask = new SetUpCloudFormationTestsTask();
    setUpTask.setProject(project);
    setUpTask.execute();
}

public void execute() {
    checkParams();
    AmazonEC2Client ec2Client = getorCreateClient(AmazonEC2Client.class);
    ec2Client
            .deleteKeyPair(new DeleteKeyPairRequest().withKeyName(keyName));
    AmazonCloudFormationClient cloudFormationClient = getorCreateClient(AmazonCloudFormationClient.class);
    cloudFormationClient.deleteStack(new DeleteStackRequest()
            .withStackName(stackName));
}

private void saveS3AccessRoleArn(AuthenticatedContext ac,PersistenceNotifier resourceNotifier) {
    AwsInstanceProfileView awsInstanceProfileView = new AwsInstanceProfileView(stack);
    if (awsInstanceProfileView.isEnableInstanceProfileStrategy() && !awsInstanceProfileView.isinstanceProfileAvailable()) {
        String s3AccessRoleArn = getCreatedS3AccessRoleArn(cFStackName,client);
        CloudResource s3AccessRoleArnCloudResource = new Builder().type(ResourceType.S3_ACCESS_ROLE_ARN).name(s3AccessRoleArn).build();
        resourceNotifier.notifyAllocation(s3AccessRoleArnCloudResource,ac.getCloudContext());
    }
}

private String getCreatedVpc(String cFStackName,AmazonCloudFormationClient client) {
    Map<String,String> outputs = getoutputs(cFStackName,client);
    if (outputs.containsKey(CREATED_VPC)) {
        return outputs.get(CREATED_VPC);
    } else {
        String outputKeyNotFound = String.format("Vpc Could not be found in the Cloudformation stack('%s') output.",cFStackName);
        throw new CloudConnectorException(outputKeyNotFound);
    }
}

private String getCreatedsubnet(String cFStackName,client);
    if (outputs.containsKey(CREATED_subnet)) {
        return outputs.get(CREATED_subnet);
    } else {
        String outputKeyNotFound = String.format("subnet Could not be found in the Cloudformation stack('%s') output.",cFStackName);
        throw new CloudConnectorException(outputKeyNotFound);
    }
}

private String getCreatedS3AccessRoleArn(String cFStackName,client);
    if (outputs.containsKey(S3_ACCESS_ROLE)) {
        return outputs.get(S3_ACCESS_ROLE);
    } else {
        String outputKeyNotFound = String.format("S3AccessRole arn Could not be found in the Cloudformation stack('%s') output.",cFStackName);
        throw new CloudConnectorException(outputKeyNotFound);
    }
}

private Map<String,String> getElasticIpAllocationIds(String cFStackName,client);
    Map<String,String> elasticIpIds = outputs.entrySet().stream().filter(e -> e.getKey().startsWith(CFS_OUTPUT_EIPALLOCATION_ID))
            .collect(Collectors.toMap(e -> e.getKey(),e -> e.getValue()));
    if (!elasticIpIds.isEmpty()) {
        return elasticIpIds;
    } else {
        String outputKeyNotFound = String.format("Allocation Id of Elastic IP Could not be found in the Cloudformation stack('%s') output.",String> getoutputs(String cFStackName,AmazonCloudFormationClient client) {
    DescribeStacksRequest describeStacksRequest = new DescribeStacksRequest().withStackName(cFStackName);
    String outputNotFound = String.format("Couldn't get Cloudformation stack's('%s') output",cFStackName);
    List<Output> cfStackOutputs = client.describeStacks(describeStacksRequest).getStacks()
            .stream().findFirst().orElseThrow(getCloudConnectorExceptionsupplier(outputNotFound)).getoutputs();
    return cfStackOutputs.stream().collect(Collectors.toMap(Output::getoutputKey,Output::getoutputValue));
}

public String getAutoscalingGroupName(AuthenticatedContext ac,AmazonCloudFormationClient amazonCFClient,String instanceGroup) {
    String cFStackName = getCfStackName(ac);
    DescribeStackResourceResult asGroupResource = amazonCFClient.describeStackResource(new DescribeStackResourceRequest()
            .withStackName(cFStackName)
            .withLogicalResourceId(String.format("AmbariNodes%s",instanceGroup.replaceAll("_",""))));
    return asGroupResource.getStackResourceDetail().getPhysicalResourceId();
}

public AmazonCloudFormationClient createCloudFormationClient(AwsCredentialView awsCredential,String regionName) {
    AmazonCloudFormationClient client = isRoleAssumerequired(awsCredential)
            ? new AmazonCloudFormationClient(credentialClient.retrieveCachedSessionCredentials(awsCredential))
            : new AmazonCloudFormationClient(createAwsCredentials(awsCredential));
    client.setRegion(RegionUtils.getRegion(regionName));
    return client;
}

private List<CloudVmMetaDataStatus> collectGroupMetaData(AuthenticatedContext ac,String groupName,List<CloudInstance> cloudInstances) {

    List<CloudVmMetaDataStatus> cloudVmMetaDataStatuses = new ArrayList<>();

    String asGroupName = cloudFormationStackUtil.getAutoscalingGroupName(ac,groupName);
    List<String> instanceIds = cloudFormationStackUtil.getInstanceIds(amazonASClient,asGroupName);

    DescribeInstancesRequest instancesRequest = cloudFormationStackUtil.createDescribeInstancesRequest(instanceIds);
    DescribeInstancesResult instancesResult = amazonEC2Client.describeInstances(instancesRequest);

    //contains instances with instanceId
    Map<String,CloudInstance> mapByInstanceId = mapByInstanceId(cloudInstances);

    //contains instances with privateId (without instanceId)
    Queue<CloudInstance> untrackedInstances = untrackedInstances(cloudInstances);

    for (Reservation reservation : instancesResult.getReservations()) {
        LOGGER.info("Number of instances found in reservation: {}",reservation.getInstances().size());
        for (Instance instance : reservation.getInstances()) {

            String instanceId = instance.getInstanceId();
            CloudInstance cloudInstance = ensureInstanceTag(mapByInstanceId,instance,instanceId,untrackedInstances,amazonEC2Client);
            if (cloudInstance != null) {
                CloudInstanceMetaData md = new CloudInstanceMetaData(instance.getPrivateIpAddress(),instance.getPublicIpAddress());
                CloudVmInstanceStatus cloudVmInstanceStatus = new CloudVmInstanceStatus(cloudInstance,InstanceStatus.CREATED);
                CloudVmMetaDataStatus cloudVmMetaDataStatus = new CloudVmMetaDataStatus(cloudVmInstanceStatus,md);
                cloudVmMetaDataStatuses.add(cloudVmMetaDataStatus);
            }
        }
    }

    return cloudVmMetaDataStatuses;
}

@Override
public void validate(AuthenticatedContext ac,CloudStack cloudStack) {
    AwsCredentialView credentialView = new AwsCredentialView(ac.getCloudCredential());
    String regionName = ac.getCloudContext().getLocation().getRegion().value();
    AmazonCloudFormationClient cfClient = awsClient.createCloudFormationClient(credentialView,regionName);
    String cFStackName = cfStackUtil.getCfStackName(ac);
    try {
        cfClient.describeStacks(new DescribeStacksRequest().withStackName(cFStackName));
        throw new CloudConnectorException(String.format("Stack is already exists with the given name: %s",cFStackName));
    } catch (AmazonServiceException ignored) {

    }
}

AbstractAwsstackStatusCheckerTask(AuthenticatedContext authenticatedContext,AmazonCloudFormationClient cfClient,StackStatus successstatus,StackStatus errorStatus,List<StackStatus> stackerrorStatuses,String cloudFormationStackName,boolean cancellable) {
    super(authenticatedContext,cancellable);
    this.cfClient = cfClient;
    this.successstatus = successstatus;
    this.errorStatus = errorStatus;
    this.stackerrorStatuses = stackerrorStatuses;
    this.cloudFormationStackName = cloudFormationStackName;

    describeStacksRequest = new DescribeStacksRequest().withStackName(cloudFormationStackName);
    stackEventsRequest = new DescribeStackEventsRequest().withStackName(cloudFormationStackName);
}

@AfterSuite
@Parameters({ "regionName","vpcStackName" })
public void deleteNetwork(String regionName,@Optional("it-vpc-stack") String vpcStackName) {
    AmazonCloudFormationClient client = new AmazonCloudFormationClient();
    client.setRegion(RegionUtils.getRegion(regionName));
    client.deleteStack(new DeleteStackRequest().withStackName(vpcStackName));
}

@Test
@Parameters({ "networkName","description","publicInAccount","regionName","vpcStackName","vpcName","existingsubnet" })
public void createNetwork(String networkName,@Optional("") String description,@Optional("false") boolean publicInAccount,String regionName,@Optional("it-vpc-stack") String vpcStackName,@Optional("it-vpc") String vpcName,boolean existingsubnet) {
    AmazonCloudFormationClient client = new AmazonCloudFormationClient();
    client.setRegion(RegionUtils.getRegion(regionName));

    Map<String,Object> networkMap = new HashMap<>();

    String vpcCreationjson = existingsubnet ?  "public_vpc_with_subnet.json" : "public_vpc_wihout_subnet.json";

    try (InputStream vpcJsonInputStream = getClass().getResourceAsstream("/cloudformation/" + vpcCreationjson)) {
        String vpcCFTemplateString = IoUtils.toString(vpcJsonInputStream);
        CreateStackRequest stackRequest = createStackRequest(vpcStackName,vpcName,vpcCFTemplateString);
        client.createStack(stackRequest);

        List<Output> outputForRequest = getoutputForRequest(vpcStackName,client);
        if (existingsubnet) {
            networkMap.put("vpcId",outputForRequest.get(0).getoutputValue());
            networkMap.put("subnetId",outputForRequest.get(1).getoutputValue());
        } else {
            networkMap.put("vpcId",outputForRequest.get(1).getoutputValue());
            networkMap.put("internetGatewayId",outputForRequest.get(0).getoutputValue());
        }
    } catch (IOException e) {
        LOGGER.error("can't read vpc cloudformation template file");
        throw new RuntimeException(e);
    }

    NetworkRequest networkRequest = new NetworkRequest();
    networkRequest.setName(networkName);
    networkRequest.setDescription(description);
    networkRequest.setParameters(networkMap);
    if (!existingsubnet) {
        networkRequest.setsubnetCIDR("10.0.0.0/24");
    }
    networkRequest.setCloudplatform("AWS");
    String id = getCloudbreakClient().networkEndpoint().postPrivate(networkRequest).getId().toString();
    getItContext().putContextParam(CloudbreakITContextConstants.NETWORK_ID,id,true);
}

public CloudFrontLogEventHandler() {
    this(new AmazonCloudFormationClient(),new AmazonS3Client(),new AWSWAFClient());
}

@Override
protected void before() throws Throwable {
    try {
        String awsCredentialsDir = System.getProperty("aws.credentials.path");
        File awsCredentialsFile = new File(awsCredentialsDir,"aws.credentials.properties");
        Properties awsCredentials = new Properties();
        awsCredentials.load(new FileReader(awsCredentialsFile));
        String accessKey = awsCredentials.getProperty("cloud.aws.credentials.accessKey");
        String secretKey = awsCredentials.getProperty("cloud.aws.credentials.secretKey");
        this.cloudFormation = new AmazonCloudFormationClient(new BasicAWSCredentials(accessKey,secretKey));

        YamlPropertiesfactorybean yamlPropertiesfactorybean = new YamlPropertiesfactorybean();
        yamlPropertiesfactorybean.setResources(new ClassPathResource("application.yml"));
        Properties applicationProperties = yamlPropertiesfactorybean.getobject();

        this.stackName = applicationProperties.getProperty("cloud.aws.stack.name");

        after();

        ClassPathResource stackTemplate = new ClassPathResource("AwsIntegrationTestTemplate.json");
        String templateBody = FilecopyUtils.copyToString(new InputStreamReader(stackTemplate.getInputStream()));

        this.cloudFormation.createStack(
                new CreateStackRequest()
                        .withTemplateBody(templateBody)
                        .withOnFailure(OnFailure.DELETE)
                        .withStackName(this.stackName));

        waitForCompletion();

        System.setProperty("cloud.aws.credentials.accessKey",accessKey);
        System.setProperty("cloud.aws.credentials.secretKey",secretKey);
    }
    catch (Exception e) {
        if (!(e instanceof AssumptionViolatedException)) {
            Assume.assumeTrue("Can't perform AWS integration test because of: " + e.getMessage(),false);
        }
        else {
            throw e;
        }
    }
}

protected AmazonCloudFormation amazonCloudFormationClient() {
    AmazonCloudFormation amazonCloudFormation = new AmazonCloudFormationClient(amazonCredentialsProvider());
    amazonCloudFormation.setRegion(getRegion());
    return amazonCloudFormation;
}

@Override
protected AmazonCloudFormation amazonCloudFormationClient() {
    AmazonCloudFormation amazonCloudFormation = new AmazonCloudFormationClient(awsCredentials());
    amazonCloudFormation.setRegion(getRegion());
    return amazonCloudFormation;
}

@Bean
@ConditionalOnMissingAmazonClient(AmazonCloudFormation.class)
public AmazonWebserviceClientfactorybean<AmazonCloudFormationClient> amazonCloudFormation() {
    return new AmazonWebserviceClientfactorybean<>(AmazonCloudFormationClient.class,this.credentialsProvider,this.regionProvider);
}

@Override
public List<CloudResourceStatus> launch(AuthenticatedContext ac,PersistenceNotifier resourceNotifier,AdjustmentType adjustmentType,Long threshold) throws Exception {
    createKeyPair(ac,stack);
    String cFStackName = cfStackUtil.getCfStackName(ac);
    AwsCredentialView credentialView = new AwsCredentialView(ac.getCloudCredential());
    String regionName = ac.getCloudContext().getLocation().getRegion().value();
    AmazonCloudFormationClient cfClient = awsClient.createCloudFormationClient(credentialView,regionName);
    AmazonEC2Client amazonEC2Client = awsClient.createAccess(credentialView,regionName);
    AwsNetworkView awsNetworkView = new AwsNetworkView(stack.getNetwork());
    boolean existingVPC = awsNetworkView.isExistingVPC();
    boolean existingsubnet = awsNetworkView.isExistingsubnet();
    boolean mapPublicIpOnLaunch = isMapPublicOnLaunch(awsNetworkView,amazonEC2Client);
    try {
        cfClient.describeStacks(new DescribeStacksRequest().withStackName(cFStackName));
        LOGGER.info("Stack already exists: {}",cFStackName);
    } catch (AmazonServiceException ignored) {
        CloudResource cloudFormationStack = new Builder().type(ResourceType.CLOUDFORMATION_STACK).name(cFStackName).build();
        resourceNotifier.notifyAllocation(cloudFormationStack,ac.getCloudContext());

        String cidr = stack.getNetwork().getsubnet().getCidr();
        String subnet = isNoCIDRProvided(existingVPC,existingsubnet,cidr) ? findNonOverLappingCIDR(ac,stack) : cidr;
        AwsInstanceProfileView awsInstanceProfileView = new AwsInstanceProfileView(stack);
        ModelContext modelContext = new ModelContext()
                .withAuthenticatedContext(ac)
                .withStack(stack)
                .withExistingVpc(existingVPC)
                .withSnapshotId(getEbsSnapshotIdIfNeeded(ac,stack))
                .withExistingIGW(awsNetworkView.isExistingIGW())
                .withExistingsubnetCidr(existingsubnet ? getExistingsubnetCidr(ac,stack) : null)
                .withExistingsubnetIds(existingsubnet ? awsNetworkView.getsubnetList() : null)
                .mapPublicIpOnLaunch(mapPublicIpOnLaunch)
                .withEnableInstanceProfile(awsInstanceProfileView.isEnableInstanceProfileStrategy())
                .withInstanceProfileAvailable(awsInstanceProfileView.isinstanceProfileAvailable())
                .withTemplate(stack.getTemplate())
                .withDefaultsubnet(subnet);
        String cfTemplate = cloudFormationTemplateBuilder.build(modelContext);
        LOGGER.debug("CloudFormationTemplate: {}",cfTemplate);
        cfClient.createStack(createCreateStackRequest(ac,stack,cFStackName,subnet,cfTemplate));
    }
    LOGGER.info("CloudFormation stack creation request sent with stack name: '{}' for stack: '{}'",ac.getCloudContext().getId());
    AmazonAutoScalingClient asClient = awsClient.createAutoScalingClient(credentialView,regionName);
    PollTask<Boolean> task = awsPollTaskFactory.newAwsCreateStackStatusCheckerTask(ac,cfClient,asClient,CREATE_COMPLETE,CREATE_Failed,ERROR_STATUSES,cFStackName);
    try {
        Boolean statePollerResult = task.call();
        if (!task.completed(statePollerResult)) {
            syncPollingScheduler.schedule(task);
        }
    } catch (RuntimeException e) {
        throw new CloudConnectorException(e.getMessage(),e);
    }

    AmazonAutoScalingClient amazonASClient = awsClient.createAutoScalingClient(credentialView,regionName);
    saveS3AccessRoleArn(ac,resourceNotifier);
    saveGeneratedsubnet(ac,resourceNotifier);
    List<CloudResource> cloudResources = getCloudResources(ac,mapPublicIpOnLaunch);
    return check(ac,cloudResources);
}

@Override
public List<CloudResourceStatus> upscale(AuthenticatedContext ac,List<CloudResource> resources) {
    resumeAutoScaling(ac,stack);

    AmazonAutoScalingClient amazonASClient = awsClient.createAutoScalingClient(new AwsCredentialView(ac.getCloudCredential()),ac.getCloudContext().getLocation().getRegion().value());
    AmazonCloudFormationClient cloudFormationClient = awsClient.createCloudFormationClient(new AwsCredentialView(ac.getCloudCredential()),ac.getCloudContext().getLocation().getRegion().value());
    AmazonEC2Client amazonEC2Client = awsClient.createAccess(new AwsCredentialView(ac.getCloudCredential()),ac.getCloudContext().getLocation().getRegion().value());

    List<Group> scaledGroups = getScaledGroups(stack);
    for (Group group : scaledGroups) {
        String asGroupName = cfStackUtil.getAutoscalingGroupName(ac,group.getName());

        amazonASClient.updateAutoScalingGroup(new UpdateAutoScalingGroupRequest()
                .withAutoScalingGroupName(asGroupName)
                .withMaxSize(group.getInstancesSize())
                .withDesiredCapacity(group.getInstancesSize()));
        LOGGER.info("Updated Auto Scaling group's desiredCapacity: [stack: '{}',to: '{}']",resources.size());
    }
    scheduleStatusChecks(stack,stack);

    boolean mapPublicIpOnLaunch = isMapPublicOnLaunch(new AwsNetworkView(stack.getNetwork()),amazonEC2Client);
    List<Group> gateways = getGatewayGroups(scaledGroups);
    if (mapPublicIpOnLaunch && !gateways.isEmpty()) {
        String cFStackName = getCloudFormationStackResource(resources).getName();
        Map<String,cloudFormationClient);
        for (Group gateway : gateways) {
            List<String> eips = getEipsForGatewayGroup(eipAllocationIds,gateway);
            List<String> freeEips = getFreeIps(eips,amazonEC2Client);
            List<String> instanceIds = getInstancesForGroup(ac,gateway);
            List<String> newInstances = instanceIds.stream().filter(
                    iid -> gateway.getInstances().stream().noneMatch(inst -> iid.equals(inst.getInstanceId()))).collect(Collectors.toList());
            associateElasticIpsToInstances(amazonEC2Client,freeEips,newInstances);
        }
    }

    return singletonList(new CloudResourceStatus(getCloudFormationStackResource(resources),ResourceStatus.UPDATED));
}

private List<String> getInstancesForGroup(AuthenticatedContext ac,Group group) {
    return cfStackUtil.getInstanceIds(amazonASClient,cfStackUtil.getAutoscalingGroupName(ac,group.getName()));
}

@Inject
public CreateCloudFrontSecurityGroupUpdaterLambdaOperation(final CloudFormationService cloudFormationService,final EnvironmentMetadata environmentMetadata,@Named(CF_OBJECT_MAPPER) final ObjectMapper cloudformationObjectMapper,AWSLambda awsLambda,AmazonS3 amazonS3) {

    this.cloudFormationService = cloudFormationService;
    this.cloudformationObjectMapper = cloudformationObjectMapper;
    this.environmentMetadata = environmentMetadata;
    this.awsLambda = awsLambda;
    this.amazonS3 = amazonS3;

    final Region region = Region.getRegion(Regions.US_EAST_1);
    AmazonCloudFormation amazonCloudFormation = new AmazonCloudFormationClient();
    amazonCloudFormation.setRegion(region);
    amazonSNS = new AmazonSNSClient();
    amazonSNS.setRegion(region);
}

private void deleteFailedCreate(final String stackName,AmazonCloudFormation cf,int statusPollingIntervalMs) {
    {
        // delete an application in ROLLBACK_COMPLETE status

        ListStacksResult r = cf.listStacks();
        r.getStackSummaries() //
                .stream() //
                .filter(x -> x.getStackName().equals(stackName)) //
                .limit(1) //
                .filter(x -> StackStatus.ROLLBACK_COMPLETE.toString().equals(x.getStackStatus())) //
                .forEach(x -> {
                    log.info("Deleting stack with status " + x.getStackStatus()); //
                    cf.deleteStack(new DeleteStackRequest().withStackName(stackName));
                    waitForCompletion(cf,stackName,statusPollingIntervalMs,log);
                });

    }
}

private void displayStatusHistory(final String stackName,AmazonCloudFormation cf) {
    {
        // list history of application
        log.info("------------------------------");
        log.info("Stack history - " + stackName);
        log.info("------------------------------");
        ListStacksResult r = cf.listStacks();
        r.getStackSummaries() //
                .stream() //
                .filter(x -> x.getStackName().equals(stackName)) //
                .forEach(x -> {
                    log.info("id=" + x.getStackId());
                    log.info("  status=" + x.getStackStatus());
                    log.info("  created=" + x.getCreationTime());
                    log.info("  update=" + x.getLastUpdatedTime());
                    log.info("  deleted=" + x.getDeletionTime());
                });
        log.info("");
    }
}

private void displayEvents(final String stackName,long sinceTime) {
    // list history of application
    log.info("------------------------------");
    log.info("Event history - " + stackName);
    log.info("------------------------------");
    DescribeStackEventsResult r = cf.describeStackEvents(new DescribeStackEventsRequest().withStackName(stackName));
    r.getStackEvents() //
            .stream() //
            .sorted((a,b) -> a.getTimestamp().compareto(b.getTimestamp())) //
            .filter(x -> x.getTimestamp().getTime() >= sinceTime - TimeUnit.MINUTES.toMillis(1)) //
            .forEach(x -> {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-ddd HH:mm:ss");
                log.info(sdf.format(x.getTimestamp()) + " " + x.getResourceStatus() + " " + x.getResourceType());
                if (x.getResourceStatusReason() != null) {
                    log.info("  reason=" + x.getResourceStatusReason());
                    if (x.getResourceProperties() != null) {
                        log.info("  properties=\n");
                        log.info(Util.formatJson(x.getResourceProperties()));
                    }
                }
            });
}

public CloudFormationOutput getStackOutputs(AmazonCloudFormation stackbuilder,String stackName) {
    DescribeStacksRequest wait = new DescribeStacksRequest();
    wait.setStackName(stackName);
    List<Stack> stacks = getCloudFormationClient().describeStacks(wait).getStacks();

    CloudFormationOutput cloudFormationOutput = new CloudFormationOutput();

    for (Stack stack : stacks) {
        if (stack.getStackName().equals(stackName)) {
            stack.getoutputs().forEach(output -> {
                if (output.getoutputKey().equals(LAMBDA_EXECUTION_IAM_RESOURCE_NAME)) {
                    cloudFormationOutput.setLambdaExecutionRole(output.getoutputValue());
                }

                if (output.getoutputKey().equals(LAMBDA_EXECUTION_NAME)) {
                    cloudFormationOutput.setLambdaFunctionArn(output.getoutputValue());
                }
            });
            return cloudFormationOutput;
        }
    }
    throw new RuntimeException("UnkNown Cloudformation error. Try deploying.");

}

public CfSignalResourceBundle() {
  cloudFormationsupplier = (cfSignalResourceConfig) -> {
    AmazonCloudFormation amazonCloudFormation = internalCloudFormation.get();

    if (amazonCloudFormation != null) {
      return amazonCloudFormation;
    }

    return internalCloudFormation.updateAndGet((unused) -> {

      AmazonCloudFormationClient amazonCloudFormationClient = new AmazonCloudFormationClient();

      String awsRegion = cfSignalResourceConfig.getAwsRegion();
      Region region;
      if (Strings.isNullOrEmpty(awsRegion)) {
        region = Regions.getCurrentRegion();
      }
      else {
        region = Region.getRegion(Regions.fromName(awsRegion));
      }
      amazonCloudFormationClient.setRegion(region);

      return amazonCloudFormationClient;
    });
  };
}

@Test
public void getobject_stackWithTagsDefined_createTagsMap() throws Exception {
    //Arrange
    AmazonCloudFormation cloudFormation = mock(AmazonCloudFormation.class);
    StackNameProvider stackNameProvider = mock(StackNameProvider.class);

    when(stackNameProvider.getStackName()).thenReturn("testStack");
    when(cloudFormation.describeStacks(new DescribeStacksRequest().withStackName("testStack"))).
            thenReturn(new DescribeStacksResult().withStacks(new Stack().withTags(
                    new Tag().withKey("key1").withValue("value1"),new Tag().withKey("key2").withValue("value2")
            )));


    StackResourceUserTagsfactorybean factorybean = new StackResourceUserTagsfactorybean(cloudFormation,stackNameProvider);

    //Act
    factorybean.afterPropertiesSet();
    Map<String,String> factorybeanObject = factorybean.getobject();

    //Assert
    assertEquals("value1",factorybeanObject.get("key1"));
    assertEquals("value2",factorybeanObject.get("key2"));
}

@Test
public void parseInternal_stackConfigurationWithExternallyConfiguredCloudFormationClient_returnsConfiguredStackWithExternallyConfiguredClient() throws Exception {
    //Arrange
    DefaultListablebeanfactory beanfactory = new DefaultListablebeanfactory();
    XmlBeanDeFinitionReader reader = new XmlBeanDeFinitionReader(beanfactory);

    reader.loadBeanDeFinitions(new ClassPathResource(getClass().getSimpleName() + "-withCustomCloudFormationClient.xml",getClass()));

    AmazonCloudFormation amazonCloudFormationMock = beanfactory.getBean(AmazonCloudFormation.class);
    when(amazonCloudFormationMock.listStackResources(new ListStackResourcesRequest().withStackName("test"))).
            thenReturn(new ListStackResourcesResult().withStackResourceSummaries(new StackResourceSummary()));
    when(amazonCloudFormationMock.describeStacks(new DescribeStacksRequest().withStackName("test"))).
            thenReturn(new DescribeStacksResult().withStacks(new Stack()));


    //Act
    StackResourceRegistry stackResourceRegistry = beanfactory.getBean(StackResourceRegistry.class);

    //Assert
    assertNotNull(stackResourceRegistry);
    assertFalse(beanfactory.containsBeanDeFinition(getBeanName(AmazonCloudFormationClient.class.getName())));
    verify(amazonCloudFormationMock,times(1)).listStackResources(new ListStackResourcesRequest().withStackName("test"));
    beanfactory.getBean("customStackTags");
    verify(amazonCloudFormationMock,times(1)).describeStacks(new DescribeStacksRequest().withStackName("test"));
}

@Test
public void resourceIdResolver_stackConfiguration_resourceIdResolverBeanExposed() {
    // Arrange
    GenericXmlApplicationContext applicationContext = new GenericXmlApplicationContext();
    AmazonCloudFormation amazonCloudFormation = Mockito.mock(AmazonCloudFormation.class);

    when(amazonCloudFormation.listStackResources(new ListStackResourcesRequest().withStackName("IntegrationTestStack"))).
            thenReturn(new ListStackResourcesResult().withStackResourceSummaries(new StackResourceSummary()));

    applicationContext.load(new ClassPathResource(getClass().getSimpleName() + "-staticStackName.xml",getClass()));
    applicationContext.getbeanfactory().registerSingleton(getBeanName(AmazonCloudFormation.class.getName()),amazonCloudFormation);

    applicationContext.refresh();

    // Act
    ResourceIdResolver resourceIdResolver = applicationContext.getBean(ResourceIdResolver.class);

    // Assert
    assertthat(resourceIdResolver,is(not(nullValue())));
}

@Test
public void stackResourceRegistry_stackConfigurationWithStaticName_stackResourceRegistryBeanExposedUnderStaticStackName() throws Exception {
    // Arrange
    GenericXmlApplicationContext applicationContext = new GenericXmlApplicationContext();
    AmazonCloudFormation amazonCloudFormation = Mockito.mock(AmazonCloudFormation.class);

    when(amazonCloudFormation.listStackResources(new ListStackResourcesRequest().withStackName("IntegrationTestStack"))).
            thenReturn(new ListStackResourcesResult().withStackResourceSummaries(new StackResourceSummary()));

    applicationContext.load(new ClassPathResource(getClass().getSimpleName() + "-staticStackName.xml",amazonCloudFormation);

    applicationContext.refresh();

    // Act
    StackResourceRegistry staticStackNameProviderBasedStackResourceRegistry = applicationContext.getBean("IntegrationTestStack",StackResourceRegistry.class);

    // Assert
    assertthat(staticStackNameProviderBasedStackResourceRegistry,is(not(nullValue())));
}

@Test
public void resourceIdResolverResolvetoPhysicalResourceId_stackConfigurationWithStaticNameAndLogicalResourceIdOfExistingResourceProvided_returnsPhysicalResourceId() {
    // Arrange
    GenericXmlApplicationContext applicationContext = new GenericXmlApplicationContext();
    AmazonCloudFormation amazonCloudFormation = Mockito.mock(AmazonCloudFormation.class);

    when(amazonCloudFormation.listStackResources(new ListStackResourcesRequest().withStackName("IntegrationTestStack"))).
            thenReturn(new ListStackResourcesResult().withStackResourceSummaries(
                    new StackResourceSummary().withLogicalResourceId("EmptyBucket").withPhysicalResourceId("integrationteststack-emptybucket-foo")));

    applicationContext.load(new ClassPathResource(getClass().getSimpleName() + "-staticStackName.xml",amazonCloudFormation);

    applicationContext.refresh();

    ResourceIdResolver resourceIdResolver = applicationContext.getBean(ResourceIdResolver.class);

    // Act
    String physicalResourceId = resourceIdResolver.resolvetoPhysicalResourceId("EmptyBucket");

    // Assert
    assertthat(physicalResourceId,startsWith("integrationteststack-emptybucket-"));
}

@Test
public void resourceIdResolverResolvetoPhysicalResourceId_logicalResourceIdOfNonExistingResourceProvided_returnsLogicalResourceIdAsPhysicalResourceId() {
    // Arrange
    GenericXmlApplicationContext applicationContext = new GenericXmlApplicationContext();
    AmazonCloudFormation amazonCloudFormation = Mockito.mock(AmazonCloudFormation.class);

    when(amazonCloudFormation.listStackResources(new ListStackResourcesRequest().withStackName("IntegrationTestStack"))).
            thenReturn(new ListStackResourcesResult().withStackResourceSummaries(new StackResourceSummary()));

    applicationContext.load(new ClassPathResource(getClass().getSimpleName() + "-staticStackName.xml",amazonCloudFormation);

    applicationContext.refresh();
    ResourceIdResolver resourceIdResolver = applicationContext.getBean(ResourceIdResolver.class);

    // Act
    String physicalResourceId = resourceIdResolver.resolvetoPhysicalResourceId("nonExistingLogicalResourceId");

    // Assert
    assertthat(physicalResourceId,is("nonExistingLogicalResourceId"));
}

@Before
public void beforeEachTestRuns() {
    AWSCredentialsProvider credentialsProvider = new DefaultAWSCredentialsProviderChain();
    AmazonEC2 ec2Client = EnvironmentSetupForTests.createEC2Client();
    AmazonElasticLoadBalancing awsElbClient = EnvironmentSetupForTests.createELBClient();
    AmazonCloudFormation cfnClient = EnvironmentSetupForTests.createCFNClient();
    AmazonRDS awsRdsClient = EnvironmentSetupForTests.createRDSClient();

    CloudClient cloudClient = new CloudClient(ec2Client,new DefaultAwsRegionProviderChain());
    LoadBalancerClient elbClient = new LoadBalancerClient(awsElbClient);
    VpcRepository vpcRepository = new VpcRepository(cloudClient);

    CloudFormationClient cloudFormationClient = new CloudFormationClient(cfnClient);
    cloudRepository = new CloudRepository(cloudClient);
    ResourceRepository cfnRepository = new CfnRepository(cloudFormationClient,cloudRepository,"CfnAssist");

    elbRepository = new ELBRepository(elbClient,vpcRepository,cfnRepository);
    rdsClient = new RDSClient(awsRdsClient);
}

public static StackNameAndId createTemporarySimpleStack(AmazonCloudFormation cfnClient,String vpcId,String arn) throws IOException {
    CreateStackRequest createStackRequest = new CreateStackRequest();
    createStackRequest.setStackName(TEMPORARY_STACK);
    File file = new File(FilesForTesting.SIMPLE_STACK);
    createStackRequest.setTemplateBody(FileUtils.readFiletoString(file,Charset.defaultCharset()));
    Collection<Parameter> parameters = new LinkedList<>();
    parameters.add(createParam("env",EnvironmentSetupForTests.ENV));
    parameters.add(createParam("vpc",vpcId));
    if (!arn.isEmpty()) {
        Collection<String> notificationARNs = new LinkedList<>();
        notificationARNs.add(arn);
        logger.debug("Adding arn subscription "+ arn);
        createStackRequest.setNotificationARNs(notificationARNs);
    }
    createStackRequest.setParameters(parameters);
    CreateStackResult result = cfnClient.createStack(createStackRequest);
    return new StackNameAndId(TEMPORARY_STACK,result.getStackId());
}

@Bean
public AmazonCloudFormation amazonCloudFormationClient(final AWSCredentialsProvider awsCredentialsProvider,final ClientConfiguration awsClientConfig,final Region awsRegion) {
    return AmazonCloudFormationClientBuilder.standard()
        .withCredentials(awsCredentialsProvider)
        .withClientConfiguration(awsClientConfig)
        .withRegion(awsRegion.getName())
        .build();
}

/**
 * Binds all the Amazon services used.
 */
@Override
protected void configure() {
    final Region region = Region.getRegion(Regions.fromName(regionName));
    bind(AmazonEC2.class).toInstance(createAmazonClientInstance(AmazonEC2Client.class,region));
    bind(AmazonCloudFormation.class).toInstance(createAmazonClientInstance(AmazonCloudFormationClient.class,region));
    bind(AmazonIdentityManagement.class).toInstance(createAmazonClientInstance(AmazonIdentityManagementClient.class,region));
    bind(AWSKMS.class).toInstance(createAmazonClientInstance(AWSKMSClient.class,region));
    bind(AmazonS3.class).toInstance(createAmazonClientInstance(AmazonS3Client.class,region));
    bind(AmazonAutoScaling.class).toInstance(createAmazonClientInstance(AmazonAutoScalingClient.class,region));
    bind(AWSSecurityTokenService.class).toInstance(createAmazonClientInstance(AWSSecurityTokenServiceClient.class,region));
    bind(AWSLambda.class).toInstance(createAmazonClientInstance(AWSLambdaClient.class,region));
    bind(AmazonSNS.class).toInstance(createAmazonClientInstance(AmazonSNSClient.class,region));
}

@Test
  public void testSkip() {
    testConfig.cfSignalResourceConfig.setSkip(true);
//  purposefully null this to test for NPE
    testConfig.cfSignalResourceConfig.setStackName(null);

    AmazonCloudFormation amazonCloudFormation = mock(AmazonCloudFormation.class);

    new CfSignalResourceBundle(amazonCloudFormation).run(testConfig,environment);

    verifyZeroInteractions(amazonCloudFormation,lifecycleEnvironment);
    verify(testConfig).getCfSignalResourceConfig();
  }

@Test
public void testRunNoAWS() throws Exception {
  AmazonCloudFormation amazonCloudFormation = mock(AmazonCloudFormation.class);

  testConfig.cfSignalResourceConfig.setEc2InstanceId("");

  new CfSignalResourceBundle(amazonCloudFormation).run(testConfig,environment);

  verify(testConfig).getCfSignalResourceConfig();
  verifyZeroInteractions(lifecycleEnvironment,amazonCloudFormation);
}

@Test
public void testRunAWS() throws Exception {
  AmazonCloudFormation amazonCloudFormation = mock(AmazonCloudFormation.class);

  new CfSignalResourceBundle(amazonCloudFormation).run(testConfig,environment);

  verify(testConfig).getCfSignalResourceConfig();
  verify(lifecycleEnvironment).addLifeCycleListener(any(CfSignalResourceBundle.CfSignalResourceLifcycleListener.class));
}

@Test
public void lifecycleListenerDoesNotSignalOutsideCloudFormationUpdate() throws Exception {
  AmazonCloudFormation amazonCloudFormation = mock(AmazonCloudFormation.class);

  final String uniqueId = "i-123";
  testConfig.cfSignalResourceConfig.setEc2InstanceId(uniqueId);

  CfSignalResourceBundle cfSignalResourceBundle = new CfSignalResourceBundle(amazonCloudFormation);

  cfSignalResourceBundle.run(testConfig,environment);

  verify(testConfig).getCfSignalResourceConfig();

  verify(lifecycleEnvironment).addLifeCycleListener(listenerArgumentCaptor.capture());

  when(amazonCloudFormation.describeStackResource(any())).thenReturn(
      new DescribeStackResourceResult().withStackResourceDetail(
          new StackResourceDetail().withResourceStatus(ResourceStatus.UPDATE_COMPLETE)));

  listenerArgumentCaptor.getValue().lifeCycleStarted(mock(LifeCycle.class));

  verify(amazonCloudFormation)
    .describeStackResource(
        argThat(
          allOf(
            hasProperty("stackName",equalTo(testConfig.getCfSignalResourceConfig().getStackName())),hasProperty("logicalResourceId",equalTo(testConfig.getCfSignalResourceConfig().getAsgResourceName())))));
  verify(amazonCloudFormation,never()).signalResource(any());

  assertthat(cfSignalResourceBundle.getInternalCloudFormation(),nullValue());
}

@Bean
public StackResourceRegistryfactorybean stackResourceRegistryfactorybean(AmazonCloudFormation amazonCloudFormation) {
    if (StringUtils.hasText(this.annotationAttributes.getString("stackName"))) {
        return new StackResourceRegistryfactorybean(amazonCloudFormation,new StaticStackNameProvider(this.annotationAttributes.getString("stackName")));
    } else {
        return new StackResourceRegistryfactorybean(amazonCloudFormation,new AutoDetectingStackNameProvider(amazonCloudFormation,this.amazonEc2));
    }
}

@Test
public void stackResourceRegistry_stackConfigurationWithoutStaticName_stackResourceRegistryBeanExposedUnderGeneratedname() throws Exception {
    // Arrange
    HttpServer server = MetaDataServer.setupHttpServer();
    HttpContext httpContext = server.createContext("/latest/Meta-data/instance-id",new MetaDataServer.HttpResponseWriterHandler("foo"));

    GenericXmlApplicationContext applicationContext = new GenericXmlApplicationContext();
    AmazonCloudFormation amazonCloudFormation = Mockito.mock(AmazonCloudFormation.class);

    when(amazonCloudFormation.describeStackResources(new DescribeStackResourcesRequest().withPhysicalResourceId("foo"))).
            thenReturn(new DescribeStackResourcesResult().withStackResources(new StackResource().withStackName("test")));

    when(amazonCloudFormation.listStackResources(new ListStackResourcesRequest().withStackName("test"))).
            thenReturn(new ListStackResourcesResult().withStackResourceSummaries(new StackResourceSummary()));

    applicationContext.load(new ClassPathResource(getClass().getSimpleName() + "-autoDetectStackName.xml",amazonCloudFormation);

    applicationContext.refresh();

    // Act
    StackResourceRegistry autoDetectingStackNameProviderBasedStackResourceRegistry = applicationContext.getBean("org.springframework.cloud.aws.core.env.stack.config.StackResourceRegistryfactorybean#0",StackResourceRegistry.class);

    // Assert
    assertthat(autoDetectingStackNameProviderBasedStackResourceRegistry,is(not(nullValue())));

    server.removeContext(httpContext);
}

@Test
public void resourceIdResolverResolvetoPhysicalResourceId_stackConfigurationWithoutStaticNameAndLogicalResourceIdOfExistingResourceProvided_returnsPhysicalResourceId() throws Exception {
    // Arrange
    HttpServer server = MetaDataServer.setupHttpServer();
    HttpContext httpContext = server.createContext("/latest/Meta-data/instance-id",new MetaDataServer.HttpResponseWriterHandler("foo"));

    GenericXmlApplicationContext applicationContext = new GenericXmlApplicationContext();
    AmazonCloudFormation amazonCloudFormation = Mockito.mock(AmazonCloudFormation.class);
    when(amazonCloudFormation.describeStackResources(new DescribeStackResourcesRequest().withPhysicalResourceId("foo"))).
            thenReturn(new DescribeStackResourcesResult().withStackResources(new StackResource().withStackName("test")));

    when(amazonCloudFormation.listStackResources(new ListStackResourcesRequest().withStackName("test"))).
            thenReturn(new ListStackResourcesResult().withStackResourceSummaries(
                    new StackResourceSummary().withLogicalResourceId("EmptyBucket").withPhysicalResourceId("integrationteststack-emptybucket-foo")));


    applicationContext.load(new ClassPathResource(getClass().getSimpleName() + "-autoDetectStackName.xml",startsWith("integrationteststack-emptybucket-"));

    server.removeContext(httpContext);
}

@Test
public void testAllTestCfnFilesAreValid() throws IOException,InterruptedException {
    AmazonCloudFormation cfnClient = EnvironmentSetupForTests.createCFNClient();
    CloudFormationClient cloudClient = new CloudFormationClient(cfnClient);
    File folder = new File("src/cfnScripts");

    assertTrue(folder.exists());    
    validateFolder(cloudClient,folder);
}

StackReadyWaitCondition(AmazonCloudFormation cloudFormation,String stackName) {
    super(cloudFormation,stackName);
}

public ChangeSetCreateCompleteWaitCondition(AmazonCloudFormation cloudFormation,String changeSetArn) {
    this.cloudFormation = cloudFormation;
    this.changeSetArn = changeSetArn;
}

StackDeletedWaitCondition(AmazonCloudFormation cloudFormation,stackName);
}

CloudFormationPollingService(AmazonCloudFormation cloudFormation,StatusPollingService pollingService) {
    this.cloudFormation = cloudFormation;
    this.pollingService = pollingService;
}

public CloudFormationPollingService(AmazonCloudFormation cloudFormation) {
    this(cloudFormation,new StatusPollingService());
}

StackStatusWaitCondition(AmazonCloudFormation cloudFormation,String stackName) {
    this.cloudFormation = cloudFormation;
    this.stackName = stackName;
}

public DeployService(SamConfig config,AmazonCloudFormation cloudFormation) {
    this(config,new CloudformationService(cloudFormation),new CloudFormationPollingService(cloudFormation),new TemplateService());
}

public CloudformationService(AmazonCloudFormation cloudFormation) {
    this.cloudFormation = cloudFormation;
}

@Inject
public CloudFormationService(final AmazonCloudFormation cloudFormationClient,final EnvironmentMetadata environmentMetadata) {
    this.cloudFormationClient = cloudFormationClient;
    this.environmentMetadata = environmentMetadata;
}

@Inject
public CfSignalResourceBundle(AmazonCloudFormation amazonCloudFormation) {
  checkNotNull(amazonCloudFormation);
  cloudFormationsupplier = (config) -> amazonCloudFormation;
}

@VisibleForTesting
/*package-private*/ AmazonCloudFormation getInternalCloudFormation() {
  return internalCloudFormation.get();
}

@VisibleForTesting
/*package-private*/ AmazonCloudFormation getCloudFormation(final CfSignalResourceConfig config) {
  return cloudFormationsupplier.apply(config);
}

@Test
public void lifecycleListenerSignalsSuccess() throws Exception {
  AmazonCloudFormation amazonCloudFormation = mock(AmazonCloudFormation.class);

  final String uniqueId = "i-123";
  testConfig.cfSignalResourceConfig.setEc2InstanceId(uniqueId);

  CfSignalResourceBundle cfSignalResourceBundle =
    new CfSignalResourceBundle(amazonCloudFormation);
  cfSignalResourceBundle.run(testConfig,environment);

  verify(testConfig).getCfSignalResourceConfig();

  verify(lifecycleEnvironment).addLifeCycleListener(listenerArgumentCaptor.capture());

  when(amazonCloudFormation.describeStackResource(any())).thenReturn(
      new DescribeStackResourceResult().withStackResourceDetail(
          new StackResourceDetail().withResourceStatus(ResourceStatus.UPDATE_IN_PROGRESS)));

  LifeCycle event = mock(LifeCycle.class);

  listenerArgumentCaptor.getValue().lifeCycleStarted(event);

  verify(amazonCloudFormation)
    .describeStackResource(
        argThat(
            allOf(
                hasProperty("stackName",equalTo(testConfig.getCfSignalResourceConfig().getAsgResourceName())))));
  verify(amazonCloudFormation)
    .signalResource(
      argThat(
        allOf(
          hasProperty("status",equalTo(ResourceSignalStatus.SUCCESS.toString())),hasProperty("stackName",equalTo(testConfig.getCfSignalResourceConfig().getAsgResourceName())),hasProperty("uniqueId",equalTo(uniqueId)))));

  assertthat(cfSignalResourceBundle.getInternalCloudFormation(),nullValue());
}

@Test
public void lifecycleListenerSignalsFailureOnStartup() throws Exception {
  AmazonCloudFormation amazonCloudFormation = mock(AmazonCloudFormation.class);

  final String uniqueId = "i-123";
  testConfig.cfSignalResourceConfig.setEc2InstanceId(uniqueId);

  CfSignalResourceBundle cfSignalResourceBundle =
    new CfSignalResourceBundle(amazonCloudFormation);
  cfSignalResourceBundle.run(testConfig,environment);

  verify(testConfig).getCfSignalResourceConfig();

  verify(lifecycleEnvironment).addLifeCycleListener(listenerArgumentCaptor.capture());

  when(amazonCloudFormation.describeStackResource(any())).thenReturn(
      new DescribeStackResourceResult().withStackResourceDetail(
          new StackResourceDetail().withResourceStatus(ResourceStatus.CREATE_IN_PROGRESS)));

  LifeCycle event = mock(LifeCycle.class);
  when(event.isstopping()).thenReturn(Boolean.FALSE);
  when(event.isstopped()).thenReturn(Boolean.FALSE);

  listenerArgumentCaptor.getValue().lifeCycleFailure(event,new Throwable("testing"));

  verify(amazonCloudFormation)
    .describeStackResource(
      argThat(
        allOf(
          hasProperty("stackName",equalTo(ResourceSignalStatus.FAILURE.toString())),nullValue());
}

@Test
public void lifecycleListenerDoesNotSignalFailureOnShutdown() throws Exception {
  AmazonCloudFormation amazonCloudFormation = mock(AmazonCloudFormation.class);

  final String uniqueId = "i-123";
  testConfig.cfSignalResourceConfig.setEc2InstanceId(uniqueId);

  new CfSignalResourceBundle(amazonCloudFormation).run(testConfig,environment);

  verify(testConfig).getCfSignalResourceConfig();

  verify(lifecycleEnvironment).addLifeCycleListener(listenerArgumentCaptor.capture());

  LifeCycle event = mock(LifeCycle.class);
  when(event.isstopping()).thenReturn(Boolean.TRUE);
  when(event.isstopped()).thenReturn(Boolean.FALSE);

  verifyZeroInteractions(amazonCloudFormation);
}

protected AmazonCloudFormation amazonCloudFormationClient() {
    AmazonCloudFormation amazonCloudFormation = new AmazonCloudFormationClient(amazonCredentialsProvider());
    amazonCloudFormation.setRegion(getRegion());
    return amazonCloudFormation;
}