Example usage for com.amazonaws.services.ec2.model Instance getPublicDnsName

List of usage examples for com.amazonaws.services.ec2.model Instance getPublicDnsName

  1. HOME
  2. Java
  3. com.amazonaws
  4. com.amazonaws.services.ec2.model.*
  5. Instance
  6. getPublicDnsName

Introduction

In this page you can find the example usage for com.amazonaws.services.ec2.model Instance getPublicDnsName.

Prototype


public String getPublicDnsName()

Source Link

Document

(IPv4 only) The public DNS name assigned to the instance.

Usage

From source file:AwsSample.java

License:Open Source License

public static void main(String[] args) throws Exception {

    BasicAWSCredentials credentials = new BasicAWSCredentials("", "");

    /*********************************************
     * //  w  w w.  j ava2 s . co  m
     *  #1 Create Amazon Client object
     *  
     *********************************************/
    System.out.println("#1 Create Amazon Client object");
    ec2 = new AmazonEC2Client(credentials);

    try {

        /*********************************************
         * 
          *  #2 Describe Availability Zones.
          *  
          *********************************************/
        System.out.println("#2 Describe Availability Zones.");
        DescribeAvailabilityZonesResult availabilityZonesResult = ec2.describeAvailabilityZones();
        System.out.println("You have access to " + availabilityZonesResult.getAvailabilityZones().size()
                + " Availability Zones.");

        /*********************************************
         * 
         *  #3 Describe Available Images
         *  
         *********************************************/
        System.out.println("#3 Describe Available Images");
        DescribeImagesResult dir = ec2.describeImages();
        List<Image> images = dir.getImages();
        System.out.println("You have " + images.size() + " Amazon images");

        /*********************************************
         *                 
         *  #4 Describe Key Pair
         *                 
         *********************************************/
        System.out.println("#9 Describe Key Pair");
        DescribeKeyPairsResult dkr = ec2.describeKeyPairs();
        System.out.println(dkr.toString());

        /*********************************************
         * 
         *  #5 Describe Current Instances
         *  
         *********************************************/
        System.out.println("#4 Describe Current Instances");
        DescribeInstancesResult describeInstancesRequest = ec2.describeInstances();
        List<Reservation> reservations = describeInstancesRequest.getReservations();
        Set<Instance> instances = new HashSet<Instance>();
        // add all instances to a Set.
        for (Reservation reservation : reservations) {
            instances.addAll(reservation.getInstances());
        }

        System.out.println("You have " + instances.size() + " Amazon EC2 instance(s).");
        for (Instance ins : instances) {

            // instance id
            String instanceId = ins.getInstanceId();

            // instance state
            InstanceState is = ins.getState();
            System.out.println(instanceId + " " + is.getName());
        }
        ///////////////////////////////////////

        String Temp_Group = "Testgroup1"; //name of the group
        CreateSecurityGroupRequest r1 = new CreateSecurityGroupRequest(Temp_Group, "temporal group");
        ec2.createSecurityGroup(r1);
        AuthorizeSecurityGroupIngressRequest r2 = new AuthorizeSecurityGroupIngressRequest();
        r2.setGroupName(Temp_Group);

        /*************the property of http*****************/
        IpPermission permission = new IpPermission();
        permission.setIpProtocol("tcp");
        permission.setFromPort(80);
        permission.setToPort(80);
        List<String> ipRanges = new ArrayList<String>();
        ipRanges.add("0.0.0.0/0");
        permission.setIpRanges(ipRanges);

        /*************the property of SSH**********************/
        IpPermission permission1 = new IpPermission();
        permission1.setIpProtocol("tcp");
        permission1.setFromPort(22);
        permission1.setToPort(22);
        List<String> ipRanges1 = new ArrayList<String>();
        ipRanges1.add("0.0.0.0/22");
        permission1.setIpRanges(ipRanges1);

        /*************the property of https**********************/
        IpPermission permission2 = new IpPermission();
        permission2.setIpProtocol("tcp");
        permission2.setFromPort(443);
        permission2.setToPort(443);
        List<String> ipRanges2 = new ArrayList<String>();
        ipRanges2.add("0.0.0.0/0");
        permission2.setIpRanges(ipRanges2);

        /*************the property of tcp**********************/
        IpPermission permission3 = new IpPermission();
        permission3.setIpProtocol("tcp");
        permission3.setFromPort(0);
        permission3.setToPort(65535);
        List<String> ipRanges3 = new ArrayList<String>();
        ipRanges3.add("0.0.0.0/0");
        permission3.setIpRanges(ipRanges3);

        /**********************add rules to the group*********************/
        List<IpPermission> permissions = new ArrayList<IpPermission>();
        permissions.add(permission);
        permissions.add(permission1);
        permissions.add(permission2);
        permissions.add(permission3);
        r2.setIpPermissions(permissions);

        ec2.authorizeSecurityGroupIngress(r2);
        List<String> groupName = new ArrayList<String>();
        groupName.add(Temp_Group);//wait to out our instance into this group

        /*********************************************
        *
        *  #6.2 Create a New Key Pair
        * 
        *********************************************/

        CreateKeyPairRequest newKeyRequest = new CreateKeyPairRequest();
        newKeyRequest.setKeyName("Test_Key2");
        CreateKeyPairResult keyresult = ec2.createKeyPair(newKeyRequest);

        /************************print the properties of this key*****************/
        KeyPair kp = new KeyPair();

        kp = keyresult.getKeyPair();
        System.out.println("The key we created is = " + kp.getKeyName() + "\nIts fingerprint is="
                + kp.getKeyFingerprint() + "\nIts material is= \n" + kp.getKeyMaterial());

        String fileName = "C:/Users/Akhil/workspace/Test_Key2.pem";
        File distFile = new File(fileName);
        BufferedReader bufferedReader = new BufferedReader(new StringReader(kp.getKeyMaterial()));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(distFile));
        char buf[] = new char[1024];
        int len;
        while ((len = bufferedReader.read(buf)) != -1) {
            bufferedWriter.write(buf, 0, len);
        }
        bufferedWriter.flush();
        bufferedReader.close();
        bufferedWriter.close();
        //String myinstance; 
        /*********************************************
          * 
          *  #6 Create an Instance
          *  
          *********************************************/
        System.out.println("#5 Create an Instance");
        String imageId = "ami-76f0061f"; //Basic 32-bit Amazon Linux AMI
        int minInstanceCount = 1; // create 1 instance
        int maxInstanceCount = 1;
        RunInstancesRequest rir = new RunInstancesRequest(imageId, minInstanceCount, maxInstanceCount);
        rir.setKeyName("Test_Key2");
        rir.withSecurityGroups("Testgroup1");

        RunInstancesResult result = ec2.runInstances(rir);

        //get instanceId from the result
        List<Instance> resultInstance = result.getReservation().getInstances();
        String createdInstanceId = null;
        String myAvailabilityZone = null;
        for (Instance ins : resultInstance) {
            createdInstanceId = ins.getInstanceId();
            System.out.println("New instance has been created: " + ins.getInstanceId());
            //myinstance = ins.getInstanceId();

        }

        Thread.currentThread().sleep(60000);

        /*********************************************
         * 
         * 
         * Create a New Volume and attach it
         * 
         ***********************************************/

        List<Instance> resultInstance2 = result.getReservation().getInstances();

        createdInstanceId = null;
        for (Instance ins : resultInstance2) {

            createdInstanceId = ins.getInstanceId();
            System.out.println("New instance has been created: " + ins.getInstanceId());//print the instance ID

            /*********************************************
              * 
              *  #6.4 Create an Instance
              *  
              *********************************************/

            CreateVolumeRequest newVol = new CreateVolumeRequest(1, "us-east-1a");

            CreateVolumeResult volresult = ec2.createVolume(newVol);
            Volume vol1 = volresult.getVolume();
            String volId = vol1.getVolumeId();
            Thread.currentThread().sleep(30000);

            AttachVolumeRequest attachRequest = new AttachVolumeRequest().withInstanceId(createdInstanceId)
                    .withVolumeId(volId);
            attachRequest.withDevice("/dev/sda5");
            ec2.attachVolume(attachRequest);

            System.out.println("EBS volume has been attached and the volume ID is: " + volId);
        }
        /*********************************************
         * 
         *  #7 Create a 'tag' for the new instance.
         *  
         *********************************************/
        System.out.println("#6 Create a 'tag' for the new instance.");
        List<String> resources = new LinkedList<String>();
        List<Tag> tags = new LinkedList<Tag>();
        Tag nameTag = new Tag("Akhil", "MyFirstInstance");

        resources.add(createdInstanceId);
        tags.add(nameTag);

        CreateTagsRequest ctr = new CreateTagsRequest(resources, tags);
        ec2.createTags(ctr);

        /*********************************************
         * 
         *  #8 Stop/Start an Instance
         *  
         *********************************************/
        System.out.println("#7 Stop the Instance");
        List<String> instanceIds = new LinkedList<String>();
        instanceIds.add(createdInstanceId);

        //stop
        StopInstancesRequest stopIR = new StopInstancesRequest(instanceIds);
        ec2.stopInstances(stopIR);

        //start
        StartInstancesRequest startIR = new StartInstancesRequest(instanceIds);
        ec2.startInstances(startIR);

        System.out.println("#8 Getting DNS, IP.");

        DescribeInstancesRequest request = new DescribeInstancesRequest();
        request.setInstanceIds(instanceIds);

        DescribeInstancesResult result1 = ec2.describeInstances(request);
        List<Reservation> reservations1 = result1.getReservations();

        List<Instance> instances1;
        for (Reservation res : reservations1) {
            instances1 = res.getInstances();
            for (Instance ins1 : instances1) {
                System.out
                        .println("The public DNS is: " + ins1.getPublicDnsName() + "\n" + ins1.getRamdiskId());
                System.out.println("The private IP is: " + ins1.getPrivateIpAddress());
                System.out.println("The public IP is: " + ins1.getPublicIpAddress());

            }

            /*********************************************
                     
                    
              *  #10 Terminate an Instance
              *  
              *********************************************/
            System.out.println("#8 Terminate the Instance");
            TerminateInstancesRequest tir = new TerminateInstancesRequest(instanceIds);
            //ec2.terminateInstances(tir);

            /*********************************************
             *  
             *  #11 shutdown client object
             *  
             *********************************************/
            ec2.shutdown();

        }
    } catch (AmazonServiceException ase) {
        System.out.println("Caught Exception: " + ase.getMessage());
        System.out.println("Reponse Status Code: " + ase.getStatusCode());
        System.out.println("Error Code: " + ase.getErrorCode());
        System.out.println("Request ID: " + ase.getRequestId());
    }

}

