org.jclouds.softlayer.compute.strategy.SoftLayerComputeServiceAdapter Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jclouds-shaded Show documentation
Show all versions of jclouds-shaded Show documentation
Provides a shaded jclouds with relocated guava and guice
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jclouds.softlayer.compute.strategy;
import static shaded.com.google.common.base.Preconditions.checkArgument;
import static shaded.com.google.common.base.Preconditions.checkNotNull;
import static shaded.com.google.common.base.Preconditions.checkState;
import static shaded.com.google.common.collect.Iterables.contains;
import static shaded.com.google.common.collect.Iterables.filter;
import static shaded.com.google.common.collect.Iterables.get;
import static shaded.com.google.common.collect.Iterables.tryFind;
import static java.lang.Math.round;
import static java.lang.String.format;
import static org.jclouds.compute.util.ComputeServiceUtils.getCores;
import static org.jclouds.compute.util.ComputeServiceUtils.getSpace;
import static org.jclouds.softlayer.reference.SoftLayerConstants.PROPERTY_SOFTLAYER_VIRTUALGUEST_ACTIVE_TRANSACTIONS_DELAY;
import static org.jclouds.softlayer.reference.SoftLayerConstants.PROPERTY_SOFTLAYER_VIRTUALGUEST_LOGIN_DETAILS_DELAY;
import static org.jclouds.util.Predicates2.retry;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import javax.annotation.Resource;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
import org.jclouds.collect.Memoized;
import org.jclouds.compute.ComputeServiceAdapter;
import org.jclouds.compute.domain.Hardware;
import org.jclouds.compute.domain.HardwareBuilder;
import org.jclouds.compute.domain.Processor;
import org.jclouds.compute.domain.Template;
import org.jclouds.compute.domain.Volume;
import org.jclouds.compute.domain.Volume.Type;
import org.jclouds.compute.domain.internal.VolumeImpl;
import org.jclouds.compute.reference.ComputeServiceConstants;
import org.jclouds.domain.LoginCredentials;
import org.jclouds.logging.Logger;
import org.jclouds.softlayer.SoftLayerApi;
import org.jclouds.softlayer.compute.options.SoftLayerTemplateOptions;
import org.jclouds.softlayer.domain.ContainerVirtualGuestConfiguration;
import org.jclouds.softlayer.domain.Datacenter;
import org.jclouds.softlayer.domain.NetworkVlan;
import org.jclouds.softlayer.domain.OperatingSystem;
import org.jclouds.softlayer.domain.Password;
import org.jclouds.softlayer.domain.SecuritySshKey;
import org.jclouds.softlayer.domain.SoftwareDescription;
import org.jclouds.softlayer.domain.SoftwareLicense;
import org.jclouds.softlayer.domain.VirtualDiskImage;
import org.jclouds.softlayer.domain.VirtualDiskImageSoftware;
import org.jclouds.softlayer.domain.VirtualGuest;
import org.jclouds.softlayer.domain.VirtualGuestAttribute;
import org.jclouds.softlayer.domain.VirtualGuestBlockDevice;
import org.jclouds.softlayer.domain.VirtualGuestBlockDeviceTemplate;
import org.jclouds.softlayer.domain.VirtualGuestBlockDeviceTemplateGroup;
import org.jclouds.softlayer.domain.VirtualGuestNetworkComponent;
import shaded.com.google.common.base.Function;
import shaded.com.google.common.base.Optional;
import shaded.com.google.common.base.Predicate;
import shaded.com.google.common.base.Stopwatch;
import shaded.com.google.common.base.Strings;
import shaded.com.google.common.base.Supplier;
import shaded.com.google.common.collect.ComparisonChain;
import shaded.com.google.common.collect.FluentIterable;
import shaded.com.google.common.collect.ImmutableList;
import shaded.com.google.common.collect.ImmutableSet;
import shaded.com.google.common.collect.ImmutableSet.Builder;
import shaded.com.google.common.collect.ImmutableSortedSet;
import shaded.com.google.common.collect.Sets;
/**
* defines the connection between the {@link SoftLayerApi} implementation and
* the jclouds {@link org.jclouds.compute.ComputeService}
*
*/
@Singleton
public class SoftLayerComputeServiceAdapter implements
ComputeServiceAdapter {
private static final String USER_META_NOTES = "notes";
private static final int USER_META_NOTES_MAX_LENGTH = 1000;
private static final String BOOTABLE_DEVICE = "0";
public static final String DEFAULT_DISK_TYPE = "LOCAL";
@Resource
@Named(ComputeServiceConstants.COMPUTE_LOGGER)
protected Logger logger = Logger.NULL;
private final SoftLayerApi api;
private final Supplier createObjectOptionsSupplier;
private final Predicate loginDetailsTester;
private final long guestLoginDelay;
private final long activeTransactionsDelay;
@Inject
public SoftLayerComputeServiceAdapter(SoftLayerApi api,
VirtualGuestHasLoginDetailsPresent virtualGuestHasLoginDetailsPresent,
@Memoized Supplier createObjectOptionsSupplier,
@Named(PROPERTY_SOFTLAYER_VIRTUALGUEST_LOGIN_DETAILS_DELAY) long guestLoginDelay,
@Named(PROPERTY_SOFTLAYER_VIRTUALGUEST_ACTIVE_TRANSACTIONS_DELAY) long activeTransactionsDelay) {
this.api = checkNotNull(api, "api");
this.guestLoginDelay = guestLoginDelay;
this.activeTransactionsDelay = activeTransactionsDelay;
this.createObjectOptionsSupplier = checkNotNull(createObjectOptionsSupplier, "createObjectOptionsSupplier");
checkArgument(guestLoginDelay > 500, "guestOrderDelay must be in milliseconds and greater than 500");
this.loginDetailsTester = retry(virtualGuestHasLoginDetailsPresent, guestLoginDelay);
}
@Override
public NodeAndInitialCredentials createNodeWithGroupEncodedIntoName(String group, String name,
Template template) {
checkNotNull(template, "template was null");
checkNotNull(template.getOptions(), "template options was null");
checkArgument(template.getOptions().getClass().isAssignableFrom(SoftLayerTemplateOptions.class),
"options class %s should have been assignable from SoftLayerTemplateOptions",
template.getOptions().getClass());
SoftLayerTemplateOptions templateOptions = template.getOptions().as(SoftLayerTemplateOptions.class);
String domainName = templateOptions.getDomainName();
String diskType = templateOptions.getDiskType() == null ? DEFAULT_DISK_TYPE : templateOptions.getDiskType();
boolean hourlyBillingFlag = templateOptions.isHourlyBillingFlag() == null ? true : templateOptions.isHourlyBillingFlag();
Integer portSpeed = templateOptions.getPortSpeed();
Set networkComponents = portSpeed != null ?
ImmutableSet.of(VirtualGuestNetworkComponent.builder().speed(portSpeed).build()) :
ImmutableSet.of();
final Datacenter datacenter = Datacenter.builder().name(template.getLocation().getId()).build();
final String imageId = template.getImage().getId();
int cores = (int) template.getHardware().getProcessors().get(0).getCores();
String notes = getNotes(templateOptions);
VirtualGuest.Builder virtualGuestBuilder = VirtualGuest.builder()
.domain(domainName)
.hostname(name)
.hourlyBillingFlag(hourlyBillingFlag)
.startCpus(cores)
.maxMemory(template.getHardware().getRam())
.datacenter(datacenter)
.localDiskFlag(isLocalDisk(diskType))
.networkComponents(networkComponents);
// set operating system or blockDeviceTemplateGroup
Optional optionalOperatingSystem = tryExtractOperatingSystemFrom(imageId);
if (optionalOperatingSystem.isPresent()) {
virtualGuestBuilder.operatingSystem(optionalOperatingSystem.get());
// the imageId specified is an id of a public/private/flex image
} else {
VirtualGuestBlockDeviceTemplateGroup blockDeviceTemplateGroup = VirtualGuestBlockDeviceTemplateGroup
.builder().globalIdentifier(imageId).build();
virtualGuestBuilder.blockDeviceTemplateGroup(blockDeviceTemplateGroup);
}
// set multi-disks
if (!templateOptions.getBlockDevices().isEmpty()) {
List blockDevices = getBlockDevices(templateOptions.getBlockDevices(), diskType);
virtualGuestBuilder.blockDevices(blockDevices);
}
// set dedicatedAccountHostOnlyFlag
if (templateOptions.isDedicatedAccountHostOnlyFlag() != null) {
virtualGuestBuilder.dedicatedAccountHostOnly(templateOptions.isDedicatedAccountHostOnlyFlag());
}
// set privateNetworkOnlyFlag
if (templateOptions.isPrivateNetworkOnlyFlag() != null) {
virtualGuestBuilder.privateNetworkOnlyFlag(templateOptions.isPrivateNetworkOnlyFlag());
}
// set primaryNetworkComponent.networkVlan.id
if (templateOptions.getPrimaryNetworkComponentNetworkVlanId() != null) {
int primaryNetworkComponentNetworkVlanId = templateOptions.getPrimaryNetworkComponentNetworkVlanId();
virtualGuestBuilder.primaryNetworkComponent(
VirtualGuestNetworkComponent.builder()
.networkVlan(NetworkVlan.builder().id(primaryNetworkComponentNetworkVlanId).build())
.build());
}
// set primaryBackendNetworkComponent.networkVlan.id
if (templateOptions.getPrimaryBackendNetworkComponentNetworkVlanId() != null) {
int primaryBackendNetworkComponentNetworkVlanId = templateOptions.getPrimaryBackendNetworkComponentNetworkVlanId();
virtualGuestBuilder.primaryBackendNetworkComponent(
VirtualGuestNetworkComponent.builder()
.networkVlan(NetworkVlan.builder().id(primaryBackendNetworkComponentNetworkVlanId).build())
.build());
}
// set postInstallScriptUri
if (templateOptions.getPostInstallScriptUri() != null) {
// Specifies the uri location of the script to be downloaded and run after installation is complete.
virtualGuestBuilder.postInstallScriptUri(templateOptions.getPostInstallScriptUri());
}
// set userData
if (templateOptions.getUserData() != null) {
virtualGuestBuilder.virtualGuestAttribute(VirtualGuestAttribute.builder().value(templateOptions.getUserData()).build());
}
// set sshKeys
if (!templateOptions.getSshKeys().isEmpty()) {
Set sshKeys = Sets.newHashSet();
for (int sshKeyId : templateOptions.getSshKeys()) {
sshKeys.add(SecuritySshKey.builder().id(sshKeyId).build());
}
virtualGuestBuilder.sshKeys(sshKeys);
}
VirtualGuest virtualGuest = virtualGuestBuilder.build();
logger.debug(">> creating new VirtualGuest(%s)", virtualGuest);
VirtualGuest result = api.getVirtualGuestApi().createVirtualGuest(virtualGuest);
logger.trace("<< VirtualGuest(%s)", result.getId());
// tags
if (!templateOptions.getTags().isEmpty()) {
api.getVirtualGuestApi().setTags(result.getId(), templateOptions.getTags());
}
// notes
if (!Strings.isNullOrEmpty(notes)) {
api.getVirtualGuestApi().setNotes(result.getId(), notes);
}
logger.debug(">> awaiting login details for virtualGuest(%s)", result.getId());
boolean orderInSystem = loginDetailsTester.apply(result);
logger.trace("<< VirtualGuest(%s) complete(%s)", result.getId(), orderInSystem);
if (!orderInSystem) {
logger.warn("VirtualGuest(%s) doesn't have login details within %sms so it will be destroyed.", result,
Long.toString(guestLoginDelay));
api.getVirtualGuestApi().deleteVirtualGuest(result.getId());
throw new IllegalStateException(format("VirtualGuest(%s) is being destroyed as it doesn't have login details" +
" after %sms. Please, try by increasing `jclouds.softlayer.virtualguest.login_details_delay` and " +
" try again", result, Long.toString(guestLoginDelay)));
}
result = api.getVirtualGuestApi().getVirtualGuest(result.getId());
Password pwd = get(result.getOperatingSystem().getPasswords(), 0);
return new NodeAndInitialCredentials(result, result.getId() + "",
LoginCredentials.builder().user(pwd.getUsername()).password(pwd.getPassword()).build());
}
private String getNotes(SoftLayerTemplateOptions templateOptions) {
String notes = null;
Map meta = templateOptions.getUserMetadata();
if (meta != null) {
notes = meta.get(USER_META_NOTES);
if (!Strings.isNullOrEmpty(notes)) {
checkArgument(notes.length() <= USER_META_NOTES_MAX_LENGTH, "'notes' property in user metadata should be long at most " + USER_META_NOTES_MAX_LENGTH + " characters.");
}
}
return notes;
}
@Override
public Iterable listHardwareProfiles() {
ContainerVirtualGuestConfiguration virtualGuestConfiguration = createObjectOptionsSupplier.get();
Builder hardware = ImmutableSortedSet.orderedBy(new Comparator() {
@Override
public int compare(Hardware h1, Hardware h2) {
List volumes1 = h1.getVolumes();
List volumes2 = h2.getVolumes();
ComparisonChain comparisonChain = ComparisonChain.start().compare(getCores(h1), getCores(h2))
.compare(h1.getRam(), h2.getRam())
.compare(getSpace(h1), getSpace(h2))
.compare(getBootableDeviceType(h1), getBootableDeviceType(h2));
if (!volumes1.isEmpty() && !volumes2.isEmpty() && volumes1.size() == volumes2.size()) {
for (int i = 0; i < volumes1.size(); i++) {
comparisonChain = comparisonChain.compare(volumes1.get(i).getType(), volumes2.get(i).getType());
}
}
return comparisonChain.result();
}
});
for (VirtualGuestBlockDevice blockDevice : virtualGuestConfiguration.getVirtualGuestBlockDevices()) {
float capacity = blockDevice.getVirtualDiskImage().getCapacity();
Type type = blockDevice.getVirtualGuest().isLocalDiskFlag() ? Type.LOCAL : Type.SAN;
if (blockDevice.getDevice().equals(BOOTABLE_DEVICE)) {
for (Integer cpus : virtualGuestConfiguration.getCpusOfProcessors()) {
for (Integer memory : virtualGuestConfiguration.getMemories()) {
String id = format("cpu=%s,memory=%s,disk=%s,type=%s", cpus, memory, round(capacity), type);
hardware.add(new HardwareBuilder()
.ids(id)
.ram(memory)
.processors(ImmutableList.of(new Processor(cpus, 2)))
.hypervisor("XenServer")
.volumes(ImmutableList.of(
new VolumeImpl(blockDevice.getId() + "",
type,
capacity,
blockDevice.getDevice(),
blockDevice.getBootableFlag() == 1,
true)))
.build());
}
}
}
}
return hardware.build();
}
@Override
public Set listImages() {
Set result = Sets.newHashSet();
// add allObjects filtered by the available OS
Set allObjects = api.getSoftwareDescriptionApi().getAllObjects();
for (OperatingSystem os : createObjectOptionsSupplier.get().getVirtualGuestOperatingSystems()) {
result.addAll(FluentIterable.from(allObjects)
.filter(new IsOperatingSystem())
.filter(new HasSameOsReferenceCode(os.getOperatingSystemReferenceCode()))
.transform(new SoftwareDescriptionToOperatingSystem(os.getId()))
.toSet());
}
return result;
}
@Override
public OperatingSystem getImage(final String id) {
// look for imageId among stock images
Optional operatingSystemOptional = tryFind(listImages(),
new Predicate() {
@Override
public boolean apply(OperatingSystem input) {
return input.getId().equals(id);
}
}
);
if (operatingSystemOptional.isPresent()) return operatingSystemOptional.get();
// if imageId is not a stock image, it searches among private and public images
Stopwatch stopwatch = Stopwatch.createStarted();
VirtualGuestBlockDeviceTemplateGroup image = api.getVirtualGuestBlockDeviceTemplateGroupApi().getObject(id);
logger.trace("<< Image(%s) found in (%s)", id, stopwatch.elapsed(TimeUnit.SECONDS));
return tryExtractOperatingSystemFrom(image).orNull();
}
@Override
public Iterable listNodes() {
return api.getAccountApi().listVirtualGuests();
}
@Override
public Iterable listNodesByIds(final Iterable ids) {
return filter(listNodes(), new Predicate() {
@Override
public boolean apply(VirtualGuest server) {
return contains(ids, server.getId());
}
});
}
@Override
public Iterable listLocations() {
Set result = Sets.newHashSet();
Set unfiltered = api.getDatacenterApi().listDatacenters();
Set datacenterAvailable = createObjectOptionsSupplier.get().getVirtualGuestDatacenters();
for (Datacenter datacenter : datacenterAvailable) {
final String datacenterName = datacenter.getName();
result.addAll(Sets.newHashSet(filter(unfiltered,
new Predicate() {
@Override
public boolean apply(Datacenter input) {
return input.getName().equals(datacenterName);
}
})));
}
return result;
}
@Override
public VirtualGuest getNode(String id) {
long serverId = Long.parseLong(id);
return api.getVirtualGuestApi().getVirtualGuest(serverId);
}
@Override
public void destroyNode(String id) {
VirtualGuest guest = getNode(id);
if (guest == null) return;
logger.debug(">> awaiting virtualGuest(%s) without active transactions", guest.getId());
checkState(retry(new Predicate() {
public boolean apply(VirtualGuest guest) {
return getNode(guest.getId() + "").getActiveTransactionCount() == 0;
}
}, activeTransactionsDelay).apply(guest), "%s still has active transactions!", guest);
logger.debug(">> canceling virtualGuest with globalIdentifier(%s)", id);
checkState(api.getVirtualGuestApi().deleteVirtualGuest(guest.getId()), "server(%s) still there after deleting!?", id);
}
@Override
public void rebootNode(String id) {
api.getVirtualGuestApi().rebootHardVirtualGuest(Long.parseLong(id));
}
@Override
public void resumeNode(String id) {
api.getVirtualGuestApi().resumeVirtualGuest(Long.parseLong(id));
}
@Override
public void suspendNode(String id) {
api.getVirtualGuestApi().pauseVirtualGuest(Long.parseLong(id));
}
/**
* This method will deliberately skip device position 1 as it is reserved to SWAP
* @param blockDeviceCapacities list of blockDevices to be attached
* @param diskType disks can be LOCAL or SAN
* @return
*/
private static List getBlockDevices(List blockDeviceCapacities, String diskType) {
ImmutableList.Builder blockDevicesBuilder = ImmutableList.builder();
int devicePosition = 0;
for (int i = 0; i < blockDeviceCapacities.size(); i++) {
if (i > 0) { devicePosition = i + 1; }
blockDevicesBuilder.add(VirtualGuestBlockDevice.builder()
.device(devicePosition + "")
.diskImage(VirtualDiskImage.builder()
.capacity(blockDeviceCapacities.get(i))
.typeId(Type.valueOf(diskType).ordinal())
.build())
.build());
}
return blockDevicesBuilder.build();
}
private static boolean isLocalDisk(String diskType) {
return diskType.equalsIgnoreCase(Type.LOCAL.name());
}
private static int getBootableDeviceType(Hardware hardware) {
List volumes = hardware.getVolumes();
Optional optionalBootableVolume = tryFind(volumes, new Predicate() {
@Override
public boolean apply(Volume volume) {
return volume.getDevice().equals(BOOTABLE_DEVICE);
}
});
if (!optionalBootableVolume.isPresent()) {
return Type.LOCAL.ordinal();
}
return optionalBootableVolume.get().getType().ordinal();
}
private Optional tryExtractOperatingSystemFrom(final String imageId) {
Set operatingSystemsAvailable = createObjectOptionsSupplier.get().getVirtualGuestOperatingSystems();
return FluentIterable.from(operatingSystemsAvailable)
.filter(new Predicate() {
@Override
public boolean apply(OperatingSystem input) {
if (input == null) return false;
return input.getId().contains(imageId);
}
})
.first();
}
private Optional tryExtractOperatingSystemFrom(VirtualGuestBlockDeviceTemplateGroup image) {
if (image.getGlobalIdentifier() == null) return Optional.absent();
return FluentIterable.from(image.getChildren())
.transformAndConcat(new BlockDeviceTemplateGroupToBlockDeviceTemplateIterable())
.filter(new IsBootableDevice())
.transformAndConcat(new BlockDeviceTemplateToDiskImageSoftware())
.transform(new DiskImageSoftwareToSoftwareDescription())
.filter(new IsOperatingSystem())
.transform(new SoftwareDescriptionToOperatingSystem(image.getGlobalIdentifier()))
.first();
}
public static class VirtualGuestHasLoginDetailsPresent implements Predicate {
private final SoftLayerApi client;
@Inject
public VirtualGuestHasLoginDetailsPresent(SoftLayerApi client) {
this.client = checkNotNull(client, "client was null");
}
@Override
public boolean apply(VirtualGuest guest) {
checkNotNull(guest, "virtual guest was null");
VirtualGuest virtualGuest = client.getVirtualGuestApi().getVirtualGuest(guest.getId());
boolean hasBackendIp = virtualGuest.getPrimaryBackendIpAddress() != null;
boolean hasPrimaryIp = virtualGuest.getPrimaryIpAddress() != null;
boolean hasPasswords = virtualGuest.getOperatingSystem() != null
&& !virtualGuest.getOperatingSystem().getPasswords().isEmpty();
return virtualGuest.isPrivateNetworkOnly() ? hasBackendIp && hasPasswords : hasBackendIp && hasPrimaryIp && hasPasswords;
}
}
private static class SoftwareDescriptionToOperatingSystem implements Function {
private final String osId;
public SoftwareDescriptionToOperatingSystem(String osId) {
this.osId = osId;
}
@Override
public OperatingSystem apply(SoftwareDescription input) {
return OperatingSystem.builder().id(osId)
.softwareLicense(SoftwareLicense.builder().softwareDescription(input).build())
.operatingSystemReferenceCode(input.getReferenceCode())
.build();
}
}
private static class IsBootableDevice implements Predicate {
@Override
public boolean apply(VirtualGuestBlockDeviceTemplate blockDeviceTemplate) {
return blockDeviceTemplate.getDevice().equals(BOOTABLE_DEVICE);
}
}
private static class BlockDeviceTemplateGroupToBlockDeviceTemplateIterable implements Function> {
@Override
public Iterable apply(VirtualGuestBlockDeviceTemplateGroup input) {
return input.getBlockDevices();
}
}
private static class BlockDeviceTemplateToDiskImageSoftware implements Function> {
@Override
public Iterable apply(VirtualGuestBlockDeviceTemplate bootableDevice) {
return bootableDevice.getDiskImage().getSoftwareReferences();
}
}
private static class DiskImageSoftwareToSoftwareDescription implements Function {
@Override
public SoftwareDescription apply(VirtualDiskImageSoftware software) {
return software.getSoftwareDescription();
}
}
private static class HasSameOsReferenceCode implements Predicate {
private final String osReferenceCode;
public HasSameOsReferenceCode(String osReferenceCode) {
this.osReferenceCode = osReferenceCode;
}
@Override
public boolean apply(SoftwareDescription input) {
return input.getReferenceCode().equals(osReferenceCode);
}
}
private static class IsOperatingSystem implements Predicate {
@Override
public boolean apply(SoftwareDescription softwareDescription) {
// operatingSystem is set to '1' if this Software Description describes an Operating System.
return softwareDescription.getOperatingSystem() == 1;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy