Example usage for com.amazonaws.services.elasticloadbalancing.model SetLoadBalancerPoliciesOfListenerRequest SetLoadBalancerPoliciesOfListenerRequest

List of usage examples for com.amazonaws.services.elasticloadbalancing.model SetLoadBalancerPoliciesOfListenerRequest SetLoadBalancerPoliciesOfListenerRequest

Introduction

In this page you can find the example usage for com.amazonaws.services.elasticloadbalancing.model SetLoadBalancerPoliciesOfListenerRequest SetLoadBalancerPoliciesOfListenerRequest.

Prototype

public SetLoadBalancerPoliciesOfListenerRequest() 

Source Link

Document

Default constructor for SetLoadBalancerPoliciesOfListenerRequest object.

Usage

From source file:com.netflix.spinnaker.clouddriver.aws.deploy.handlers.MigrateLoadBalancerStrategy.java

License:Apache License

/**
 * Applies any listener policies from the source load balancer to the target load balancer.
 *
 * Since policy names are unique to each load balancer, two policies with the same name in different load balancers
 * may contain different policy attributes. For the sake of simplicity, we assume that policies with the same name
 * are structurally the same, and do not attempt to reconcile any differences between attributes.
 *
 * We will, however, attempt to override the policies applied to a given listener if it's different, e.g., if the
 * source load balancer has policy "a" on port 7000, and the target load balancer has policy "b" on port 7000, we
 * will:/*from  ww  w.  jav a  2s . c o m*/
 *   1. create policy "a" if it doesn't exist on the target load balancer, then
 *   2. update the target load balancer so port 7000 will have only policy "a"
 */
public void applyListenerPolicies(AmazonElasticLoadBalancing sourceClient,
        AmazonElasticLoadBalancing targetClient, LoadBalancerDescription source, String loadBalancerName) {
    Set<String> policiesToRetrieve = new HashSet<>();
    Map<String, String> policyNameMap = new HashMap<>();
    source.getListenerDescriptions().forEach(d -> policiesToRetrieve.addAll(d.getPolicyNames()));
    List<PolicyDescription> sourcePolicies = sourceClient
            .describeLoadBalancerPolicies(new DescribeLoadBalancerPoliciesRequest()
                    .withLoadBalancerName(source.getLoadBalancerName()).withPolicyNames(policiesToRetrieve))
            .getPolicyDescriptions();
    List<PolicyDescription> targetPolicies = targetClient
            .describeLoadBalancerPolicies(
                    new DescribeLoadBalancerPoliciesRequest().withLoadBalancerName(loadBalancerName))
            .getPolicyDescriptions();

    sourcePolicies.forEach(p -> {
        Optional<PolicyDescription> match = targetPolicies.stream().filter(
                tp -> tp.getPolicyAttributeDescriptions().size() == p.getPolicyAttributeDescriptions().size()
                        && tp.getPolicyAttributeDescriptions().containsAll(p.getPolicyAttributeDescriptions()))
                .findFirst();

        if (match.isPresent()) {
            policyNameMap.put(p.getPolicyName(), match.get().getPolicyName());
        } else {
            String policyName = p.getPolicyName();
            if (policyName.startsWith("ELBSample-") || policyName.startsWith("ELBSecurityPolicy-")) {
                policyName = "migrated-" + policyName;
            }
            policyNameMap.put(p.getPolicyName(), policyName);
            CreateLoadBalancerPolicyRequest request = new CreateLoadBalancerPolicyRequest()
                    .withPolicyName(policyName).withLoadBalancerName(loadBalancerName)
                    .withPolicyTypeName(p.getPolicyTypeName());
            // only copy policy attributes if this is not a pre-defined policy
            // (as defined by the presence of 'Reference-Security-Policy'
            Optional<PolicyAttributeDescription> referencePolicy = p.getPolicyAttributeDescriptions().stream()
                    .filter(d -> d.getAttributeName().equals("Reference-Security-Policy")).findFirst();
            if (referencePolicy.isPresent()) {
                request.withPolicyAttributes(new PolicyAttribute(referencePolicy.get().getAttributeName(),
                        referencePolicy.get().getAttributeValue()));
            } else {
                request.withPolicyAttributes(p.getPolicyAttributeDescriptions().stream()
                        .map(d -> new PolicyAttribute(d.getAttributeName(), d.getAttributeValue()))
                        .collect(Collectors.toList()));
            }
            targetClient.createLoadBalancerPolicy(request);
        }
    });
    source.getListenerDescriptions().forEach(l -> targetClient.setLoadBalancerPoliciesOfListener(
            new SetLoadBalancerPoliciesOfListenerRequest().withLoadBalancerName(loadBalancerName)
                    .withLoadBalancerPort(l.getListener().getLoadBalancerPort()).withPolicyNames(
                            l.getPolicyNames().stream().map(policyNameMap::get).collect(Collectors.toList()))));
}