From source file:AWS.java

private void jButton4ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton4ActionPerformed
    // TODO add your handling code here:
    // Group handealing

    List<String> groupID = new ArrayList<String>();
    String Temp_Group = "sg-aa5efdcf";

    groupID.add(Temp_Group);//wait to out our instance into this group

    System.out.println("#5 Create an Instance");
    String imageId = "ami-08be1f7f";//  
    int minInstanceCount = 1; // create 1 instance
    int maxInstanceCount = 1;
    RunInstancesRequest rir = new RunInstancesRequest(imageId, minInstanceCount, maxInstanceCount);

    rir.setInstanceType("t2.micro");
    rir.setKeyName("14_LP1_KEY_D7001D_aledem-4");// give the instance the key we just created
    // rir.setSecurityGroups(groupName);// set the instance in the group we just created
    rir.setSecurityGroupIds(groupID);/*from  www. jav  a 2 s  .  c  om*/
    rir.setSubnetId("subnet-47ca2d1e");

    RunInstancesResult result = ec2client.runInstances(rir);

    /***********to make sure the instance's state is "running instead of "pending",**********/
    /***********we wait for a while                                                **********/
    System.out.println("waiting");
    try {
        Thread.currentThread().sleep(60000);
    } catch (InterruptedException ex) {
        Logger.getLogger(AWS.class.getName()).log(Level.SEVERE, null, ex);
    }
    System.out.println("OK");

    List<Instance> resultInstance = result.getReservation().getInstances();

    String createdInstanceId = null;
    for (Instance ins : resultInstance) {

        createdInstanceId = ins.getInstanceId();
        String createdInstanceIp = ins.getPublicDnsName();

        System.out.println("New instance has been created: " + ins.getInstanceId());//print the instance ID

    }

    System.out.println("#6 Create a 'tag' for the new instance.");
    List<String> resources = new LinkedList<>();
    List<Tag> tags = new LinkedList<>();
    Tag nameTag = new Tag("Name", "FromCoordinator");

    resources.add(createdInstanceId);
    tags.add(nameTag);

    CreateTagsRequest ctr = new CreateTagsRequest(resources, tags);
    ec2client.createTags(ctr);

    fetchInstanceInfo(createdInstanceId);
}

