Esempio n. 1
0
  /** Unbind the EIP that this instance is associated with. */
  public void unbindEIP() throws Exception {
    InstanceInfo myInfo = applicationInfoManager.getInfo();
    String myPublicIP = null;
    if (myInfo != null && myInfo.getDataCenterInfo().getName() == Name.Amazon) {
      myPublicIP = ((AmazonInfo) myInfo.getDataCenterInfo()).get(MetaDataKey.publicIpv4);
      if (myPublicIP == null) {
        logger.info("Instance is not associated with an EIP. Will not try to unbind");
        return;
      }

      try {
        AmazonEC2 ec2Service = getEC2Service();
        DescribeAddressesRequest describeAddressRequest =
            new DescribeAddressesRequest().withPublicIps(myPublicIP);
        DescribeAddressesResult result = ec2Service.describeAddresses(describeAddressRequest);
        if ((result.getAddresses() != null) && (!result.getAddresses().isEmpty())) {
          Address eipAddress = result.getAddresses().get(0);
          DisassociateAddressRequest dissociateRequest = new DisassociateAddressRequest();
          String domain = eipAddress.getDomain();
          if ("vpc".equals(domain)) {
            dissociateRequest.setAssociationId(eipAddress.getAssociationId());
          } else {
            dissociateRequest.setPublicIp(eipAddress.getPublicIp());
          }

          ec2Service.disassociateAddress(dissociateRequest);
          logger.info("Dissociated the EIP {} from this instance", myPublicIP);
        }
      } catch (Throwable e) {
        throw new RuntimeException("Cannot dissociate address from this instance", e);
      }
    }
  }
  public Address unmarshall(StaxUnmarshallerContext context) throws Exception {
    Address address = new Address();
    int originalDepth = context.getCurrentDepth();
    int targetDepth = originalDepth + 1;

    if (context.isStartOfDocument()) targetDepth += 1;

    while (true) {
      XMLEvent xmlEvent = context.nextEvent();
      if (xmlEvent.isEndDocument()) return address;

      if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

        if (context.testExpression("instanceId", targetDepth)) {
          address.setInstanceId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("publicIp", targetDepth)) {
          address.setPublicIp(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("allocationId", targetDepth)) {
          address.setAllocationId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("associationId", targetDepth)) {
          address.setAssociationId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("domain", targetDepth)) {
          address.setDomain(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("networkInterfaceId", targetDepth)) {
          address.setNetworkInterfaceId(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("networkInterfaceOwnerId", targetDepth)) {
          address.setNetworkInterfaceOwnerId(
              StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }

        if (context.testExpression("privateIpAddress", targetDepth)) {
          address.setPrivateIpAddress(StringStaxUnmarshaller.getInstance().unmarshall(context));
          continue;
        }
      } else if (xmlEvent.isEndElement()) {
        if (context.getCurrentDepth() < originalDepth) {
          return address;
        }
      }
    }
  }
Esempio n. 3
0
  /**
   * Checks if an EIP is bound and optionally binds the EIP.
   *
   * <p>The list of EIPs are arranged with the EIPs allocated in the zone first followed by other
   * EIPs.
   *
   * <p>If an EIP is already bound to this instance this method simply returns. Otherwise, this
   * method tries to find an unused EIP based on information from AWS. If it cannot find any unused
   * EIP this method, it will be retried for a specified interval.
   *
   * <p>One of the following scenarios can happen here :
   *
   * <p>1) If the instance is already bound to an EIP as deemed by AWS, no action is taken. 2) If an
   * EIP is already bound to another instance as deemed by AWS, that EIP is skipped. 3) If an EIP is
   * not already bound to an instance and if this instance is not bound to an EIP, then the EIP is
   * bound to this instance.
   */
  public void bindEIP() {
    InstanceInfo myInfo = applicationInfoManager.getInfo();
    String myInstanceId = ((AmazonInfo) myInfo.getDataCenterInfo()).get(MetaDataKey.instanceId);
    String myZone = ((AmazonInfo) myInfo.getDataCenterInfo()).get(MetaDataKey.availabilityZone);

    Collection<String> candidateEIPs = getCandidateEIPs(myInstanceId, myZone);

    AmazonEC2 ec2Service = getEC2Service();
    boolean isMyinstanceAssociatedWithEIP = false;
    Address selectedEIP = null;

    for (String eipEntry : candidateEIPs) {
      try {
        String associatedInstanceId;

        // Check with AWS, if this EIP is already been used by another instance
        DescribeAddressesRequest describeAddressRequest =
            new DescribeAddressesRequest().withPublicIps(eipEntry);
        DescribeAddressesResult result = ec2Service.describeAddresses(describeAddressRequest);
        if ((result.getAddresses() != null) && (!result.getAddresses().isEmpty())) {
          Address eipAddress = result.getAddresses().get(0);
          associatedInstanceId = eipAddress.getInstanceId();
          // This EIP is not used by any other instance, hence mark it for selection if it is not
          // already marked.
          if (((associatedInstanceId == null) || (associatedInstanceId.isEmpty()))) {
            if (selectedEIP == null) {
              selectedEIP = eipAddress;
            }
          } else if (isMyinstanceAssociatedWithEIP = (associatedInstanceId.equals(myInstanceId))) {
            // This EIP is associated with an instance, check if this is the same as the current
            // instance.
            // If it is the same, stop searching for an EIP as this instance is already associated
            // with an
            // EIP
            selectedEIP = eipAddress;
            break;
          } else {
            // The EIP is used by some other instance, hence skip it
            logger.warn(
                "The selected EIP {} is associated with another instance {} according to AWS,"
                    + " hence skipping this",
                eipEntry,
                associatedInstanceId);
          }
        }
      } catch (Throwable t) {
        logger.error("Failed to bind elastic IP: {} to {}", eipEntry, myInstanceId, t);
      }
    }
    if (null != selectedEIP) {
      String publicIp = selectedEIP.getPublicIp();
      // Only bind if the EIP is not already associated
      if (!isMyinstanceAssociatedWithEIP) {

        AssociateAddressRequest associateAddressRequest =
            new AssociateAddressRequest().withInstanceId(myInstanceId);

        String domain = selectedEIP.getDomain();
        if ("vpc".equals(domain)) {
          associateAddressRequest.setAllocationId(selectedEIP.getAllocationId());
        } else {
          associateAddressRequest.setPublicIp(publicIp);
        }

        ec2Service.associateAddress(associateAddressRequest);
        logger.info(
            "\n\n\nAssociated {} running in zone: {} to elastic IP: {}",
            myInstanceId,
            myZone,
            publicIp);
      }
      logger.info(
          "My instance {} seems to be already associated with the EIP {}", myInstanceId, publicIp);
    } else {
      logger.info(
          "No EIP is free to be associated with this instance. Candidate EIPs are: {}",
          candidateEIPs);
    }
  }