From source file:fr.xebia.demo.amazon.aws.AmazonAwsInfrastructureMaker.java

License:Apache License

public CreateLoadBalancerResult createElasticLoadBalancer(List<Instance> ec2Instances) {
    Set<String> availabilityZones = Sets
            .newHashSet(Lists.transform(ec2Instances, new Function<Instance, String>() {
                @Override/*from   w ww.ja  va2s  .  co m*/
                public String apply(Instance instance) {
                    return instance.getPlacement().getAvailabilityZone();
                }
            }));

    List<com.amazonaws.services.elasticloadbalancing.model.Instance> elbInstances = Lists.transform(
            ec2Instances, new Function<Instance, com.amazonaws.services.elasticloadbalancing.model.Instance>() {
                @Override
                public com.amazonaws.services.elasticloadbalancing.model.Instance apply(Instance ec2Instance) {
                    return new com.amazonaws.services.elasticloadbalancing.model.Instance(
                            ec2Instance.getInstanceId());
                }
            });

    CreateLoadBalancerRequest createLoadBalancerRequest = new CreateLoadBalancerRequest() //
            .withLoadBalancerName("travel-ecommerce") //
            .withListeners(new Listener("HTTP", 80, 8080)) //
            .withAvailabilityZones(availabilityZones) //
    ;
    CreateLoadBalancerResult createLoadBalancerResult = elb.createLoadBalancer(createLoadBalancerRequest);

    // HEALTH CHECK
    HealthCheck helsathCheck = new HealthCheck() //
            .withTarget("HTTP:8080/") //
            .withHealthyThreshold(2) //
            .withUnhealthyThreshold(2) //
            .withInterval(30) //
            .withTimeout(2);
    ConfigureHealthCheckRequest configureHealthCheckRequest = new ConfigureHealthCheckRequest(
            createLoadBalancerRequest.getLoadBalancerName(), //
            helsathCheck);
    elb.configureHealthCheck(configureHealthCheckRequest);

    // COOKIE STICKINESS
    CreateLBCookieStickinessPolicyRequest createLbCookieStickinessPolicy = new CreateLBCookieStickinessPolicyRequest() //
            .withLoadBalancerName(createLoadBalancerRequest.getLoadBalancerName())//
            .withPolicyName("travel-ecommerce-stickiness-policy");
    elb.createLBCookieStickinessPolicy(createLbCookieStickinessPolicy);

    SetLoadBalancerPoliciesOfListenerRequest setLoadBalancerPoliciesOfListenerRequest = new SetLoadBalancerPoliciesOfListenerRequest() //
            .withLoadBalancerName(createLoadBalancerRequest.getLoadBalancerName()) //
            .withLoadBalancerPort(80) //
            .withPolicyNames(createLbCookieStickinessPolicy.getPolicyName())//
    ;
    elb.setLoadBalancerPoliciesOfListener(setLoadBalancerPoliciesOfListenerRequest);

    // INSTANCES
    RegisterInstancesWithLoadBalancerRequest registerInstancesWithLoadBalancerRequest = new RegisterInstancesWithLoadBalancerRequest(
            createLoadBalancerRequest.getLoadBalancerName(), elbInstances);
    elb.registerInstancesWithLoadBalancer(registerInstancesWithLoadBalancerRequest);

    logger.info("Created {}", createLoadBalancerResult);

    return createLoadBalancerResult;
}

From source file:fr.xebia.demo.amazon.aws.PetclinicInfrastructureEnforcer.java

License:Apache License

/**
 * // w ww.j a  v  a  2s . co  m
 * @param healthCheckUri
 *            start with slash. E.g. "/myapp/healthcheck.jsp
 * @param applicationIdentifier
 *            used to name the load balancer and to filter the instances on
 *            their "Role" tag.
 * @return created load balancer description
 */