From source file:com.appdynamics.connectors.AWSConnector.java

License:Apache License

public IMachine createMachine(IComputeCenter computeCenter, IImage image, IMachineDescriptor machineDescriptor)
        throws InvalidObjectException, ConnectorException {
    boolean succeeded = false;
    Exception createFailureRootCause = null;
    Instance instance = null;

    try {/*from   www  . j a  v a  2s .  c  o  m*/
        IProperty[] macProps = machineDescriptor.getProperties();

        AmazonEC2 connector = getConnector(image, computeCenter, controllerServices);
        String amiName = Utils.getAMIName(image.getProperties(), controllerServices);
        List<String> securityGroups = getSecurityGroup(macProps);
        validateAndConfigureSecurityGroups(securityGroups, connector);

        controllerServices.getStringPropertyByName(macProps, Utils.SECURITY_GROUP)
                .setValue(getSecurityGroupsAsString(securityGroups));

        String keyPair = Utils.getKeyPair(macProps, controllerServices);

        InstanceType instanceType = getInstanceType(macProps);

        String zone = Utils.getZone(macProps, controllerServices);
        String kernel = Utils.getKernel(macProps, controllerServices);
        String ramdisk = Utils.getRamDisk(macProps, controllerServices);

        String controllerHost = System.getProperty(CONTROLLER_SERVICES_HOST_NAME_PROPERTY_KEY,
                InetAddress.getLocalHost().getHostName());

        int controllerPort = Integer.getInteger(CONTROLLER_SERVICES_PORT_PROPERTY_KEY,
                DEFAULT_CONTROLLER_PORT_VALUE);

        IAccount account = computeCenter.getAccount();

        String accountName = account.getName();
        String accountAccessKey = account.getAccessKey();

        AgentResolutionEncoder agentResolutionEncoder = new AgentResolutionEncoder(controllerHost,
                controllerPort, accountName, accountAccessKey);

        String userData = agentResolutionEncoder.encodeAgentResolutionInfo();

        String instanceName = Utils.getInstanceName(macProps, controllerServices);

        logger.info("Starting EC2 machine of Image :" + amiName + " Name :" + instanceName + " security :"
                + securityGroups + " keypair :" + keyPair + " instance :" + instanceType + " zone :" + zone
                + " kernel :" + kernel + " ramdisk :" + ramdisk + " userData :" + userData);

        RunInstancesRequest runInstancesRequest = new RunInstancesRequest(amiName, 1, 1);
        runInstancesRequest.setSecurityGroups(securityGroups);
        runInstancesRequest.setUserData(Base64.encodeAsString(userData.getBytes()));
        runInstancesRequest.setKeyName(keyPair);
        runInstancesRequest.setInstanceType(instanceType);
        runInstancesRequest.setKernelId(kernel);
        runInstancesRequest.setRamdiskId(ramdisk);

        Reservation reservation = connector.runInstances(runInstancesRequest).getReservation();
        List<Instance> instances = reservation.getInstances();

        if (instances.size() == 0)
            throw new ConnectorException("Cannot create instance for image :" + image.getName());

        instance = instances.get(0);

        //Set name for the instance
        if (!Strings.isNullOrEmpty(instanceName)) {
            CreateTagsRequest createTagsRequest = new CreateTagsRequest();
            createTagsRequest.withResources(instance.getInstanceId()).withTags(new Tag("Name", instanceName));
            connector.createTags(createTagsRequest);
        }

        logger.info("EC2 machine started; id:" + instance.getInstanceId());

        IMachine machine;

        if (Strings.isNullOrEmpty(instance.getPublicDnsName())) {
            machine = controllerServices.createMachineInstance(instance.getInstanceId(),
                    agentResolutionEncoder.getUniqueHostIdentifier(), computeCenter, machineDescriptor, image,
                    getAgentPort());
        } else {
            machine = controllerServices.createMachineInstance(instance.getInstanceId(),
                    agentResolutionEncoder.getUniqueHostIdentifier(), instance.getPublicDnsName(),
                    computeCenter, machineDescriptor, image, getAgentPort());
        }

        if (kernel == null) {
            controllerServices.getStringPropertyByName(macProps, Utils.KERNEL).setValue(instance.getKernelId());
        }

        if (zone == null) {
            DescribeAvailabilityZonesResult describeAvailabilityZonesResult = connector
                    .describeAvailabilityZones();
            List<AvailabilityZone> availabilityZones = describeAvailabilityZonesResult.getAvailabilityZones();
            controllerServices.getStringPropertyByName(macProps, Utils.ZONE)
                    .setValue(availabilityZones.get(0).getZoneName());
        }

        controllerServices.getStringPropertyByName(macProps, Utils.INSTANCE_TYPE)
                .setValue(instance.getInstanceType());

        succeeded = true;

        return machine;

    } catch (InvalidObjectException e) {
        createFailureRootCause = e;
        throw e;
    } catch (ConnectorException e) {
        createFailureRootCause = e;
        throw e;
    } catch (Exception e) {
        createFailureRootCause = e;
        throw new ConnectorException(e.getMessage(), e);
    } finally {
        // We have to make sure to terminate any orphan EC2 instances if 
        // the machine create fails.
        if (!succeeded && instance != null) {
            try {
                ConnectorLocator.getInstance().getConnector(computeCenter, controllerServices)
                        .terminateInstances(
                                new TerminateInstancesRequest(Lists.newArrayList(instance.getInstanceId())));
            } catch (Exception e) {
                throw new ConnectorException("Machine create failed, but terminate failed as well! "
                        + "We have an orphan EC2 instance with id: " + instance.getInstanceId()
                        + " that must be shut down manually. Root cause for machine "
                        + "create failure is following: ", createFailureRootCause);
            }
        }
    }
}

