@Override
public NodeMetadata createNodeWithGroupEncodedIntoNameThenStoreCredentials(
String group, String name, Template template, Map<String, Credentials> credentialStore) {
NodeMetadataBuilder builder = new NodeMetadataBuilder();
String id = idProvider.get() + "";
builder.ids(id);
builder.name(name);
// using a predictable name so tests will pass
builder.hostname(group);
builder.tags(template.getOptions().getTags());
builder.group(group);
builder.location(location.get());
builder.imageId(template.getImage().getId());
builder.operatingSystem(template.getImage().getOperatingSystem());
builder.state(NodeState.PENDING);
builder.publicAddresses(ImmutableSet.<String>of(publicIpPrefix + id));
builder.privateAddresses(ImmutableSet.<String>of(privateIpPrefix + id));
Credentials creds = template.getOptions().getOverridingCredentials();
if (creds == null) creds = new Credentials(null, null);
if (creds.identity == null) creds = creds.toBuilder().identity("root").build();
if (creds.credential == null) creds = creds.toBuilder().credential(passwordPrefix + id).build();
builder.credentials(creds);
NodeMetadata node = builder.build();
credentialStore.put("node#" + node.getId(), node.getCredentials());
nodes.put(node.getId(), node);
StubComputeServiceDependenciesModule.setState(node, NodeState.RUNNING, 100);
return node;
}
@Override
public NodeMetadata apply(VirtualGuest from) {
NodeMetadataBuilder builder = new NodeMetadataBuilder();
builder.ids(from.getId() + "");
builder.name(from.getHostname());
builder.hostname(from.getFullyQualifiedDomainName());
if (from.getDatacenter() != null) {
builder.location(
from(locations.get())
.firstMatch(LocationPredicates.idEquals(from.getDatacenter().getName()))
.orNull());
}
builder.group(nodeNamingConvention.groupInUniqueNameOrNull(from.getHostname()));
builder.hardware(virtualGuestToHardware.apply(from));
Image image = virtualGuestToImage.apply(from);
if (image != null) {
builder.imageId(image.getId());
builder.operatingSystem(image.getOperatingSystem());
}
if (from.getPowerState() != null) {
builder.status(serverStateToNodeStatus.get(from.getPowerState().getKeyName()));
}
if (from.getPrimaryIpAddress() != null)
builder.publicAddresses(ImmutableSet.of(from.getPrimaryIpAddress()));
if (from.getPrimaryBackendIpAddress() != null)
builder.privateAddresses(ImmutableSet.of(from.getPrimaryBackendIpAddress()));
// TODO simplify once we move domain classes to AutoValue
if (from.getOperatingSystem() != null
&& from.getOperatingSystem().getPasswords() != null
&& !from.getOperatingSystem().getPasswords().isEmpty()) {
Password password = getBestPassword(from.getOperatingSystem().getPasswords(), from);
builder.credentials(
LoginCredentials.builder()
.identity(password.getUsername())
.credential(password.getPassword())
.build());
}
if (from.getTagReferences() != null && !from.getTagReferences().isEmpty()) {
List<String> tags = Lists.newArrayList();
for (TagReference tagReference : from.getTagReferences()) {
if (tagReference != null) {
tags.add(tagReference.getTag().getName());
}
}
builder.tags(tags);
}
return builder.build();
}
protected NodeMetadataBuilder buildInstance(
final RunningInstance instance, NodeMetadataBuilder builder) {
builder.providerId(instance.getId());
builder.id(instance.getRegion() + "/" + instance.getId());
String group = getGroupForInstance(instance);
builder.group(group);
// standard convention from aws-ec2, which might not be re-used outside.
if (instance.getPrivateDnsName() != null)
builder.hostname(instance.getPrivateDnsName().replaceAll("\\..*", ""));
addCredentialsForInstance(builder, instance);
builder.status(instanceToNodeStatus.get(instance.getInstanceState()));
builder.backendStatus(instance.getRawState());
// collect all ip addresses into one bundle in case the api mistakenly put a private address
// into the public address field
Builder<String> addressesBuilder = ImmutableSet.builder();
if (Strings.emptyToNull(instance.getIpAddress()) != null)
addressesBuilder.add(instance.getIpAddress());
// Add dnsName (if available) to addresses, when the IPAddress is null
// happens on Eucalyptus sometimes.
else if (Strings.emptyToNull(instance.getDnsName()) != null)
addressesBuilder.add(instance.getDnsName());
if (Strings.emptyToNull(instance.getPrivateIpAddress()) != null)
addressesBuilder.add(instance.getPrivateIpAddress());
Set<String> addresses = addressesBuilder.build();
builder.publicAddresses(filter(addresses, not(IsPrivateIPAddress.INSTANCE)));
builder.privateAddresses(filter(addresses, IsPrivateIPAddress.INSTANCE));
builder.hardware(parseHardware(instance));
Location location = getLocationForAvailabilityZoneOrRegion(instance);
builder.location(location);
builder.imageId(instance.getRegion() + "/" + instance.getImageId());
// extract the operating system from the image
RegionAndName regionAndName = new RegionAndName(instance.getRegion(), instance.getImageId());
try {
Image image = imageMap.get().getUnchecked(regionAndName);
if (image != null) builder.operatingSystem(image.getOperatingSystem());
} catch (CacheLoader.InvalidCacheLoadException e) {
logger.debug("image not found for %s: %s", regionAndName, e);
} catch (UncheckedExecutionException e) {
logger.debug("error getting image for %s: %s", regionAndName, e);
}
return builder;
}
@Override
public NodeMetadata apply(ServerInZone serverInZone) {
Location zone = locationIndex.get().get(serverInZone.getZone());
checkState(
zone != null,
"location %s not in locationIndex: %s",
serverInZone.getZone(),
locationIndex.get());
Server from = serverInZone.getServer();
NodeMetadataBuilder builder = new NodeMetadataBuilder();
builder.id(serverInZone.slashEncode());
builder.providerId(from.getId());
builder.name(from.getName());
builder.hostname(from.getName());
builder.location(
from.getHostId() != null
? new LocationBuilder()
.scope(LocationScope.HOST)
.id(from.getHostId())
.description(from.getHostId())
.parent(zone)
.build()
: zone);
addMetadataAndParseTagsFromCommaDelimitedValue(builder, from.getMetadata());
builder.group(nodeNamingConvention.groupInUniqueNameOrNull(from.getName()));
builder.imageId(
ZoneAndId.fromZoneAndId(serverInZone.getZone(), from.getImage().getId()).slashEncode());
builder.operatingSystem(findOperatingSystemForServerOrNull(serverInZone));
builder.hardware(findHardwareForServerOrNull(serverInZone));
builder.status(from.getStatus().getNodeStatus());
builder.publicAddresses(
filter(
transform(
filter(from.getAddresses().values(), Predicates.not(isPrivateAddress)),
AddressToStringTransformationFunction.INSTANCE),
isInet4Address));
builder.privateAddresses(
filter(
transform(
filter(from.getAddresses().values(), isPrivateAddress),
AddressToStringTransformationFunction.INSTANCE),
isInet4Address));
return builder.build();
}
@Override
public NodeMetadata apply(Server from) {
// convert the result object to a jclouds NodeMetadata
NodeMetadataBuilder builder = new NodeMetadataBuilder();
builder.ids(from.id + "");
builder.name(from.name);
builder.location(findLocationForServer.apply(from));
builder.group(nodeNamingConvention.groupInUniqueNameOrNull(from.name));
builder.imageId(from.imageId + "");
Image image = findImageForServer.apply(from);
if (image != null) builder.operatingSystem(image.getOperatingSystem());
builder.hardware(findHardwareForServer.apply(from));
builder.state(serverStatusToNodeState.get(from.status));
builder.publicAddresses(ImmutableSet.<String>of(from.publicAddress));
builder.privateAddresses(ImmutableSet.<String>of(from.privateAddress));
builder.credentials(LoginCredentials.fromCredentials(credentialStore.get(from.id + "")));
return builder.build();
}
@Override
public NodeMetadata apply(Server from) {
NodeMetadataBuilder builder = new NodeMetadataBuilder();
builder.ids(from.getId() + "");
builder.name(from.getName());
builder.hostname(from.getName());
builder.location(
new LocationBuilder()
.scope(LocationScope.HOST)
.id(from.getHostId())
.description(from.getHostId())
.parent(location.get())
.build());
addMetadataAndParseTagsFromCommaDelimitedValue(builder, from.getMetadata());
builder.group(groupFromMapOrName(from.getMetadata(), from.getName(), nodeNamingConvention));
builder.imageId(from.getImageId() + "");
builder.operatingSystem(parseOperatingSystem(from));
builder.hardware(parseHardware(from));
builder.status(serverToNodeStatus.get(from.getStatus()));
builder.publicAddresses(from.getAddresses().getPublicAddresses());
builder.privateAddresses(from.getAddresses().getPrivateAddresses());
return builder.build();
}
@Override
public NodeMetadata apply(VirtualMachine from) {
// convert the result object to a jclouds NodeMetadata
NodeMetadataBuilder builder = new NodeMetadataBuilder();
builder.ids(from.getId() + "");
builder.name(from.getName());
// TODO: in cloudstack 2.2.12, when "name" was set fine on the backend,
// but wrong API response was returned to the user
// http://bugs.cloud.com/show_bug.cgi?id=11664
//
// we set displayName to the same value as name, but this could be wrong
// on hosts not started with jclouds
builder.hostname(from.getDisplayName());
builder.location(findLocationForVirtualMachine.apply(from));
builder.group(parseGroupFromName(from.getDisplayName()));
Image image = findImageForVirtualMachine.apply(from);
if (image != null) {
builder.imageId(image.getId());
builder.operatingSystem(image.getOperatingSystem());
}
builder.hardware(
new HardwareBuilder()
.ids(from.getServiceOfferingId() + "")
.name(from.getServiceOfferingName() + "")
// .tags() TODO
.processors(ImmutableList.of(new Processor(from.getCpuCount(), from.getCpuSpeed())))
.ram((int) from.getMemory()) //
.hypervisor(from.getHypervisor()) //
.build());
builder.state(vmStateToNodeState.get(from.getState()));
Set<String> publicAddresses = newHashSet(), privateAddresses = newHashSet();
if (from.getIPAddress() != null) {
boolean isPrivate = isPrivateIPAddress(from.getIPAddress());
if (isPrivate) {
privateAddresses.add(from.getIPAddress());
} else {
publicAddresses.add(from.getIPAddress());
}
}
for (NIC nic : from.getNICs()) {
if (nic.getIPAddress() != null) {
if (isPrivateIPAddress(nic.getIPAddress())) {
privateAddresses.add(nic.getIPAddress());
} else {
publicAddresses.add(nic.getIPAddress());
}
}
}
try {
/* Also add to the list of public IPs any public IP address that has a
forwarding rule that links to this machine */
Iterables.addAll(
publicAddresses,
transform(
filter(
getIPForwardingRulesByVirtualMachine.getUnchecked(from.getId()),
new Predicate<IPForwardingRule>() {
@Override
public boolean apply(@Nullable IPForwardingRule rule) {
return !"Deleting".equals(rule.getState());
}
}),
new Function<IPForwardingRule, String>() {
@Override
public String apply(@Nullable IPForwardingRule rule) {
return rule.getIPAddress();
}
}));
} catch (UncheckedExecutionException e) {
if (Throwables2.getFirstThrowableOfType(e, ResourceNotFoundException.class) == null) {
Throwables.propagateIfPossible(e.getCause());
throw e;
}
}
return builder.privateAddresses(privateAddresses).publicAddresses(publicAddresses).build();
}