@Nonnull
public LoadBalancerDescription createOrUpdateElasticLoadBalancer(@Nonnull String healthCheckUri,
        @Nonnull String applicationIdentifier) {
    LOGGER.info("ENFORCE LOAD BALANCER");

    DescribeInstancesRequest describeInstancesWithRoleRequest = new DescribeInstancesRequest(). //
            withFilters(new Filter("tag:Role", Arrays.asList(applicationIdentifier)));
    DescribeInstancesResult describeInstancesResult = ec2.describeInstances(describeInstancesWithRoleRequest);

    Iterable<Instance> expectedEc2Instances = toEc2Instances(describeInstancesResult.getReservations());

    Set<String> expectedAvailabilityZones = Sets
            .newHashSet(Iterables.transform(expectedEc2Instances, EC2_INSTANCE_TO_AVAILABILITY_ZONE));
    Listener expectedListener = new Listener("HTTP", 80, 8080);

    String loadBalancerName = applicationIdentifier;

    LoadBalancerDescription actualLoadBalancerDescription;
    try {
        DescribeLoadBalancersResult describeLoadBalancers = elb
                .describeLoadBalancers(new DescribeLoadBalancersRequest(Arrays.asList(loadBalancerName)));
        if (describeLoadBalancers.getLoadBalancerDescriptions().isEmpty()) {
            // unexpected, this should have been a
            // LoadBalancerNotFoundException
            actualLoadBalancerDescription = null;
        } else {
            // re-query to get updated config

            actualLoadBalancerDescription = Iterables
                    .getFirst(describeLoadBalancers.getLoadBalancerDescriptions(), null);
        }
    } catch (LoadBalancerNotFoundException e) {
        actualLoadBalancerDescription = null;
    }

    Set<String> actualAvailabilityZones;
    Set<String> actualInstanceIds;
    Policies actualPolicies;
    HealthCheck actualHealthCheck;
    ListenerDescription actualListenerDescription = null;
    if (actualLoadBalancerDescription == null) {
        CreateLoadBalancerRequest createLoadBalancerRequest = new CreateLoadBalancerRequest() //
                .withLoadBalancerName(loadBalancerName) //
                .withAvailabilityZones(expectedAvailabilityZones) //
                .withListeners(expectedListener);
        elb.createLoadBalancer(createLoadBalancerRequest);

        actualListenerDescription = new ListenerDescription().withListener(expectedListener);
        actualAvailabilityZones = expectedAvailabilityZones;
        actualInstanceIds = Collections.emptySet();
        actualHealthCheck = new HealthCheck();
        actualPolicies = new Policies();
    } else {
        // check listeners
        List<ListenerDescription> actualListenerDescriptions = actualLoadBalancerDescription
                .getListenerDescriptions();
        boolean loadBalancerMustBeRecreated;

        if (actualListenerDescriptions.size() == 1) {
            actualListenerDescription = Iterables.getOnlyElement(actualListenerDescriptions);
            Listener actualListener = actualListenerDescription.getListener();
            if (ObjectUtils.equals(expectedListener.getProtocol(), actualListener.getProtocol()) && //
                    ObjectUtils.equals(expectedListener.getLoadBalancerPort(),
                            actualListener.getLoadBalancerPort())
                    && //
                    ObjectUtils.equals(expectedListener.getInstancePort(), actualListener.getInstancePort())) {
                loadBalancerMustBeRecreated = false;
            } else {
                loadBalancerMustBeRecreated = true;
            }
        } else {
            loadBalancerMustBeRecreated = true;
        }

        if (loadBalancerMustBeRecreated) {
            LOGGER.info("Recreate miss configured load balancer actualListeners:{}, expectedListener:{}",
                    actualListenerDescriptions, expectedListener);
            elb.deleteLoadBalancer(new DeleteLoadBalancerRequest(loadBalancerName));
            return createOrUpdateElasticLoadBalancer(healthCheckUri, applicationIdentifier);
        }

        //
        actualAvailabilityZones = Sets.newHashSet(actualLoadBalancerDescription.getAvailabilityZones());
        actualInstanceIds = Sets.newHashSet(
                Iterables.transform(actualLoadBalancerDescription.getInstances(), ELB_INSTANCE_TO_INSTANCE_ID));

        actualHealthCheck = actualLoadBalancerDescription.getHealthCheck();

        actualPolicies = actualLoadBalancerDescription.getPolicies();
    }

    // HEALTH CHECK
    if (!healthCheckUri.startsWith("/")) {
        healthCheckUri = "/" + healthCheckUri;
    }

    HealthCheck expectedHealthCheck = new HealthCheck() //
            .withTarget("HTTP:8080" + healthCheckUri) //
            .withHealthyThreshold(2) //
            .withUnhealthyThreshold(2) //
            .withInterval(30) //
            .withTimeout(2);
    if (Objects.equal(expectedHealthCheck.getTarget(), actualHealthCheck.getTarget()) && //
            Objects.equal(expectedHealthCheck.getHealthyThreshold(), actualHealthCheck.getHealthyThreshold()) && //
            Objects.equal(expectedHealthCheck.getInterval(), actualHealthCheck.getInterval()) && //
            Objects.equal(expectedHealthCheck.getTimeout(), actualHealthCheck.getTimeout()) && //
            Objects.equal(expectedHealthCheck.getUnhealthyThreshold(),
                    actualHealthCheck.getHealthyThreshold())) {
        // health check is ok
    } else {
        LOGGER.info("Set Healthcheck: {}", expectedHealthCheck);
        elb.configureHealthCheck(new ConfigureHealthCheckRequest(loadBalancerName, expectedHealthCheck));
    }

    // AVAILABILITY ZONES
    // enable
    Iterable<String> availabilityZonesToEnable = Sets.difference(expectedAvailabilityZones,
            actualAvailabilityZones);
    LOGGER.info("Enable availability zones: {}", availabilityZonesToEnable);
    if (!Iterables.isEmpty(availabilityZonesToEnable)) {
        elb.enableAvailabilityZonesForLoadBalancer(new EnableAvailabilityZonesForLoadBalancerRequest(
                loadBalancerName, Lists.newArrayList(availabilityZonesToEnable)));
    }

    // disable
    Iterable<String> availabilityZonesToDisable = Sets.difference(actualAvailabilityZones,
            expectedAvailabilityZones);
    LOGGER.info("Disable availability zones: {}", availabilityZonesToDisable);
    if (!Iterables.isEmpty(availabilityZonesToDisable)) {
        elb.disableAvailabilityZonesForLoadBalancer(new DisableAvailabilityZonesForLoadBalancerRequest(
                loadBalancerName, Lists.newArrayList(availabilityZonesToDisable)));
    }

    // STICKINESS
    List<AppCookieStickinessPolicy> appCookieStickinessPoliciesToDelete = actualPolicies
            .getAppCookieStickinessPolicies();
    LOGGER.info("Delete app cookie stickiness policies: {}", appCookieStickinessPoliciesToDelete);
    for (AppCookieStickinessPolicy appCookieStickinessPolicyToDelete : appCookieStickinessPoliciesToDelete) {
        elb.deleteLoadBalancerPolicy(new DeleteLoadBalancerPolicyRequest(loadBalancerName,
                appCookieStickinessPolicyToDelete.getPolicyName()));
    }

    final LBCookieStickinessPolicy expectedLbCookieStickinessPolicy = new LBCookieStickinessPolicy(
            applicationIdentifier + "-stickiness-policy", null);
    Predicate<LBCookieStickinessPolicy> isExpectedPolicyPredicate = new Predicate<LBCookieStickinessPolicy>() {
        @Override
        public boolean apply(LBCookieStickinessPolicy lbCookieStickinessPolicy) {
            return Objects.equal(expectedLbCookieStickinessPolicy.getPolicyName(),
                    lbCookieStickinessPolicy.getPolicyName()) && //
            Objects.equal(expectedLbCookieStickinessPolicy.getCookieExpirationPeriod(),
                    lbCookieStickinessPolicy.getCookieExpirationPeriod());
        }
    };
    Collection<LBCookieStickinessPolicy> lbCookieStickinessPoliciesToDelete = Collections2
            .filter(actualPolicies.getLBCookieStickinessPolicies(), Predicates.not(isExpectedPolicyPredicate));
    LOGGER.info("Delete lb cookie stickiness policies: {}", lbCookieStickinessPoliciesToDelete);
    for (LBCookieStickinessPolicy lbCookieStickinessPolicy : lbCookieStickinessPoliciesToDelete) {
        elb.deleteLoadBalancerPolicy(new DeleteLoadBalancerPolicyRequest(loadBalancerName,
                lbCookieStickinessPolicy.getPolicyName()));
    }

    Collection<LBCookieStickinessPolicy> matchingLbCookieStyckinessPolicy = Collections2
            .filter(actualPolicies.getLBCookieStickinessPolicies(), isExpectedPolicyPredicate);
    if (matchingLbCookieStyckinessPolicy.isEmpty()) {
        // COOKIE STICKINESS
        CreateLBCookieStickinessPolicyRequest createLbCookieStickinessPolicy = new CreateLBCookieStickinessPolicyRequest() //
                .withLoadBalancerName(loadBalancerName) //
                .withPolicyName(expectedLbCookieStickinessPolicy.getPolicyName())
                //
                .withCookieExpirationPeriod(expectedLbCookieStickinessPolicy.getCookieExpirationPeriod());
        LOGGER.info("Create LBCookieStickinessPolicy: {}", createLbCookieStickinessPolicy);
        elb.createLBCookieStickinessPolicy(createLbCookieStickinessPolicy);

    } else {
        // what ?
    }

    // TODO verify load balancer policy is associated with the listener
    List<String> expectedListenerDescriptionPolicyNames = Lists
            .newArrayList(expectedLbCookieStickinessPolicy.getPolicyName());

    boolean mustOverWriteListenerPolicy = !ObjectUtils.equals(expectedListenerDescriptionPolicyNames,
            actualListenerDescription.getPolicyNames());

    if (mustOverWriteListenerPolicy) {

        SetLoadBalancerPoliciesOfListenerRequest setLoadBalancerPoliciesOfListenerRequest = new SetLoadBalancerPoliciesOfListenerRequest() //
                .withLoadBalancerName(loadBalancerName) //
                .withLoadBalancerPort(expectedListener.getLoadBalancerPort()) //
                .withPolicyNames(expectedLbCookieStickinessPolicy.getPolicyName());
        LOGGER.debug("setLoadBalancerPoliciesOfListener: {}", setLoadBalancerPoliciesOfListenerRequest);
        elb.setLoadBalancerPoliciesOfListener(setLoadBalancerPoliciesOfListenerRequest);
    }

    // INSTANCES
    Set<String> expectedEc2InstanceIds = Sets
            .newHashSet(Iterables.transform(expectedEc2Instances, EC2_INSTANCE_TO_INSTANCE_ID));
    // register
    Iterable<String> instanceIdsToRegister = Sets.difference(expectedEc2InstanceIds, actualInstanceIds);
    LOGGER.info("Register {} instances: {}", applicationIdentifier, instanceIdsToRegister);
    if (!Iterables.isEmpty(instanceIdsToRegister)) {
        elb.registerInstancesWithLoadBalancer(new RegisterInstancesWithLoadBalancerRequest(loadBalancerName,
                Lists.newArrayList(Iterables.transform(instanceIdsToRegister, INSTANCE_ID_TO_ELB_INSTANCE))));
    }

    // deregister
    Iterable<String> instanceIdsToDeregister = Sets.difference(actualInstanceIds, expectedEc2InstanceIds);
    LOGGER.info("Deregister {} instances: {}", applicationIdentifier, instanceIdsToDeregister);
    if (!Iterables.isEmpty(instanceIdsToDeregister)) {
        elb.deregisterInstancesFromLoadBalancer(new DeregisterInstancesFromLoadBalancerRequest(loadBalancerName,
                Lists.newArrayList(Iterables.transform(instanceIdsToDeregister, INSTANCE_ID_TO_ELB_INSTANCE))));
    }

    // QUERY TO GET UP TO DATE LOAD BALANCER DESCRIPTION
    LoadBalancerDescription elasticLoadBalancerDescription = Iterables.getOnlyElement(
            elb.describeLoadBalancers(new DescribeLoadBalancersRequest(Arrays.asList(loadBalancerName)))
                    .getLoadBalancerDescriptions());

    return elasticLoadBalancerDescription;
}