From source file:com.appdynamics.connectors.AWSConnector.java

License:Apache License

public void refreshMachineState(IMachine machine) throws InvalidObjectException, ConnectorException {
    AmazonEC2 connector = getConnector(machine.getImage(), machine.getComputeCenter(), controllerServices);

    Instance ec2Instance = getEc2Instance(machine, connector);

    MachineState currentState = machine.getState();

    if (ec2Instance == null) {
        // machine not found. MUST have been terminated
        if (currentState != STOPPED)
            machine.setState(STOPPED);//from w  w  w.  ja  v  a 2  s .  co m
    } else {
        MachineState newState = getMachineState(ec2Instance);

        if (newState == STARTED) {
            // IP may only be set when the machine is running
            String elasticIp = Utils.getElasticIP(machine.getMachineDescriptor().getProperties(),
                    controllerServices);

            elasticIp = elasticIp == null ? "" : elasticIp.trim();

            if (elasticIp.length() > 0) {
                // associate the address
                setElasticIp(machine, elasticIp, connector);
            } else {
                machine.setIpAddress(ec2Instance.getPublicDnsName());
            }
        }

        if (newState != currentState) {
            machine.setState(newState);
        }
    }
}

From source file:com.automata.cloudcore.xmlbindings.RunningInstancesItemType.java

