/*
* 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 com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import static com.google.common.collect.Iterables.contains;
import static com.google.common.collect.Iterables.filter;
import static com.google.common.collect.Iterables.find;
import static com.google.common.collect.Iterables.get;
import static com.google.common.collect.Iterables.tryFind;
import static java.lang.Math.round;
import static java.lang.String.format;
import static org.jclouds.compute.domain.Volume.Type;
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_INCLUDE_PUBLIC_IMAGES;
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.Set;
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.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 com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.base.Predicate;
import com.google.common.base.Supplier;
import com.google.common.collect.ComparisonChain;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet.Builder;
import com.google.common.collect.ImmutableSortedSet;
import 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<VirtualGuest, Hardware, OperatingSystem, Datacenter> {
private static final String BOOTABLE_DEVICE = "0";
public static final String DEFAULT_DISK_TYPE = "LOCAL";
public static final int DEFAULT_MAX_PORT_SPEED = 100;
@Resource
@Named(ComputeServiceConstants.COMPUTE_LOGGER)
protected Logger logger = Logger.NULL;
private final SoftLayerApi api;
private final Supplier<ContainerVirtualGuestConfiguration> createObjectOptionsSupplier;
private final Predicate<VirtualGuest> loginDetailsTester;
private final long guestLoginDelay;
private final long activeTransactionsDelay;
private final boolean includePublicImages;
@Inject
public SoftLayerComputeServiceAdapter(SoftLayerApi api,
VirtualGuestHasLoginDetailsPresent virtualGuestHasLoginDetailsPresent,
@Memoized Supplier<ContainerVirtualGuestConfiguration> createObjectOptionsSupplier,
@Named(PROPERTY_SOFTLAYER_VIRTUALGUEST_LOGIN_DETAILS_DELAY) long guestLoginDelay,
@Named(PROPERTY_SOFTLAYER_VIRTUALGUEST_ACTIVE_TRANSACTIONS_DELAY) long activeTransactionsDelay,
@Named(PROPERTY_SOFTLAYER_INCLUDE_PUBLIC_IMAGES) boolean includePublicImages) {
this.api = checkNotNull(api, "api");
this.guestLoginDelay = checkNotNull(guestLoginDelay, "guestLoginDelay");
this.activeTransactionsDelay = checkNotNull(activeTransactionsDelay, "activeTransactionsDelay");
this.includePublicImages = checkNotNull(includePublicImages, "includePublicImages");
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<VirtualGuest> 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().or(DEFAULT_DISK_TYPE);
boolean hourlyBillingFlag = templateOptions.isHourlyBillingFlag().or(true);
int maxPortSpeed = templateOptions.getPortSpeed().or(DEFAULT_MAX_PORT_SPEED);
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();
VirtualGuest.Builder virtualGuestBuilder = VirtualGuest.builder()
.domain(domainName)
.hostname(name)
.hourlyBillingFlag(hourlyBillingFlag)
.startCpus(cores)
.maxMemory(template.getHardware().getRam())
.datacenter(datacenter);
// set operating system or blockDeviceTemplateGroup
Optional<OperatingSystem> optionalOperatingSystem = tryExtractOperatingSystemFrom(imageId);
if (optionalOperatingSystem.isPresent()) {
virtualGuestBuilder.operatingSystem(optionalOperatingSystem.get());
// the imageId specified is a the id of a public/private/flex image
} else {
VirtualGuestBlockDeviceTemplateGroup blockDeviceTemplateGroup = VirtualGuestBlockDeviceTemplateGroup
.builder().globalIdentifier(imageId).build();
virtualGuestBuilder.blockDeviceTemplateGroup(blockDeviceTemplateGroup).build();
}
// set multi-disks
if (templateOptions.getBlockDevices().isPresent()) {
List<VirtualGuestBlockDevice> blockDevices = getBlockDevices(templateOptions.getBlockDevices().get(), diskType);
virtualGuestBuilder.blockDevices(blockDevices);
virtualGuestBuilder.localDiskFlag(isLocalDisk(diskType));
}
// set dedicatedAccountHostOnlyFlag
if (templateOptions.isDedicatedAccountHostOnlyFlag().isPresent()) {
virtualGuestBuilder.dedicatedAccountHostOnly(templateOptions.isDedicatedAccountHostOnlyFlag().get());
}
// set privateNetworkOnlyFlag
if (templateOptions.isPrivateNetworkOnlyFlag().isPresent()) {
virtualGuestBuilder.privateNetworkOnlyFlag(templateOptions.isPrivateNetworkOnlyFlag().get());
}
// set primaryNetworkComponent.networkVlan.id
if (templateOptions.getPrimaryNetworkComponentNetworkVlanId().isPresent()) {
int primaryNetworkComponentNetworkVlanId = templateOptions.getPrimaryNetworkComponentNetworkVlanId().get();
virtualGuestBuilder.primaryNetworkComponent(
VirtualGuestNetworkComponent.builder()
.networkVlan(NetworkVlan.builder().id(primaryNetworkComponentNetworkVlanId).build())
.speed(maxPortSpeed).build());
}
// set primaryBackendNetworkComponent.networkVlan.id
if (templateOptions.getPrimaryBackendNetworkComponentNetworkVlanId().isPresent()) {
int primaryBackendNetworkComponentNetworkVlanId = templateOptions.getPrimaryBackendNetworkComponentNetworkVlanId().get();
virtualGuestBuilder.primaryBackendNetworkComponent(
VirtualGuestNetworkComponent.builder()
.networkVlan(NetworkVlan.builder().id(primaryBackendNetworkComponentNetworkVlanId).build())
.speed(maxPortSpeed).build());
}
// set postInstallScriptUri
if (templateOptions.getPostInstallScriptUri().isPresent()) {
// Specifies the uri location of the script to be downloaded and run after installation is complete.
virtualGuestBuilder.postInstallScriptUri(templateOptions.getPostInstallScriptUri().get());
}
// set userData
if (templateOptions.getUserData().isPresent()) {
virtualGuestBuilder.virtualGuestAttribute(VirtualGuestAttribute.builder().value(templateOptions.getUserData().get()).build());
}
// set sshKeys
if (templateOptions.getSshKeys().isPresent()) {
Set<SecuritySshKey> sshKeys = Sets.newHashSet();
for (int sshKeyId : templateOptions.getSshKeys().get()) {
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() != null) {
api.getVirtualGuestApi().setTags(result.getId(), templateOptions.getTags());
}
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());
}
@Override
public Iterable<Hardware> listHardwareProfiles() {
ContainerVirtualGuestConfiguration virtualGuestConfiguration = createObjectOptionsSupplier.get();
Builder<Hardware> hardware = ImmutableSortedSet.orderedBy(new Comparator<Hardware>() {
@Override
public int compare(Hardware h1, Hardware h2) {
List<? extends Volume> volumes1 = h1.getVolumes();
List<? extends Volume> 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.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.<Volume>of(
new VolumeImpl(blockDevice.getId() + "",
type,
capacity,
blockDevice.getDevice(),
blockDevice.getBootableFlag() == 1,
true)))
.build());
}
}
}
}
return hardware.build();
}
@Override
public Set<OperatingSystem> listImages() {
Set<OperatingSystem> result = Sets.newHashSet();
Set<SoftwareDescription> allObjects = api.getSoftwareDescriptionApi().getAllObjects();
// add private images
Set<VirtualGuestBlockDeviceTemplateGroup> privateImages = api.getAccountApi().getBlockDeviceTemplateGroups();
for (VirtualGuestBlockDeviceTemplateGroup privateImage : privateImages) {
Optional<OperatingSystem> operatingSystemOptional = tryExtractOperatingSystemFrom(privateImage);
if (operatingSystemOptional.isPresent()) {
result.add(operatingSystemOptional.get());
}
}
if (includePublicImages) {
Set<VirtualGuestBlockDeviceTemplateGroup> publicImages = api.getVirtualGuestBlockDeviceTemplateGroupApi().getPublicImages();
for (VirtualGuestBlockDeviceTemplateGroup publicImage : publicImages) {
Optional<OperatingSystem> operatingSystemOptional = tryExtractOperatingSystemFrom(publicImage);
if (operatingSystemOptional.isPresent()) {
result.add(operatingSystemOptional.get());
}
}
}
// add allObjects filtered by the available OS
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) {
return find(listImages(), new Predicate<OperatingSystem>() {
@Override
public boolean apply(OperatingSystem input) {
return input.getId().equals(id);
}
}, null);
}
@Override
public Iterable<VirtualGuest> listNodes() {
return api.getAccountApi().listVirtualGuests();
}
@Override
public Iterable<VirtualGuest> listNodesByIds(final Iterable<String> ids) {
return filter(listNodes(), new Predicate<VirtualGuest>() {
@Override
public boolean apply(VirtualGuest server) {
return contains(ids, server.getId());
}
});
}
@Override
public Iterable<Datacenter> listLocations() {
Set<Datacenter> result = Sets.newHashSet();
Set<Datacenter> unfiltered = api.getDatacenterApi().listDatacenters();
Set<Datacenter> datacenterAvailable = createObjectOptionsSupplier.get().getVirtualGuestDatacenters();
for (Datacenter datacenter : datacenterAvailable) {
final String datacenterName = datacenter.getName();
result.addAll(Sets.newHashSet(filter(unfiltered,
new Predicate<Datacenter>() {
@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<VirtualGuest>() {
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<VirtualGuestBlockDevice> getBlockDevices(List<Integer> blockDeviceCapacities, String diskType) {
ImmutableList.Builder<VirtualGuestBlockDevice> 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<? extends Volume> volumes = hardware.getVolumes();
Optional<? extends Volume> optionalBootableVolume = tryFind(volumes, new Predicate<Volume>() {
@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<OperatingSystem> tryExtractOperatingSystemFrom(final String imageId) {
Set<OperatingSystem> operatingSystemsAvailable = createObjectOptionsSupplier.get().getVirtualGuestOperatingSystems();
return FluentIterable.from(operatingSystemsAvailable)
.filter(new Predicate<OperatingSystem>() {
@Override
public boolean apply(OperatingSystem input) {
if (input == null) return false;
return input.getId().contains(imageId);
}
})
.first();
}
private Optional<OperatingSystem> tryExtractOperatingSystemFrom(VirtualGuestBlockDeviceTemplateGroup image) {
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<VirtualGuest> {
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<SoftwareDescription, OperatingSystem> {
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<VirtualGuestBlockDeviceTemplate> {
@Override
public boolean apply(VirtualGuestBlockDeviceTemplate blockDeviceTemplate) {
return blockDeviceTemplate.getDevice().equals(BOOTABLE_DEVICE);
}
}
private static class BlockDeviceTemplateGroupToBlockDeviceTemplateIterable implements Function<VirtualGuestBlockDeviceTemplateGroup,
Iterable<VirtualGuestBlockDeviceTemplate>> {
@Override
public Iterable<VirtualGuestBlockDeviceTemplate> apply(VirtualGuestBlockDeviceTemplateGroup input) {
return input.getBlockDevices();
}
}
private static class BlockDeviceTemplateToDiskImageSoftware implements Function<VirtualGuestBlockDeviceTemplate, Iterable<VirtualDiskImageSoftware>> {
@Override
public Iterable<VirtualDiskImageSoftware> apply(VirtualGuestBlockDeviceTemplate bootableDevice) {
return bootableDevice.getDiskImage().getSoftwareReferences();
}
}
private static class DiskImageSoftwareToSoftwareDescription implements Function<VirtualDiskImageSoftware, SoftwareDescription> {
@Override
public SoftwareDescription apply(VirtualDiskImageSoftware software) {
return software.getSoftwareDescription();
}
}
private static class HasSameOsReferenceCode implements Predicate<SoftwareDescription> {
private final String osReferenceCode;
public HasSameOsReferenceCode(String osReferenceCode) {
this.osReferenceCode = osReferenceCode;
}
@Override
public boolean apply(SoftwareDescription input) {
return input.getReferenceCode().equals(osReferenceCode);
}
}
private class IsOperatingSystem implements Predicate<SoftwareDescription> {
@Override
public boolean apply(SoftwareDescription softwareDescription) {
// operatingSystem is set to '1' if this Software Description describes an Operating System.
return softwareDescription.getOperatingSystem() == 1;
}
}
}