From source file:fr.xebia.workshop.infrastructureascode.AmazonAwsPetclinicInfrastructureEnforcer.java

License:Apache License

/**
 * /* w ww.j a v a  2s.  c om*/
 * @param healthCheckUri
 *            start with slash. E.g. "/myapp/healthcheck.jsp
 * @param applicationIdentifier
 *            used to name the load balancer and to filter the instances on
 *            their "Role" tag.
 * @return created load balancer description
 */
@Nonnull
public LoadBalancerDescription createOrUpdateElasticLoadBalancer(@Nonnull String healthCheckUri,
        @Nonnull String applicationIdentifier) {
    logger.info("ENFORCE LOAD BALANCER");

    DescribeInstancesRequest describeInstancesWithRoleRequest = new DescribeInstancesRequest(). //
            withFilters(new Filter("tag:Role", Arrays.asList(applicationIdentifier)));
    DescribeInstancesResult describeInstancesResult = ec2.describeInstances(describeInstancesWithRoleRequest);

    Iterable<Instance> expectedEc2Instances = toEc2Instances(describeInstancesResult.getReservations());

    Set<String> expectedAvailabilityZones = Sets
            .newHashSet(Iterables.transform(expectedEc2Instances, EC2_INSTANCE_TO_AVAILABILITY_ZONE));
    Listener expectedListener = new Listener("HTTP", 80, 8080);

    String loadBalancerName = applicationIdentifier;

    LoadBalancerDescription actualLoadBalancerDescription;
    try {
        DescribeLoadBalancersResult describeLoadBalancers = elb
                .describeLoadBalancers(new DescribeLoadBalancersRequest(Arrays.asList(loadBalancerName)));
        if (describeLoadBalancers.getLoadBalancerDescriptions().isEmpty()) {
            // unexpected, this should have been a
            // LoadBalancerNotFoundException
            actualLoadBalancerDescription = null;
        } else {
            // re-query to get updated config

            actualLoadBalancerDescription = Iterables
                    .getFirst(describeLoadBalancers.getLoadBalancerDescriptions(), null);
        }
    } catch (LoadBalancerNotFoundException e) {
        actualLoadBalancerDescription = null;
    }

    Set<String> actualAvailabilityZones;
    Set<String> actualInstanceIds;
    Policies actualPolicies;
    HealthCheck actualHealthCheck;
    ListenerDescription actualListenerDescription = null;
    if (actualLoadBalancerDescription == null) {
        CreateLoadBalancerRequest createLoadBalancerRequest = new CreateLoadBalancerRequest() //
                .withLoadBalancerName(loadBalancerName) //
                .withAvailabilityZones(expectedAvailabilityZones) //
                .withListeners(expectedListener);
        elb.createLoadBalancer(createLoadBalancerRequest);

        actualListenerDescription = new ListenerDescription().withListener(expectedListener);
        actualAvailabilityZones = expectedAvailabilityZones;
        actualInstanceIds = Collections.emptySet();
        actualHealthCheck = new HealthCheck();
        actualPolicies = new Policies();
    } else {
        // check listeners
        List<ListenerDescription> actualListenerDescriptions = actualLoadBalancerDescription
                .getListenerDescriptions();
        boolean loadBalancerMustBeRecreated;

        if (actualListenerDescriptions.size() == 1) {
            actualListenerDescription = Iterables.getOnlyElement(actualListenerDescriptions);
            Listener actualListener = actualListenerDescription.getListener();
            if (ObjectUtils.equals(expectedListener.getProtocol(), actualListener.getProtocol()) && //
                    ObjectUtils.equals(expectedListener.getLoadBalancerPort(),
                            actualListener.getLoadBalancerPort())
                    && //
                    ObjectUtils.equals(expectedListener.getInstancePort(), actualListener.getInstancePort())) {
                loadBalancerMustBeRecreated = false;
            } else {
                loadBalancerMustBeRecreated = true;
            }
        } else {
            loadBalancerMustBeRecreated = true;
        }

        if (loadBalancerMustBeRecreated) {
            logger.info("Recreate miss configured load balancer actualListeners:{}, expectedListener:{}",
                    actualListenerDescriptions, expectedListener);
            elb.deleteLoadBalancer(new DeleteLoadBalancerRequest(loadBalancerName));
            return createOrUpdateElasticLoadBalancer(healthCheckUri, applicationIdentifier);
        }

        //
        actualAvailabilityZones = Sets.newHashSet(actualLoadBalancerDescription.getAvailabilityZones());
        actualInstanceIds = Sets.newHashSet(
                Iterables.transform(actualLoadBalancerDescription.getInstances(), ELB_INSTANCE_TO_INSTANCE_ID));

        actualHealthCheck = actualLoadBalancerDescription.getHealthCheck();

        actualPolicies = actualLoadBalancerDescription.getPolicies();
    }

    // HEALTH CHECK
    if (!healthCheckUri.startsWith("/")) {
        healthCheckUri = "/" + healthCheckUri;
    }

    HealthCheck expectedHealthCheck = new HealthCheck() //
            .withTarget("HTTP:8080" + healthCheckUri) //
            .withHealthyThreshold(2) //
            .withUnhealthyThreshold(2) //
            .withInterval(30) //
            .withTimeout(2);
    if (Objects.equal(expectedHealthCheck.getTarget(), actualHealthCheck.getTarget()) && //
            Objects.equal(expectedHealthCheck.getHealthyThreshold(), actualHealthCheck.getHealthyThreshold()) && //
            Objects.equal(expectedHealthCheck.getInterval(), actualHealthCheck.getInterval()) && //
            Objects.equal(expectedHealthCheck.getTimeout(), actualHealthCheck.getTimeout()) && //
            Objects.equal(expectedHealthCheck.getUnhealthyThreshold(),
                    actualHealthCheck.getHealthyThreshold())) {
        // health check is ok
    } else {
        logger.info("Set Healthcheck: " + expectedHealthCheck);
        elb.configureHealthCheck(new ConfigureHealthCheckRequest(loadBalancerName, expectedHealthCheck));
    }

    // AVAILABILITY ZONES
    // enable
    Iterable<String> availabilityZonesToEnable = Sets.difference(expectedAvailabilityZones,
            actualAvailabilityZones);
    logger.info("Enable availability zones: " + availabilityZonesToEnable);
    if (!Iterables.isEmpty(availabilityZonesToEnable)) {
        elb.enableAvailabilityZonesForLoadBalancer(new EnableAvailabilityZonesForLoadBalancerRequest(
                loadBalancerName, Lists.newArrayList(availabilityZonesToEnable)));
    }

    // disable
    Iterable<String> availabilityZonesToDisable = Sets.difference(actualAvailabilityZones,
            expectedAvailabilityZones);
    logger.info("Disable availability zones: " + availabilityZonesToDisable);
    if (!Iterables.isEmpty(availabilityZonesToDisable)) {
        elb.disableAvailabilityZonesForLoadBalancer(new DisableAvailabilityZonesForLoadBalancerRequest(
                loadBalancerName, Lists.newArrayList(availabilityZonesToDisable)));
    }

    // STICKINESS
    List<AppCookieStickinessPolicy> appCookieStickinessPoliciesToDelete = actualPolicies
            .getAppCookieStickinessPolicies();
    logger.info("Delete app cookie stickiness policies:" + appCookieStickinessPoliciesToDelete);
    for (AppCookieStickinessPolicy appCookieStickinessPolicyToDelete : appCookieStickinessPoliciesToDelete) {
        elb.deleteLoadBalancerPolicy(new DeleteLoadBalancerPolicyRequest(loadBalancerName,
                appCookieStickinessPolicyToDelete.getPolicyName()));
    }

    final LBCookieStickinessPolicy expectedLbCookieStickinessPolicy = new LBCookieStickinessPolicy(
            applicationIdentifier + "-stickiness-policy", null);
    Predicate<LBCookieStickinessPolicy> isExpectedPolicyPredicate = new Predicate<LBCookieStickinessPolicy>() {
        @Override
        public boolean apply(LBCookieStickinessPolicy lbCookieStickinessPolicy) {
            return Objects.equal(expectedLbCookieStickinessPolicy.getPolicyName(),
                    lbCookieStickinessPolicy.getPolicyName()) && //
            Objects.equal(expectedLbCookieStickinessPolicy.getCookieExpirationPeriod(),
                    lbCookieStickinessPolicy.getCookieExpirationPeriod());
        }
    };
    Collection<LBCookieStickinessPolicy> lbCookieStickinessPoliciesToDelete = Collections2
            .filter(actualPolicies.getLBCookieStickinessPolicies(), Predicates.not(isExpectedPolicyPredicate));
    logger.info("Delete lb cookie stickiness policies: " + lbCookieStickinessPoliciesToDelete);
    for (LBCookieStickinessPolicy lbCookieStickinessPolicy : lbCookieStickinessPoliciesToDelete) {
        elb.deleteLoadBalancerPolicy(new DeleteLoadBalancerPolicyRequest(loadBalancerName,
                lbCookieStickinessPolicy.getPolicyName()));
    }

    Collection<LBCookieStickinessPolicy> matchingLbCookieStyckinessPolicy = Collections2
            .filter(actualPolicies.getLBCookieStickinessPolicies(), isExpectedPolicyPredicate);
    if (matchingLbCookieStyckinessPolicy.isEmpty()) {
        // COOKIE STICKINESS
        CreateLBCookieStickinessPolicyRequest createLbCookieStickinessPolicy = new CreateLBCookieStickinessPolicyRequest() //
                .withLoadBalancerName(loadBalancerName) //
                .withPolicyName(expectedLbCookieStickinessPolicy.getPolicyName()) //
                .withCookieExpirationPeriod(expectedLbCookieStickinessPolicy.getCookieExpirationPeriod());
        logger.info("Create LBCookieStickinessPolicy: " + createLbCookieStickinessPolicy);
        elb.createLBCookieStickinessPolicy(createLbCookieStickinessPolicy);

    } else {
        // what ?
    }

    // TODO verify load balancer policy is associated with the listener
    List<String> expectedListenerDescriptionPolicyNames = Lists
            .newArrayList(expectedLbCookieStickinessPolicy.getPolicyName());

    boolean mustOverWriteListenerPolicy = !ObjectUtils.equals(expectedListenerDescriptionPolicyNames,
            actualListenerDescription.getPolicyNames());

    if (mustOverWriteListenerPolicy) {

        SetLoadBalancerPoliciesOfListenerRequest setLoadBalancerPoliciesOfListenerRequest = new SetLoadBalancerPoliciesOfListenerRequest() //
                .withLoadBalancerName(loadBalancerName) //
                .withLoadBalancerPort(expectedListener.getLoadBalancerPort()) //
                .withPolicyNames(expectedLbCookieStickinessPolicy.getPolicyName());
        logger.debug("setLoadBalancerPoliciesOfListener: {}", setLoadBalancerPoliciesOfListenerRequest);
        elb.setLoadBalancerPoliciesOfListener(setLoadBalancerPoliciesOfListenerRequest);
    }

    // INSTANCES
    Set<String> expectedEc2InstanceIds = Sets
            .newHashSet(Iterables.transform(expectedEc2Instances, EC2_INSTANCE_TO_INSTANCE_ID));
    // register
    Iterable<String> instanceIdsToRegister = Sets.difference(expectedEc2InstanceIds, actualInstanceIds);
    logger.info("Register " + applicationIdentifier + " instances: " + instanceIdsToRegister);
    if (!Iterables.isEmpty(instanceIdsToRegister)) {
        elb.registerInstancesWithLoadBalancer(new RegisterInstancesWithLoadBalancerRequest(loadBalancerName,
                Lists.newArrayList(Iterables.transform(instanceIdsToRegister, INSTANCE_ID_TO_ELB_INSTANCE))));
    }

    // deregister
    Iterable<String> instanceIdsToDeregister = Sets.difference(actualInstanceIds, expectedEc2InstanceIds);
    logger.info("Deregister " + applicationIdentifier + " instances: " + instanceIdsToDeregister);
    if (!Iterables.isEmpty(instanceIdsToDeregister)) {
        elb.deregisterInstancesFromLoadBalancer(new DeregisterInstancesFromLoadBalancerRequest(loadBalancerName,
                Lists.newArrayList(Iterables.transform(instanceIdsToDeregister, INSTANCE_ID_TO_ELB_INSTANCE))));
    }

    // QUERY TO GET UP TO DATE LOAD BALANCER DESCRIPTION
    LoadBalancerDescription elasticLoadBalancerDescription = Iterables.getOnlyElement(
            elb.describeLoadBalancers(new DescribeLoadBalancersRequest(Arrays.asList(loadBalancerName)))
                    .getLoadBalancerDescriptions());

    return elasticLoadBalancerDescription;
}