License:Open Source License

public RunningInstancesItemType(Instance instance) {
    this.instanceId = instance.getInstanceId();
    InstanceStateType instanceStateType = new InstanceStateType();
    instanceStateType.setName(instance.getInstanceLifecycle());
    //instanceStateType.setCode();
    this.instanceState = instanceStateType;
    this.privateDnsName = instance.getPrivateDnsName();
    this.imageId = instance.getImageId();
    this.dnsName = instance.getPublicDnsName();
    //this.reason   = instance.get
    this.keyName = instance.getKeyName();
    if (instance.getStateTransitionReason() != null)
        this.reason = instance.getStateTransitionReason().toString();
    this.amiLaunchIndex = instance.getAmiLaunchIndex().toString();
    //this.productCodes = instance.getProductCodes();
    this.instanceType = instance.getInstanceType();
    //this.launchTime = instance.getLaunchTime();
    //this.placement = instance.getPlacement();
    this.kernelId = instance.getKernelId();
    this.ramdiskId = instance.getRamdiskId();
    this.platform = instance.getPlatform();

    InstanceMonitoringStateType instanceMonitoringStateType;
    instanceMonitoringStateType = new InstanceMonitoringStateType();
    instanceMonitoringStateType.setState(instance.getMonitoring().toString());
    this.monitoring = instanceMonitoringStateType;

    this.subnetId = instance.getSubnetId();
    this.vpcId = instance.getVpcId();
    this.privateIpAddress = instance.getPrivateIpAddress();
    this.ipAddress = instance.getPublicIpAddress();
    this.sourceDestCheck = instance.getSourceDestCheck();
    //this.groupSet = 

    if (instance.getStateReason() != null) {
        StateReasonType stateReasonType = new StateReasonType();
        stateReasonType.setMessage(instance.getStateReason().getMessage());
        this.stateReason = stateReasonType;
    }// w w  w.j  a va2s  .  c  om
    this.architecture = instance.getArchitecture();
    this.rootDeviceType = instance.getRootDeviceType();
    this.rootDeviceName = instance.getRootDeviceName();

    /*BlockDeviceMappingsType blockDeviceMappingsType = new BlockDeviceMappingsType();
    List<BlockDeviceMapping> blockDeviceMappingList = new ArrayList<BlockDeviceMapping>();
    BlockDeviceMapping blockDeviceMapping = new BlockDeviceMapping();
    for (){
               
    }
            
    blockDeviceMappingsType = 
    this.blockDeviceMapping = instance.getBlockDeviceMappings();*/
    this.instanceLifecycle = instance.getInstanceLifecycle();
    this.spotInstanceRequestId = instance.getSpotInstanceRequestId();

    if (instance.getLicense() != null) {
        InstanceLicenseResponseType instanceLicenseResponseType;
        instanceLicenseResponseType = new InstanceLicenseResponseType();
        instanceLicenseResponseType.setPool(instance.getLicense().getPool());
        this.license = instanceLicenseResponseType;
    }

    this.virtualizationType = instance.getVirtualizationType();
    this.clientToken = instance.getClientToken();

    /*ResourceTagSetType resourceTagSetType;
    ResourceTagSetItemType resourceTagSetItemType;
    List<ResourceTagSetItemType> resourceTagSetItemTypeList;
            
    resourceTagSetItemTypeList = new ArrayList<ResourceTagSetItemType>();
            
    resourceTagSetType = new ResourceTagSetType();
    resourceTagSetType.getItem()
    this.tagSet = instance.getTags();
    this.hypervisor = instance.get*/
}

