Apache
/
jclouds
mirror of https://github.com/apache/jclouds.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added domain model objects for VM and its parts. Reworked tests and IsoToIMachine accordingly. More work to be done.

This commit is contained in:
Mattias Holmqvist 2011-12-15 01:41:35 +01:00
parent 81d9a0afcd
commit 6712e661ce
26 changed files with 1021 additions and 606 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/DeviceDetails.java Normal file
View File

@ -0,0 +1,59 @@
/**
* Licensed to jclouds, Inc. (jclouds) under one or more
* contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. jclouds 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.virtualbox.domain;
import org.virtualbox_4_1.DeviceType;
/**
* Represents a specification for a device attachment.
* <p/>
* <p/>
* From the VirtualBox SDK:
* <p/>
* port:
* For an IDE controller, 0 specifies the primary controller and 1 specifies the secondary controller.
* For a SCSI controller, this must range from 0 to 15; for a SATA controller, from 0 to 29; for an SAS controller,
* from 0 to 7
*/
public class DeviceDetails {
private final int port;
private final int deviceSlot;
private final DeviceType deviceType;
public DeviceDetails(int port, int deviceSlot, DeviceType deviceType) {
this.port = port;
this.deviceSlot = deviceSlot;
this.deviceType = deviceType;
}
public int getPort() {
return port;
}
public int getDeviceSlot() {
return deviceSlot;
}
public DeviceType getDeviceType() {
return deviceType;
}
}

79
sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/HardDisk.java Normal file
View File

@ -0,0 +1,79 @@
/**
* Licensed to jclouds, Inc. (jclouds) under one or more
* contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. jclouds 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.virtualbox.domain;
/**
* A representation of a hard disk in a VirtualBox VM.
*
* diskPath is an absolute path to the file that is the location of the storage for the hard disk.
* diskFormat is any of the formats supported by ISystemProperties.getMediumFormats() in the VirtualBox API.
* This call is platform-dependent so the supported formats differ from host to host. The default format used is VDI.
* deviceDetails contains information about how the HardDisk is attached to the StorageController.
*
*/
public class HardDisk {
public static final String DEFAULT_DISK_FORMAT = "vdi";
private final String diskFormat;
private final String diskPath;
private final DeviceDetails deviceDetails;
public HardDisk(DeviceDetails deviceDetails, String diskPath, String diskFormat) {
this.diskPath = diskPath;
this.diskFormat = diskFormat;
this.deviceDetails = deviceDetails;
}
public String getDiskPath() {
return diskPath;
}
public String getDiskFormat() {
return diskFormat;
}
public DeviceDetails getDeviceDetails() {
return deviceDetails;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
HardDisk hardDisk = (HardDisk) o;
if (deviceDetails != null ? !deviceDetails.equals(hardDisk.deviceDetails) : hardDisk.deviceDetails != null)
return false;
if (diskFormat != null ? !diskFormat.equals(hardDisk.diskFormat) : hardDisk.diskFormat != null) return false;
if (diskPath != null ? !diskPath.equals(hardDisk.diskPath) : hardDisk.diskPath != null) return false;
return true;
}
@Override
public int hashCode() {
int result = diskFormat != null ? diskFormat.hashCode() : 0;
result = 31 * result + (diskPath != null ? diskPath.hashCode() : 0);
result = 31 * result + (deviceDetails != null ? deviceDetails.hashCode() : 0);
return result;
}
}

72
sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/IsoImage.java Normal file
View File

@ -0,0 +1,72 @@
/**
* Licensed to jclouds, Inc. (jclouds) under one or more
* contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. jclouds 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.virtualbox.domain;
/**
* Represents an optical medium (DVD) in a VirtualBox VM.
*
* sourcePath is the location of the .iso file to load the medium from.
* deviceDetails contains information about how the Dvd is attached to the StorageController.
*/
public class IsoImage {
private DeviceDetails deviceDetails;
private String sourcePath;
public IsoImage(DeviceDetails deviceDetails, String sourcePath) {
this.deviceDetails = deviceDetails;
this.sourcePath = sourcePath;
}
public DeviceDetails getDeviceDetails() {
return deviceDetails;
}
public String getSourcePath() {
return sourcePath;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
IsoImage dvd = (IsoImage) o;
if (deviceDetails != null ? !deviceDetails.equals(dvd.deviceDetails) : dvd.deviceDetails != null) return false;
if (sourcePath != null ? !sourcePath.equals(dvd.sourcePath) : dvd.sourcePath != null) return false;
return true;
}
@Override
public int hashCode() {
int result = deviceDetails != null ? deviceDetails.hashCode() : 0;
result = 31 * result + (sourcePath != null ? sourcePath.hashCode() : 0);
return result;
}
@Override
public String toString() {
return "Dvd{" +
"deviceDetails=" + deviceDetails +
", sourcePath='" + sourcePath + '\'' +
'}';
}
}

93
sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/NatAdapter.java Normal file
View File

@ -0,0 +1,93 @@
/**
* Licensed to jclouds, Inc. (jclouds) under one or more
* contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. jclouds 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.virtualbox.domain;
import org.virtualbox_4_1.NATProtocol;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
/**
* Represents a NAT network adapter in VirtualBox.
*
* redirectRules are the redirect rules that are applied to the network adapter.
*/
public class NatAdapter {
private final Set<RedirectRule> redirectRules = new HashSet<RedirectRule>();
public NatAdapter(Set<RedirectRule> redirectRules) {
this.redirectRules.addAll(redirectRules);
}
public static Builder builder() {
return new Builder();
}
public static class Builder {
private Set<RedirectRule> redirectRules = new HashSet<RedirectRule>();
private long adapterSlot;
public Builder tcpRedirectRule(String host, int hostPort, String guest, int guestPort) {
redirectRules.add(new RedirectRule(NATProtocol.TCP, host, hostPort, guest, guestPort));
return this;
}
public Builder udpRedirectRule(String host, int hostPort, String guest, int guestPort) {
redirectRules.add(new RedirectRule(NATProtocol.UDP, host, hostPort, guest, guestPort));
return this;
}
public NatAdapter build() {
return new NatAdapter(redirectRules);
}
}
public Set<RedirectRule> getRedirectRules() {
return Collections.unmodifiableSet(redirectRules);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
NatAdapter that = (NatAdapter) o;
if (redirectRules != null ? !redirectRules.equals(that.redirectRules) : that.redirectRules != null) return false;
return true;
}
@Override
public int hashCode() {
return redirectRules != null ? redirectRules.hashCode() : 0;
}
@Override
public String toString() {
return "NatAdapter{" +
"redirectRules=" + redirectRules +
'}';
}
}

147
sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/StorageController.java Normal file
View File

@ -0,0 +1,147 @@
/*
* Licensed to jclouds, Inc. (jclouds) under one or more
* contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. jclouds 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.virtualbox.domain;
import org.virtualbox_4_1.DeviceType;
import org.virtualbox_4_1.StorageBus;
import java.util.HashSet;
import java.util.Set;
import static com.google.common.base.Preconditions.checkNotNull;
import static org.jclouds.virtualbox.domain.HardDisk.DEFAULT_DISK_FORMAT;
/**
* Represents a storage controller in a VirtualBox VM.
*
* name is the unique name of the controller.
* bus is the type of connection bus for the controller
* hardDisks contains the hard disks that are attached (or should be attached) to this controller
* isoImages contains the ISOs that are attached (or should be attached) to this controller
*
* @see StorageBus
*/
public class StorageController {
private final String name;
private final StorageBus bus;
private Set<HardDisk> hardDisks;
private Set<IsoImage> isoImages;
public StorageController(String name, StorageBus bus, Set<HardDisk> hardDisks, Set<IsoImage> isoImages) {
this.name = name;
this.bus = bus;
this.hardDisks = hardDisks;
this.isoImages = isoImages;
}
public String getName() {
return name;
}
public StorageBus getBus() {
return bus;
}
public Set<HardDisk> getHardDisks() {
return hardDisks;
}
public Set<IsoImage> getIsoImages() {
return isoImages;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
StorageController that = (StorageController) o;
if (bus != that.bus) return false;
if (isoImages != null ? !isoImages.equals(that.isoImages) : that.isoImages != null) return false;
if (hardDisks != null ? !hardDisks.equals(that.hardDisks) : that.hardDisks != null) return false;
if (name != null ? !name.equals(that.name) : that.name != null) return false;
return true;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + (bus != null ? bus.hashCode() : 0);
result = 31 * result + (hardDisks != null ? hardDisks.hashCode() : 0);
result = 31 * result + (isoImages != null ? isoImages.hashCode() : 0);
return result;
}
@Override
public String toString() {
return "StorageController{" +
"name='" + name + '\'' +
", bus=" + bus +
", hardDisks=" + hardDisks +
", isoImages=" + isoImages +
'}';
}
public static Builder builder() {
return new Builder();
}
public static class Builder {
private String name;
private StorageBus bus;
private Set<HardDisk> hardDisks = new HashSet<HardDisk>();
private Set<IsoImage> dvds = new HashSet<IsoImage>();
public Builder name(String name) {
this.name = name;
return this;
}
public Builder bus(StorageBus bus) {
this.bus = bus;
return this;
}
public Builder attachISO(int controllerPort, int deviceSlot, String sourcePath) {
dvds.add(new IsoImage(new DeviceDetails(controllerPort, deviceSlot, DeviceType.DVD), sourcePath));
return this;
}
public Builder attachHardDisk(int controllerPort, int deviceSlot, String diskPath) {
hardDisks.add(new HardDisk(new DeviceDetails(controllerPort, deviceSlot, DeviceType.HardDisk), diskPath, DEFAULT_DISK_FORMAT));
return this;
}
public Builder attachHardDisk(int controllerPort, int deviceSlot, String diskPath, String diskFormat) {
hardDisks.add(new HardDisk(new DeviceDetails(controllerPort, deviceSlot, DeviceType.HardDisk), diskPath, diskFormat));
return this;
}
public StorageController build() {
checkNotNull(name);
checkNotNull(bus);
return new StorageController(name, bus, hardDisks, dvds);
}
}
}

162
sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/VmSpecification.java Normal file
View File