From source file:org.apache.stratos.aws.extension.AWSHelper.java

License:Apache License

private void applyPolicyToListener(String loadBalancerName, int listenerPort, String policyName,
        String region) {/*from w  w  w .ja  va2 s .  co  m*/

    SetLoadBalancerPoliciesOfListenerRequest loadBalancerPoliciesOfListenerReq = new SetLoadBalancerPoliciesOfListenerRequest()
            .withLoadBalancerName(loadBalancerName).withLoadBalancerPort(listenerPort)
            .withPolicyNames(policyName);

    elbClient.setEndpoint(String.format(Constants.ELB_ENDPOINT_URL_FORMAT, region));

    SetLoadBalancerPoliciesOfListenerResult setLBPoliciesOfListenerRes = null;
    try {
        setLBPoliciesOfListenerRes = elbClient
                .setLoadBalancerPoliciesOfListener(loadBalancerPoliciesOfListenerReq);

    } catch (AmazonServiceException e) {
        log.error(e.getMessage(), e);

    } catch (AmazonClientException e) {
        log.error(e.getMessage(), e);
    }

    if (setLBPoliciesOfListenerRes == null) {
        log.error("Unable to apply policy " + policyName + " for Listener port: " + listenerPort + " for LB: "
                + loadBalancerName);
    } else {
        log.info("Successfully applied policy " + policyName + " for Listener port: " + listenerPort
                + " for LB: " + loadBalancerName);
    }
}