From source file:com.axemblr.provisionr.amazon.activities.PublishListOfMachines.java

License:Apache License

@Override
public void execute(AmazonEC2 client, Pool pool, DelegateExecution execution) throws Exception {
    @SuppressWarnings("unchecked")
    List<String> instanceIds = (List<String>) execution.getVariable(ProcessVariables.INSTANCE_IDS);
    checkNotNull(instanceIds, "%s not found as a process variable", ProcessVariables.INSTANCE_IDS);

    LOG.info(">> Describing instances {}", instanceIds);
    DescribeInstancesResult result = client
            .describeInstances(new DescribeInstancesRequest().withInstanceIds(instanceIds));
    checkArgument(result.getReservations().size() == 1, "found more than one reservation");

    Reservation reservation = result.getReservations().get(0);
    LOG.info("<< Got one reservation with {} running instances", reservation.getInstances().size());

    List<Machine> machines = Lists.transform(reservation.getInstances(), new Function<Instance, Machine>() {
        @Override//from  w  w  w  .  ja  va2 s.c  om
        public Machine apply(Instance instance) {
            return Machine.builder().externalId(instance.getInstanceId())
                    .publicDnsName(instance.getPublicDnsName()).publicIp(instance.getPublicIpAddress())
                    .privateDnsName(instance.getPrivateDnsName()).privateIp(instance.getPrivateIpAddress())
                    .createMachine();
        }
    });

    /* Create a new ArrayList to force evaluation for lazy collections */
    execution.setVariable(CoreProcessVariables.MACHINES, Lists.newArrayList(machines));
}

From source file:com.bloomreach.bstore.highavailability.zookeeper.ZkClient.java

License:Apache License

/**
 * Fetch the public DNS names for the corresponding private Ips. SolrCloud defaults to private ips for all
 * interactions. If you want to run HAFT locally to copy data across 2 different zookeeper clusters, then we need
 * public IP translations to access the index. This method helps achieve that.
 *
 * @return {@link #getZkClusterData()} with private Ip to Public DNS Mapping based on EC2 api.
 *//*  w  ww  .  j a v  a2  s .c  o m*/
public ZkClusterData translatePrivateIpToPublicHostNames() {
    AWSCredentials credentials = new BasicAWSCredentials(AwsConfigReader.fetchAccessKey(),
            AwsConfigReader.fetchSecretyKey());
    AmazonEC2 ec2 = new AmazonEC2Client(credentials);

    Set<String> publicDnsNameHosts = new HashSet<String>();
    Map<String, String> privateIptoPublicHostNames = new HashMap<String, String>();

    if (allSolrNodes.isEmpty()) {
        logger.info("No valid solr hosts are found. Cannot do any mapping");
        return zkClusterData;
    }

    //Describe Filter with private-ips matching all solr nodes
    DescribeInstancesRequest request = new DescribeInstancesRequest()
            .withFilters(new Filter("private-ip-address").withValues(allSolrNodes));
    DescribeInstancesResult describeInstancesResult = ec2.describeInstances(request);
    List<Reservation> reservations = describeInstancesResult.getReservations();
    //Iterate over all instances and map their private Ip to Public Host Name
    logger.info("Fetching Public HostNames....");

    for (Reservation reservation : reservations) {
        List<Instance> instances = reservation.getInstances();
        for (Instance instance : instances) {
            logger.info("Private to Public Name of the Host is " + instance.getPrivateIpAddress() + " => "
                    + instance.getPublicDnsName());
            publicDnsNameHosts.add(instance.getPublicDnsName());
            privateIptoPublicHostNames.put(instance.getPrivateIpAddress(), instance.getPublicDnsName());
        }

    }
    //Point all zk data to point to the public dns names
    zkClusterData.updateSolrNodes(publicDnsNameHosts);
    //Set the data in a map so that it doesn't need to get recomputed by every function needing hostnames
    zkClusterData.setPrivateIpToPublicHostNameMap(privateIptoPublicHostNames);
    return zkClusterData;

}