@ -0,0 +1,162 @@
/*
* Licensed to jclouds, Inc. (jclouds) under one or more
* contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. jclouds 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.virtualbox.domain;
import java.util.*;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* A description of a Virtual Machine in VirtualBox.
*/
public class VmSpecification {
private final String vmName;
private final String osTypeId;
private final String vmId;
private final boolean forceOverwrite;
private final Map<Long, NatAdapter> natNetworkAdapters;
private final Set<StorageController> controllers;
public VmSpecification(String vmId, String vmName, String osTypeId, boolean forceOverwrite, Set<StorageController> controllers, Map<Long, NatAdapter> natNetworkAdapters) {
this.vmId = vmId;
this.vmName = vmName;
this.osTypeId = osTypeId;
this.controllers = controllers;
this.forceOverwrite = forceOverwrite;
this.natNetworkAdapters = natNetworkAdapters;
}
public static Builder builder() {
return new Builder();
}
public static class Builder {
private Set<StorageController> controllers = new HashSet<StorageController>();
private String name;
private String id;
private String osTypeId = "";
private boolean forceOverwrite;
private Map<Long, NatAdapter> natNetworkAdapters = new HashMap<Long, NatAdapter>();
public Builder controller(StorageController controller) {
controllers.add(controller);
return this;
}
public Builder name(String name) {
this.name = name;
return this;
}
public Builder id(String id) {
this.id = id;
return this;
}
public Builder osTypeId(String osTypeId) {
this.osTypeId = osTypeId;
return this;
}
public Builder forceOverwrite(boolean forceOverwrite) {
this.forceOverwrite = forceOverwrite;
return this;
}
public Builder natNetworkAdapter(int slot, NatAdapter adapter) {
this.natNetworkAdapters.put((long) slot, adapter);
return this;
}
public VmSpecification build() {
checkNotNull(name, "name");
checkNotNull(id, "id");
return new VmSpecification(id, name, osTypeId, forceOverwrite, controllers, natNetworkAdapters);
}
}
public String getVmName() {
return vmName;
}
public String getOsTypeId() {
return osTypeId;
}
public String getVmId() {
return vmId;
}
public boolean isForceOverwrite() {
return forceOverwrite;
}
public Set<StorageController> getControllers() {
return Collections.unmodifiableSet(controllers);
}
public Map<Long, NatAdapter> getNatNetworkAdapters() {
return Collections.unmodifiableMap(natNetworkAdapters);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
VmSpecification that = (VmSpecification) o;
if (forceOverwrite != that.forceOverwrite) return false;
if (controllers != null ? !controllers.equals(that.controllers) : that.controllers != null) return false;
if (natNetworkAdapters != null ? !natNetworkAdapters.equals(that.natNetworkAdapters) : that.natNetworkAdapters != null)
return false;
if (osTypeId != null ? !osTypeId.equals(that.osTypeId) : that.osTypeId != null) return false;
if (vmId != null ? !vmId.equals(that.vmId) : that.vmId != null) return false;
if (vmName != null ? !vmName.equals(that.vmName) : that.vmName != null) return false;
return true;
}
@Override
public int hashCode() {
int result = vmName != null ? vmName.hashCode() : 0;
result = 31 * result + (osTypeId != null ? osTypeId.hashCode() : 0);
result = 31 * result + (vmId != null ? vmId.hashCode() : 0);
result = 31 * result + (forceOverwrite ? 1 : 0);
result = 31 * result + (natNetworkAdapters != null ? natNetworkAdapters.hashCode() : 0);
result = 31 * result + (controllers != null ? controllers.hashCode() : 0);
return result;
}
@Override
public String toString() {
return "VmSpecification{" +
"vmName='" + vmName + '\'' +
", osTypeId='" + osTypeId + '\'' +
", vmId='" + vmId + '\'' +
", forceOverwrite=" + forceOverwrite +
", natNetworkAdapters=" + natNetworkAdapters +
", controllers=" + controllers +
'}';
}
}

11
sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/AddIDEControllerIfNotExists.java
View File