From source file:org.openinfinity.cloud.service.administrator.EC2Wrapper.java

License:Apache License

public void setLoadBalancerPoliciesOfListener(String policyName, String lbName, Integer lbPort) {
    if (this.cloudType == InstanceService.CLOUD_TYPE_AMAZON) {
        try {//from   www  .j  a  v  a 2  s . co  m
            SetLoadBalancerPoliciesOfListenerRequest request = new SetLoadBalancerPoliciesOfListenerRequest();
            request.setLoadBalancerName(lbName);
            request.setLoadBalancerPort(lbPort);
            ArrayList<String> policyList = new ArrayList<String>();
            policyList.add(policyName);
            request.setPolicyNames(policyList);
            LOG.info(request.toString());
            lb.setLoadBalancerPoliciesOfListener(request);
        } catch (Exception e) {
            String message = e.getMessage();
            LOG.error("Error setting load balancer policy: " + message);
            ExceptionUtil.throwSystemException(message, e);
        }
    }
}

From source file:web.component.impl.aws.AWSELBImpl.java

@Override
public SetLoadBalancerPoliciesOfListenerResult setLoadBalancerPoliciesOfListener(String loadBalancerName,
        int port, Collection<String> policyNames) {

    return setLoadBalancerPoliciesOfListener(new SetLoadBalancerPoliciesOfListenerRequest()
            .withLoadBalancerName(loadBalancerName).withLoadBalancerPort(port).withPolicyNames(policyNames));

}