Java NodeMetadata.getPublicAddresses方法代码示例

import org.jclouds.compute.domain.NodeMetadata; //导入方法依赖的package包/类
private void sanityCheckSuccessfulNodes(Set<NodeMetadata> successfulNodes,
    Map<NodeMetadata, Throwable> lostNodes) {
  logger.info(String.format("Sanity check on successful nodes... "));
  List<NodeMetadata> tmpNodes = new ArrayList<>();
  tmpNodes.addAll(successfulNodes);
  successfulNodes.clear();
  for (int i = 0; i < tmpNodes.size(); i++) {
    NodeMetadata nm = tmpNodes.get(i);
    if (nm == null) {
      logger.info("for some reason one of the nodes is null, we removed it from the successfull nodes");
    } else if (nm.getPublicAddresses() == null || nm.getPublicAddresses().isEmpty()) {
      logger.info("Ec2 hasn't assined public-ip address to a node, we remove it from successfull nodes");
      lostNodes.put(nm, new KaramelException("No public-ip assigned"));
    } else if (nm.getPrivateAddresses() == null || nm.getPrivateAddresses().isEmpty()) {
      logger.info("Ec2 hasn't assined private-ip address to a node, we remove it from successfull nodes");
      lostNodes.put(nm, new KaramelException("No private-ip assigned"));
    } else {
      successfulNodes.add(nm);
    }
  }
}
 

import org.jclouds.compute.domain.NodeMetadata; //导入方法依赖的package包/类
/**
 * Creates a /etc/hosts file for a particular node
 * @param nodeIndex node index
 * @return hosts file
 */
private String generateHostsFileForNode(int nodeIndex) {
	NodeMetadata thisNode = getNodeMetadata().asList().get(nodeIndex);
	StringBuilder hostsFile = new StringBuilder();
	hostsFile.append("127.0.0.1 localhost\n");
	hostsFile.append("127.0.1.1 "+thisNode.getHostname());
	for (NodeMetadata node : getNodeMetadata()) {
		if (!node.equals(thisNode)) {
			for (String address : node.getPublicAddresses()) {
			hostsFile.append("\n"+address+" "+node.getHostname());
			}
		}
	}
	
	return hostsFile.toString();
}
 

import org.jclouds.compute.domain.NodeMetadata; //导入方法依赖的package包/类
@Override
public String retrievePublicIpAddress( TargetHandlerParameters parameters, String machineId )
throws TargetException {

	ComputeService computeService = jcloudContext( parameters.getTargetProperties());
	NodeMetadata metadata = computeService.getNodeMetadata( machineId );

	String result = null;
	if( metadata != null
			&& metadata.getPublicAddresses() != null
			&& ! metadata.getPublicAddresses().isEmpty())
		result = metadata.getPublicAddresses().iterator().next();

	return result;
}
 

import org.jclouds.compute.domain.NodeMetadata; //导入方法依赖的package包/类
@Override
public List<String> associateAddresses(NodeMetadata node) {

    ComputeServiceContext context = iaasProvider.getComputeService().getContext();
    String region = ComputeServiceBuilderUtil.extractRegion(iaasProvider);

    if (StringUtils.isEmpty(region)) {
        throw new RuntimeException("Could not find region in iaas provider: " + iaasProvider.getName());
    }

    NovaApi novaApi = context.unwrapApi(NovaApi.class);
    FloatingIPApi floatingIPApi = novaApi.getFloatingIPExtensionForZone(region).get();

    String ip = null;
    // first try to find an unassigned IP.
    FluentIterable<FloatingIP> floatingIPs = floatingIPApi.list();
    ArrayList<FloatingIP> unassignedIps = Lists.newArrayList(Iterables.filter(floatingIPs,
            new Predicate<FloatingIP>() {
                @Override
                public boolean apply(FloatingIP floatingIP) {
                    return floatingIP.getInstanceId() == null;
                }
            }));

    if (!unassignedIps.isEmpty()) {
        // try to prevent multiple parallel launches from choosing the same ip.
        Collections.shuffle(unassignedIps);
        ip = Iterables.getLast(unassignedIps).getIp();
    }

    // if no unassigned IP is available, we'll try to allocate an IP.
    if (StringUtils.isEmpty(ip)) {
        String floatingIpPool = iaasProvider.getProperty(CloudControllerConstants.DEFAULT_FLOATING_IP_POOL);
        FloatingIP allocatedFloatingIP;
        if (StringUtils.isEmpty(floatingIpPool)) {
            allocatedFloatingIP = floatingIPApi.create();
        } else {
            log.debug(String.format("Trying to allocate a floating IP address from IP pool %s", floatingIpPool));
            allocatedFloatingIP = floatingIPApi.allocateFromPool(floatingIpPool);
        }
        if (allocatedFloatingIP == null) {
            String msg = String.format("Floating IP API did not return a floating IP address from IP pool %s",
                    floatingIpPool);
            log.error(msg);
            throw new CloudControllerException(msg);
        }
        ip = allocatedFloatingIP.getIp();
    }

    // wait till the fixed IP address gets assigned - this is needed before
    // we associate a public IP
    log.info(String.format("Waiting for private IP addresses get allocated: [node-id] %s", node.getId()));
    while (node.getPrivateAddresses() == null) {
        CloudControllerUtil.sleep(1000);
    }
    log.info(String.format("Private IP addresses allocated: %s", node.getPrivateAddresses()));

    if ((node.getPublicAddresses() != null) && (node.getPublicAddresses().iterator().hasNext())) {
        log.info("Public IP address "
                + node.getPublicAddresses().iterator().next()
                + " is already allocated to the instance: [node-id]  "
                + node.getId());
        return null;
    }

    int retries = 0;
    int retryCount = Integer.getInteger("stratos.public.ip.association.retry.count", 5);
    while ((retries < retryCount) && (!associateIp(floatingIPApi, ip, node.getProviderId()))) {
        // wait for 5s
        CloudControllerUtil.sleep(5000);
        retries++;
    }

    log.info(String.format("Successfully associated an IP address: [node-id] %s [ip] %s", node.getId(), ip));

    List<String> allocatedIPAddresses = new ArrayList<String>();
    allocatedIPAddresses.add(ip);
    return allocatedIPAddresses;
}