/**
* Copyright (C) 2008 - Abiquo Holdings S.L. All rights reserved.
*
* Please see /opt/abiquo/tomcat/webapps/legal/ on Abiquo server
* or contact contact@abiquo.com for licensing information.
*/
package com.abiquo.hypervisor.model.builder;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import com.abiquo.hypervisor.model.DhcpOptionCom;
import com.abiquo.hypervisor.model.DiskDescription.DiskControllerType;
import com.abiquo.hypervisor.model.DiskStandard;
import com.abiquo.hypervisor.model.DiskStateful;
import com.abiquo.hypervisor.model.SecondaryDiskStandard;
import com.abiquo.hypervisor.model.SecondaryDiskStateful;
import com.abiquo.hypervisor.model.VirtualMachineDefinition;
import com.abiquo.hypervisor.model.VirtualMachineDefinition.AntiaffinityRule;
import com.abiquo.hypervisor.model.VirtualMachineDefinition.BootstrapConfiguration;
import com.abiquo.hypervisor.model.VirtualMachineDefinition.Cdrom;
import com.abiquo.hypervisor.model.VirtualMachineDefinition.EthernetDriver;
import com.abiquo.hypervisor.model.VirtualMachineDefinition.HardwareConfiguration;
import com.abiquo.hypervisor.model.VirtualMachineDefinition.NetworkConfiguration;
import com.abiquo.hypervisor.model.VirtualMachineDefinition.OperatingSystem;
import com.abiquo.hypervisor.model.VirtualMachineDefinition.Owner;
import com.abiquo.hypervisor.model.VirtualMachineDefinition.PrimaryDisk;
import com.abiquo.hypervisor.model.VirtualMachineDefinition.SecondaryDisks;
import com.abiquo.hypervisor.model.VirtualNIC;
import com.abiquo.hypervisor.model.builder.BuilderException.VirtualMachineDescriptionBuilderError;
import com.abiquo.hypervisor.model.enumerator.DiskFormatType;
public class VirtualMachineDescriptionBuilder
{
private String name;
private String uuid;
private String layer;
private HardwareConfiguration hardConf;
private NetworkConfiguration netConf;
private PrimaryDisk primaryDisk;
private SecondaryDisks secondaryDisks;
private OperatingSystem operatingSystem;
private BootstrapConfiguration bootstrapConf;
private AntiaffinityRule antiaffinityRule;
private Owner owner;
private boolean isHA;
private boolean hasDvd = false;
private boolean isImported;
public VirtualMachineDescriptionBuilder hardware(final int virtualCpu, final int ramInMb)
{
return hardware(virtualCpu, null, ramInMb, null);
}
public VirtualMachineDescriptionBuilder hardware(final int virtualCpu,
final Integer coresPerSocket, final int ramInMb)
{
return hardware(virtualCpu, coresPerSocket, ramInMb, null);
}
public VirtualMachineDescriptionBuilder hardware(final int virtualCpu,
final Integer coresPerSocket, final int ramInMb, final String name)
{
hardConf = new HardwareConfiguration();
hardConf.setNumVirtualCpus(virtualCpu);
hardConf.setCoresPerSocket(coresPerSocket);
hardConf.setRamInMb((long) ramInMb);
hardConf.setName(name);
return this;
}
public VirtualMachineDescriptionBuilder setRdPort(final int rdport)
{
if (netConf == null)
{
netConf = new NetworkConfiguration();
}
netConf.setRdPort(rdport);
return this;
}
public VirtualMachineDescriptionBuilder setRdEnabled(final boolean enabled)
{
if (netConf == null)
{
netConf = new NetworkConfiguration();
}
netConf.setRdEnabled(enabled);
return this;
}
public VirtualMachineDescriptionBuilder setBasics(final String name, final String uuid)
{
this.name = name;
this.uuid = uuid;
return this;
}
public VirtualMachineDescriptionBuilder setHA(final boolean isHA)
{
this.isHA = isHA;
return this;
}
public VirtualMachineDescriptionBuilder addNetwork(final String macAddress, final String ip,
final String vSwitchName, final String networkName, final int vlanTag,
final String leaseName, final String forwardMode, final String netAddress,
final String gateway, final String mask, final String primaryDNS,
final String secondaryDNS, final String sufixDNS, final int sequence,
final List<DhcpOptionCom> list, final boolean configureGateway, final boolean isUnmanaged,
final EthernetDriver driver)
{
if (netConf == null)
{
netConf = new NetworkConfiguration();
}
final VirtualNIC nic = new VirtualNIC();
nic.setMacAddress(macAddress);
nic.setIp(ip);
nic.setVSwitchName(vSwitchName);
nic.setNetworkName(networkName);
nic.setVlanTag(vlanTag);
nic.setSequence(sequence);
nic.setLeaseName(leaseName);
nic.setForwardMode(forwardMode);
nic.setNetAddress(netAddress);
nic.setGateway(gateway);
nic.setMask(mask);
nic.setPrimaryDNS(primaryDNS);
nic.setSecondaryDNS(secondaryDNS);
nic.setSufixDNS(sufixDNS);
nic.setDhcpOptions(list);
nic.setConfigureGateway(configureGateway);
nic.setUnmanaged(isUnmanaged);
if (driver != null)
{
nic.setEthernetDriver(driver);
}
netConf.getVirtualNICs().add(nic);
return this;
}
public VirtualMachineDescriptionBuilder addNetwork(final String macAddress, final String ip,
final String vSwitchName, final String networkName, final int vlanTag,
final String leaseName, final String forwardMode, final String netAddress,
final String gateway, final String mask, final String primaryDNS,
final String secondaryDNS, final String sufixDNS, final int sequence,
final List<DhcpOptionCom> list, final boolean configureGateway, final boolean isUnmanaged)
{
return addNetwork(macAddress, ip, vSwitchName, networkName, vlanTag, leaseName,
forwardMode, netAddress, gateway, mask, primaryDNS, secondaryDNS, sufixDNS, sequence,
list, configureGateway, isUnmanaged, null);
}
public VirtualMachineDescriptionBuilder dhcp(final String dhcpAddress, final Integer dhcpPort)
{
if (netConf == null)
{
netConf = new NetworkConfiguration();
}
netConf.setDhcpAddress(dhcpAddress);
netConf.setDhcpPort(dhcpPort);
return this;
}
public VirtualMachineDescriptionBuilder setRdPassword(final String rdpassword)
{
if (netConf == null)
{
netConf = new NetworkConfiguration();
}
netConf.setRdPassword(rdpassword);
return this;
}
public VirtualMachineDescriptionBuilder setKeyMap(final String keymap)
{
if (netConf == null)
{
netConf = new NetworkConfiguration();
}
netConf.setKeyMap(keymap);
return this;
}
public VirtualMachineDescriptionBuilder bootstrap(final String uri, final String auth)
{
bootstrapConf = new BootstrapConfiguration();
bootstrapConf.setUri(uri);
bootstrapConf.setAuth(auth);
return this;
}
/**
* Add info about the running guest operating system
*
* @param type, from CIM OSTYpe
* @param version, optional additional info
*/
public VirtualMachineDescriptionBuilder operatingSystem(final String type, final String version)
{
operatingSystem = new OperatingSystem();
operatingSystem.setType(type);
operatingSystem.setVersion(version);
return this;
}
public VirtualMachineDescriptionBuilder antiaffinityRule(final String ruleName,
final List<String> vmUuids)
{
antiaffinityRule = new AntiaffinityRule();
antiaffinityRule.setName(ruleName);
antiaffinityRule.setVirtualMachineUuids(vmUuids);
return this;
}
public VirtualMachineDescriptionBuilder primaryDisk(final DiskFormatType format,
final long capacityInBytes, final String repository, final String sourcePath,
final String destinationDatastore, final String repositoryManagerAddress,
final DiskControllerType controllerType)
{
final DiskStandard disk = new DiskStandard();
disk.setFormat(format);
disk.setCapacityInBytes(capacityInBytes);
disk.setRepository(repository);
disk.setPath(sourcePath);
disk.setDestinationDatastore(destinationDatastore);
disk.setRepositoryManagerAddress(repositoryManagerAddress);
disk.setDiskControllerType(controllerType);
primaryDisk = new PrimaryDisk();
primaryDisk.setDiskStandard(disk);
// If repository is not present; it is an imported one
isImported = StringUtils.isBlank(disk.getRepository());
return this;
}
public VirtualMachineDescriptionBuilder primaryDisk(final DiskFormatType format,
final long capacityInBytes, final String address, final String type,
final String destinationDatastore, final DiskControllerType controllerType,
final String name)
{
final DiskStateful disk = new DiskStateful();
disk.setFormat(format);
disk.setCapacityInBytes(capacityInBytes);
disk.setType(type);
disk.setLocation(address);
disk.setDestinationDatastore(destinationDatastore);
disk.setDiskControllerType(controllerType);
disk.setName(name); // Used in XenServer
primaryDisk = new PrimaryDisk();
primaryDisk.setDiskStateful(disk);
// Never will be imported, because it is stateful
isImported = false;
return this;
}
public VirtualMachineDescriptionBuilder addSecondaryPersistentDisk(final DiskFormatType format,
final long capacityInBytes, final String address, final String type,
final String destinationDatastore, final int sequence,
final DiskControllerType controllerType, final String name)
{
if (secondaryDisks == null)
{
secondaryDisks = new SecondaryDisks();
}
final SecondaryDiskStateful auxDisk = new SecondaryDiskStateful();
auxDisk.setFormat(format);
auxDisk.setCapacityInBytes(capacityInBytes);
auxDisk.setType(type);
auxDisk.setLocation(address);
auxDisk.setDestinationDatastore(destinationDatastore);
auxDisk.setSequence(sequence);
auxDisk.setDiskControllerType(controllerType);
auxDisk.setName(name); // Used in XenServer
secondaryDisks.getStatefulDisks().add(auxDisk);
return this;
}
public VirtualMachineDescriptionBuilder addSecondaryHardDisk(final long diskFileSizeInBytes,
final long diskCapacityInBytes, final int sequence, final String datastorePath,
final DiskControllerType controllerType, final Integer diskManagementId,
final String diskManagementUUID)
{
if (secondaryDisks == null)
{
secondaryDisks = new SecondaryDisks();
}
final SecondaryDiskStandard hdDisk = new SecondaryDiskStandard();
hdDisk.setDiskManagementId(diskManagementId);
hdDisk.setDiskManagementUUID(diskManagementUUID);
hdDisk.setDestinationDatastore(datastorePath);
hdDisk.setCapacityInBytes(diskCapacityInBytes);
hdDisk.setDiskFileSizeInBytes(diskFileSizeInBytes);
hdDisk.setFormat(null);
hdDisk.setPath(null);
hdDisk.setRepository(null);
hdDisk.setRepositoryManagerAddress(null);
hdDisk.setSequence(sequence);
hdDisk.setDiskControllerType(controllerType);
secondaryDisks.getStandardDisks().add(hdDisk);
return this;
}
public VirtualMachineDescriptionBuilder setHasDvd()
{
hasDvd = true;
return this;
}
public VirtualMachineDescriptionBuilder setLayer(final String layer)
{
this.layer = layer;
return this;
}
public VirtualMachineDescriptionBuilder ownerPublicKey(final String publicKey)
{
owner = new Owner();
owner.setPublicSshKey(publicKey);
return this;
}
public VirtualMachineDefinition build()
{
final VirtualMachineDefinition virtualMachine = new VirtualMachineDefinition();
// TODO check not null
virtualMachine.setName(name);
virtualMachine.setUuid(uuid);
virtualMachine.setLayer(layer);
virtualMachine.setHardwareConfiguration(hardConf);
virtualMachine.setNetworkConfiguration(netConf);
virtualMachine.setOperatingSystem(operatingSystem);
virtualMachine.setBootstrap(bootstrapConf);
virtualMachine.setAntiaffinityRule(antiaffinityRule);
virtualMachine.setOwner(owner);
virtualMachine.setPrimaryDisk(primaryDisk);
virtualMachine.setSecondaryDisks(secondaryDisks);
virtualMachine.setHA(isHA);
virtualMachine.setImported(isImported);
if (hasDvd)
{
virtualMachine.setCdrom(new Cdrom());
}
if (primaryDisk == null)
{
throw new BuilderException(VirtualMachineDescriptionBuilderError.NO_PRIMARY_DISK);
}
if (name == null || uuid == null)
{
throw new BuilderException(VirtualMachineDescriptionBuilderError.NO_IDENTIFIED);
}
if (hardConf == null)
{
throw new BuilderException(VirtualMachineDescriptionBuilderError.NO_HARDWARE);
}
return DiskSequenceToBusAndUnitNumber.numerateBusAndUnitBasedOnSequences(virtualMachine);
}
}// create builder