@ -21,6 +21,7 @@ package org.jclouds.virtualbox.functions;
import static com.google.common.base.Preconditions.checkNotNull;
import org.jclouds.virtualbox.domain.StorageController;
import org.virtualbox_4_1.IMachine;
import org.virtualbox_4_1.StorageBus;
import org.virtualbox_4_1.VBoxException;
@ -33,16 +34,16 @@ import com.google.common.base.Function;
*
*/
public class AddIDEControllerIfNotExists implements Function<IMachine, Void> {
private final String controllerName;
private final StorageController storageController;
public AddIDEControllerIfNotExists(String controllerName) {
this.controllerName = checkNotNull(controllerName, "controllerName");
public AddIDEControllerIfNotExists(StorageController storageController) {
this.storageController = checkNotNull(storageController, "storageController");
}
@Override
public Void apply(IMachine machine) {
try {
machine.addStorageController(controllerName, StorageBus.IDE);
machine.addStorageController(storageController.getName(), storageController.getBus());
machine.saveSettings();
} catch (VBoxException e) {
if (!e.getMessage().contains("already exists"))
@ -53,6 +54,6 @@ public class AddIDEControllerIfNotExists implements Function<IMachine, Void> {
@Override
public String toString() {
return String.format("addStorageController(%s, IDE)", controllerName);
return String.format("addStorageController(%s)", storageController);
}
}

62
sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/AttachDistroMediumToMachine.java
View File

@ -1,62 +0,0 @@
/**
* Licensed to jclouds, Inc. (jclouds) under one or more
* contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. jclouds 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.virtualbox.functions;
import javax.annotation.Nullable;
import org.virtualbox_4_1.DeviceType;
import org.virtualbox_4_1.IMachine;
import org.virtualbox_4_1.IMedium;
import org.virtualbox_4_1.VBoxException;
import com.google.common.base.Function;
/**
* @author Mattias Holmqvist
*/
public class AttachDistroMediumToMachine implements Function<IMachine, Void> {
private final String controllerIDE;
private final IMedium distroMedium;
public AttachDistroMediumToMachine(String controllerIDE, IMedium distroMedium) {
this.controllerIDE = controllerIDE;
this.distroMedium = distroMedium;
}
@Override
public Void apply(@Nullable IMachine machine) {
try {
int controllerPort = 0;
int device = 0;
machine.attachDevice(controllerIDE, controllerPort, device, DeviceType.DVD, distroMedium);
machine.saveSettings();
} catch (VBoxException e) {
if (!alreadyAttached(e))
throw e;
}
return null;
}
private boolean alreadyAttached(VBoxException e) {
return e.getMessage().contains("is already attached to port");
}
}

21
sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/AttachMediumToMachineIfNotAlreadyAttached.java
View File

@ -21,7 +21,7 @@ package org.jclouds.virtualbox.functions;
import javax.annotation.Nullable;
import org.virtualbox_4_1.DeviceType;
import org.jclouds.virtualbox.domain.DeviceDetails;
import org.virtualbox_4_1.IMachine;
import org.virtualbox_4_1.IMedium;
import org.virtualbox_4_1.VBoxException;
@ -33,25 +33,20 @@ import com.google.common.base.Function;
*/
public class AttachMediumToMachineIfNotAlreadyAttached implements Function<IMachine, Void> {
private String controllerIDE;
private IMedium medium;
private int controllerPort;
private int device;
private DeviceType deviceType;
private final DeviceDetails device;
private final IMedium medium;
private final String controllerName;
public AttachMediumToMachineIfNotAlreadyAttached(String controllerIDE, IMedium medium, int controllerPort,
int device, DeviceType deviceType) {
this.controllerIDE = controllerIDE;
this.medium = medium;
this.controllerPort = controllerPort;
public AttachMediumToMachineIfNotAlreadyAttached(DeviceDetails device, IMedium medium, String controllerName) {
this.device = device;
this.deviceType = deviceType;
this.medium = medium;
this.controllerName = controllerName;
}
@Override
public Void apply(@Nullable IMachine machine) {
try {
machine.attachDevice(controllerIDE, controllerPort, device, deviceType, medium);
machine.attachDevice(controllerName, device.getPort(), device.getDeviceSlot(), device.getDeviceType(), medium);
machine.saveSettings();
} catch (VBoxException e) {
if (!alreadyAttached(e))

30
sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/AttachNATRedirectRuleToMachine.java → sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/AttachNATAdapterToMachine.java
View File

@ -19,11 +19,11 @@
package org.jclouds.virtualbox.functions;
import static org.virtualbox_4_1.NATProtocol.TCP;
import static org.virtualbox_4_1.NetworkAttachmentType.NAT;
import javax.annotation.Nullable;
import org.jclouds.virtualbox.domain.NatAdapter;
import org.jclouds.virtualbox.domain.RedirectRule;
import org.virtualbox_4_1.IMachine;
import org.virtualbox_4_1.INetworkAdapter;
@ -33,26 +33,28 @@ import com.google.common.base.Function;
/**
* @author Mattias Holmqvist
*/
public class AttachNATRedirectRuleToMachine implements Function<IMachine, Void> {
public class AttachNATAdapterToMachine implements Function<IMachine, Void> {
private long adapterIndex;
private RedirectRule redirectRule;
private long adapterSlot;
private NatAdapter natAdapter;
public AttachNATRedirectRuleToMachine(long adapterSlot, RedirectRule redirectRule) {
this.adapterIndex = adapterSlot;
this.redirectRule = redirectRule;
public AttachNATAdapterToMachine(long adapterSlot, NatAdapter natAdapter) {
this.adapterSlot = adapterSlot;
this.natAdapter = natAdapter;
}
@Override
public Void apply(@Nullable IMachine machine) {
INetworkAdapter networkAdapter = machine.getNetworkAdapter(adapterIndex);
INetworkAdapter networkAdapter = machine.getNetworkAdapter(adapterSlot);
networkAdapter.setAttachmentType(NAT);
networkAdapter.getNatDriver().addRedirect("guestssh",
redirectRule.getProtocol(),
redirectRule.getHost(),
redirectRule.getHostPort(),
redirectRule.getGuest(),
redirectRule.getGuestPort());
for (RedirectRule rule : natAdapter.getRedirectRules()) {
networkAdapter.getNatDriver().addRedirect("guestssh",
rule.getProtocol(),
rule.getHost(),
rule.getHostPort(),
rule.getGuest(),
rule.getGuestPort());
}
networkAdapter.setEnabled(true);
machine.saveSettings();
return null;

23
sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/CreateAndRegisterMachineFromIsoIfNotAlreadyExists.java
View File

@ -20,6 +20,7 @@
package org.jclouds.virtualbox.functions;
import com.google.common.base.Function;
import org.jclouds.virtualbox.domain.VmSpecification;
import org.virtualbox_4_1.IMachine;
import org.virtualbox_4_1.IVirtualBox;
import org.virtualbox_4_1.VBoxException;
@ -30,31 +31,24 @@ import javax.annotation.Nullable;
/**
* @author Mattias Holmqvist
*/
public class CreateAndRegisterMachineFromIsoIfNotAlreadyExists implements Function<String, IMachine> {
public class CreateAndRegisterMachineFromIsoIfNotAlreadyExists implements Function<VmSpecification, IMachine> {
private String osTypeId;
private String vmId;
private boolean forceOverwrite;
private VirtualBoxManager manager;
public CreateAndRegisterMachineFromIsoIfNotAlreadyExists(String osTypeId, String vmId,
boolean forceOverwrite, VirtualBoxManager manager) {
this.osTypeId = osTypeId;
this.vmId = vmId;
this.forceOverwrite = forceOverwrite;
public CreateAndRegisterMachineFromIsoIfNotAlreadyExists(VirtualBoxManager manager) {
this.manager = manager;
}
@Override
public IMachine apply(@Nullable String vmName) {
public IMachine apply(@Nullable VmSpecification launchSpecification) {
final IVirtualBox vBox = manager.getVBox();
String vmName = launchSpecification.getVmName();
try {
vBox.findMachine(vmName);
throw new IllegalStateException("Machine " + vmName + " is already registered.");
} catch (VBoxException e) {
if (machineNotFoundException(e))
return createMachine(vBox, vmName);
return createMachine(vBox, launchSpecification);
else
throw e;
}
@ -64,10 +58,11 @@ public class CreateAndRegisterMachineFromIsoIfNotAlreadyExists implements Functi
return e.getMessage().contains("VirtualBox error: Could not find a registered machine named ");
}
private IMachine createMachine(IVirtualBox vBox, String vmName) {
private IMachine createMachine(IVirtualBox vBox, VmSpecification launchSpecification) {
// TODO: add support for settingsfile
String settingsFile1 = null;
IMachine newMachine = vBox.createMachine(settingsFile1, vmName, osTypeId, vmId, forceOverwrite);
IMachine newMachine = vBox.createMachine(settingsFile1, launchSpecification.getVmName(),
launchSpecification.getOsTypeId(), launchSpecification.getVmId(), launchSpecification.isForceOverwrite());
manager.getVBox().registerMachine(newMachine);
return newMachine;
}

42
sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/CreateMediumIfNotAlreadyExists.java
View File

@ -19,55 +19,49 @@
package org.jclouds.virtualbox.functions;
import javax.annotation.Nullable;
import org.virtualbox_4_1.DeviceType;
import org.virtualbox_4_1.IMedium;
import org.virtualbox_4_1.IProgress;
import org.virtualbox_4_1.IVirtualBox;
import org.virtualbox_4_1.VBoxException;
import org.virtualbox_4_1.VirtualBoxManager;
import com.google.common.base.Function;
import org.jclouds.virtualbox.domain.HardDisk;
import org.virtualbox_4_1.*;
import javax.annotation.Nullable;
/**
* @author Mattias Holmqvist
*/
public class CreateMediumIfNotAlreadyExists implements Function<String, IMedium> {
public class CreateMediumIfNotAlreadyExists implements Function<HardDisk, IMedium> {
private final VirtualBoxManager manager;
private final String diskFormat;
private boolean overwriteIfExists;
public CreateMediumIfNotAlreadyExists(VirtualBoxManager manager, String diskFormat, boolean overwriteIfExists) {
public CreateMediumIfNotAlreadyExists(VirtualBoxManager manager, boolean overwriteIfExists) {
this.manager = manager;
this.diskFormat = diskFormat;
this.overwriteIfExists = overwriteIfExists;
}
@Override
public IMedium apply(@Nullable String path) {
public IMedium apply(@Nullable HardDisk hardDisk) {
IVirtualBox vBox = manager.getVBox();
try {
final IMedium medium = vBox.findMedium(path, DeviceType.HardDisk);
String diskPath = hardDisk.getDiskPath();
final IMedium medium = vBox.findMedium(diskPath, DeviceType.HardDisk);
if (overwriteIfExists) {
final IProgress progress = medium.deleteStorage();
progress.waitForCompletion(-1);
return createNewMedium(vBox, path);
return createNewMedium(vBox, hardDisk);
} else {
throw new IllegalStateException("Medium for path " + path + " already exists.");
throw new IllegalStateException("Medium for path " + diskPath + " already exists.");
}
} catch (VBoxException e) {
if (notFoundException(e))
return createNewMedium(vBox, path);
return createNewMedium(vBox, hardDisk);
throw e;
}
}
private IMedium createNewMedium(IVirtualBox vBox, String path) {
IMedium hardDisk = vBox.createHardDisk(diskFormat, path);
createBaseStorage(hardDisk);
return hardDisk;
private IMedium createNewMedium(IVirtualBox vBox, HardDisk hardDisk) {
IMedium medium = vBox.createHardDisk(hardDisk.getDiskFormat(), hardDisk.getDiskPath());
createBaseStorage(medium);
return medium;
}
private boolean notFoundException(VBoxException e) {
@ -78,7 +72,7 @@ public class CreateMediumIfNotAlreadyExists implements Function<String, IMedium>
try {
long size = 4L * 1024L * 1024L * 1024L - 4L;
IProgress storageCreation = hardDisk.createBaseStorage(size,
(long) org.virtualbox_4_1.jaxws.MediumVariant.STANDARD.ordinal());
(long) org.virtualbox_4_1.jaxws.MediumVariant.STANDARD.ordinal());
storageCreation.waitForCompletion(-1);
} catch (VBoxException e) {
if (fileNotFoundException(e)) {
@ -100,7 +94,7 @@ public class CreateMediumIfNotAlreadyExists implements Function<String, IMedium>
private boolean storageAlreadyExists(VBoxException e) {
return e.getMessage().contains("VirtualBox error: Storage for the medium ")
&& e.getMessage().contains("is already created");
&& e.getMessage().contains("is already created");
}
}

174
sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/IsoToIMachine.java
View File

@ -30,27 +30,23 @@ import org.jclouds.javax.annotation.Nullable;
import org.jclouds.logging.Logger;
import org.jclouds.net.IPSocket;
import org.jclouds.ssh.SshException;
import org.jclouds.virtualbox.domain.ExecutionType;
import org.jclouds.virtualbox.domain.RedirectRule;
import org.jclouds.virtualbox.domain.*;
import org.jclouds.virtualbox.settings.KeyboardScancodes;
import org.virtualbox_4_1.*;
import javax.annotation.Resource;
import javax.inject.Named;
import java.io.File;
import java.util.Map;
import java.util.Set;
import static com.google.common.base.Preconditions.checkNotNull;
import static org.jclouds.compute.options.RunScriptOptions.Builder.runAsRoot;
import static org.jclouds.compute.options.RunScriptOptions.Builder.wrapInInitScript;
import static org.jclouds.virtualbox.util.MachineUtils.*;
import static org.jclouds.virtualbox.config.VirtualBoxConstants.VIRTUALBOX_INSTALLATION_KEY_SEQUENCE;
import static org.jclouds.virtualbox.config.VirtualBoxConstants.VIRTUALBOX_WORKINGDIR;
import static org.virtualbox_4_1.AccessMode.ReadOnly;
import static org.virtualbox_4_1.DeviceType.DVD;
import static org.virtualbox_4_1.DeviceType.HardDisk;
import static org.jclouds.virtualbox.util.MachineUtils.*;
import static org.virtualbox_4_1.LockType.Shared;
import static org.virtualbox_4_1.LockType.Write;
import static org.virtualbox_4_1.NATProtocol.TCP;
public class IsoToIMachine implements Function<String, IMachine> {
@ -58,40 +54,30 @@ public class IsoToIMachine implements Function<String, IMachine> {
@Named(ComputeServiceConstants.COMPUTE_LOGGER)
protected Logger logger = Logger.NULL;
private VirtualBoxManager manager;
private String adminDisk;
private String diskFormat;
private String vmName;
private String osTypeId;
private String vmId;
private String controllerIDE;
private boolean forceOverwrite;
private ComputeServiceContext context;
private String hostId;
private final VirtualBoxManager manager;
private String guestId;
private Predicate<IPSocket> socketTester;
private String webServerHost;
private int webServerPort;
private final VmSpecification vmSpecification;
private final ComputeServiceContext context;
private final String hostId;
private final Predicate<IPSocket> socketTester;
private final String webServerHost;
private final int webServerPort;
private final ExecutionType executionType;
@Inject
public IsoToIMachine(VirtualBoxManager manager, String adminDisk, String diskFormat,
String vmName, String osTypeId, String vmId, boolean forceOverwrite, String controllerIDE,
ComputeServiceContext context, String hostId, String guestId, Predicate<IPSocket> socketTester,
String webServerHost, int webServerPort) {
public IsoToIMachine(VirtualBoxManager manager, String guestId,
VmSpecification vmSpecification, ComputeServiceContext context,
String hostId, Predicate<IPSocket> socketTester,
String webServerHost, int webServerPort, ExecutionType executionType) {
this.manager = manager;
this.adminDisk = adminDisk;
this.diskFormat = diskFormat;
this.vmName = vmName;
this.osTypeId = osTypeId;
this.vmId = vmId;
this.controllerIDE = controllerIDE;
this.forceOverwrite = forceOverwrite;
this.guestId = guestId;
this.vmSpecification = vmSpecification;
this.context = context;
this.hostId = hostId;
this.guestId = guestId;
this.socketTester = socketTester;
this.webServerHost = webServerHost;
this.webServerPort = webServerPort;
this.executionType = executionType;
}
@Override
@ -99,51 +85,37 @@ public class IsoToIMachine implements Function<String, IMachine> {
ensureWebServerIsRunning();
final IMachine vm = new CreateAndRegisterMachineFromIsoIfNotAlreadyExists(osTypeId, vmId, forceOverwrite,
manager).apply(vmName);
final IMachine vm = new CreateAndRegisterMachineFromIsoIfNotAlreadyExists(manager).apply(vmSpecification);
final String defaultWorkingDir = System.getProperty("user.home") + "/jclouds-virtualbox-test";
final String workingDir = System.getProperty(VIRTUALBOX_WORKINGDIR, defaultWorkingDir);
String vmName = vmSpecification.getVmName();
// Change RAM
ensureMachineHasMemory(vmName, 1024l);
// IDE Controller
ensureMachineHasIDEControllerNamed(vmName, controllerIDE);
// Distribution medium
ensureMachineHasAttachedDistroMedium(isoName, workingDir, controllerIDE);
// DISK
final String adminDiskPath = workingDir + "/" + adminDisk;
if (new File(adminDiskPath).exists()) {
boolean deleted = new File(adminDiskPath).delete();
if (!deleted) {
logger.error(String.format("File %s could not be deleted.", adminDiskPath));
}
Set<StorageController> controllers = vmSpecification.getControllers();
if (controllers.isEmpty()) {
throw new IllegalStateException(missingIDEControllersMessage());
}
StorageController controller = controllers.iterator().next();
ensureMachineHasIDEControllerNamed(vmName, controller);
setupHardDisksForController(vmName, controller);
setupDvdsForController(vmName, controller);
missingIDEControllersMessage();
// Create hard disk
final IMedium hardDisk = new CreateMediumIfNotAlreadyExists(manager, diskFormat, true).apply(adminDiskPath);
// Attach hard disk to machine
ensureMachineHasHardDiskAttached(vmName, hardDisk);
// NAT
ensureNATNetworkingIsAppliedToMachine(vmName);
final String guestAdditionsDvd = workingDir + "/VBoxGuestAdditions_4.1.2.iso";
final IMedium guestAdditionsDvdMedium = manager.getVBox().openMedium(guestAdditionsDvd, DeviceType.DVD,
AccessMode.ReadOnly, forceOverwrite);
// Guest additions
ensureGuestAdditionsMediumIsAttached(vmName, guestAdditionsDvdMedium);
Map<Long, NatAdapter> natNetworkAdapters = vmSpecification.getNatNetworkAdapters();
for (Map.Entry<Long, NatAdapter> natAdapterAndSlot : natNetworkAdapters.entrySet()) {
long slotId = natAdapterAndSlot.getKey();
NatAdapter natAdapter = natAdapterAndSlot.getValue();
ensureNATNetworkingIsAppliedToMachine(vmName, slotId, natAdapter);
}
// Launch machine and wait for it to come online
ensureMachineIsLaunched(vmName);
final String installKeySequence = System.getProperty(VIRTUALBOX_INSTALLATION_KEY_SEQUENCE, defaultInstallSequence());
sendKeyboardSequence(installKeySequence);
final String installKeySequence = System.getProperty(VIRTUALBOX_INSTALLATION_KEY_SEQUENCE, defaultInstallSequence(vmName));
sendKeyboardSequence(installKeySequence, vmName);
boolean sshDeamonIsRunning = false;
while (!sshDeamonIsRunning) {
@ -171,6 +143,35 @@ public class IsoToIMachine implements Function<String, IMachine> {
return vm;
}
private void setupDvdsForController(String vmName, StorageController controller) {
Set<IsoImage> dvds = controller.getIsoImages();
for (IsoImage dvd : dvds) {
String dvdSource = dvd.getSourcePath();
final IMedium dvdMedium = manager.getVBox().openMedium(dvdSource, DeviceType.DVD,
AccessMode.ReadOnly, vmSpecification.isForceOverwrite());
ensureMachineDevicesAttached(vmName, dvdMedium, dvd.getDeviceDetails(), controller.getName());
}
}
private void setupHardDisksForController(String vmName, StorageController controller) {
Set<HardDisk> hardDisks = controller.getHardDisks();
for (HardDisk hardDisk : hardDisks) {
String sourcePath = hardDisk.getDiskPath();
if (new File(sourcePath).exists()) {
boolean deleted = new File(sourcePath).delete();
if (!deleted) {
logger.error(String.format("File %s could not be deleted.", sourcePath));
}
}
IMedium medium = new CreateMediumIfNotAlreadyExists(manager, true).apply(hardDisk);
ensureMachineDevicesAttached(vmName, medium, hardDisk.getDeviceDetails(), controller.getName());
}
}
private String missingIDEControllersMessage() {
return String.format("First controller is not an IDE controller. Please verify that the VM spec is a correct master node: %s", vmSpecification);
}
private void ensureWebServerIsRunning() {
final IPSocket webServerSocket = new IPSocket(webServerHost, webServerPort);
if (!socketTester.apply(webServerSocket)) {
@ -179,52 +180,27 @@ public class IsoToIMachine implements Function<String, IMachine> {
}
private void ensureMachineIsLaunched(String vmName) {
applyForMachine(manager, vmName, new LaunchMachineIfNotAlreadyRunning(manager, ExecutionType.HEADLESS, ""));
applyForMachine(manager, vmName, new LaunchMachineIfNotAlreadyRunning(manager, executionType, ""));
}
private void ensureGuestAdditionsMediumIsAttached(String vmName, final IMedium guestAdditionsDvdMedium) {
lockMachineAndApply(manager, Write, vmName, new AttachMediumToMachineIfNotAlreadyAttached(controllerIDE,
guestAdditionsDvdMedium, 1, 1, DeviceType.DVD));
}
private void ensureMachineHasHardDiskAttached(String vmName, IMedium hardDisk) {
lockMachineAndApply(manager, Write, vmName, new AttachMediumToMachineIfNotAlreadyAttached(controllerIDE,
hardDisk, 0, 1, HardDisk));
private void ensureMachineDevicesAttached(String vmName, IMedium medium, DeviceDetails deviceDetails, String controllerName) {
lockMachineAndApply(manager, Write, vmName, new AttachMediumToMachineIfNotAlreadyAttached(deviceDetails, medium, controllerName));
}
private void ensureMachineHasMemory(String vmName, final long memorySize) {
lockMachineAndApply(manager, Write, vmName, new ApplyMemoryToMachine(memorySize));
}
private void ensureNATNetworkingIsAppliedToMachine(String vmName) {
lockMachineAndApply(manager, Write, vmName, new AttachNATRedirectRuleToMachine(0l, new RedirectRule(TCP, "127.0.0.1", 2222, "", 22)));
private void ensureNATNetworkingIsAppliedToMachine(String vmName, long slotId, NatAdapter natAdapter) {
lockMachineAndApply(manager, Write, vmName, new AttachNATAdapterToMachine(slotId, natAdapter));
}
private void ensureMachineHasAttachedDistroMedium(String isoName, String workingDir, String controllerIDE) {
final String pathToIsoFile = checkFileExists(workingDir + "/" + isoName);
final IMedium distroMedium = manager.getVBox().openMedium(pathToIsoFile, DVD, ReadOnly, forceOverwrite);
lockMachineAndApply(
manager,
Write,
vmName,
new AttachDistroMediumToMachine(checkNotNull(controllerIDE, "controllerIDE"), checkNotNull(distroMedium,
"distroMedium")));
}
public static String checkFileExists(String filePath) {
if (new File(filePath).exists()) {
return filePath;
}
throw new IllegalStateException("File " + filePath + " does not exist.");
}
public void ensureMachineHasIDEControllerNamed(String vmName, String controllerIDE) {
public void ensureMachineHasIDEControllerNamed(String vmName, StorageController storageController) {
lockMachineAndApply(manager, Write, checkNotNull(vmName, "vmName"),
new AddIDEControllerIfNotExists(checkNotNull(controllerIDE, "controllerIDE")));
new AddIDEControllerIfNotExists(checkNotNull(storageController, "storageController")));
}
private String defaultInstallSequence() {
private String defaultInstallSequence(String vmName) {
return "<Esc><Esc><Enter> "
+ "/install/vmlinuz noapic preseed/url=http://10.0.2.2:" + webServerPort + "/src/test/resources/preseed.cfg "
+ "debian-installer=en_US auto locale=en_US kbd-chooser/method=us " + "hostname=" + vmName + " "
@ -233,7 +209,7 @@ public class IsoToIMachine implements Function<String, IMachine> {
+ "initrd=/install/initrd.gz -- <Enter>";
}
private void sendKeyboardSequence(String keyboardSequence) {
private void sendKeyboardSequence(String keyboardSequence, String vmName) {
String[] splitSequence = keyboardSequence.split(" ");
StringBuilder sb = new StringBuilder();
for (String line : splitSequence) {

31
sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/util/PropertyUtils.java Normal file
View File

@ -0,0 +1,31 @@
/*
* Licensed to jclouds, Inc. (jclouds) under one or more
* contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. jclouds 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.virtualbox.util;
import static org.jclouds.virtualbox.config.VirtualBoxConstants.VIRTUALBOX_WORKINGDIR;
public class PropertyUtils {
public static String getWorkingDirFromProperty() {
final String defaultWorkingDir = System.getProperty("user.home") + "/jclouds-virtualbox-test";
return System.getProperty(VIRTUALBOX_WORKINGDIR, defaultWorkingDir);
}
}

29
sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/AddIDEControllerIfNotExistsTest.java
View File

@ -19,22 +19,18 @@
package org.jclouds.virtualbox.functions;
import static org.easymock.EasyMock.expect;
import static org.easymock.classextension.EasyMock.createMock;
import static org.easymock.classextension.EasyMock.createNiceMock;
import static org.easymock.classextension.EasyMock.replay;
import static org.easymock.classextension.EasyMock.verify;
import org.jclouds.virtualbox.domain.StorageController;
import org.testng.annotations.Test;
import org.virtualbox_4_1.IMachine;
import org.virtualbox_4_1.IStorageController;
import org.virtualbox_4_1.StorageBus;
import org.virtualbox_4_1.VBoxException;
import static org.easymock.EasyMock.expect;
import static org.easymock.classextension.EasyMock.*;
/**
*
* @author Adrian Cole
*
*/
@Test(groups = "unit", testName = "AddIDEControllerIfNotExistsTest")
public class AddIDEControllerIfNotExistsTest {
@ -44,14 +40,15 @@ public class AddIDEControllerIfNotExistsTest {
IMachine vm = createMock(IMachine.class);
String controllerName = "IDE Controller";
StorageController storageController = StorageController.builder().bus(StorageBus.IDE).name(controllerName).build();
expect(vm.addStorageController(controllerName, StorageBus.IDE)).andReturn(
createNiceMock(IStorageController.class));
createNiceMock(IStorageController.class));
vm.saveSettings();
replay(vm);
new AddIDEControllerIfNotExists(controllerName).apply(vm);
new AddIDEControllerIfNotExists(storageController).apply(vm);
verify(vm);
}
@ -61,14 +58,15 @@ public class AddIDEControllerIfNotExistsTest {
IMachine vm = createMock(IMachine.class);
String controllerName = "IDE Controller";
StorageController storageController = StorageController.builder().bus(StorageBus.IDE).name(controllerName).build();
expect(vm.addStorageController(controllerName, StorageBus.IDE)).andThrow(
new VBoxException(createNiceMock(Throwable.class),
"VirtualBox error: Storage controller named 'IDE Controller' already exists (0x80BB000C)"));
new VBoxException(createNiceMock(Throwable.class),
"VirtualBox error: Storage controller named 'IDE Controller' already exists (0x80BB000C)"));
replay(vm);
new AddIDEControllerIfNotExists(controllerName).apply(vm);
new AddIDEControllerIfNotExists(storageController).apply(vm);
verify(vm);
}
@ -78,13 +76,14 @@ public class AddIDEControllerIfNotExistsTest {
IMachine vm = createMock(IMachine.class);
String controllerName = "IDE Controller";
StorageController storageController = StorageController.builder().bus(StorageBus.IDE).name(controllerName).build();
expect(vm.addStorageController(controllerName, StorageBus.IDE)).andThrow(
new VBoxException(createNiceMock(Throwable.class), "VirtualBox error: General Error"));
new VBoxException(createNiceMock(Throwable.class), "VirtualBox error: General Error"));
replay(vm);
new AddIDEControllerIfNotExists(controllerName).apply(vm);
new AddIDEControllerIfNotExists(storageController).apply(vm);
verify(vm);
}

80
sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/AttachDistroMediumToMachineLiveTest.java
View File

@ -1,80 +0,0 @@
/*
* Licensed to jclouds, Inc. (jclouds) under one or more
* contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. jclouds 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.virtualbox.functions;
import org.jclouds.virtualbox.BaseVirtualBoxClientLiveTest;
import org.jclouds.virtualbox.functions.admin.UnregisterMachineIfExists;
import org.jclouds.virtualbox.util.MachineUtils;
import org.testng.annotations.Test;
import org.virtualbox_4_1.CleanupMode;
import org.virtualbox_4_1.IMedium;
import org.virtualbox_4_1.LockType;
import java.io.File;
import static org.jclouds.virtualbox.util.MachineUtils.lockMachineAndApply;
import static org.testng.Assert.assertTrue;
/**
* @author Mattias Holmqvist
*/
public class AttachDistroMediumToMachineLiveTest extends BaseVirtualBoxClientLiveTest {
@Test
public void testAttachMediumToMachine() throws Exception {
String nodeName = "test-attach-medium-node-1";
String controllerName = "My Controller";
new UnregisterMachineIfExists(manager, CleanupMode.Full).apply(nodeName);
String path = System.getProperty("user.home") + "/jclouds-virtualbox-test/test-attach-medium-1.vdi";
new CreateAndRegisterMachineFromIsoIfNotAlreadyExists("Debian", nodeName, true, manager)
.apply(nodeName);
lockMachineAndApply(manager, LockType.Write, nodeName,
new AddIDEControllerIfNotExists(controllerName));
IMedium medium = new CreateMediumIfNotAlreadyExists(manager, "vdi", true).apply(path);
lockMachineAndApply(manager, LockType.Write, nodeName,
new AttachDistroMediumToMachine(controllerName, medium));
new UnregisterMachineIfExists(manager, CleanupMode.Full).apply(nodeName);
medium.close();
assertFileCanBeDeleted(path);
}
@Test
public void testAttachMediumToMachineTwice() throws Exception {
String nodeName = "test-attach-medium-node-2";
String controllerName = "My Controller";
new UnregisterMachineIfExists(manager, CleanupMode.Full).apply(nodeName);
String path = System.getProperty("user.home") + "/jclouds-virtualbox-test/test-attach-medium-2.vdi";
new CreateAndRegisterMachineFromIsoIfNotAlreadyExists("Debian", nodeName, true, manager)
.apply(nodeName);
lockMachineAndApply(manager, LockType.Write, nodeName, new AddIDEControllerIfNotExists(controllerName));
IMedium medium = new CreateMediumIfNotAlreadyExists(manager, "vdi", true).apply(path);
lockMachineAndApply(manager, LockType.Write, nodeName, new AttachDistroMediumToMachine(controllerName, medium));
lockMachineAndApply(manager, LockType.Write, nodeName, new AttachDistroMediumToMachine(controllerName, medium));
new UnregisterMachineIfExists(manager, CleanupMode.Full).apply(nodeName);
medium.close();
assertFileCanBeDeleted(path);
}
private void assertFileCanBeDeleted(String path) {
File file = new File(path);
boolean mediumDeleted = file.delete();
assertTrue(mediumDeleted);
}
}

110
sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/AttachDistroMediumToMachineTest.java
View File

@ -1,110 +0,0 @@
/**
* Licensed to jclouds, Inc. (jclouds) under one or more
* contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. jclouds 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.virtualbox.functions;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.classextension.EasyMock.createMock;
import static org.easymock.classextension.EasyMock.createNiceMock;
import static org.easymock.classextension.EasyMock.replay;
import static org.easymock.classextension.EasyMock.verify;
import org.testng.annotations.Test;
import org.virtualbox_4_1.DeviceType;
import org.virtualbox_4_1.IMachine;
import org.virtualbox_4_1.IMedium;
import org.virtualbox_4_1.VBoxException;
/**
* @author Mattias Holmqvist
*/
@Test(groups = "unit", testName = "AttachDistroMediumToMachineTest")
public class AttachDistroMediumToMachineTest {
@Test
public void testAttachDistroMedium() throws Exception {
String controllerIDE = "IDE Controller";
IMedium distroMedium = createNiceMock(IMedium.class);
IMachine machine = createMock(IMachine.class);
machine.saveSettings();
machine.attachDevice(controllerIDE, 0, 0, DeviceType.DVD, distroMedium);
replay(machine, distroMedium);
new AttachDistroMediumToMachine(controllerIDE, distroMedium).apply(machine);
verify(machine);
}
@Test
public void testAcceptAlreadyAttachedDistroMedium() throws Exception {
String controllerIDE = "IDE Controller";
IMedium distroMedium = createNiceMock(IMedium.class);
IMachine machine = createNiceMock(IMachine.class);
final StringBuilder errorBuilder = new StringBuilder();
errorBuilder.append("VirtualBox error: ");
errorBuilder.append("Medium '/Users/johndoe/jclouds-virtualbox-test/ubuntu-11.04-server-i386.iso' ");
errorBuilder.append("is already attached to port 0, device 0 of controller 'IDE Controller' ");
errorBuilder.append("of this virtual machine (0x80BB000C)");
String isoAlreadyAttachedException = errorBuilder.toString();
VBoxException isoAttachedException = new VBoxException(createNiceMock(Throwable.class),
isoAlreadyAttachedException);
machine.attachDevice(controllerIDE, 0, 0, DeviceType.DVD, distroMedium);
expectLastCall().andThrow(isoAttachedException);
replay(machine, distroMedium);
new AttachDistroMediumToMachine(controllerIDE, distroMedium).apply(machine);
verify(machine);
}
@Test(expectedExceptions = VBoxException.class)
public void testFailOnOtherVBoxErrors() throws Exception {
String controllerIDE = "IDE Controller";
IMedium distroMedium = createNiceMock(IMedium.class);
IMachine machine = createNiceMock(IMachine.class);
final StringBuilder errorBuilder = new StringBuilder();
errorBuilder.append("VirtualBox error: ");
errorBuilder.append("Some other VBox error");
String isoAlreadyAttachedException = errorBuilder.toString();
VBoxException isoAttachedException = new VBoxException(createNiceMock(Throwable.class),
isoAlreadyAttachedException);
machine.attachDevice(controllerIDE, 0, 0, DeviceType.DVD, distroMedium);
expectLastCall().andThrow(isoAttachedException);
replay(machine, distroMedium);
new AttachDistroMediumToMachine(controllerIDE, distroMedium).apply(machine);
}
}

72
sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/AttachMediumToMachineIfNotAlreadyAttachedTest.java
View File

@ -19,6 +19,14 @@
package org.jclouds.virtualbox.functions;
import com.google.common.collect.Iterables;
import org.jclouds.virtualbox.domain.DeviceDetails;
import org.jclouds.virtualbox.domain.HardDisk;
import org.jclouds.virtualbox.domain.StorageController;
import org.testng.annotations.Test;
import org.virtualbox_4_1.*;
import static com.google.common.collect.Iterables.getOnlyElement;
import static org.easymock.EasyMock.anyLong;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.expectLastCall;
@ -28,14 +36,6 @@ import static org.easymock.classextension.EasyMock.replay;
import static org.easymock.classextension.EasyMock.verify;
import static org.virtualbox_4_1.DeviceType.HardDisk;
import org.testng.annotations.Test;
import org.virtualbox_4_1.IMachine;
import org.virtualbox_4_1.IMedium;
import org.virtualbox_4_1.IProgress;
import org.virtualbox_4_1.IVirtualBox;
import org.virtualbox_4_1.VBoxException;
import org.virtualbox_4_1.VirtualBoxManager;
/**
* @author Mattias Holmqvist
*/
@ -45,8 +45,8 @@ public class AttachMediumToMachineIfNotAlreadyAttachedTest {
@Test
public void testAttachHardDiskIfNotAttached() throws Exception {
String controllerIDE = "IDE Controller";
String adminDiskPath = "/Users/johndoe/jclouds-virtualbox-images/admin.vdi";
String controllerName = "IDE Controller";
String diskPath = "/Users/johndoe/jclouds-virtualbox-images/admin.vdi";
String diskFormat = "vdi";
int controllerPort = 0;
int device = 1;
@ -58,15 +58,22 @@ public class AttachMediumToMachineIfNotAlreadyAttachedTest {
IProgress progress = createNiceMock(IProgress.class);
expect(manager.getVBox()).andReturn(vBox).anyTimes();
expect(vBox.createHardDisk(diskFormat, adminDiskPath)).andReturn(hardDisk);
expect(vBox.createHardDisk(diskFormat, diskPath)).andReturn(hardDisk);
expect(hardDisk.createBaseStorage(anyLong(), anyLong())).andReturn(progress);
machine.attachDevice(controllerIDE, controllerPort, device, HardDisk, hardDisk);
machine.attachDevice(controllerName, controllerPort, device, HardDisk, hardDisk);
machine.saveSettings();
replay(manager, machine, vBox, hardDisk);
new AttachMediumToMachineIfNotAlreadyAttached(controllerIDE, hardDisk, controllerPort, device, HardDisk)
.apply(machine);
StorageController controller = StorageController.builder()
.name(controllerName)
.bus(StorageBus.IDE)
.attachHardDisk(controllerPort, device, diskPath)
.build();
DeviceDetails deviceDetails = getOnlyElement(controller.getHardDisks()).getDeviceDetails();
new AttachMediumToMachineIfNotAlreadyAttached(deviceDetails, hardDisk, controllerName).apply(machine);
verify(machine);
@ -75,9 +82,9 @@ public class AttachMediumToMachineIfNotAlreadyAttachedTest {
@Test
public void testDoNothingIfAlreadyAttachedAttachHardDisk() throws Exception {
String controllerIDE = "IDE Controller";
String controllerName = "IDE Controller";
int controllerPort = 0;
int device = 1;
int deviceSlot = 1;
VirtualBoxManager manager = createNiceMock(VirtualBoxManager.class);
IMachine machine = createMock(IMachine.class);
@ -92,14 +99,20 @@ public class AttachMediumToMachineIfNotAlreadyAttachedTest {
String isoAlreadyAttachedException = errorBuilder.toString();
VBoxException isoAttachedException = new VBoxException(createNiceMock(Throwable.class),
isoAlreadyAttachedException);
machine.attachDevice(controllerIDE, controllerPort, device, HardDisk, hardDisk);
isoAlreadyAttachedException);
machine.attachDevice(controllerName, controllerPort, deviceSlot, HardDisk, hardDisk);
expectLastCall().andThrow(isoAttachedException);
replay(manager, machine, vBox, hardDisk);
new AttachMediumToMachineIfNotAlreadyAttached(controllerIDE, hardDisk, controllerPort, device, HardDisk)
.apply(machine);
StorageController controller = StorageController.builder()
.name(controllerName)
.bus(StorageBus.IDE)
.attachHardDisk(controllerPort, deviceSlot, "/Users/mattias/jclouds-virtualbox-test/testadmin.vdi")
.build();
DeviceDetails deviceDetails = getOnlyElement(controller.getHardDisks()).getDeviceDetails();
new AttachMediumToMachineIfNotAlreadyAttached(deviceDetails, hardDisk, controllerName).apply(machine);
verify(machine);
@ -108,9 +121,9 @@ public class AttachMediumToMachineIfNotAlreadyAttachedTest {
@Test(expectedExceptions = VBoxException.class)
public void testFailOnOtherVBoxError() throws Exception {
String controllerIDE = "IDE Controller";
String controllerName = "IDE Controller";
int controllerPort = 0;
int device = 1;
int deviceSlot = 1;
VirtualBoxManager manager = createNiceMock(VirtualBoxManager.class);
IMachine machine = createMock(IMachine.class);
@ -123,14 +136,21 @@ public class AttachMediumToMachineIfNotAlreadyAttachedTest {
String isoAlreadyAttachedException = errorBuilder.toString();
VBoxException isoAttachedException = new VBoxException(createNiceMock(Throwable.class),
isoAlreadyAttachedException);
machine.attachDevice(controllerIDE, controllerPort, device, HardDisk, hardDisk);
isoAlreadyAttachedException);
machine.attachDevice(controllerName, controllerPort, deviceSlot, HardDisk, hardDisk);
expectLastCall().andThrow(isoAttachedException);
replay(manager, machine, vBox, hardDisk);
new AttachMediumToMachineIfNotAlreadyAttached(controllerIDE, hardDisk, controllerPort, device, HardDisk)
.apply(machine);
StorageController controller = StorageController.builder()
.name(controllerName)
.bus(StorageBus.IDE)
.attachHardDisk(controllerPort, deviceSlot, "/Users/mattias/jclouds-virtualbox-test/testadmin.vdi")
.build();
DeviceDetails deviceDetails = getOnlyElement(controller.getHardDisks()).getDeviceDetails();
new AttachMediumToMachineIfNotAlreadyAttached(deviceDetails, hardDisk, controllerName).apply(machine);
}

34
sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/AttachNATRedirectRuleToMachineTest.java → sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/AttachNATAdapterToMachineTest.java
View File

@ -19,35 +19,32 @@
package org.jclouds.virtualbox.functions;
import static org.easymock.EasyMock.expect;
import static org.easymock.classextension.EasyMock.createMock;
import static org.easymock.classextension.EasyMock.createNiceMock;
import static org.easymock.classextension.EasyMock.replay;
import static org.easymock.classextension.EasyMock.verify;
import static org.virtualbox_4_1.NATProtocol.TCP;
import static org.virtualbox_4_1.NetworkAttachmentType.NAT;
import org.jclouds.virtualbox.domain.RedirectRule;
import org.jclouds.virtualbox.domain.NatAdapter;
import org.testng.annotations.Test;
import org.virtualbox_4_1.IMachine;
import org.virtualbox_4_1.INATEngine;
import org.virtualbox_4_1.INetworkAdapter;
import org.virtualbox_4_1.VBoxException;
import static org.easymock.EasyMock.expect;
import static org.easymock.classextension.EasyMock.*;
import static org.virtualbox_4_1.NATProtocol.TCP;
import static org.virtualbox_4_1.NetworkAttachmentType.NAT;
/**
* @author Mattias Holmqvist
*/
@Test(groups = "unit", testName = "AttachNATRedirectRuleToMachineTest")
public class AttachNATRedirectRuleToMachineTest {
@Test(groups = "unit", testName = "AttachNATAdapterToMachineTest")
public class AttachNATAdapterToMachineTest {
@Test
public void testApplyNetworkingToNonExistingAdapter() throws Exception {
Long adapterId = 0l;
Long slotId = 0l;
IMachine machine = createMock(IMachine.class);
INetworkAdapter networkAdapter = createMock(INetworkAdapter.class);
INATEngine natEngine = createMock(INATEngine.class);
expect(machine.getNetworkAdapter(adapterId)).andReturn(networkAdapter);
expect(machine.getNetworkAdapter(slotId)).andReturn(networkAdapter);
networkAdapter.setAttachmentType(NAT);
expect(networkAdapter.getNatDriver()).andReturn(natEngine);
natEngine.addRedirect("guestssh", TCP, "127.0.0.1", 2222, "", 22);
@ -55,15 +52,15 @@ public class AttachNATRedirectRuleToMachineTest {
machine.saveSettings();
replay(machine, networkAdapter, natEngine);
new AttachNATRedirectRuleToMachine(adapterId, new RedirectRule(TCP, "127.0.0.1", 2222, "", 22)).apply(machine);
NatAdapter natAdapter = NatAdapter.builder().tcpRedirectRule("127.0.0.1", 2222, "", 22).build();
new AttachNATAdapterToMachine(slotId, natAdapter).apply(machine);
verify(machine, networkAdapter, natEngine);
}
@Test(expectedExceptions = VBoxException.class)
public void testRethrowInvalidAdapterSlotException() throws Exception {
Long adapterId = 30l;
Long slotId = 30l;
IMachine machine = createMock(IMachine.class);
INetworkAdapter networkAdapter = createMock(INetworkAdapter.class);
INATEngine natEngine = createMock(INATEngine.class);
@ -72,11 +69,12 @@ public class AttachNATRedirectRuleToMachineTest {
+ "(must be slot < RT_ELEMENTS(mNetworkAdapters)) (0x80070057)";
VBoxException invalidSlotException = new VBoxException(createNiceMock(Throwable.class), error);
expect(machine.getNetworkAdapter(adapterId)).andThrow(invalidSlotException);
expect(machine.getNetworkAdapter(slotId)).andThrow(invalidSlotException);
replay(machine, networkAdapter, natEngine);
new AttachNATRedirectRuleToMachine(adapterId, new RedirectRule(TCP, "127.0.0.1", 2222, "", 22)).apply(machine);
NatAdapter natAdapter = NatAdapter.builder().tcpRedirectRule("127.0.0.1", 2222, "", 22).build();
new AttachNATAdapterToMachine(slotId, natAdapter).apply(machine);
verify(machine, networkAdapter, natEngine);
}

39
sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/CloneAndRegisterMachineFromIsoIfNotAlreadyExistsLiveTest.java
View File

@ -19,24 +19,26 @@
package org.jclouds.virtualbox.functions;
import static org.jclouds.virtualbox.experiment.TestUtils.computeServiceForLocalhostAndGuest;
import static org.testng.Assert.assertEquals;
import static org.virtualbox_4_1.NetworkAttachmentType.Bridged;
import java.util.concurrent.TimeUnit;
import com.google.common.base.Predicate;
import org.jclouds.compute.ComputeServiceContext;
import org.jclouds.domain.Credentials;
import org.jclouds.net.IPSocket;
import org.jclouds.predicates.InetSocketAddressConnect;
import org.jclouds.predicates.RetryablePredicate;
import org.jclouds.virtualbox.BaseVirtualBoxClientLiveTest;
import org.jclouds.virtualbox.domain.HardDisk;
import org.jclouds.virtualbox.domain.StorageController;
import org.jclouds.virtualbox.domain.VmSpecification;
import org.jclouds.virtualbox.util.PropertyUtils;
import org.testng.annotations.Test;
import org.virtualbox_4_1.IMachine;
import org.virtualbox_4_1.ISession;
import org.virtualbox_4_1.VirtualBoxManager;
import org.virtualbox_4_1.*;
import com.google.common.base.Predicate;
import java.util.concurrent.TimeUnit;
import static org.jclouds.virtualbox.domain.ExecutionType.HEADLESS;
import static org.jclouds.virtualbox.experiment.TestUtils.computeServiceForLocalhostAndGuest;
import static org.testng.Assert.assertEquals;
import static org.virtualbox_4_1.NetworkAttachmentType.Bridged;
/**
* @author Andrea Turli
@ -49,8 +51,6 @@ public class CloneAndRegisterMachineFromIsoIfNotAlreadyExistsLiveTest extends Ba
private String vmId = "jclouds-image-iso-1";
private String osTypeId = "";
private String controllerIDE = "IDE Controller";
private String diskFormat = "";
private String adminDisk = "testadmin.vdi";
private String guestId = "guest";
private String hostId = "host";
private String snapshotName = "snap";
@ -84,10 +84,17 @@ public class CloneAndRegisterMachineFromIsoIfNotAlreadyExistsLiveTest extends Ba
private IMachine getMasterNode(VirtualBoxManager manager, ComputeServiceContext localHostContext) {
try {
Predicate<IPSocket> socketTester = new RetryablePredicate<IPSocket>(new InetSocketAddressConnect(), 10, 1, TimeUnit.SECONDS);
return new IsoToIMachine(manager, adminDisk, diskFormat,
vmName, osTypeId, vmId, forceOverwrite,
controllerIDE, localHostContext, hostId, guestId, socketTester,
"127.0.0.1", 8080).apply(isoName);
String workingDir = PropertyUtils.getWorkingDirFromProperty();
StorageController ideController = StorageController.builder().name(controllerIDE).bus(StorageBus.IDE)
.attachISO(0, 0, workingDir + "/ubuntu-11.04-server-i386.iso")
.attachHardDisk(0, 1, workingDir + "/testadmin.vdi")
.attachISO(1, 1, workingDir + "/VBoxGuestAdditions_4.1.2.iso").build();
VmSpecification vmSpecification = VmSpecification.builder().id(vmId).name(vmName).osTypeId(osTypeId)
.controller(ideController)
.forceOverwrite(true).build();
return new IsoToIMachine(manager, guestId,
vmSpecification, localHostContext, hostId, socketTester,
"127.0.0.1", 8080, HEADLESS).apply(isoName);
} catch (IllegalStateException e) {
// already created
return manager.getVBox().findMachine(vmName);

21
sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/CreateAndRegisterMachineFromIsoIfNotAlreadyExistsLiveTest.java
View File

@ -21,6 +21,7 @@ package org.jclouds.virtualbox.functions;
import org.jclouds.virtualbox.BaseVirtualBoxClientLiveTest;
import org.jclouds.virtualbox.domain.ErrorCode;
import org.jclouds.virtualbox.domain.VmSpecification;
import org.jclouds.virtualbox.functions.admin.UnregisterMachineIfExists;
import org.testng.annotations.Test;
import org.virtualbox_4_1.CleanupMode;
@ -37,20 +38,24 @@ public class CreateAndRegisterMachineFromIsoIfNotAlreadyExistsLiveTest extends B
@Test
public void testCreateNewMachine() throws Exception {
new UnregisterMachineIfExists(manager, CleanupMode.Full).apply("jclouds-test-create-1-node");
IMachine debianNode = new CreateAndRegisterMachineFromIsoIfNotAlreadyExists("Debian", "jclouds-test-create-1", true, manager)
.apply("jclouds-test-create-1-node");
IMachine machine = manager.getVBox().findMachine("jclouds-test-create-1-node");
String vmName = "jclouds-test-create-1-node";
new UnregisterMachineIfExists(manager, CleanupMode.Full).apply(vmName);
VmSpecification launchSpecification = VmSpecification.builder().id(vmName).name(vmName)
.osTypeId("Debian").forceOverwrite(true).build();
IMachine debianNode = new CreateAndRegisterMachineFromIsoIfNotAlreadyExists(manager).apply(launchSpecification);
IMachine machine = manager.getVBox().findMachine(vmName);
assertEquals(debianNode.getName(), machine.getName());
new UnregisterMachineIfExists(manager, CleanupMode.Full).apply("jclouds-test-create-1-node");
new UnregisterMachineIfExists(manager, CleanupMode.Full).apply(vmName);
}
@Test
public void testCreateNewMachineWithBadOsType() throws Exception {
new UnregisterMachineIfExists(manager, CleanupMode.Full).apply("jclouds-test-create-2-node");
String vmName = "jclouds-test-create-2-node";
new UnregisterMachineIfExists(manager, CleanupMode.Full).apply(vmName);
VmSpecification launchSpecification = VmSpecification.builder().id(vmName).name(vmName)
.osTypeId("SomeWeirdUnknownOs").forceOverwrite(true).build();
try {
new CreateAndRegisterMachineFromIsoIfNotAlreadyExists("SomeWeirdUnknownOs", "jclouds-test-create-2", true, manager)
.apply("jclouds-test-create-2-node");
new CreateAndRegisterMachineFromIsoIfNotAlreadyExists(manager).apply(launchSpecification);
fail();
} catch (VBoxException e) {
ErrorCode errorCode = ErrorCode.valueOf(e);

15
sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/CreateAndRegisterMachineFromIsoIfNotAlreadyExistsTest.java
View File

@ -29,6 +29,7 @@ import static org.easymock.classextension.EasyMock.replay;
import static org.easymock.classextension.EasyMock.verify;
import org.easymock.EasyMock;
import org.jclouds.virtualbox.domain.VmSpecification;
import org.testng.annotations.Test;
import org.virtualbox_4_1.IMachine;
import org.virtualbox_4_1.IVirtualBox;
@ -48,6 +49,8 @@ public class CreateAndRegisterMachineFromIsoIfNotAlreadyExistsTest {
IVirtualBox vBox = createMock(IVirtualBox.class);
String vmName = "jclouds-image-my-ubuntu-image";
VmSpecification launchSpecification = VmSpecification.builder().id(vmName).name(vmName).osTypeId("").build();
IMachine createdMachine = createMock(IMachine.class);
expect(manager.getVBox()).andReturn(vBox).anyTimes();
@ -62,13 +65,13 @@ public class CreateAndRegisterMachineFromIsoIfNotAlreadyExistsTest {
expectLastCall().andThrow(vBoxException);
expect(vBox.createMachine(anyString(), eq(vmName), anyString(), anyString(), anyBoolean())).andReturn(
createdMachine).anyTimes();
createdMachine).anyTimes();
vBox.registerMachine(createdMachine);
replay(manager, vBox);
new CreateAndRegisterMachineFromIsoIfNotAlreadyExists("", "", false, manager).apply(vmName);
new CreateAndRegisterMachineFromIsoIfNotAlreadyExists(manager).apply(launchSpecification);
verify(manager, vBox);
}
@ -87,7 +90,8 @@ public class CreateAndRegisterMachineFromIsoIfNotAlreadyExistsTest {
replay(manager, vBox);
new CreateAndRegisterMachineFromIsoIfNotAlreadyExists("", "", false, manager).apply(vmName);
VmSpecification launchSpecification = VmSpecification.builder().id("").name(vmName).osTypeId("").build();
new CreateAndRegisterMachineFromIsoIfNotAlreadyExists(manager).apply(launchSpecification);
}
@Test(expectedExceptions = VBoxException.class)
@ -107,11 +111,12 @@ public class CreateAndRegisterMachineFromIsoIfNotAlreadyExistsTest {
replay(manager, vBox);
new CreateAndRegisterMachineFromIsoIfNotAlreadyExists("", "", false, manager).apply(vmName);
VmSpecification launchSpecification = VmSpecification.builder().id("").name(vmName).osTypeId("").build();
new CreateAndRegisterMachineFromIsoIfNotAlreadyExists(manager).apply(launchSpecification);
}
private String anyString() {
return EasyMock.<String> anyObject();
return EasyMock.<String>anyObject();
}
}

13
sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/CreateMediumIfNotAlreadyExistsLiveTest.java
View File

@ -20,7 +20,9 @@
package org.jclouds.virtualbox.functions;
import org.jclouds.virtualbox.BaseVirtualBoxClientLiveTest;
import org.jclouds.virtualbox.domain.DeviceDetails;
import org.jclouds.virtualbox.domain.ErrorCode;
import org.jclouds.virtualbox.domain.HardDisk;
import org.testng.annotations.Test;
import org.virtualbox_4_1.DeviceType;
import org.virtualbox_4_1.VBoxException;
@ -39,7 +41,8 @@ public class CreateMediumIfNotAlreadyExistsLiveTest extends BaseVirtualBoxClient
@Test
public void testCreateMedium() throws Exception {
String path = System.getProperty("user.home") + "/jclouds-virtualbox-test/test-medium-1.vdi";
new CreateMediumIfNotAlreadyExists(manager, "vdi", true).apply(path);
HardDisk hardDisk = new HardDisk(new DeviceDetails(0, 0, DeviceType.HardDisk), path, "vdi");
new CreateMediumIfNotAlreadyExists(manager, true).apply(hardDisk);
manager.getVBox().findMedium(path, DeviceType.HardDisk);
assertFileCanBeDeleted(path);
}
@ -47,8 +50,9 @@ public class CreateMediumIfNotAlreadyExistsLiveTest extends BaseVirtualBoxClient
@Test
public void testCreateMediumFailWhenUsingNonFullyQualifiedPath() throws Exception {
String path = "test-medium-2.vdi";
HardDisk hardDisk = new HardDisk(new DeviceDetails(0, 0, DeviceType.HardDisk), path, "vdi");
try {
new CreateMediumIfNotAlreadyExists(manager, "vdi", true).apply(path);
new CreateMediumIfNotAlreadyExists(manager, true).apply(hardDisk);
fail();
} catch (VBoxException e) {
ErrorCode errorCode = ErrorCode.valueOf(e);
@ -59,8 +63,9 @@ public class CreateMediumIfNotAlreadyExistsLiveTest extends BaseVirtualBoxClient
@Test
public void testCreateSameMediumTwiceWhenUsingOverwrite() throws Exception {
String path = System.getProperty("user.home") + "/jclouds-virtualbox-test/test-medium-3.vdi";
new CreateMediumIfNotAlreadyExists(manager, "vdi", true).apply(path);
new CreateMediumIfNotAlreadyExists(manager, "vdi", true).apply(path);
HardDisk hardDisk = new HardDisk(new DeviceDetails(0, 0, DeviceType.HardDisk), path, "vdi");
new CreateMediumIfNotAlreadyExists(manager, true).apply(hardDisk);
new CreateMediumIfNotAlreadyExists(manager, true).apply(hardDisk);
manager.getVBox().findMedium(path, DeviceType.HardDisk);
assertFileCanBeDeleted(path);
}

75
sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/CreateMediumIfNotAlreadyExistsTest.java
View File

@ -19,7 +19,9 @@
package org.jclouds.virtualbox.functions;
import static com.google.common.collect.Iterables.getOnlyElement;
import static org.easymock.EasyMock.anyLong;
import static org.easymock.EasyMock.eq;
import static org.easymock.EasyMock.expect;
import static org.easymock.classextension.EasyMock.createMock;
import static org.easymock.classextension.EasyMock.createNiceMock;
@ -27,6 +29,9 @@ import static org.easymock.classextension.EasyMock.replay;
import static org.easymock.classextension.EasyMock.verify;
import static org.testng.Assert.assertNotSame;
import org.jclouds.virtualbox.domain.DeviceDetails;
import org.jclouds.virtualbox.domain.HardDisk;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import org.virtualbox_4_1.DeviceType;
import org.virtualbox_4_1.IMachine;
@ -41,15 +46,24 @@ import org.virtualbox_4_1.VirtualBoxManager;
*/
public class CreateMediumIfNotAlreadyExistsTest {
private String adminDiskPath;
private String diskFormat;
@BeforeMethod
public void setUp() throws Exception {
adminDiskPath = "/Users/johndoe/jclouds-virtualbox-images/admin.vdi";
diskFormat = "vdi";
}
@Test
public void testCreateMediumWhenDiskDoesNotExists() throws Exception {
String adminDiskPath = "/Users/johndoe/jclouds-virtualbox-images/admin.vdi";
String diskFormat = "vdi";
HardDisk hardDisk = createTestHardDisk();
VirtualBoxManager manager = createNiceMock(VirtualBoxManager.class);
IMachine machine = createMock(IMachine.class);
IVirtualBox vBox = createMock(IVirtualBox.class);
IMedium hardDisk = createMock(IMedium.class);
IMedium medium = createMock(IMedium.class);
IProgress progress = createNiceMock(IProgress.class);
StringBuilder errorBuilder = new StringBuilder();
@ -61,13 +75,13 @@ public class CreateMediumIfNotAlreadyExistsTest {
expect(manager.getVBox()).andReturn(vBox).anyTimes();
VBoxException notFoundException = new VBoxException(createNiceMock(Throwable.class), errorMessage);
expect(vBox.findMedium(adminDiskPath, DeviceType.HardDisk)).andThrow(notFoundException);
expect(vBox.createHardDisk(diskFormat, adminDiskPath)).andReturn(hardDisk);
expect(hardDisk.createBaseStorage(anyLong(), anyLong())).andReturn(progress);
expect(vBox.findMedium(eq(adminDiskPath), eq(DeviceType.HardDisk))).andThrow(notFoundException);
expect(vBox.createHardDisk(diskFormat, adminDiskPath)).andReturn(medium);
expect(medium.createBaseStorage(anyLong(), anyLong())).andReturn(progress);
replay(manager, machine, vBox, hardDisk);
replay(manager, machine, vBox, medium);
new CreateMediumIfNotAlreadyExists(manager, diskFormat, true).apply(adminDiskPath);
new CreateMediumIfNotAlreadyExists(manager, true).apply(hardDisk);
verify(machine, vBox);
@ -75,61 +89,58 @@ public class CreateMediumIfNotAlreadyExistsTest {
@Test
public void testDeleteAndCreateNewStorageWhenMediumExistsAndUsingOverwrite() throws Exception {
String adminDiskPath = "/Users/johndoe/jclouds-virtualbox-images/admin.vdi";
String diskFormat = "vdi";
HardDisk hardDisk = createTestHardDisk();
VirtualBoxManager manager = createNiceMock(VirtualBoxManager.class);
IMachine machine = createMock(IMachine.class);
IVirtualBox vBox = createMock(IVirtualBox.class);
IMedium hardDisk = createMock(IMedium.class);
IMedium medium = createMock(IMedium.class);
IMedium newHardDisk = createMock(IMedium.class);
IProgress progress = createNiceMock(IProgress.class);
expect(manager.getVBox()).andReturn(vBox).anyTimes();
expect(vBox.findMedium(adminDiskPath, DeviceType.HardDisk)).andReturn(hardDisk);
expect(vBox.findMedium(adminDiskPath, DeviceType.HardDisk)).andReturn(medium);
expect(hardDisk.deleteStorage()).andReturn(progress);
expect(medium.deleteStorage()).andReturn(progress);
expect(vBox.createHardDisk(diskFormat, adminDiskPath)).andReturn(newHardDisk);
expect(newHardDisk.createBaseStorage(anyLong(), anyLong())).andReturn(progress);
replay(manager, machine, vBox, hardDisk, newHardDisk, progress);
replay(manager, machine, vBox, medium, newHardDisk, progress);
IMedium newDisk = new CreateMediumIfNotAlreadyExists(manager, diskFormat, true).apply(adminDiskPath);
IMedium newDisk = new CreateMediumIfNotAlreadyExists(manager, true).apply(hardDisk);
verify(machine, vBox, hardDisk);
assertNotSame(newDisk, hardDisk);
verify(machine, vBox, medium);
assertNotSame(newDisk, medium);
}
@Test(expectedExceptions = IllegalStateException.class)
public void testFailWhenMediumExistsAndNotUsingOverwrite() throws Exception {
String adminDiskPath = "/Users/johndoe/jclouds-virtualbox-images/admin.vdi";
String diskFormat = "vdi";
HardDisk hardDisk = createTestHardDisk();
VirtualBoxManager manager = createNiceMock(VirtualBoxManager.class);
IMachine machine = createMock(IMachine.class);
IVirtualBox vBox = createMock(IVirtualBox.class);
IMedium hardDisk = createMock(IMedium.class);
IMedium medium = createMock(IMedium.class);
IMedium newHardDisk = createMock(IMedium.class);
IProgress progress = createNiceMock(IProgress.class);
expect(manager.getVBox()).andReturn(vBox).anyTimes();
expect(vBox.findMedium(adminDiskPath, DeviceType.HardDisk)).andReturn(hardDisk);
expect(vBox.findMedium(adminDiskPath, DeviceType.HardDisk)).andReturn(medium);
replay(manager, machine, vBox, hardDisk, newHardDisk, progress);
replay(manager, machine, vBox, medium, newHardDisk, progress);
new CreateMediumIfNotAlreadyExists(manager, diskFormat, false).apply(adminDiskPath);
new CreateMediumIfNotAlreadyExists(manager, false).apply(hardDisk);
}
@Test(expectedExceptions = VBoxException.class)
public void testFailOnOtherVBoxException() throws Exception {
String adminDiskPath = "/Users/johndoe/jclouds-virtualbox-images/admin.vdi";
String diskFormat = "vdi";
HardDisk hardDisk = createTestHardDisk();
VirtualBoxManager manager = createNiceMock(VirtualBoxManager.class);
IMachine machine = createMock(IMachine.class);
IVirtualBox vBox = createMock(IVirtualBox.class);
IMedium hardDisk = createMock(IMedium.class);
IMedium medium = createMock(IMedium.class);
IProgress progress = createNiceMock(IProgress.class);
String errorMessage = "VirtualBox error: Some other VBox error";
@ -138,12 +149,16 @@ public class CreateMediumIfNotAlreadyExistsTest {
VBoxException notFoundException = new VBoxException(createNiceMock(Throwable.class), errorMessage);
expect(vBox.findMedium(adminDiskPath, DeviceType.HardDisk)).andThrow(notFoundException);
expect(vBox.createHardDisk(diskFormat, adminDiskPath)).andReturn(hardDisk);
expect(hardDisk.createBaseStorage(anyLong(), anyLong())).andReturn(progress);
expect(vBox.createHardDisk(diskFormat, adminDiskPath)).andReturn(medium);
expect(medium.createBaseStorage(anyLong(), anyLong())).andReturn(progress);
replay(manager, machine, vBox, hardDisk);
replay(manager, machine, vBox, medium);
new CreateMediumIfNotAlreadyExists(manager, diskFormat, true).apply(adminDiskPath);
new CreateMediumIfNotAlreadyExists(manager, true).apply(hardDisk);
}
private HardDisk createTestHardDisk() {
return new HardDisk(new DeviceDetails(0, 0, DeviceType.HardDisk), adminDiskPath, diskFormat);
}
}

57
sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/IsoToIMachineLiveTest.java
View File

@ -19,18 +19,9 @@
package org.jclouds.virtualbox.functions;
import static com.google.common.base.Predicates.equalTo;
import static com.google.common.collect.Iterables.any;
import static com.google.common.collect.Iterables.transform;
import static org.jclouds.virtualbox.experiment.TestUtils.computeServiceForLocalhostAndGuest;
import static org.testng.Assert.assertTrue;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import com.google.common.base.Function;
import com.google.common.base.Predicate;
import com.google.inject.Guice;
import org.jclouds.compute.ComputeServiceContext;
import org.jclouds.compute.config.BaseComputeServiceContextModule;
import org.jclouds.compute.domain.Image;
@ -43,16 +34,25 @@ import org.jclouds.net.IPSocket;
import org.jclouds.predicates.InetSocketAddressConnect;
import org.jclouds.predicates.RetryablePredicate;
import org.jclouds.virtualbox.BaseVirtualBoxClientLiveTest;
import org.jclouds.virtualbox.domain.*;
import org.jclouds.virtualbox.functions.admin.UnregisterMachineIfExists;
import org.jclouds.virtualbox.util.PropertyUtils;
import org.testng.annotations.BeforeGroups;
import org.testng.annotations.Test;
import org.virtualbox_4_1.CleanupMode;
import org.virtualbox_4_1.IMachine;
import org.virtualbox_4_1.VirtualBoxManager;
import com.google.inject.Guice;
import org.virtualbox_4_1.*;
import javax.annotation.Nullable;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import static com.google.common.base.Predicates.equalTo;
import static com.google.common.collect.Iterables.any;
import static com.google.common.collect.Iterables.transform;
import static org.jclouds.virtualbox.domain.ExecutionType.GUI;
import static org.jclouds.virtualbox.domain.ExecutionType.HEADLESS;
import static org.jclouds.virtualbox.experiment.TestUtils.computeServiceForLocalhostAndGuest;
import static org.testng.Assert.assertTrue;
/**
* @author Andrea Turli, Mattias Holmqvist
@ -62,20 +62,17 @@ public class IsoToIMachineLiveTest extends BaseVirtualBoxClientLiveTest {
Map<OsFamily, Map<String, String>> map = new BaseComputeServiceContextModule() {
}.provideOsVersionMap(new ComputeServiceConstants.ReferenceData(), Guice.createInjector(new GsonModule())
.getInstance(Json.class));
.getInstance(Json.class));
private boolean forceOverwrite = true;
private String vmId = "jclouds-image-iso-1";
private String osTypeId = "";
private String controllerIDE = "IDE Controller";
private String diskFormat = "";
private String adminDisk = "testadmin.vdi";
private String ideControllerName = "IDE Controller";
private String guestId = "guest";
private String hostId = "host";
private String vmName = "jclouds-image-virtualbox-iso-to-machine-test";
@BeforeGroups(groups = { "live" })
@BeforeGroups(groups = {"live"})
public void setUp() throws Exception {
identity = "toor";
credential = "password";
@ -86,11 +83,21 @@ public class IsoToIMachineLiveTest extends BaseVirtualBoxClientLiveTest {
VirtualBoxManager manager = (VirtualBoxManager) context.getProviderSpecificContext().getApi();
ComputeServiceContext localHostContext = computeServiceForLocalhostAndGuest(hostId, "localhost", guestId,
"localhost", new Credentials("toor", "password"));
"localhost", new Credentials("toor", "password"));
Predicate<IPSocket> socketTester = new RetryablePredicate<IPSocket>(new InetSocketAddressConnect(), 10, 1, TimeUnit.SECONDS);
IMachine imageMachine = new IsoToIMachine(manager, adminDisk, diskFormat, vmName, osTypeId, vmId,
forceOverwrite, controllerIDE, localHostContext, hostId, guestId, socketTester, "127.0.0.1", 8080)
.apply("ubuntu-11.04-server-i386.iso");
String workingDir = PropertyUtils.getWorkingDirFromProperty();
StorageController ideController = StorageController.builder().name(ideControllerName).bus(StorageBus.IDE)
.attachISO(0, 0, workingDir + "/ubuntu-11.04-server-i386.iso")
.attachHardDisk(0, 1, workingDir + "/testadmin.vdi")
.attachISO(1, 1, workingDir + "/VBoxGuestAdditions_4.1.2.iso").build();
VmSpecification vmSpecification = VmSpecification.builder().id(vmId).name(vmName).osTypeId(osTypeId)
.controller(ideController)
.forceOverwrite(true)
.natNetworkAdapter(0, NatAdapter.builder().tcpRedirectRule("127.0.0.1", 2222, "", 22).build()).build();
IMachine imageMachine = new IsoToIMachine(manager, guestId, vmSpecification, localHostContext, hostId,
socketTester, "127.0.0.1", 8080, HEADLESS)
.apply("ubuntu-11.04-server-i386.iso");
IMachineToImage iMachineToImage = new IMachineToImage(manager, map);
Image newImage = iMachineToImage.apply(imageMachine);

76
sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/predicates/SshAvailableLiveTest.java
View File

@ -1,13 +1,7 @@
package org.jclouds.virtualbox.predicates;
import static org.jclouds.virtualbox.experiment.TestUtils.computeServiceForLocalhostAndGuest;
import static org.jclouds.virtualbox.util.MachineUtils.applyForMachine;
import static org.jclouds.virtualbox.util.MachineUtils.lockSessionOnMachineAndApply;
import static org.virtualbox_4_1.LockType.Shared;
import static org.testng.Assert.assertTrue;
import java.util.concurrent.TimeUnit;
import com.google.common.base.Function;
import com.google.common.base.Predicate;
import org.jclouds.compute.ComputeServiceContext;
import org.jclouds.domain.Credentials;
import org.jclouds.net.IPSocket;
@ -15,47 +9,44 @@ import org.jclouds.predicates.InetSocketAddressConnect;
import org.jclouds.predicates.RetryablePredicate;
import org.jclouds.virtualbox.BaseVirtualBoxClientLiveTest;
import org.jclouds.virtualbox.domain.ExecutionType;
import org.jclouds.virtualbox.domain.StorageController;
import org.jclouds.virtualbox.domain.VmSpecification;
import org.jclouds.virtualbox.functions.IsoToIMachine;
import org.jclouds.virtualbox.functions.LaunchMachineIfNotAlreadyRunning;
import org.jclouds.virtualbox.util.PropertyUtils;
import org.testng.annotations.Test;
import org.virtualbox_4_1.IMachine;
import org.virtualbox_4_1.IProgress;
import org.virtualbox_4_1.ISession;
import org.virtualbox_4_1.VirtualBoxManager;
import org.virtualbox_4_1.*;
import com.google.common.base.Function;
import com.google.common.base.Predicate;
import java.util.concurrent.TimeUnit;
@Test(groups = "live", singleThreaded = true, testName = "IsoToIMachineLiveTest")
import static org.jclouds.virtualbox.domain.ExecutionType.HEADLESS;
import static org.jclouds.virtualbox.experiment.TestUtils.computeServiceForLocalhostAndGuest;
import static org.jclouds.virtualbox.util.MachineUtils.applyForMachine;
import static org.jclouds.virtualbox.util.MachineUtils.lockSessionOnMachineAndApply;
import static org.testng.Assert.assertTrue;
import static org.virtualbox_4_1.LockType.Shared;
@Test(groups = "live", singleThreaded = true, testName = "SshAvailableLiveTest")
public class SshAvailableLiveTest extends BaseVirtualBoxClientLiveTest {
private boolean forceOverwrite = true;
private String vmId = "jclouds-image-iso-1";
private String osTypeId = "";
private String controllerIDE = "IDE Controller";
private String diskFormat = "";
private String adminDisk = "testadmin.vdi";
private String guestId = "guest";
private String hostId = "host";
private String vmName = "jclouds-image-virtualbox-iso-to-machine-test";
private String isoName = "ubuntu-11.04-server-i386.iso";
private String vmName = "jclouds-image-virtualbox-iso-to-machine-sshtest";
@Test
public void testSshDaemonIsRunning() {
VirtualBoxManager manager = (VirtualBoxManager) context
.getProviderSpecificContext().getApi();
VirtualBoxManager manager = (VirtualBoxManager) context.getProviderSpecificContext().getApi();
ComputeServiceContext localHostContext = computeServiceForLocalhostAndGuest(
hostId, "localhost", guestId, "localhost", new Credentials("toor",
"password"));
hostId, "localhost", guestId, "localhost", new Credentials("toor","password"));
getNodeWithSshDaemonRunning(manager, localHostContext);
getNodeWithSshDaemonRunning(manager, localHostContext);
ensureMachineIsLaunched(vmName);
RetryablePredicate<String> predicate = new RetryablePredicate<String>(
new SshAvailable(localHostContext), 5, 1,
TimeUnit.SECONDS);
new SshAvailable(localHostContext), 5, 1,
TimeUnit.SECONDS);
assertTrue(predicate.apply(guestId));
lockSessionOnMachineAndApply(manager, Shared, vmName, new Function<ISession, Void>() {
@Override
@ -68,14 +59,23 @@ public class SshAvailableLiveTest extends BaseVirtualBoxClientLiveTest {
});
}
private IMachine getNodeWithSshDaemonRunning(VirtualBoxManager manager,
ComputeServiceContext localHostContext) {
private IMachine getNodeWithSshDaemonRunning(VirtualBoxManager manager, ComputeServiceContext localHostContext) {
try {
Predicate<IPSocket> socketTester = new RetryablePredicate<IPSocket>(
new InetSocketAddressConnect(), 10, 1, TimeUnit.SECONDS);
return new IsoToIMachine(manager, adminDisk, diskFormat, vmName,
osTypeId, vmId, forceOverwrite, controllerIDE, localHostContext,
hostId, guestId, socketTester, "127.0.0.1", 8080).apply(isoName);
new InetSocketAddressConnect(), 10, 1, TimeUnit.SECONDS);
String vmId = "jclouds-image-iso-2";
String isoName = "ubuntu-11.04-server-i386.iso";
String workingDir = PropertyUtils.getWorkingDirFromProperty();
StorageController ideController = StorageController.builder().name("IDE Controller").bus(StorageBus.IDE)
.attachISO(0, 0, workingDir + "/ubuntu-11.04-server-i386.iso")
.attachHardDisk(0, 1, workingDir + "/testadmin.vdi").build();
VmSpecification vmSpecification = VmSpecification.builder().id(vmId).name(vmName).osTypeId("")
.controller(ideController)
.forceOverwrite(true).build();
return new IsoToIMachine(manager, guestId, vmSpecification, localHostContext,
hostId, socketTester, "127.0.0.1", 8080, HEADLESS).apply(isoName);
} catch (IllegalStateException e) {
// already created
return manager.getVBox().findMachine(vmName);
@ -84,7 +84,7 @@ public class SshAvailableLiveTest extends BaseVirtualBoxClientLiveTest {
private void ensureMachineIsLaunched(String vmName) {
applyForMachine(manager, vmName, new LaunchMachineIfNotAlreadyRunning(
manager, ExecutionType.GUI, ""));
manager, ExecutionType.GUI, ""));
}
}