From source file:com.clouck.model.aws.ec2.Ec2Instance.java

@Override
@SuppressWarnings("rawtypes")
protected boolean isEqual(AbstractResource newResource) {
    Instance oldInstance = this.getResource();
    Ec2Instance newEc2Instance = (Ec2Instance) newResource;
    Instance newInstance = newEc2Instance.getResource();

    if (notEqual(oldInstance.getInstanceId(), newInstance.getInstanceId()))
        return false;
    if (notEqual(oldInstance.getImageId(), newInstance.getImageId()))
        return false;
    if (notEqual(oldInstance.getState(), newInstance.getState()))
        return false;
    if (notEqual(oldInstance.getPrivateDnsName(), newInstance.getPrivateDnsName()))
        return false;
    if (notEqual(oldInstance.getPublicDnsName(), newInstance.getPublicDnsName()))
        return false;
    if (notEqual(oldInstance.getStateTransitionReason(), newInstance.getStateTransitionReason()))
        return false;
    if (notEqual(oldInstance.getKeyName(), newInstance.getKeyName()))
        return false;
    if (notEqual(oldInstance.getAmiLaunchIndex(), newInstance.getAmiLaunchIndex()))
        return false;
    if (notEqualCollection(oldInstance.getProductCodes(), newInstance.getProductCodes()))
        return false;
    if (notEqual(oldInstance.getInstanceType(), newInstance.getInstanceType()))
        return false;
    if (notEqual(oldInstance.getLaunchTime(), newInstance.getLaunchTime()))
        return false;
    if (notEqual(oldInstance.getPlacement(), newInstance.getPlacement()))
        return false;
    if (notEqual(oldInstance.getKernelId(), newInstance.getKernelId()))
        return false;
    if (notEqual(oldInstance.getRamdiskId(), newInstance.getRamdiskId()))
        return false;
    if (notEqual(oldInstance.getPlatform(), newInstance.getPlatform()))
        return false;
    if (notEqual(oldInstance.getMonitoring(), newInstance.getMonitoring()))
        return false;
    if (notEqual(oldInstance.getSubnetId(), newInstance.getSubnetId()))
        return false;
    if (notEqual(oldInstance.getVpcId(), newInstance.getVpcId()))
        return false;
    if (notEqual(oldInstance.getPrivateIpAddress(), newInstance.getPrivateIpAddress()))
        return false;
    if (notEqual(oldInstance.getPublicIpAddress(), newInstance.getPublicIpAddress()))
        return false;
    if (notEqual(oldInstance.getStateReason(), newInstance.getStateReason()))
        return false;
    if (notEqual(oldInstance.getArchitecture(), newInstance.getArchitecture()))
        return false;
    if (notEqual(oldInstance.getRootDeviceType(), newInstance.getRootDeviceType()))
        return false;
    if (notEqual(oldInstance.getRootDeviceName(), newInstance.getRootDeviceName()))
        return false;
    if (notEqualCollection(oldInstance.getBlockDeviceMappings(), newInstance.getBlockDeviceMappings()))
        return false;
    if (notEqual(oldInstance.getVirtualizationType(), newInstance.getVirtualizationType()))
        return false;
    if (notEqual(oldInstance.getInstanceLifecycle(), newInstance.getInstanceLifecycle()))
        return false;
    if (notEqual(oldInstance.getSpotInstanceRequestId(), newInstance.getSpotInstanceRequestId()))
        return false;
    if (notEqual(oldInstance.getLicense(), newInstance.getLicense()))
        return false;
    if (notEqual(oldInstance.getClientToken(), newInstance.getClientToken()))
        return false;
    if (notEqualCollection(oldInstance.getTags(), newInstance.getTags()))
        return false;
    if (notEqualCollection(oldInstance.getSecurityGroups(), newInstance.getSecurityGroups()))
        return false;
    if (notEqual(oldInstance.getSourceDestCheck(), newInstance.getSourceDestCheck()))
        return false;
    if (notEqual(oldInstance.getHypervisor(), newInstance.getHypervisor()))
        return false;
    if (notEqualNetworkInterfaces(oldInstance.getNetworkInterfaces(), newInstance.getNetworkInterfaces()))
        return false;
    if (notEqual(oldInstance.getIamInstanceProfile(), newInstance.getIamInstanceProfile()))
        return false;
    if (notEqual(oldInstance.getEbsOptimized(), newInstance.getEbsOptimized()))
        return false;
    if (notEqual(this.getTerminationProtection(), newEc2Instance.getTerminationProtection()))
        return false;
    if (notEqual(this.getShutdownBehavior(), newEc2Instance.getShutdownBehavior()))
        return false;
    if (notEqual(this.getUserData(), newEc2Instance.getUserData()))
        return false;

    return true;/*from   w  w  w .j a  va 2  s  . co  m*/
}

