diff --git a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/VirtualBox.java b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/VirtualBox.java index 1824df9317..8e0e09c206 100644 --- a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/VirtualBox.java +++ b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/VirtualBox.java @@ -21,5 +21,17 @@ package org.jclouds.virtualbox; +import org.virtualbox_4_1.VirtualBoxManager; + public class VirtualBox { + + private VirtualBoxManager manager; + + public VirtualBox() { + this.manager = VirtualBoxManager.createInstance(""); + } + + public VirtualBoxManager manager() { + return manager; + } } diff --git a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/VirtualBoxPropertiesBuilder.java b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/VirtualBoxPropertiesBuilder.java index 8599902b2b..5ee27b01f7 100644 --- a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/VirtualBoxPropertiesBuilder.java +++ b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/VirtualBoxPropertiesBuilder.java @@ -24,6 +24,7 @@ package org.jclouds.virtualbox; import org.jclouds.PropertiesBuilder; import org.jclouds.virtualbox.config.VirtualBoxConstants; +import java.io.File; import java.util.Properties; import static org.jclouds.Constants.*; @@ -51,6 +52,22 @@ public class VirtualBoxPropertiesBuilder extends PropertiesBuilder { properties.put(PROPERTY_ENDPOINT, "http://localhost:18083/"); properties.put(VirtualBoxConstants.VIRTUALBOX_PRESEED_URL, "http://dl.dropbox.com/u/693111/preseed.cfg"); properties.put(VirtualBoxConstants.VIRTUALBOX_SNAPSHOT_DESCRIPTION, "jclouds-virtualbox-snaphot"); + properties.put(VirtualBoxConstants.VIRTUALBOX_HOSTNAME, "jclouds-virtualbox-kickstart-admin"); + properties.put(VirtualBoxConstants.VIRTUALBOX_INSTALLATION_KEY_SEQUENCE, " " + + "/install/vmlinuz noapic preseed/url=http://10.0.2.2:8080/src/test/resources/preseed.cfg " + + "debian-installer=en_US auto locale=en_US kbd-chooser/method=us " + + "hostname=" + + properties.get(VirtualBoxConstants.VIRTUALBOX_HOSTNAME) + + " " + + "fb=false debconf/frontend=noninteractive " + + "keyboard-configuration/layout=USA keyboard-configuration/variant=USA console-setup/ask_detect=false " + + "initrd=/install/initrd.gz -- "); + + properties.put(VirtualBoxConstants.VIRTUALBOX_WORKINGDIR, System.getProperty("user.home") + + File.separator + + System.getProperty("test.virtualbox.workingDir", + "jclouds-virtualbox-test")); + // TODO: Add more properties and use the wired properties from test code. return properties; } diff --git a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/compute/LoadMachineFromVirtualBox.java b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/compute/LoadMachineFromVirtualBox.java new file mode 100644 index 0000000000..f62245163e --- /dev/null +++ b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/compute/LoadMachineFromVirtualBox.java @@ -0,0 +1,107 @@ +/* + * * + * * 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.compute; + +import com.google.common.base.Function; +import com.google.common.cache.CacheLoader; +import org.jclouds.byon.Node; +import org.jclouds.compute.domain.OsFamily; +import org.virtualbox_4_1.IGuestOSType; +import org.virtualbox_4_1.IMachine; +import org.virtualbox_4_1.VirtualBoxManager; + +import javax.inject.Inject; +import java.net.URI; +import java.net.URISyntaxException; + +import static org.jclouds.virtualbox.config.VirtualBoxConstants.*; + +/** + * Loads a node from a VirtualBox IMachine + * + * @author Mattias Holmqvist + */ +public class LoadMachineFromVirtualBox extends CacheLoader { + + private VirtualBoxManager manager; + private Function iMachineToIpAddress; + + @Inject + public LoadMachineFromVirtualBox(VirtualBoxManager manager, Function iMachineToIpAddress) { + this.manager = manager; + this.iMachineToIpAddress = iMachineToIpAddress; + } + + @Override + public Node load(final String id) throws Exception { + + if (id.equals("host")) { + final Node hostNode = Node.builder().id("host") + .name("host installing virtualbox") + .hostname("localhost") + .osFamily(OsFamily.LINUX.toString()) + .osDescription(System.getProperty("os.name")) + .osVersion(System.getProperty("os.version")) + .group("ssh") + .username(System.getProperty("user.name")) + .credentialUrl(privateKeyFile()) + .build(); + return hostNode; + } + + final IMachine machine = manager.getVBox().findMachine(id); + final String ipAddress = iMachineToIpAddress.apply(machine); + final String osTypeId = machine.getOSTypeId(); + final IGuestOSType guestOSType = manager.getVBox().getGuestOSType(osTypeId); + + final Node node = Node.builder() + .id(machine.getId()) + .name(machine.getName()) + .description(machine.getDescription()) + .loginPort(22) + .group(System.getProperty(VIRTUALBOX_MACHINE_GROUP)) + .username(System.getProperty(VIRTUALBOX_MACHINE_USERNAME)) + .credential(System.getProperty(VIRTUALBOX_MACHINE_CREDENTIAL)) + .sudoPassword(System.getProperty(VIRTUALBOX_MACHINE_CREDENTIAL)) + .locationId(System.getProperty(VIRTUALBOX_MACHINE_LOCATION)) + .os64Bit(guestOSType.getIs64Bit()) + .osArch(guestOSType.getDescription()) + .osFamily(guestOSType.getFamilyDescription()) + .osVersion(guestOSType.getId()) + .osDescription(guestOSType.getDescription()) + .hostname(ipAddress) + .build(); + + return node; + + } + + private static URI privateKeyFile() { + try { + return new URI("file://" + System.getProperty("user.home") + "/.ssh/id_rsa"); + } catch (URISyntaxException e) { + e.printStackTrace(); + } + return null; + } + +} diff --git a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/compute/VirtualBoxComputeServiceAdapter.java b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/compute/VirtualBoxComputeServiceAdapter.java index c329e63552..65527223be 100644 --- a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/compute/VirtualBoxComputeServiceAdapter.java +++ b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/compute/VirtualBoxComputeServiceAdapter.java @@ -21,28 +21,19 @@ package org.jclouds.virtualbox.compute; -import static com.google.common.base.Preconditions.checkNotNull; - -import java.util.Collections; -import java.util.Map; - -import javax.inject.Inject; - +import com.google.common.base.Throwables; +import com.google.inject.Singleton; import org.jclouds.compute.ComputeServiceAdapter; import org.jclouds.compute.domain.Template; import org.jclouds.domain.Credentials; import org.jclouds.virtualbox.domain.Host; -import org.jclouds.virtualbox.domain.Image; -import org.jclouds.virtualbox.domain.VMSpec; -import org.virtualbox_4_1.CleanupMode; -import org.virtualbox_4_1.IMachine; -import org.virtualbox_4_1.IProgress; -import org.virtualbox_4_1.ISession; -import org.virtualbox_4_1.SessionState; -import org.virtualbox_4_1.VirtualBoxManager; +import org.virtualbox_4_1.*; -import com.google.common.base.Throwables; -import com.google.inject.Singleton; +import javax.inject.Inject; +import java.util.Collections; +import java.util.Map; + +import static com.google.common.base.Preconditions.checkNotNull; /** * Defines the connection between the {@link org.virtualbox_4_1.VirtualBoxManager} implementation and the jclouds @@ -51,7 +42,7 @@ import com.google.inject.Singleton; * @author Mattias Holmqvist, Andrea Turli */ @Singleton -public class VirtualBoxComputeServiceAdapter implements ComputeServiceAdapter { +public class VirtualBoxComputeServiceAdapter implements ComputeServiceAdapter { private final VirtualBoxManager manager; @@ -71,12 +62,12 @@ public class VirtualBoxComputeServiceAdapter implements ComputeServiceAdapter listHardwareProfiles() { + public Iterable listHardwareProfiles() { return Collections.emptyList(); } @Override - public Iterable listImages() { + public Iterable listImages() { return Collections.emptyList(); } diff --git a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/config/VirtualBoxComputeServiceContextModule.java b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/config/VirtualBoxComputeServiceContextModule.java index 0f239a20ab..5bed29ecf2 100644 --- a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/config/VirtualBoxComputeServiceContextModule.java +++ b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/config/VirtualBoxComputeServiceContextModule.java @@ -21,41 +21,39 @@ package org.jclouds.virtualbox.config; -import java.net.URI; - -import javax.inject.Named; -import javax.inject.Singleton; - +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Function; +import com.google.common.base.Supplier; +import com.google.common.collect.ImmutableMap; +import com.google.inject.Injector; +import com.google.inject.Provides; +import com.google.inject.TypeLiteral; import org.jclouds.Constants; import org.jclouds.compute.ComputeServiceAdapter; import org.jclouds.compute.config.ComputeServiceAdapterContextModule; -import org.jclouds.compute.domain.NodeMetadata; -import org.jclouds.compute.domain.OsFamily; -import org.jclouds.compute.domain.TemplateBuilder; +import org.jclouds.compute.domain.*; import org.jclouds.domain.Location; import org.jclouds.location.Provider; import org.jclouds.location.suppliers.OnlyLocationOrFirstZone; import org.jclouds.virtualbox.compute.VirtualBoxComputeServiceAdapter; import org.jclouds.virtualbox.domain.Host; -import org.jclouds.virtualbox.domain.Image; -import org.jclouds.virtualbox.domain.VMSpec; import org.jclouds.virtualbox.functions.HostToLocation; +import org.jclouds.virtualbox.functions.IMachineToHardware; +import org.jclouds.virtualbox.functions.IMachineToImage; import org.jclouds.virtualbox.functions.IMachineToNodeMetadata; -import org.jclouds.virtualbox.functions.ImageToImage; -import org.jclouds.virtualbox.functions.VMSpecToHardware; import org.virtualbox_4_1.IMachine; +import org.virtualbox_4_1.MachineState; import org.virtualbox_4_1.VirtualBoxManager; -import com.google.common.base.Function; -import com.google.common.base.Supplier; -import com.google.inject.Injector; -import com.google.inject.Provides; -import com.google.inject.TypeLiteral; +import javax.inject.Named; +import javax.inject.Singleton; +import java.net.URI; +import java.util.Map; /** * @author Mattias Holmqvist, Andrea Turli */ -public class VirtualBoxComputeServiceContextModule extends ComputeServiceAdapterContextModule { +public class VirtualBoxComputeServiceContextModule extends ComputeServiceAdapterContextModule { public VirtualBoxComputeServiceContextModule() { super(VirtualBoxManager.class, VirtualBoxManager.class); @@ -73,16 +71,16 @@ public class VirtualBoxComputeServiceContextModule extends ComputeServiceAdapter @Override protected void configure() { super.configure(); - bind(new TypeLiteral>() { + bind(new TypeLiteral>() { }).to(VirtualBoxComputeServiceAdapter.class); bind(new TypeLiteral>() { }).to(IMachineToNodeMetadata.class); bind(new TypeLiteral>() { }).to(HostToLocation.class); - bind(new TypeLiteral>() { - }).to(VMSpecToHardware.class); - bind(new TypeLiteral>() { - }).to(ImageToImage.class); + bind(new TypeLiteral>() { + }).to(IMachineToHardware.class); + bind(new TypeLiteral>() { + }).to(IMachineToImage.class); bind(new TypeLiteral>() { }).to(OnlyLocationOrFirstZone.class); } @@ -91,4 +89,34 @@ public class VirtualBoxComputeServiceContextModule extends ComputeServiceAdapter protected TemplateBuilder provideTemplate(Injector injector, TemplateBuilder template) { return template.osFamily(OsFamily.UBUNTU).os64Bit(false).osVersionMatches("11.04-server"); } + + @VisibleForTesting + public static final Map machineToNodeState = ImmutableMap + .builder() + .put(MachineState.Running, NodeState.RUNNING) + .put(MachineState.PoweredOff, NodeState.SUSPENDED) + .put(MachineState.DeletingSnapshot, NodeState.PENDING) + .put(MachineState.DeletingSnapshotOnline, NodeState.PENDING) + .put(MachineState.DeletingSnapshotPaused, NodeState.PENDING) + .put(MachineState.FaultTolerantSyncing, NodeState.PENDING) + .put(MachineState.LiveSnapshotting, NodeState.PENDING) + .put(MachineState.SettingUp, NodeState.PENDING) + .put(MachineState.Starting, NodeState.PENDING) + .put(MachineState.Stopping, NodeState.PENDING) + .put(MachineState.Restoring, NodeState.PENDING) + // TODO What to map these states to? + .put(MachineState.FirstOnline, NodeState.PENDING) + .put(MachineState.FirstTransient, NodeState.PENDING) + .put(MachineState.LastOnline, NodeState.PENDING) + .put(MachineState.LastTransient, NodeState.PENDING) + .put(MachineState.Teleported, NodeState.PENDING) + .put(MachineState.TeleportingIn, NodeState.PENDING) + .put(MachineState.TeleportingPausedVM, NodeState.PENDING) + + + .put(MachineState.Aborted, NodeState.ERROR) + .put(MachineState.Stuck, NodeState.ERROR) + + .put(MachineState.Null, NodeState.UNRECOGNIZED).build(); + } diff --git a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/config/VirtualBoxConstants.java b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/config/VirtualBoxConstants.java index 0757214f38..a9f7abad0d 100644 --- a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/config/VirtualBoxConstants.java +++ b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/config/VirtualBoxConstants.java @@ -33,5 +33,21 @@ public interface VirtualBoxConstants { public static final String VIRTUALBOX_SNAPSHOT_DESCRIPTION = "jclouds.virtualbox.snapshotDescription"; + public static final String VIRTUALBOX_INSTALLATION_KEY_SEQUENCE = "jclouds.virtualbox.installationkeysequence"; + + public static final String VIRTUALBOX_HOSTNAME = "jclouds.virtualbox.hostname"; + + public static final String VIRTUALBOX_WORKINGDIR = "jclouds.virtualbox.workingdir"; + + public static final String VIRTUALBOX_ISOFILE = "jclouds.virtualbox.isofile"; + public static final String VIRTUALBOX_MACHINE_GROUP = "jclouds.virtualbox.machinegroup"; + + public static final String VIRTUALBOX_MACHINE_USERNAME = "jclouds.virtualbox.username"; + + public static final String VIRTUALBOX_MACHINE_CREDENTIAL = "jclouds.virtualbox.credential"; + + public static final String VIRTUALBOX_MACHINE_LOCATION = "jclouds.virtualbox.location"; + + public static final String VIRTUALBOX_HOST_ID = "jclouds.virtualbox.hostid"; } diff --git a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/Image.java b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/Image.java deleted file mode 100644 index 0e9d336dfd..0000000000 --- a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/Image.java +++ /dev/null @@ -1,26 +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.domain; - -public class Image { - -} diff --git a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/Snapshot.java b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/Snapshot.java deleted file mode 100644 index acc09b8b7d..0000000000 --- a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/Snapshot.java +++ /dev/null @@ -1,25 +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.domain; - -public class Snapshot { -} diff --git a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/VMSpec.java b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/VMSpec.java deleted file mode 100644 index 03e8d78b01..0000000000 --- a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/domain/VMSpec.java +++ /dev/null @@ -1,25 +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.domain; - -public class VMSpec { -} diff --git a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/VMSpecToHardware.java b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/IMachineToHardware.java similarity index 58% rename from sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/VMSpecToHardware.java rename to sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/IMachineToHardware.java index 824cfcf190..c145242679 100644 --- a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/VMSpecToHardware.java +++ b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/IMachineToHardware.java @@ -22,15 +22,35 @@ package org.jclouds.virtualbox.functions; import com.google.common.base.Function; +import org.jclouds.compute.domain.Hardware; import org.jclouds.compute.domain.HardwareBuilder; import org.jclouds.javax.annotation.Nullable; -import org.jclouds.virtualbox.domain.VMSpec; +import org.jclouds.virtualbox.VirtualBox; +import org.virtualbox_4_1.IGuestOSType; +import org.virtualbox_4_1.IMachine; +import org.virtualbox_4_1.VirtualBoxManager; -public class VMSpecToHardware implements Function { +import javax.inject.Inject; + +public class IMachineToHardware implements Function { + + private VirtualBox vbox; + + @Inject + public IMachineToHardware(VirtualBox vbox) { + this.vbox = vbox; + } @Override - public org.jclouds.compute.domain.Hardware apply(@Nullable VMSpec input) { + public Hardware apply(@Nullable IMachine vm) { + String osTypeId = vm.getOSTypeId(); + + IGuestOSType guestOSType = vbox.manager().getVBox().getGuestOSType(osTypeId); + Boolean is64Bit = guestOSType.getIs64Bit(); HardwareBuilder hardwareBuilder = new HardwareBuilder(); - return hardwareBuilder.build(); + hardwareBuilder.ids(vm.getId()); + vm.getSessionPid(); + hardwareBuilder.is64Bit(is64Bit); + return null; } } diff --git a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/ImageToImage.java b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/IMachineToImage.java similarity index 81% rename from sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/ImageToImage.java rename to sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/IMachineToImage.java index 7f0cd12b5e..54eb8936e9 100644 --- a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/ImageToImage.java +++ b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/IMachineToImage.java @@ -22,14 +22,18 @@ package org.jclouds.virtualbox.functions; import com.google.common.base.Function; +import org.jclouds.compute.domain.Image; import org.jclouds.compute.domain.ImageBuilder; import org.jclouds.javax.annotation.Nullable; -import org.jclouds.virtualbox.domain.Image; +import org.virtualbox_4_1.IMachine; + + +public class IMachineToImage implements Function { -public class ImageToImage implements Function { @Override - public org.jclouds.compute.domain.Image apply(@Nullable Image from) { + public Image apply(@Nullable IMachine vm) { ImageBuilder imageBuilder = new ImageBuilder(); - return imageBuilder.build(); + imageBuilder.ids(vm.getId()); + return null; } } diff --git a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/IMachineToIpAddress.java b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/IMachineToIpAddress.java new file mode 100644 index 0000000000..179dd658c4 --- /dev/null +++ b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/IMachineToIpAddress.java @@ -0,0 +1,91 @@ +/* + * * + * * 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 com.google.common.base.Function; +import org.jclouds.compute.ComputeService; +import org.jclouds.compute.domain.ExecResponse; +import org.jclouds.compute.options.RunScriptOptions; +import org.jclouds.virtualbox.config.VirtualBoxConstants; +import org.virtualbox_4_1.IGuestOSType; +import org.virtualbox_4_1.IMachine; +import org.virtualbox_4_1.VirtualBoxManager; + +import javax.annotation.Nullable; + +import static org.jclouds.compute.options.RunScriptOptions.Builder.runAsRoot; + +public class IMachineToIpAddress implements Function { + + private VirtualBoxManager manager; + private ComputeService computeService; + + public IMachineToIpAddress(VirtualBoxManager manager, ComputeService computeService) { + this.manager = manager; + this.computeService = computeService; + } + + @Override + public String apply(@Nullable IMachine machine) { + + String macAddress = machine.getNetworkAdapter(0l).getMACAddress(); + int offset = 0, step = 2; + for (int j = 1; j <= 5; j++) { + macAddress = new StringBuffer(macAddress).insert(j * step + offset, ":").toString().toLowerCase(); + offset++; + } + + String simplifiedMacAddressOfClonedVM = macAddress; + + final String hostId = System.getProperty(VirtualBoxConstants.VIRTUALBOX_HOST_ID); + IMachine hostMachine = manager.getVBox().findMachine(hostId); + if (isOSX(hostMachine)) { + if (simplifiedMacAddressOfClonedVM.contains("00")) + simplifiedMacAddressOfClonedVM = new StringBuffer(simplifiedMacAddressOfClonedVM).delete(simplifiedMacAddressOfClonedVM.indexOf("00"), simplifiedMacAddressOfClonedVM.indexOf("00") + 1).toString(); + + if (simplifiedMacAddressOfClonedVM.contains("0")) + if (simplifiedMacAddressOfClonedVM.indexOf("0") + 1 != ':' && simplifiedMacAddressOfClonedVM.indexOf("0") - 1 != ':') + simplifiedMacAddressOfClonedVM = new StringBuffer(simplifiedMacAddressOfClonedVM).delete(simplifiedMacAddressOfClonedVM.indexOf("0"), simplifiedMacAddressOfClonedVM.indexOf("0") + 1).toString(); + } + + ExecResponse execResponse = runScriptOnNode(hostId, "for i in {1..254} ; do ping -c 1 -t 1 192.168.2.$i & done", runAsRoot(false).wrapInInitScript(false)); + System.out.println(execResponse); + + String arpLine = runScriptOnNode(hostId, "arp -an | grep " + simplifiedMacAddressOfClonedVM, runAsRoot(false).wrapInInitScript(false)).getOutput(); + String ipAddress = arpLine.substring(arpLine.indexOf("(") + 1, arpLine.indexOf(")")); + System.out.println("IP address " + ipAddress); + + return ipAddress; + } + + private ExecResponse runScriptOnNode(String nodeId, String command, RunScriptOptions options) { + return computeService.runScriptOnNode(nodeId, command, options); + } + + protected boolean isOSX(IMachine machine) { + String osTypeId = machine.getOSTypeId(); + IGuestOSType guestOSType = manager.getVBox().getGuestOSType(osTypeId); + String familyDescription = guestOSType.getFamilyDescription(); + return true; + } + +} diff --git a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/IMachineToNodeMetadata.java b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/IMachineToNodeMetadata.java index d8eaddcf1d..7dc2a07c62 100644 --- a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/IMachineToNodeMetadata.java +++ b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/IMachineToNodeMetadata.java @@ -19,36 +19,24 @@ package org.jclouds.virtualbox.functions; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; - -import javax.annotation.Resource; -import javax.inject.Named; - -import org.eclipse.jetty.server.Server; -import org.jclouds.collect.FindResourceInSet; -import org.jclouds.collect.Memoized; -import org.jclouds.compute.domain.HardwareBuilder; -import org.jclouds.compute.domain.NodeMetadata; -import org.jclouds.compute.domain.NodeMetadataBuilder; -import org.jclouds.compute.domain.NodeState; -import org.jclouds.compute.domain.Processor; +import com.google.common.base.Function; +import org.jclouds.compute.domain.*; import org.jclouds.compute.reference.ComputeServiceConstants; import org.jclouds.domain.Credentials; -import org.jclouds.domain.Location; import org.jclouds.domain.LocationBuilder; import org.jclouds.domain.LocationScope; import org.jclouds.javax.annotation.Nullable; import org.jclouds.logging.Logger; import org.virtualbox_4_1.IMachine; +import org.virtualbox_4_1.INetworkAdapter; import org.virtualbox_4_1.MachineState; -import com.google.common.base.Function; -import com.google.common.base.Supplier; -import com.google.inject.Inject; -import com.google.inject.Singleton; +import javax.annotation.Resource; +import javax.inject.Named; +import java.util.HashSet; +import java.util.Set; + +import static org.jclouds.virtualbox.config.VirtualBoxComputeServiceContextModule.machineToNodeState; public class IMachineToNodeMetadata implements Function { @@ -87,43 +75,21 @@ public class IMachineToNodeMetadata implements Function nodeMetadataBuilder.hostname(vm.getName()); nodeMetadataBuilder.loginPort(18083); - Map nodeStateMap = new HashMap(); - nodeStateMap.put(MachineState.Running, NodeState.RUNNING); - - nodeStateMap.put(MachineState.PoweredOff, NodeState.SUSPENDED); - nodeStateMap.put(MachineState.DeletingSnapshot, NodeState.PENDING); - nodeStateMap.put(MachineState.DeletingSnapshotOnline, NodeState.PENDING); - nodeStateMap.put(MachineState.DeletingSnapshotPaused, NodeState.PENDING); - nodeStateMap.put(MachineState.FaultTolerantSyncing, NodeState.PENDING); - nodeStateMap.put(MachineState.LiveSnapshotting, NodeState.PENDING); - nodeStateMap.put(MachineState.SettingUp, NodeState.PENDING); - nodeStateMap.put(MachineState.Starting, NodeState.PENDING); - nodeStateMap.put(MachineState.Stopping, NodeState.PENDING); - nodeStateMap.put(MachineState.Restoring, NodeState.PENDING); - - // TODO What to map these states to? - nodeStateMap.put(MachineState.FirstOnline, NodeState.PENDING); - nodeStateMap.put(MachineState.FirstTransient, NodeState.PENDING); - nodeStateMap.put(MachineState.LastOnline, NodeState.PENDING); - nodeStateMap.put(MachineState.LastTransient, NodeState.PENDING); - nodeStateMap.put(MachineState.Teleported, NodeState.PENDING); - nodeStateMap.put(MachineState.TeleportingIn, NodeState.PENDING); - nodeStateMap.put(MachineState.TeleportingPausedVM, NodeState.PENDING); - - - nodeStateMap.put(MachineState.Aborted, NodeState.ERROR); - nodeStateMap.put(MachineState.Stuck, NodeState.ERROR); - - nodeStateMap.put(MachineState.Null, NodeState.UNRECOGNIZED); MachineState vmState = vm.getState(); - NodeState nodeState = nodeStateMap.get(vmState); - if(nodeState == null) + NodeState nodeState = machineToNodeState.get(vmState); + if (nodeState == null) nodeState = NodeState.UNRECOGNIZED; nodeMetadataBuilder.state(nodeState); logger.debug("Setting virtualbox node to: " + nodeState + " from machine state: " + vmState); + INetworkAdapter networkAdapter = vm.getNetworkAdapter(0l); + if (networkAdapter != null) { + String bridgedInterface = networkAdapter.getBridgedInterface(); + System.out.println("Interface: " + bridgedInterface); + } + // nodeMetadataBuilder.imageId(""); // nodeMetadataBuilder.group(""); diff --git a/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/admin/FileDownloadFromURI.java b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/admin/FileDownloadFromURI.java new file mode 100644 index 0000000000..8637f24266 --- /dev/null +++ b/sandbox-apis/virtualbox/src/main/java/org/jclouds/virtualbox/functions/admin/FileDownloadFromURI.java @@ -0,0 +1,88 @@ +/* + * * + * * 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.admin; + +import com.google.common.base.Function; +import org.jclouds.compute.ComputeServiceContext; +import org.jclouds.compute.reference.ComputeServiceConstants; +import org.jclouds.javax.annotation.Nullable; +import org.jclouds.logging.Logger; +import org.jclouds.virtualbox.config.VirtualBoxConstants; + +import javax.annotation.Resource; +import javax.inject.Inject; +import javax.inject.Named; +import java.io.*; +import java.net.URI; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.io.ByteStreams.copy; +import static com.google.common.io.Closeables.closeQuietly; +import static org.jclouds.virtualbox.config.VirtualBoxConstants.VIRTUALBOX_WORKINGDIR; + +/** + * @author Mattias Holmqvist + */ +public class FileDownloadFromURI implements Function { + + @Resource + @Named(ComputeServiceConstants.COMPUTE_LOGGER) + protected Logger logger = Logger.NULL; + + private final ComputeServiceContext context; + private final String workingDir; + private final String isoFile; + + @Inject + public FileDownloadFromURI(final ComputeServiceContext context, + @Named(VIRTUALBOX_WORKINGDIR) final String workingDir, + @Named(VirtualBoxConstants.VIRTUALBOX_ISOFILE) final String isoFile) { + this.context = context; + this.workingDir = workingDir; + this.isoFile = isoFile; + } + + @Override + public File apply(@Nullable URI input) { + + final File file = new File(workingDir, isoFile); + + if (!file.exists()) { + final InputStream inputStream = context.utils().http().get(input); + checkNotNull(inputStream, "%s not found", input); + try { + copy(inputStream, new FileOutputStream(file)); + return file; + } catch (FileNotFoundException e) { + logger.error(e, "File %s could not be found", file); + } catch (IOException e) { + logger.error(e, "Error when downloading file %s", input); + } finally { + closeQuietly(inputStream); + } + return null; + } else { + logger.debug("File %s already exists. Skipping download", file); + return file; + } + } +} diff --git a/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/compute/VirtualBoxComputeServiceLiveTest.java b/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/compute/VirtualBoxComputeServiceLiveTest.java index 49bf83b9ec..e0ed5eef0d 100644 --- a/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/compute/VirtualBoxComputeServiceLiveTest.java +++ b/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/compute/VirtualBoxComputeServiceLiveTest.java @@ -30,12 +30,11 @@ import org.jclouds.compute.StandaloneComputeServiceContextSpec; import org.jclouds.sshj.config.SshjSshClientModule; import org.jclouds.virtualbox.VirtualBox; import org.jclouds.virtualbox.VirtualBoxContextBuilder; -import org.jclouds.virtualbox.domain.VMSpec; import org.jclouds.virtualbox.domain.Host; -import org.jclouds.virtualbox.domain.Image; import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; import org.virtualbox_4_1.IMachine; +import org.virtualbox_4_1.VirtualBoxManager; import java.util.Properties; @@ -75,8 +74,8 @@ public class VirtualBoxComputeServiceLiveTest extends BaseComputeServiceLiveTest ComputeServiceContext context = null; try { context = new ComputeServiceContextFactory() - .createContext(new StandaloneComputeServiceContextSpec( - "virtualbox", endpoint, apiversion, "", identity, credential, VirtualBox.class, + .createContext(new StandaloneComputeServiceContextSpec( + "virtualbox", endpoint, apiversion, "", identity, credential, VirtualBoxManager.class, VirtualBoxContextBuilder.class, ImmutableSet.of())); context.getComputeService().listNodes(); diff --git a/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/KickstartTest2.java b/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/KickstartTest2.java index 810fcb9022..08bbe9d7bd 100644 --- a/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/KickstartTest2.java +++ b/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/KickstartTest2.java @@ -177,8 +177,10 @@ public class KickstartTest2 { context = TestUtils.computeServiceForLocalhost(); socketTester = new RetryablePredicate( new InetSocketAddressConnect(), 130, 10, TimeUnit.SECONDS); + setupCredentials(); setupConfigurationProperties(); + downloadFileUnlessPresent(distroIsoUrl, workingDir, distroIsoName); downloadFileUnlessPresent(gaIsoUrl, workingDir, gaIsoName); @@ -189,7 +191,7 @@ public class KickstartTest2 { manager.connect(endpoint.toASCIIString(), identity, credential); // Create machine - IMachine newVM = manager.getVBox().createMachine(settingsFile, vmName, osTypeId, vmId, forceOverwrite); + IMachine newVM = manager.getVBox().createMachine(settingsFile, vmName, osTypeId, "host", forceOverwrite); manager.getVBox().registerMachine(newVM); // Change RAM @@ -301,13 +303,11 @@ public class KickstartTest2 { // Configure guest additions // TODO generalize if (isUbuntu(guestId)) { - runScriptOnNode(guestId, "m-a prepare -i", wrapInInitScript(true)); - runScriptOnNode(guestId, "mount -o loop /dev/dvd /media/cdrom"); - runScriptOnNode(guestId, "sh /media/cdrom/VBoxLinuxAdditions.run"); - runScriptOnNode(guestId, "rm /etc/udev/rules.d/70-persistent-net.rules"); - runScriptOnNode(guestId, "mkdir /etc/udev/rules.d/70-persistent-net.rules"); - runScriptOnNode(guestId, "rm -rf /dev/.udev/"); - runScriptOnNode(guestId, "rm /lib/udev/rules.d/75-persistent-net-generator.rules"); + runScriptOnNode(guestId, "rm /etc/udev/rules.d/70-persistent-net.rules"); + runScriptOnNode(guestId, "mkdir /etc/udev/rules.d/70-persistent-net.rules"); + runScriptOnNode(guestId, "rm -rf /dev/.udev/"); + runScriptOnNode(guestId, "rm /lib/udev/rules.d/75-persistent-net-generator.rules"); + runScriptOnNode(guestId, "echo 0 | tee /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts"); } logMachineStatus(machine); @@ -336,6 +336,7 @@ public class KickstartTest2 { logMachineStatus(machine); logger().debug("Changing to bridged networking..."); + session = manager.getSessionObject(); IMachine adminNode = manager.getVBox().findMachine(vmName); adminNode.lockMachine(session, LockType.Write); diff --git a/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/TestUtils.java b/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/TestUtils.java index c5a352f41b..16cf343cc1 100644 --- a/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/TestUtils.java +++ b/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/TestUtils.java @@ -31,16 +31,37 @@ import org.jclouds.compute.domain.OsFamily; import org.jclouds.encryption.bouncycastle.config.BouncyCastleCryptoModule; import org.jclouds.logging.slf4j.config.SLF4JLoggingModule; import org.jclouds.sshj.config.SshjSshClientModule; +import org.jclouds.virtualbox.compute.LoadMachineFromVirtualBox; import com.google.common.cache.Cache; import com.google.common.cache.CacheLoader; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.inject.Module; +import org.jclouds.virtualbox.config.VirtualBoxConstants; public class TestUtils { public static ComputeServiceContext computeServiceForLocalhost() throws IOException { + String hostId = System.getProperty(VirtualBoxConstants.VIRTUALBOX_HOST_ID); + Node host = Node.builder().id(hostId) + .name(System.getProperty(VirtualBoxConstants.VIRTUALBOX_HOST_ID)) + .hostname(System.getProperty(VirtualBoxConstants.VIRTUALBOX_HOSTNAME)) + .osFamily(OsFamily.LINUX.toString()) + .osDescription(System.getProperty("os.name")) + .osVersion(System.getProperty("os.version")) + .group("ssh") + .username(System.getProperty("user.name")) + .credentialUrl(privateKeyFile()) + .build(); + + final Map nodeMap = ImmutableMap.builder().put(hostId, host).build(); + return new ComputeServiceContextFactory().createContext("byon", "foo", "bar", ImmutableSet.of( + new SshjSshClientModule(), new SLF4JLoggingModule(), new BouncyCastleCryptoModule(), new CacheNodeStoreModule(nodeMap))); + } + + public static ComputeServiceContext computeServiceForLocalhostAndGuest() throws IOException { + Node host = Node.builder().id("host") .name("host installing virtualbox") .hostname("localhost") @@ -68,7 +89,7 @@ public class TestUtils { return new ComputeServiceContextFactory().createContext("byon", "foo", "bar", ImmutableSet.of( new SshjSshClientModule(), new SLF4JLoggingModule(), new BouncyCastleCryptoModule(), new CacheNodeStoreModule(nodeMap))); } - + private static URI privateKeyFile() { try { return new URI("file://" + System.getProperty("user.home") + "/.ssh/id_rsa"); @@ -77,4 +98,9 @@ public class TestUtils { } return null; } + + public static ComputeServiceContext computeServiceForVirtualBox(Cache cache) { + return new ComputeServiceContextFactory().createContext("byon", "foo", "bar", ImmutableSet.of( + new SshjSshClientModule(), new SLF4JLoggingModule(), new BouncyCastleCryptoModule(), new CacheNodeStoreModule(cache))); + } } diff --git a/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/VirtualBoxLiveTest2.java b/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/VirtualBoxLiveTest2.java index 4b98d03335..64d9f1c75e 100644 --- a/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/VirtualBoxLiveTest2.java +++ b/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/VirtualBoxLiveTest2.java @@ -22,12 +22,16 @@ package org.jclouds.virtualbox.experiment; import com.google.common.base.Predicate; +import com.google.common.cache.Cache; +import com.google.common.cache.CacheBuilder; import com.google.common.collect.ImmutableSet; import com.google.inject.Injector; import com.google.inject.Module; +import org.jclouds.byon.Node; import org.jclouds.compute.ComputeServiceContext; import org.jclouds.compute.domain.ExecResponse; import org.jclouds.compute.domain.NodeMetadata; +import org.jclouds.compute.options.RunScriptOptions; import org.jclouds.domain.Credentials; import org.jclouds.logging.Logger; import org.jclouds.logging.log4j.config.Log4JLoggingModule; @@ -37,17 +41,25 @@ import org.jclouds.predicates.RetryablePredicate; import org.jclouds.rest.RestContextFactory; import org.jclouds.ssh.SshClient; import org.jclouds.sshj.config.SshjSshClientModule; +import org.jclouds.virtualbox.compute.LoadMachineFromVirtualBox; +import org.jclouds.virtualbox.functions.IMachineToIpAddress; import org.jclouds.virtualbox.functions.IMachineToNodeMetadata; import org.virtualbox_4_1.*; +import java.io.BufferedReader; import java.io.File; import java.io.IOException; +import java.io.InputStreamReader; import java.net.URI; import java.util.ArrayList; import java.util.List; +import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; import static com.google.common.base.Preconditions.checkNotNull; +import static org.jclouds.compute.options.RunScriptOptions.Builder.wrapInInitScript; +import static org.jclouds.virtualbox.experiment.TestUtils.computeServiceForLocalhost; +import static org.jclouds.virtualbox.experiment.TestUtils.computeServiceForVirtualBox; import static org.testng.Assert.assertEquals; public class VirtualBoxLiveTest2 { @@ -58,6 +70,8 @@ public class VirtualBoxLiveTest2 { protected String credential; protected URI endpoint; protected String vmName; + private String hostId = "host"; + private String guestId = "guest"; VirtualBoxManager manager = VirtualBoxManager.createInstance(""); @@ -78,13 +92,15 @@ public class VirtualBoxLiveTest2 { protected int numberOfVirtualMachine; protected String originalDisk; private String clonedDisk; - private ComputeServiceContext context; + private ComputeServiceContext virtualBoxComputeService; private String adminNodeName; private Injector injector; + private Cache cache; + private ComputeServiceContext localhostComputeService; protected Logger logger() { - return context.utils().loggerFactory().getLogger("jclouds.compute"); + return virtualBoxComputeService.utils().loggerFactory().getLogger("jclouds.compute"); } protected void setupCredentials() { @@ -122,7 +138,7 @@ public class VirtualBoxLiveTest2 { numberOfVirtualMachine = Integer.parseInt(checkNotNull(System.getProperty("test." + provider + ".numberOfVirtualMachine", "3"))); injector = new RestContextFactory().createContextBuilder(provider, - ImmutableSet. of(new Log4JLoggingModule(), new SshjSshClientModule())).buildInjector(); + ImmutableSet.of(new Log4JLoggingModule(), new SshjSshClientModule())).buildInjector(); sshFactory = injector.getInstance(SshClient.Factory.class); } @@ -139,7 +155,11 @@ public class VirtualBoxLiveTest2 { } private void runAll() throws IOException, InterruptedException { - context = TestUtils.computeServiceForLocalhost(); + localhostComputeService = computeServiceForLocalhost(); + IMachineToIpAddress iMachineToIpAddress = new IMachineToIpAddress(manager, localhostComputeService.getComputeService()); + LoadMachineFromVirtualBox cacheLoader = new LoadMachineFromVirtualBox(manager, iMachineToIpAddress); + cache = CacheBuilder.newBuilder().build(cacheLoader); + virtualBoxComputeService = computeServiceForVirtualBox(cache); socketTester = new RetryablePredicate( new InetSocketAddressConnect(), 130, 10, TimeUnit.SECONDS); setupCredentials(); @@ -147,32 +167,29 @@ public class VirtualBoxLiveTest2 { manager.connect(endpoint.toASCIIString(), identity, credential); - for (int i = 1; i < numberOfVirtualMachine + 1; i++) { - createAndLaunchVirtualMachine(i); + createAndLaunchVirtualMachine(1); + + String instanceName = vmName + "_1"; + IMachine machine = manager.getVBox().findMachine(instanceName); + logMachineStatus(machine); + try { + ISession machineSession = manager.openMachineSession(machine); + IProgress progress = machineSession.getConsole().powerDown(); + progress.waitForCompletion(-1); + machineSession.unlockMachine(); + while (!machine.getSessionState().equals(SessionState.Unlocked)) { + try { + logger().debug("Waiting for unlocking session - session state: " + machine.getSessionState()); + Thread.sleep(1000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + logMachineStatus(machine); + } catch (Exception e) { + e.printStackTrace(); } - for (int i = 1; i < numberOfVirtualMachine + 1; i++) { - String instanceName = vmName + "_" + i; - IMachine machine = manager.getVBox().findMachine(instanceName); - logMachineStatus(machine); - try { - ISession machineSession = manager.openMachineSession(machine); - IProgress progress = machineSession.getConsole().powerDown(); - progress.waitForCompletion(-1); - machineSession.unlockMachine(); - while (!machine.getSessionState().equals(SessionState.Unlocked)) { - try { - logger().debug("Waiting for unlocking session - session state: " + machine.getSessionState()); - Thread.sleep(1000); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - logMachineStatus(machine); - } catch (Exception e) { - e.printStackTrace(); - } - } } @@ -184,30 +201,87 @@ public class VirtualBoxLiveTest2 { List options = new ArrayList(); options.add(CloneOptions.Link); IProgress progress = adminNode.getCurrentSnapshot().getMachine().cloneTo(clonedVM, CloneMode.MachineState, options); + if (progress.getCompleted()) logger().debug("clone done"); manager.getVBox().registerMachine(clonedVM); + ISession session = manager.getSessionObject(); + clonedVM.lockMachine(session, LockType.Write); + IMachine mutable = session.getMachine(); + // network + String hostInterface = null; + String command = "vboxmanage list bridgedifs"; + try { + Process child = Runtime.getRuntime().exec(command); + BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(child.getInputStream())); + String line = ""; + boolean found = false; + + while ((line = bufferedReader.readLine()) != null && !found) { + System.out.println("line: " + line); + if (line.split(":")[0].contains("Name")) { + hostInterface = line.substring(line.indexOf(":") + 1); + } + if (line.split(":")[0].contains("Status") && line.split(":")[1].contains("Up")) { + System.out.println("bridge: " + hostInterface.trim()); + found = true; + } + } + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + mutable.getNetworkAdapter(new Long(0)).setAttachmentType(NetworkAttachmentType.Bridged); + mutable.getNetworkAdapter(new Long(0)).setAdapterType(NetworkAdapterType.Am79C973); + mutable.getNetworkAdapter(new Long(0)).setMACAddress("0800279DA478"); + mutable.getNetworkAdapter(new Long(0)).setBridgedInterface(hostInterface.trim()); + mutable.getNetworkAdapter(new Long(0)).setEnabled(true); + mutable.saveSettings(); + session.unlockMachine(); + System.out.println("\nLaunching VM named " + clonedVM.getName() + " ..."); launchVMProcess(clonedVM, manager.getSessionObject()); - String ipAddress = null; - while (ipAddress == null || ipAddress.equals("")) { - try { - ipAddress = clonedVM.getGuestPropertyValue("/VirtualBox/GuestInfo/Net/0/V4/IP"); - Thread.sleep(1000); - } catch (InterruptedException e) { - e.printStackTrace(); + + clonedVM = manager.getVBox().findMachine(instanceName); + + + + try { + boolean gotIp = false; + while (!gotIp) { + Node node = cache.get(instanceName); + if (node.getHostname() != null) { + gotIp = true; + } + else { + cache.invalidate(node); + Thread.sleep(1000); + System.out.println("waiting for IP: got IP"); + } } + + } catch (ExecutionException e) { } - logger().debug(ipAddress + " is the IP address of " + clonedVM.getName()); -// TODO: This does not work yet. -// IPSocket socket = new IPSocket(ipAddress, 22); -// checkSSH(socket); + logger().debug("Trying echo..."); + runScriptOnNode(instanceName, "echo ciao"); } + protected ExecResponse runScriptOnNode(String nodeId, String command) { + return runScriptOnNode(nodeId, command, wrapInInitScript(false)); + } + + protected ExecResponse runScriptOnNode(String nodeId, String command, + RunScriptOptions options) { + ExecResponse toReturn = virtualBoxComputeService.getComputeService().runScriptOnNode(nodeId, command, options); + assert toReturn.getExitCode() == 0 : toReturn; + return toReturn; + } + private void checkSSH(IPSocket socket) { socketTester.apply(socket); SshClient client = sshFactory.create(socket, new Credentials(osUsername, osPassword)); diff --git a/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/VirtualboxAdministrationKickstartLiveTest.java b/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/VirtualboxAdministrationKickstartLiveTest.java index a24ae03452..71344155a4 100644 --- a/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/VirtualboxAdministrationKickstartLiveTest.java +++ b/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/VirtualboxAdministrationKickstartLiveTest.java @@ -209,7 +209,7 @@ public class VirtualboxAdministrationKickstartLiveTest { @BeforeGroups(groups = "live") protected void setupClient() throws Exception { - context = TestUtils.computeServiceForLocalhost(); + context = TestUtils.computeServiceForLocalhostAndGuest(); socketTester = new RetryablePredicate( new InetSocketAddressConnect(), 130, 10, TimeUnit.SECONDS); setupCredentials(); diff --git a/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/VirtualboxLiveTest.java b/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/VirtualboxLiveTest.java index c1cddb256a..120f47ea27 100644 --- a/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/VirtualboxLiveTest.java +++ b/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/experiment/VirtualboxLiveTest.java @@ -168,7 +168,7 @@ public class VirtualboxLiveTest { @BeforeGroups(groups = "live") protected void setupClient() throws Exception { - context = TestUtils.computeServiceForLocalhost(); + context = TestUtils.computeServiceForLocalhostAndGuest(); socketTester = new RetryablePredicate( new InetSocketAddressConnect(), 130, 10, TimeUnit.SECONDS); setupCredentials(); diff --git a/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/IMachineToNodeMetadataTest.java b/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/IMachineToNodeMetadataTest.java index 3b4ee3b07b..1786292150 100644 --- a/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/IMachineToNodeMetadataTest.java +++ b/sandbox-apis/virtualbox/src/test/java/org/jclouds/virtualbox/functions/IMachineToNodeMetadataTest.java @@ -19,14 +19,37 @@ package org.jclouds.virtualbox.functions; +import com.google.common.collect.ImmutableSet; +import org.jclouds.compute.domain.Image; +import org.jclouds.compute.domain.NodeState; +import org.jclouds.domain.Credentials; +import org.jclouds.virtualbox.VirtualBox; +import org.jclouds.virtualbox.config.VirtualBoxComputeServiceContextModule; import org.testng.annotations.Test; -import org.virtualbox_4_1.IMachine; +import org.virtualbox_4_1.MachineState; import org.virtualbox_4_1.VirtualBoxManager; +import java.util.Map; +import java.util.Set; + +//@Test(groups = "live") public class IMachineToNodeMetadataTest { @Test public void testCreate() throws Exception { - + + Credentials creds = new Credentials("admin", "123456"); + VirtualBoxManager manager = VirtualBoxManager.createInstance(""); + + Map machineToNodeState = VirtualBoxComputeServiceContextModule.machineToNodeState; + Set images = ImmutableSet.of(); + Set hardwares = ImmutableSet.of(); + + VirtualBox virtualBox = new VirtualBox(); + IMachineToNodeMetadata parser = new IMachineToNodeMetadata(); + IMachineToHardware hwParser = new IMachineToHardware(virtualBox); + +// hwParser.apply() + } }