From source file:com.deploymentio.ec2namer.helpers.DnsRegistrar.java

License:Apache License

protected Change createName(NamerRequest req, LambdaContext context, String name) {

    Instance instance = instanceLookup.lookup(context, req.getInstanceId());

    boolean isVpc = req.isAlwaysUsePublicName() ? false : !StringUtils.isEmpty(instance.getVpcId());
    RRType recordType = isVpc ? RRType.A : RRType.CNAME;

    ResourceRecordSet set = new ResourceRecordSet(req.createFqdn(name) + ".", recordType);
    set.withTTL(60l);//from  www.j  a  v  a2s  . c o m
    set.withResourceRecords(
            new ResourceRecord(isVpc ? instance.getPrivateIpAddress() : instance.getPublicDnsName()));

    return new Change(ChangeAction.UPSERT, set);
}

From source file:com.deploymentio.ec2namer.helpers.DnsRegistrar.java

License:Apache License

protected Change createName(NamerRequest req, LambdaContext context, RequestedName additionalName,
        String assignedName) {/*from w ww  . j a v  a2 s .c o  m*/

    String fullAssignedName = req.createFqdn(assignedName);
    String fullAdditionalName = req.createFqdn(additionalName.getName());

    Instance instance = instanceLookup.lookup(context, req.getInstanceId());
    boolean usePublicHostname = req.isAlwaysUsePublicName() || StringUtils.isEmpty(instance.getVpcId());

    ResourceRecordSet set = new ResourceRecordSet(fullAdditionalName + ".", RRType.CNAME).withTTL(60l)
            .withResourceRecords(
                    new ResourceRecord(usePublicHostname ? instance.getPublicDnsName() : fullAssignedName))
            .withSetIdentifier(fullAssignedName).withWeight(Long.valueOf(additionalName.getWeight()));

    if (additionalName.isHealthChecked()) {

        String uuid = instance.getInstanceId() + "-" + UUID.randomUUID().toString();
        String hcId = null;

        for (int i = 0; i < 5; i++) {
            try {

                if (i > 0) {
                    Thread.sleep(5000);
                }

                CreateHealthCheckResult result = route53.createHealthCheck(
                        new CreateHealthCheckRequest().withCallerReference(uuid).withHealthCheckConfig(
                                new HealthCheckConfig().withFullyQualifiedDomainName(fullAssignedName)
                                        .withIPAddress(instance.getPublicIpAddress())
                                        .withPort(additionalName.getHealthCheckPort())
                                        .withType(additionalName.getHealthCheckType())
                                        .withResourcePath(additionalName.getHealthCheckUri())));

                hcId = result.getHealthCheck().getId();
                context.log("Created health-check: Name=" + fullAdditionalName + " Protocol="
                        + additionalName.getHealthCheckType() + " Port=" + additionalName.getHealthCheckPort()
                        + " Uri=" + additionalName.getHealthCheckUri() + " Id=" + hcId);

                // create tags on health-check
                route53.changeTagsForResource(new ChangeTagsForResourceRequest().withResourceId(hcId)
                        .withResourceType(TagResourceType.Healthcheck).withAddTags(
                                new Tag().withKey("Name").withValue(req.getEnvironment() + ":" + assignedName),
                                new Tag().withKey("InstanceId").withValue(req.getInstanceId())));

                break;

            } catch (Exception e) {
                context.log("Can't create health-check: Attempt= " + (i + 1) + " Name=" + fullAdditionalName
                        + " Protocol=" + additionalName.getHealthCheckType() + " Port="
                        + additionalName.getHealthCheckPort() + " Uri=" + additionalName.getHealthCheckUri()
                        + " Id=" + hcId + " Ref=" + uuid + " Error=" + e.getMessage());
            }
        }

        if (!StringUtils.isEmpty(hcId)) {
            set.setHealthCheckId(hcId);
        }
    }

    return new Change(ChangeAction.UPSERT, set);
}