diff --git a/build/build-cloud.xml b/build/build-cloud.xml
index a50ad6123d7..24fc26c3e1b 100755
--- a/build/build-cloud.xml
+++ b/build/build-cloud.xml
@@ -111,6 +111,8 @@
   <property name="meld.home" location="/usr/local/bin" />
   <property name="assertion" value="-da" />
 
+  <!-- directory for vmware-base library -->
+  <property name="vmware-base.dir" location="${base.dir}/vmware-base" />
 
   <!-- directories for testing -->
   <property name="test.target.dir" location="${target.dir}/test" />
@@ -126,6 +128,7 @@
   <property name="console-common.jar" value="cloud-console-common.jar" />
   <property name="console-proxy.jar" value="cloud-console-proxy.jar" />
   <property name="api.jar" value="cloud-api.jar"/>
+  <property name="vmware-base.jar" value="cloud-vmware-base.jar" />
 
   <!--
 		Import information about the build version and company information
@@ -199,10 +202,18 @@
     <path refid="deps.classpath" />
     <path refid="dist.classpath" />
   </path>
-  <target name="compile-core" depends="-init, compile-utils, compile-api" description="Compile the core business logic.">
+  <target name="compile-core" depends="-init, compile-utils, compile-api, compile-vmware-base" description="Compile the core business logic.">
     <compile-java jar.name="${core.jar}" top.dir="${core.dir}" classpath="core.classpath" />
   </target>
 
+  <path id="vmware-base.classpath">
+    <path refid="thirdparty.classpath" />
+    <path refid="dist.classpath" />
+  </path>
+  <target name="compile-vmware-base" depends="-init, compile-utils" description="Compile the VMware support library">
+    <compile-java jar.name="${vmware-base.jar}" top.dir="${vmware-base.dir}" classpath="vmware-base.classpath" />
+  </target>
+	
   <path id="server.classpath">
     <path refid="deps.classpath" />
     <path refid="dist.classpath" />
diff --git a/build/package.xml b/build/package.xml
index a9ed788dbf5..480164ea365 100755
--- a/build/package.xml
+++ b/build/package.xml
@@ -185,12 +185,33 @@
         <include name="cloud-commons-codec-1.4.jar" />
         <include name="cloud-commons-pool-1.4.jar" />
         <include name="cloud-cglib.jar" />
+        <include name="cloud-axis.jar" />
+        <include name="cloud-commons-discovery.jar" />
+        <include name="cloud-wsdl4j.jar" />
+        <include name="vmware-apputils.jar" />
+        <include name="vmware-lib-jaxen-core.jar" />
+        <include name="vmware-lib-jdom.jar" />
+        <include name="vmware-lib-smtp.jar" />
+        <include name="vmware-lib-xerces.jar" />
+        <include name="vmware-vim.jar" />
+        <include name="vmware-credstore.jar" />
+        <include name="vmware-lib-jaxen-jdom.jar" />
+        <include name="vmware-lib-mailapi.jar" />
+        <include name="vmware-lib-wbem.jar" />
+        <include name="vmware-lib-xml-apis.jar" />
+        <include name="vmware-lib-activation.jar" />
+        <include name="vmware-lib-jaxrpc.jar" />
+        <include name="vmware-lib-saxpath.jar" />
+        <include name="vmware-lib-xalan.jar" />
+        <include name="vmware-vim25.jar" />
+        <include name="vmware-vim.jar" />
       </zipfileset>
       <zipfileset dir="${jar.dir}">
         <include name="${agent.jar}" />
         <include name="${utils.jar}" />
         <include name="${core.jar}" />
         <include name="${api.jar}" />
+        <include name="${vmware-base.jar}" />
       </zipfileset>
       <zipfileset dir="${console-proxy.dist.dir}" filemode="555">
       </zipfileset>
diff --git a/core/.classpath b/core/.classpath
index ea0a6a56506..75386efe374 100644
--- a/core/.classpath
+++ b/core/.classpath
@@ -7,5 +7,6 @@
 	<classpathentry combineaccessrules="false" kind="src" path="/api"/>
 	<classpathentry combineaccessrules="false" kind="src" path="/deps"/>
 	<classpathentry combineaccessrules="false" kind="src" path="/tools"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/vmware-base"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/core/src/com/cloud/hypervisor/vmware/manager/VmwareHostService.java b/core/src/com/cloud/hypervisor/vmware/manager/VmwareHostService.java
new file mode 100644
index 00000000000..5ea35118525
--- /dev/null
+++ b/core/src/com/cloud/hypervisor/vmware/manager/VmwareHostService.java
@@ -0,0 +1,17 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.manager;
+
+import com.cloud.agent.api.Command;
+import com.cloud.hypervisor.vmware.mo.VmwareHypervisorHost;
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+
+public interface VmwareHostService {
+	VmwareContext getServiceContext(Command cmd);
+	void invalidateServiceContext(VmwareContext context);
+	VmwareHypervisorHost getHyperHost(VmwareContext context, Command cmd);
+
+	String getWorkerName(VmwareContext context, Command cmd);
+}
diff --git a/core/src/com/cloud/hypervisor/vmware/manager/VmwareManager.java b/core/src/com/cloud/hypervisor/vmware/manager/VmwareManager.java
new file mode 100755
index 00000000000..040e790bef9
--- /dev/null
+++ b/core/src/com/cloud/hypervisor/vmware/manager/VmwareManager.java
@@ -0,0 +1,54 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.manager;
+
+import java.io.File;
+import java.util.List;
+import java.util.Map;
+
+//import com.cloud.cluster.CheckPointManager;
+import com.cloud.hypervisor.vmware.mo.HostMO;
+import com.cloud.hypervisor.vmware.mo.VirtualEthernetCardType;
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.cloud.utils.Pair;
+import com.vmware.vim25.ManagedObjectReference;
+
+public interface VmwareManager {
+	public final String CONTEXT_STOCK_NAME = "vmwareMgr";
+	
+	// this limitation comes from the fact that we are using linked clone on shared VMFS storage,
+	// we need to limit the size of vCenter cluster, http://en.wikipedia.org/wiki/VMware_VMFS
+	public final int MAX_HOSTS_PER_CLUSTER = 8;
+
+	String composeWorkerName();
+	
+    String getSystemVMIsoFileNameOnDatastore();
+	void prepareSecondaryStorageStore(String strStorageUrl);
+	
+	void setupResourceStartupParams(Map<String, Object> params);
+	List<ManagedObjectReference> addHostToPodCluster(VmwareContext serviceContext, long dcId, Long podId, Long clusterId,
+			String hostInventoryPath) throws Exception;
+
+	String getManagementPortGroupByHost(HostMO hostMo) throws Exception; 
+	String getServiceConsolePortGroupName();
+	String getManagementPortGroupName();
+	
+	String getSecondaryStorageStoreUrl(long dcId);
+	
+	File getSystemVMKeyFile();
+	
+	VmwareStorageManager getStorageManager();
+	long pushCleanupCheckpoint(String hostGuid, String vmName);
+	void popCleanupCheckpoint(long checkpiont);
+	void gcLeftOverVMs(VmwareContext context);
+	
+	Pair<Integer, Integer> getAddiionalVncPortRange();
+	VirtualEthernetCardType getGuestNicDeviceType();
+	
+	int getMaxHostsPerCluster();
+	
+	boolean beginExclusiveOperation(int timeOutSeconds);
+	void endExclusiveOperation();
+}
diff --git a/core/src/com/cloud/hypervisor/vmware/manager/VmwareStorageManager.java b/core/src/com/cloud/hypervisor/vmware/manager/VmwareStorageManager.java
new file mode 100644
index 00000000000..cf0514b0a78
--- /dev/null
+++ b/core/src/com/cloud/hypervisor/vmware/manager/VmwareStorageManager.java
@@ -0,0 +1,26 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.manager;
+
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.BackupSnapshotCommand;
+import com.cloud.agent.api.CreatePrivateTemplateFromSnapshotCommand;
+import com.cloud.agent.api.CreatePrivateTemplateFromVolumeCommand;
+import com.cloud.agent.api.CreateVolumeFromSnapshotCommand;
+import com.cloud.agent.api.DeleteSnapshotBackupCommand;
+import com.cloud.agent.api.DeleteSnapshotsDirCommand;
+import com.cloud.agent.api.storage.CopyVolumeCommand;
+import com.cloud.agent.api.storage.PrimaryStorageDownloadCommand;
+
+public interface VmwareStorageManager {
+    Answer execute(VmwareHostService hostService, PrimaryStorageDownloadCommand cmd);
+	Answer execute(VmwareHostService hostService, BackupSnapshotCommand cmd);
+	Answer execute(VmwareHostService hostService, DeleteSnapshotsDirCommand cmd);
+	Answer execute(VmwareHostService hostService, DeleteSnapshotBackupCommand cmd);
+	Answer execute(VmwareHostService hostService, CreatePrivateTemplateFromVolumeCommand cmd);
+	Answer execute(VmwareHostService hostService, CreatePrivateTemplateFromSnapshotCommand cmd);
+	Answer execute(VmwareHostService hostService, CopyVolumeCommand cmd);
+	Answer execute(VmwareHostService hostService, CreateVolumeFromSnapshotCommand cmd);
+}
diff --git a/core/src/com/cloud/hypervisor/vmware/manager/VmwareStorageManagerImpl.java b/core/src/com/cloud/hypervisor/vmware/manager/VmwareStorageManagerImpl.java
new file mode 100644
index 00000000000..0f20b1e5b35
--- /dev/null
+++ b/core/src/com/cloud/hypervisor/vmware/manager/VmwareStorageManagerImpl.java
@@ -0,0 +1,905 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.manager;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.rmi.RemoteException;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.BackupSnapshotAnswer;
+import com.cloud.agent.api.BackupSnapshotCommand;
+import com.cloud.agent.api.CreatePrivateTemplateFromSnapshotCommand;
+import com.cloud.agent.api.CreatePrivateTemplateFromVolumeCommand;
+import com.cloud.agent.api.CreateVolumeFromSnapshotAnswer;
+import com.cloud.agent.api.CreateVolumeFromSnapshotCommand;
+import com.cloud.agent.api.DeleteSnapshotBackupAnswer;
+import com.cloud.agent.api.DeleteSnapshotBackupCommand;
+import com.cloud.agent.api.DeleteSnapshotsDirCommand;
+import com.cloud.agent.api.storage.CopyVolumeAnswer;
+import com.cloud.agent.api.storage.CopyVolumeCommand;
+import com.cloud.agent.api.storage.CreatePrivateTemplateAnswer;
+import com.cloud.agent.api.storage.PrimaryStorageDownloadAnswer;
+import com.cloud.agent.api.storage.PrimaryStorageDownloadCommand;
+import com.cloud.agent.api.to.StorageFilerTO;
+import com.cloud.hypervisor.vmware.mo.CustomFieldConstants;
+import com.cloud.hypervisor.vmware.mo.DatacenterMO;
+import com.cloud.hypervisor.vmware.mo.DatastoreMO;
+import com.cloud.hypervisor.vmware.mo.HostMO;
+import com.cloud.hypervisor.vmware.mo.HypervisorHostHelper;
+import com.cloud.hypervisor.vmware.mo.VirtualMachineMO;
+import com.cloud.hypervisor.vmware.mo.VmwareHypervisorHost;
+import com.vmware.vim25.VirtualDeviceConfigSpec;
+import com.vmware.vim25.VirtualLsiLogicController;
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.cloud.hypervisor.vmware.util.VmwareHelper;
+import com.cloud.storage.JavaStorageLayer;
+import com.cloud.storage.Storage.ImageFormat;
+import com.cloud.storage.StorageLayer;
+import com.cloud.utils.NumbersUtil;
+import com.cloud.utils.Pair;
+import com.cloud.utils.StringUtils;
+import com.cloud.utils.Ternary;
+import com.cloud.utils.script.Script;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.VirtualDisk;
+import com.vmware.vim25.VirtualMachineConfigSpec;
+import com.vmware.vim25.VirtualMachineFileInfo;
+import com.vmware.vim25.VirtualMachineGuestOsIdentifier;
+import com.vmware.vim25.VirtualSCSISharing;
+import com.vmware.vim25.VirtualDeviceConfigSpec;
+import com.vmware.vim25.VirtualDeviceConfigSpecOperation;
+
+public class VmwareStorageManagerImpl implements VmwareStorageManager {
+    private static final Logger s_logger = Logger.getLogger(VmwareStorageManagerImpl.class);
+    
+    private final VmwareStorageMount _mountService;
+    private final StorageLayer _storage = new JavaStorageLayer();
+    
+    private int _timeout;
+    
+    public VmwareStorageManagerImpl(VmwareStorageMount mountService) {
+        assert(mountService != null);
+        _mountService = mountService;
+    }
+    
+    public void configure(Map<String, Object> params) {
+        s_logger.info("Configure VmwareStorageManagerImpl");
+        
+        String value = (String)params.get("scripts.timeout");
+        _timeout = NumbersUtil.parseInt(value, 1440) * 1000;
+    }
+    
+    @Override
+    public Answer execute(VmwareHostService hostService, PrimaryStorageDownloadCommand cmd) {
+		String secondaryStorageUrl = cmd.getSecondaryStorageUrl();
+		assert (secondaryStorageUrl != null);
+
+		String templateUrl = cmd.getUrl();
+
+		String templateName = null;
+		String mountPoint = null;
+		if (templateUrl.endsWith(".ova")) {
+			int index = templateUrl.lastIndexOf("/");
+			mountPoint = templateUrl.substring(0, index);
+			mountPoint = mountPoint.substring(secondaryStorageUrl.length() + 1);
+			if (!mountPoint.endsWith("/")) {
+				mountPoint = mountPoint + "/";
+			}
+
+			templateName = templateUrl.substring(index + 1).replace("." + ImageFormat.OVA.getFileExtension(), "");
+
+			if (templateName == null || templateName.isEmpty()) {
+				templateName = cmd.getName();
+			}
+		} else {
+			mountPoint = templateUrl.substring(secondaryStorageUrl.length() + 1);
+			if (!mountPoint.endsWith("/")) {
+				mountPoint = mountPoint + "/";
+			}
+			templateName = cmd.getName();
+		}
+		
+		VmwareContext context = hostService.getServiceContext(cmd);
+		try {
+			VmwareHypervisorHost hyperHost = hostService.getHyperHost(context, cmd);
+			
+			String templateUuidName = UUID.nameUUIDFromBytes((templateName + "@" + cmd.getPoolUuid() + "-" + hyperHost.getMor().get_value()).getBytes()).toString();
+			
+			DatacenterMO dcMo = new DatacenterMO(context, hyperHost.getHyperHostDatacenter());
+			VirtualMachineMO templateMo = VmwareHelper.pickOneVmOnRunningHost(dcMo.findVmByNameAndLabel(templateUuidName), true);
+			
+			if (templateMo == null) {
+			    if(s_logger.isInfoEnabled())
+			        s_logger.info("Template " + templateName + " is not setup yet, setup template from secondary storage with uuid name: " + templateUuidName);
+				ManagedObjectReference morDs = hyperHost.findDatastore(cmd.getPoolUuid());
+				assert (morDs != null);
+				DatastoreMO primaryStorageDatastoreMo = new DatastoreMO(context, morDs);
+
+				copyTemplateFromSecondaryToPrimary(hyperHost,
+					primaryStorageDatastoreMo, secondaryStorageUrl,
+					mountPoint, templateUuidName);
+			} else {
+				s_logger.info("Template " + templateName + " has already been setup, skip the template setup process in primary storage");
+			}
+
+			return new PrimaryStorageDownloadAnswer(templateUuidName, 0);
+		} catch (Throwable e) {
+			if (e instanceof RemoteException) {
+				hostService.invalidateServiceContext(context);
+			}
+
+			String msg = "Unable to execute PrimaryStorageDownloadCommand due to exception";
+			s_logger.error(msg, e);
+			return new PrimaryStorageDownloadAnswer(msg);
+		}
+    }
+    
+    @Override
+	public Answer execute(VmwareHostService hostService, BackupSnapshotCommand cmd) {
+		Long accountId = cmd.getAccountId();
+		Long volumeId = cmd.getVolumeId();
+		String secondaryStoragePoolURL = cmd.getSecondaryStoragePoolURL();
+		String snapshotUuid = cmd.getSnapshotUuid(); // not null: Precondition.
+		String prevSnapshotUuid = cmd.getPrevSnapshotUuid();
+		String prevBackupUuid = cmd.getPrevBackupUuid();
+        VirtualMachineMO workerVm=null;
+        String workerVMName = null;
+		String volumePath = cmd.getVolumePath();
+		ManagedObjectReference morDs = null;
+		String snapshotUUID = null;
+		DatastoreMO dsMo=null;
+
+		// By default assume failure
+		String details = null;
+		boolean success = false;
+		String snapshotBackupUuid = null;
+
+		VmwareContext context = hostService.getServiceContext(cmd);
+		try {
+			VmwareHypervisorHost hyperHost = hostService.getHyperHost(context, cmd);
+			morDs = hyperHost.findDatastore(cmd.getPool().getUuid());
+
+			VirtualMachineMO vmMo = hyperHost.findVmOnHyperHost(cmd.getVmName());
+			if (vmMo == null) {
+				if(s_logger.isDebugEnabled())
+					s_logger.debug("Unable to find owner VM for BackupSnapshotCommand on host " + hyperHost.getHyperHostName() + ", will try within datacenter");
+
+				vmMo = hyperHost.findVmOnPeerHyperHost(cmd.getVmName());
+				if(vmMo == null) {
+					dsMo = new DatastoreMO(hyperHost.getContext(), morDs);
+					//restrict VM name to 32 chars, (else snapshot descriptor file name will be truncated to 32 chars of vm name)
+					workerVMName = UUID.randomUUID().toString().replaceAll("-", "");
+
+					//attach a volume to dummay wrapper VM for taking snapshot and exporting the VM for backup
+					if (!hyperHost.createBlankVm(workerVMName, 1, 512, 0, false, 4, VirtualMachineGuestOsIdentifier._otherGuest.toString(), morDs, false)) {
+						String msg = "Unable to create worker VM to execute BackupSnapshotCommand";
+						s_logger.error(msg);
+						throw new Exception(msg);
+					}
+					vmMo = hyperHost.findVmOnHyperHost(workerVMName);
+					if (vmMo == null) {
+						throw new Exception("Failed to find the newly create or relocated VM. vmName: " + workerVMName);
+						}
+					workerVm = vmMo;
+
+					//attach volume to worker VM
+					String datastoreVolumePath = String.format("[%s] %s.vmdk", dsMo.getName(), volumePath);
+					vmMo.attachDisk(new String[] { datastoreVolumePath }, morDs);
+					snapshotUUID = UUID.randomUUID().toString();
+					if (!vmMo.createSnapshot(snapshotUUID, "Snapshot taken for " + cmd.getSnapshotName(), false, false)) {
+						throw new Exception("Failed to take snapshot " + cmd.getSnapshotName() + " on vm: " + cmd.getVmName());
+					}
+				}
+			}
+
+			snapshotBackupUuid = backupSnapshotToSecondaryStorage(vmMo, accountId,
+							volumeId, cmd.getVolumePath(), snapshotUuid,
+							secondaryStoragePoolURL, prevSnapshotUuid,
+							prevBackupUuid,
+							hostService.getWorkerName(context, cmd));
+
+			success = (snapshotBackupUuid != null);
+
+			if (success) {
+				details = "Successfully backedUp the snapshotUuid: " + snapshotUuid + " to secondary storage.";
+				vmMo.removeAllSnapshots();
+			}
+		} catch (Throwable e) {
+			if (e instanceof RemoteException) {
+				hostService.invalidateServiceContext(context);
+			}
+
+			s_logger.error("Unexpecpted exception ", e);
+
+			details = "BackupSnapshotCommand exception: " + StringUtils.getExceptionStackInfo(e);
+			return new BackupSnapshotAnswer(cmd, false, details, snapshotBackupUuid, true);
+		} finally {
+			try {
+	            if (workerVm != null) {
+	                //detach volume and destroy worker vm
+	            	workerVm.moveAllVmDiskFiles(dsMo, "", false);
+	                workerVm.detachAllDisks();
+	                workerVm.destroy();
+	            }
+	        } catch (Throwable e) {
+	        	s_logger.warn("Failed to destroy worker VM: " + workerVMName);
+	        }			
+		}
+
+		return new BackupSnapshotAnswer(cmd, success, details, snapshotBackupUuid, true);
+	}
+
+    @Override
+	public Answer execute(VmwareHostService hostService, DeleteSnapshotsDirCommand cmd) {
+		Long accountId = cmd.getAccountId();
+		Long volumeId = cmd.getVolumeId();
+		String secondaryStoragePoolURL = cmd.getSecondaryStoragePoolURL();
+
+		String details = null;
+		boolean success = false;
+
+		VmwareContext context = hostService.getServiceContext(cmd);
+		try {
+			details = deleteSnapshotDirOnSecondaryStorage(accountId, volumeId, secondaryStoragePoolURL);
+			if (details == null) {
+				success = true;
+			}
+
+		} catch (Throwable e) {
+			if (e instanceof RemoteException) {
+				hostService.invalidateServiceContext(context);
+			}
+
+			s_logger.error("Unexpecpted exception ", e);
+
+			details = "DeleteSnapshotDirCommand exception: " + StringUtils.getExceptionStackInfo(e);
+			return new Answer(cmd, false, details);
+		}
+
+		return new Answer(cmd, success, details);
+	}
+    
+	public Answer execute(VmwareHostService hostService, DeleteSnapshotBackupCommand cmd) {
+		Long accountId = cmd.getAccountId();
+		Long volumeId = cmd.getVolumeId();
+		String secStorageUrl = cmd.getSecondaryStoragePoolURL();
+		String backupUUID = cmd.getSnapshotUuid();
+		String details = null;
+		boolean success = false;
+		
+		VmwareContext context = hostService.getServiceContext(cmd);
+		try {
+			details = deleteSnapshotOnSecondaryStorge(accountId, volumeId, secStorageUrl, backupUUID);
+			if (details == null) {
+				success = true;
+			}
+		} catch (Throwable e) {
+			if (e instanceof RemoteException) {
+				hostService.invalidateServiceContext(context);
+			}
+
+			s_logger.error("Unexpecpted exception ", e);
+			details = "DeleteSnapshotBackupCommand exception: " + StringUtils.getExceptionStackInfo(e);
+			return new DeleteSnapshotBackupAnswer(cmd, false, details);
+		}
+
+		return new DeleteSnapshotBackupAnswer(cmd, success, details);
+	}
+
+    @Override
+	public Answer execute(VmwareHostService hostService, CreatePrivateTemplateFromVolumeCommand cmd) {
+		String secondaryStoragePoolURL = cmd.getSecondaryStorageURL();
+		String volumePath = cmd.getVolumePath();
+		Long accountId = cmd.getAccountId();
+		Long templateId = cmd.getTemplateId();
+		String details = null;
+
+		VmwareContext context = hostService.getServiceContext(cmd);
+		try {
+			VmwareHypervisorHost hyperHost = hostService.getHyperHost(context, cmd);
+			
+			VirtualMachineMO vmMo = hyperHost.findVmOnHyperHost(cmd.getVmName());
+			if (vmMo == null) {
+				if(s_logger.isDebugEnabled())
+					s_logger.debug("Unable to find the owner VM for CreatePrivateTemplateFromVolumeCommand on host " + hyperHost.getHyperHostName() + ", try within datacenter");
+				vmMo = hyperHost.findVmOnPeerHyperHost(cmd.getVmName());
+
+				if(vmMo == null) {
+					String msg = "Unable to find the owner VM for volume operation. vm: " + cmd.getVmName();
+					s_logger.error(msg);
+					throw new Exception(msg);
+				}
+			}
+
+			Ternary<String, Long, Long> result = createTemplateFromVolume(vmMo,
+					accountId, templateId, cmd.getTemplateName(),
+					secondaryStoragePoolURL, volumePath, 
+					hostService.getWorkerName(context, cmd));
+
+			return new CreatePrivateTemplateAnswer(cmd, true, null,
+					result.first(), result.third(), result.second(),
+					cmd.getTemplateName(), ImageFormat.OVA);
+
+		} catch (Throwable e) {
+			if (e instanceof RemoteException) {
+				hostService.invalidateServiceContext(context);
+			}
+
+			s_logger.error("Unexpecpted exception ", e);
+
+			details = "CreatePrivateTemplateFromVolumeCommand exception: " + StringUtils.getExceptionStackInfo(e);
+			return new CreatePrivateTemplateAnswer(cmd, false, details);
+		}
+	}
+
+    @Override
+	public Answer execute(VmwareHostService hostService, CreatePrivateTemplateFromSnapshotCommand cmd) {
+		Long accountId = cmd.getAccountId();
+		Long volumeId = cmd.getVolumeId();
+		String secondaryStoragePoolURL = cmd.getSecondaryStoragePoolURL();
+		String backedUpSnapshotUuid = cmd.getSnapshotUuid();
+		Long newTemplateId = cmd.getNewTemplateId();
+		String details;
+		String uniqeName = UUID.randomUUID().toString();
+
+		VmwareContext context = hostService.getServiceContext(cmd);
+		try {
+			Ternary<String, Long, Long> result = createTemplateFromSnapshot(accountId,
+				newTemplateId, uniqeName,
+				secondaryStoragePoolURL, volumeId,
+				backedUpSnapshotUuid);
+
+			return new CreatePrivateTemplateAnswer(cmd, true, null,
+					result.first(), result.third(), result.second(),
+					uniqeName, ImageFormat.OVA);
+		} catch (Throwable e) {
+			if (e instanceof RemoteException) {
+				hostService.invalidateServiceContext(context);
+			}
+
+			s_logger.error("Unexpecpted exception ", e);
+
+			details = "CreatePrivateTemplateFromSnapshotCommand exception: " + StringUtils.getExceptionStackInfo(e);
+			return new CreatePrivateTemplateAnswer(cmd, false, details);
+		}
+	}
+	
+    @Override
+	public Answer execute(VmwareHostService hostService, CopyVolumeCommand cmd) {
+		Long volumeId = cmd.getVolumeId();
+		String volumePath = cmd.getVolumePath();
+		String secondaryStorageURL = cmd.getSecondaryStorageURL();
+		String vmName = cmd.getVmName();
+
+		VmwareContext context = hostService.getServiceContext(cmd);
+		try {
+			VmwareHypervisorHost hyperHost = hostService.getHyperHost(context, cmd);
+
+			Pair<String, String> result;
+			if (cmd.toSecondaryStorage()) {
+				result = copyVolumeToSecStorage(
+						hyperHost, vmName, volumeId, cmd.getPool().getUuid(), volumePath,
+						secondaryStorageURL,
+						hostService.getWorkerName(context, cmd));
+			} else {
+				StorageFilerTO poolTO = cmd.getPool();
+
+				ManagedObjectReference morDatastore = hyperHost.findDatastore(poolTO.getUuid());
+				if (morDatastore == null) {
+					morDatastore = hyperHost.mountDatastore(
+							false,
+							poolTO.getHost(), 0, poolTO.getPath(),
+							poolTO.getUuid());
+
+					if (morDatastore == null) {
+						throw new Exception("Unable to mount storage pool on host. storeUrl: " + poolTO.getHost() + ":/" + poolTO.getPath());
+					}
+				}
+
+				result = copyVolumeFromSecStorage(
+						hyperHost, volumeId,
+						new DatastoreMO(context, morDatastore),
+						secondaryStorageURL, volumePath);
+			}
+			return new CopyVolumeAnswer(cmd, true, null, result.first(), result.second());
+		} catch (Throwable e) {
+			if (e instanceof RemoteException) {
+				hostService.invalidateServiceContext(context);
+			}
+
+			String msg = "Unable to execute CopyVolumeCommand due to exception";
+			s_logger.error(msg, e);
+			return new CopyVolumeAnswer(cmd, false, "CopyVolumeCommand failed due to exception: " + StringUtils.getExceptionStackInfo(e), null, null);
+		}
+	}
+    
+    @Override
+	public Answer execute(VmwareHostService hostService, CreateVolumeFromSnapshotCommand cmd) {
+
+		String primaryStorageNameLabel = cmd.getPrimaryStoragePoolNameLabel();
+		Long accountId = cmd.getAccountId();
+		Long volumeId = cmd.getVolumeId();
+		String secondaryStoragePoolURL = cmd.getSecondaryStoragePoolURL();
+		String backedUpSnapshotUuid = cmd.getSnapshotUuid();
+
+		String details = null;
+		boolean success = false;
+		String newVolumeName = UUID.randomUUID().toString().replaceAll("-", "");
+
+		VmwareContext context = hostService.getServiceContext(cmd);
+		try {
+			VmwareHypervisorHost hyperHost = hostService.getHyperHost(context, cmd);
+			
+			ManagedObjectReference morPrimaryDs = hyperHost.findDatastore(primaryStorageNameLabel);
+			if (morPrimaryDs == null) {
+				String msg = "Unable to find datastore: " + primaryStorageNameLabel;
+				s_logger.error(msg);
+				throw new Exception(msg);
+			}
+
+			DatastoreMO primaryDsMo = new DatastoreMO(hyperHost.getContext(), morPrimaryDs);
+			details = createVolumeFromSnapshot(hyperHost, primaryDsMo,
+					newVolumeName, accountId, volumeId,
+					secondaryStoragePoolURL, backedUpSnapshotUuid);
+			if (details == null) {
+				success = true;
+			}
+		} catch (Throwable e) {
+			if (e instanceof RemoteException) {
+				hostService.invalidateServiceContext(context);
+			}
+
+			s_logger.error("Unexpecpted exception ", e);
+			details = "CreateVolumeFromSnapshotCommand exception: " + StringUtils.getExceptionStackInfo(e);
+		}
+
+		return new CreateVolumeFromSnapshotAnswer(cmd, success, details, newVolumeName);
+	}
+	
+    private void copyTemplateFromSecondaryToPrimary(VmwareHypervisorHost hyperHost, DatastoreMO datastoreMo, String secondaryStorageUrl,
+        String templatePathAtSecondaryStorage, String templateName) throws Exception {
+        
+        s_logger.info("Executing copyTemplateFromSecondaryToPrimary. secondaryStorage: " 
+            + secondaryStorageUrl + ", templatePathAtSecondaryStorage: " + templatePathAtSecondaryStorage
+            + ", templateName: " + templateName);
+        
+        String secondaryMountPoint = _mountService.getMountPoint(secondaryStorageUrl);
+        s_logger.info("Secondary storage mount point: " + secondaryMountPoint);
+        
+        String srcOVAFileName = secondaryMountPoint + "/" +  templatePathAtSecondaryStorage + 
+            templateName + "." + ImageFormat.OVA.getFileExtension();
+        
+        String srcFileName = getOVFFilePath(srcOVAFileName);
+        if(srcFileName == null) {
+            String msg = "Unable to locate OVF file in template package directory: " + srcOVAFileName; 
+            s_logger.error(msg);
+            throw new Exception(msg);
+        }
+        
+        String vmName = templateName;
+        hyperHost.importVmFromOVF(srcFileName, vmName, datastoreMo, "thin");
+        
+        VirtualMachineMO vmMo = hyperHost.findVmOnHyperHost(vmName);
+        if(vmMo == null) {
+            String msg = "Failed to import OVA template. secondaryStorage: " 
+                + secondaryStorageUrl + ", templatePathAtSecondaryStorage: " + templatePathAtSecondaryStorage
+                + ", templateName: " + templateName;
+            s_logger.error(msg);
+            throw new Exception(msg);
+        }
+        
+        if(vmMo.createSnapshot("cloud.template.base", "Base snapshot", false, false)) {
+            vmMo.setCustomFieldValue(CustomFieldConstants.CLOUD_UUID, templateName);
+            vmMo.markAsTemplate();
+        } else {
+            vmMo.destroy();
+            String msg = "Unable to create base snapshot for template: " + templateName; 
+            s_logger.error(msg);
+            throw new Exception(msg);
+        }
+    }
+    
+    private Ternary<String, Long, Long> createTemplateFromVolume(VirtualMachineMO vmMo, long accountId, long templateId, String templateName, 
+        String secStorageUrl, String volumePath, String workerVmName) throws Exception {
+        
+        String secondaryMountPoint = _mountService.getMountPoint(secStorageUrl);
+        String installPath = getTemplateRelativeDirInSecStorage(accountId, templateId);
+        String installFullPath = secondaryMountPoint + "/" + installPath;
+        synchronized(installPath.intern()) {
+            Script command = new Script(false, "mkdir", _timeout, s_logger);
+            command.add("-p");
+            command.add(installFullPath);
+            
+            String result = command.execute();
+            if(result != null) {
+                String msg = "unable to prepare template directory: " 
+                    + installPath + ", storage: " + secStorageUrl + ", error msg: " + result;
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+        }
+        
+        String tmpSnapshotName = UUID.randomUUID().toString();
+        VirtualMachineMO clonedVm = null;
+        try {
+            Pair<VirtualDisk, String> volumeDeviceInfo = vmMo.getDiskDevice(volumePath, false);
+            if(volumeDeviceInfo == null) {
+                String msg = "Unable to find related disk device for volume. volume path: " + volumePath;
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+            
+            if(!vmMo.createSnapshot(tmpSnapshotName, "Temporary snapshot for template creation", false, false)) {
+                String msg = "Unable to take snapshot for creating template from volume. volume path: " + volumePath;
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+        
+            // 4 MB is the minimum requirement for VM memory in VMware
+            vmMo.cloneFromCurrentSnapshot(workerVmName, 0, 4, volumeDeviceInfo.second(), 
+                VmwareHelper.getDiskDeviceDatastore(volumeDeviceInfo.first()));
+            clonedVm = vmMo.getRunningHost().findVmOnHyperHost(workerVmName);
+            if(clonedVm == null) {
+                String msg = "Unable to create dummy VM to export volume. volume path: " + volumePath;
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+        
+            clonedVm.exportVm(secondaryMountPoint + "/" + installPath, templateName, true, false);
+            
+            // TODO, need to find out virtual size and physical size
+            long size = new File(installFullPath + "/" + templateName + ".ova").length();
+            postCreatePrivateTemplate(installFullPath, templateId, templateName, size, size);
+            
+            return new Ternary<String, Long, Long>(installPath + "/" + templateName + ".ova", size, size);
+            
+        } finally {
+            if(clonedVm != null)
+                clonedVm.destroy();
+        
+            vmMo.removeSnapshot(tmpSnapshotName, false);
+        }
+    }
+    
+    private Ternary<String, Long, Long> createTemplateFromSnapshot(long accountId, long templateId, String templateName, 
+        String secStorageUrl, long volumeId, String backedUpSnapshotUuid) throws Exception {
+        
+        String secondaryMountPoint = _mountService.getMountPoint(secStorageUrl);
+        String installPath = getTemplateRelativeDirInSecStorage(accountId, templateId);
+        String installFullPath = secondaryMountPoint + "/" + installPath;
+        String installFullName = installFullPath + "/" + templateName + ".ova";
+        String snapshotFullName = secondaryMountPoint + "/" + getSnapshotRelativeDirInSecStorage(accountId, volumeId) 
+            + "/" + backedUpSnapshotUuid + ".ova";
+        String result;
+        Script command;
+        
+        synchronized(installPath.intern()) {
+            command = new Script(false, "mkdir", _timeout, s_logger);
+            command.add("-p");
+            command.add(installFullPath);
+            
+            result = command.execute();
+            if(result != null) {
+                String msg = "unable to prepare template directory: " 
+                    + installPath + ", storage: " + secStorageUrl + ", error msg: " + result;
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+        }
+        
+        try {
+            command = new Script(false, "cp", _timeout, s_logger);
+            command.add(snapshotFullName);
+            command.add(installFullName);
+            result = command.execute();
+            if(result != null) {
+                String msg = "unable to copy snapshot " + snapshotFullName + " to " + installFullPath; 
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+            
+            // untar OVA file at template directory
+            command = new Script("tar", 0, s_logger);
+            command.add("-xf", installFullName);
+            command.setWorkDir(installFullPath);
+            result = command.execute();
+            if(result != null) {
+                String msg = "unable to copy snapshot " + snapshotFullName + " to " + installFullPath; 
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+            
+            long size = new File(installFullName).length();
+            postCreatePrivateTemplate(installFullPath, templateId, templateName, size, size);
+            return new Ternary<String, Long, Long>(installPath + "/" + templateName + ".ova", size, size);
+        
+        } catch(Exception e) {
+            // TODO, clean up left over files
+            throw e;
+        }
+    }
+    
+    private void postCreatePrivateTemplate(String installFullPath, long templateId, 
+        String templateName, long size, long virtualSize) throws Exception {
+
+        // TODO a bit ugly here
+        BufferedWriter out = null;
+        try {
+            out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(installFullPath + "/template.properties")));
+            out.write("filename=" + templateName + ".ova"); 
+            out.newLine();
+            out.write("description="); 
+            out.newLine();
+            out.write("checksum="); 
+            out.newLine();
+            out.write("hvm=false"); 
+            out.newLine();
+            out.write("size=" + size); 
+            out.newLine();
+            out.write("ova=true"); 
+            out.newLine();
+            out.write("id=" + templateId); 
+            out.newLine();
+            out.write("public=false"); 
+            out.newLine();
+            out.write("ova.filename=" + templateName + ".ova"); 
+            out.newLine();
+            out.write("uniquename=" + templateName);
+            out.newLine();
+            out.write("ova.virtualsize=" + virtualSize); 
+            out.newLine();
+            out.write("virtualsize=" + virtualSize); 
+            out.newLine();
+            out.write("ova.size=" + size); 
+            out.newLine();
+        } finally {
+            if(out != null)
+                out.close();
+        }
+    }
+
+    private String createVolumeFromSnapshot(VmwareHypervisorHost hyperHost, DatastoreMO primaryDsMo, String newVolumeName, 
+        long accountId, long volumeId, String secStorageUrl, String snapshotBackupUuid) throws Exception {
+        
+        restoreVolumeFromSecStorage(hyperHost, primaryDsMo, newVolumeName, 
+            secStorageUrl, getSnapshotRelativeDirInSecStorage(accountId, volumeId), snapshotBackupUuid);
+        return null;
+    }
+    
+    private void restoreVolumeFromSecStorage(VmwareHypervisorHost hyperHost, DatastoreMO primaryDsMo, String newVolumeName, 
+        String secStorageUrl, String secStorageDir, String backupName) throws Exception {
+        
+        String secondaryMountPoint = _mountService.getMountPoint(secStorageUrl);
+        String srcOVAFileName = secondaryMountPoint + "/" +  secStorageDir + "/"  
+            + backupName + "." + ImageFormat.OVA.getFileExtension();
+        
+        String srcFileName = getOVFFilePath(srcOVAFileName);
+        if(srcFileName == null) {
+            Script command = new Script("tar", 0, s_logger);
+            command.add("-xf", srcOVAFileName);
+            command.setWorkDir(secondaryMountPoint + "/" +  secStorageDir);
+            String result = command.execute();
+            if(result != null) {
+                String msg = "Unable to unpack snapshot OVA file at: " + srcOVAFileName;
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+        }
+        
+        srcFileName = getOVFFilePath(srcOVAFileName);
+        if(srcFileName == null) {
+            String msg = "Unable to locate OVF file in template package directory: " + srcOVAFileName; 
+            s_logger.error(msg);
+            throw new Exception(msg);
+        }
+        
+        VirtualMachineMO clonedVm = null;
+        try {
+            hyperHost.importVmFromOVF(srcFileName, newVolumeName, primaryDsMo, "thin");
+            clonedVm = hyperHost.findVmOnHyperHost(newVolumeName);
+            if(clonedVm == null)
+                throw new Exception("Unable to create container VM for volume creation");
+            
+            clonedVm.moveAllVmDiskFiles(primaryDsMo, "", false);
+            clonedVm.detachAllDisks();
+        } finally {
+            if(clonedVm != null)
+                clonedVm.destroy();
+        }
+    }
+    
+    private String backupSnapshotToSecondaryStorage(VirtualMachineMO vmMo, long accountId, long volumeId, 
+        String volumePath, String snapshotUuid, String secStorageUrl, 
+        String prevSnapshotUuid, String prevBackupUuid, String workerVmName) throws Exception {
+        
+        String backupUuid = UUID.randomUUID().toString();
+        exportVolumeToSecondaryStroage(vmMo, volumePath, secStorageUrl, 
+            getSnapshotRelativeDirInSecStorage(accountId, volumeId), backupUuid, workerVmName);
+        return backupUuid;
+    }
+    
+    private void exportVolumeToSecondaryStroage(VirtualMachineMO vmMo, String volumePath,  
+        String secStorageUrl, String secStorageDir, String exportName,
+        String workerVmName) throws Exception {
+        
+        String secondaryMountPoint = _mountService.getMountPoint(secStorageUrl);
+        String exportPath =  secondaryMountPoint + "/" + secStorageDir;
+        
+        synchronized(exportPath.intern()) {
+            if(!new File(exportPath).exists()) {
+                Script command = new Script(false, "mkdir", _timeout, s_logger);
+                command.add("-p");
+                command.add(exportPath);
+                if(command.execute() != null)
+                    throw new Exception("unable to prepare snapshot backup directory");
+            }
+        }
+
+        VirtualMachineMO clonedVm = null;
+        try {
+        
+            Pair<VirtualDisk, String> volumeDeviceInfo = vmMo.getDiskDevice(volumePath, false);
+            if(volumeDeviceInfo == null) {
+                String msg = "Unable to find related disk device for volume. volume path: " + volumePath;
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+        
+            // 4 MB is the minimum requirement for VM memory in VMware
+            vmMo.cloneFromCurrentSnapshot(workerVmName, 0, 4, volumeDeviceInfo.second(), 
+                VmwareHelper.getDiskDeviceDatastore(volumeDeviceInfo.first()));
+            clonedVm = vmMo.getRunningHost().findVmOnHyperHost(workerVmName);
+            if(clonedVm == null) {
+                String msg = "Unable to create dummy VM to export volume. volume path: " + volumePath;
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+        
+            clonedVm.exportVm(exportPath, exportName, true, true);
+        } finally {
+            if(clonedVm != null)
+                clonedVm.destroy();
+        }
+    }
+    
+    private String deleteSnapshotOnSecondaryStorge(long accountId, long volumeId, String secStorageUrl, String backupUuid) throws Exception {
+
+        String secondaryMountPoint = _mountService.getMountPoint(secStorageUrl);
+        String snapshotMountRoot = secondaryMountPoint + "/" + getSnapshotRelativeDirInSecStorage(accountId, volumeId);
+        File file = new File(snapshotMountRoot + "/" + backupUuid + ".ova");
+        if(file.exists()) {
+            if(file.delete())
+                return null;
+            
+        } else {
+            return "Backup file does not exist. backupUuid: " + backupUuid;
+        }
+        
+        return "Failed to delete snapshot backup file, backupUuid: " + backupUuid;
+    }
+    
+    private String deleteSnapshotDirOnSecondaryStorage(long accountId, long volumeId, String secStorageUrl) throws Exception {
+        String secondaryMountPoint = _mountService.getMountPoint(secStorageUrl);
+        String snapshotMountRoot = secondaryMountPoint + "/" + getSnapshotRelativeDirInSecStorage(accountId, volumeId);
+
+        synchronized(snapshotMountRoot.intern()) {
+            Script command = new Script(false, "rm", _timeout, s_logger);
+            command.add("-rf");
+            command.add(snapshotMountRoot);
+            return command.execute();
+        }
+    }
+    
+    private Pair<String, String> copyVolumeToSecStorage(VmwareHypervisorHost hyperHost, String vmName, long volumeId, String poolId, String volumePath, 
+        String secStorageUrl, String workerVmName) throws Exception {
+        String volumeFolder = String.valueOf(volumeId) + "/";
+        VirtualMachineMO workerVm=null;
+        VirtualMachineMO vmMo=null;
+        String exportName = UUID.randomUUID().toString();
+
+        try {
+            ManagedObjectReference morDs = hyperHost.findDatastore(poolId);
+
+            if (morDs == null) {
+                String msg = "Unable to find volumes's storage pool for copy volume operation";
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+
+            vmMo = hyperHost.findVmOnHyperHost(vmName);
+            if (vmMo == null) {
+                //create a dummy worker vm for attaching the volume
+                DatastoreMO dsMo = new DatastoreMO(hyperHost.getContext(), morDs);
+                //restrict VM name to 32 chars, (else snapshot descriptor file name will be truncated to 32 chars of vm name)
+                String workerVMName = UUID.randomUUID().toString().replaceAll("-", "");
+                VirtualMachineConfigSpec vmConfig = new VirtualMachineConfigSpec();
+                vmConfig.setName(workerVMName);
+                vmConfig.setMemoryMB((long) 4);
+                vmConfig.setNumCPUs(1);
+                vmConfig.setGuestId(VirtualMachineGuestOsIdentifier._otherGuest.toString());
+                VirtualMachineFileInfo fileInfo = new VirtualMachineFileInfo();
+                fileInfo.setVmPathName(String.format("[%s]", dsMo.getName()));
+                vmConfig.setFiles(fileInfo);
+
+                // Scsi controller
+                VirtualLsiLogicController scsiController = new VirtualLsiLogicController();
+                scsiController.setSharedBus(VirtualSCSISharing.noSharing);
+                scsiController.setBusNumber(0);
+                scsiController.setKey(1);
+                VirtualDeviceConfigSpec scsiControllerSpec = new VirtualDeviceConfigSpec();
+                scsiControllerSpec.setDevice(scsiController);
+                scsiControllerSpec.setOperation(VirtualDeviceConfigSpecOperation.add);
+                vmConfig.setDeviceChange(new VirtualDeviceConfigSpec[] { scsiControllerSpec });
+	
+                hyperHost.createVm(vmConfig);
+                workerVm = hyperHost.findVmOnHyperHost(workerVMName);
+                if (workerVm == null) {
+                    String msg = "Unable to create worker VM to execute CopyVolumeCommand";
+                    s_logger.error(msg);
+                    throw new Exception(msg);
+                }
+	
+                //attach volume to worker VM
+                String datastoreVolumePath = String.format("[%s] %s.vmdk", dsMo.getName(), volumePath);
+                workerVm.attachDisk(new String[] { datastoreVolumePath }, morDs);
+                vmMo = workerVm;
+            }
+
+            vmMo.createSnapshot(exportName, "Temporary snapshot for copy-volume command", false, false);
+
+            exportVolumeToSecondaryStroage(vmMo, volumePath, secStorageUrl, "volumes/" + volumeFolder, exportName, workerVmName);
+            return new Pair<String, String>(volumeFolder, exportName);
+
+        } finally {
+            vmMo.removeSnapshot(exportName, false);
+            if (workerVm != null) {
+                //detach volume and destroy worker vm
+                workerVm.detachAllDisks();
+                workerVm.destroy();
+            }
+        }
+    }
+
+    private Pair<String, String> copyVolumeFromSecStorage(VmwareHypervisorHost hyperHost, long volumeId, 
+        DatastoreMO dsMo, String secStorageUrl, String exportName) throws Exception {
+
+        String volumeFolder = String.valueOf(volumeId) + "/";
+        String newVolume    = UUID.randomUUID().toString().replaceAll("-", "");
+        restoreVolumeFromSecStorage(hyperHost, dsMo, newVolume, secStorageUrl, "volumes/" + volumeFolder, exportName);
+        
+        return new Pair<String, String>(volumeFolder, newVolume);
+    }
+    
+    private String getOVFFilePath(String srcOVAFileName) {
+        File file = new File(srcOVAFileName);
+        assert(_storage != null);
+        String[] files = _storage.listFiles(file.getParent());
+        if(files != null) {
+            for(String fileName : files) {
+                if(fileName.toLowerCase().endsWith(".ovf")) {
+                    File ovfFile = new File(fileName);
+                    return file.getParent() + File.separator + ovfFile.getName();
+                }
+            }
+        }
+        return null;
+    }
+    
+    private static String getTemplateRelativeDirInSecStorage(long accountId, long templateId) {
+        return "template/tmpl/" + accountId + "/" + templateId;
+    }
+    
+    private static String getSnapshotRelativeDirInSecStorage(long accountId, long volumeId) {
+        return "snapshots/" + accountId + "/" + volumeId;
+    }
+}
diff --git a/core/src/com/cloud/hypervisor/vmware/manager/VmwareStorageMount.java b/core/src/com/cloud/hypervisor/vmware/manager/VmwareStorageMount.java
new file mode 100644
index 00000000000..6e582b86cd2
--- /dev/null
+++ b/core/src/com/cloud/hypervisor/vmware/manager/VmwareStorageMount.java
@@ -0,0 +1,9 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.manager;
+
+public interface VmwareStorageMount {
+    String getMountPoint(String storageUrl);
+}
diff --git a/core/src/com/cloud/hypervisor/vmware/resource/SshHelper.java b/core/src/com/cloud/hypervisor/vmware/resource/SshHelper.java
new file mode 100755
index 00000000000..723912d93a2
--- /dev/null
+++ b/core/src/com/cloud/hypervisor/vmware/resource/SshHelper.java
@@ -0,0 +1,193 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.resource;
+
+import java.io.File;
+import java.io.InputStream;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.utils.Pair;
+import com.trilead.ssh2.ChannelCondition;
+
+public class SshHelper {
+	private static int DEFAULT_CONNECT_TIMEOUT = 60000;
+	private static int DEFAULT_KEX_TIMEOUT = 60000;
+	
+	private static final Logger s_logger = Logger.getLogger(SshHelper.class);
+	
+	public static Pair<Boolean, String> sshExecute(String host, int port, String user, File pemKeyFile, String password, String command) 
+		throws Exception {
+	
+		return sshExecute(host, port, user, pemKeyFile, password, command, 60000, 60000, 120000);
+	}
+	
+	public static void scpTo(String host, int port, String user, File pemKeyFile, String password, String remoteTargetDirectory, 
+		String localFile, String fileMode) throws Exception {
+		
+		scpTo(host, port, user, pemKeyFile, password, remoteTargetDirectory, localFile, fileMode, 
+			DEFAULT_CONNECT_TIMEOUT, DEFAULT_KEX_TIMEOUT);
+	}
+	
+	public static void scpTo(String host, int port, String user, File pemKeyFile, String password, String remoteTargetDirectory, 
+		byte[] data, String remoteFileName, String fileMode) throws Exception {
+		
+		scpTo(host, port, user, pemKeyFile, password, remoteTargetDirectory, data, remoteFileName, fileMode, 
+			DEFAULT_CONNECT_TIMEOUT, DEFAULT_KEX_TIMEOUT);
+	}
+	
+	public static void scpTo(String host, int port, String user, File pemKeyFile, String password, String remoteTargetDirectory, 
+		String localFile, String fileMode, int connectTimeoutInMs, int kexTimeoutInMs) throws Exception {
+		
+		com.trilead.ssh2.Connection conn = null;
+		com.trilead.ssh2.SCPClient scpClient = null;
+		
+		try {
+			conn = new com.trilead.ssh2.Connection(host, port);
+			conn.connect(null, connectTimeoutInMs, kexTimeoutInMs);
+			
+			if(pemKeyFile == null) {
+				if(!conn.authenticateWithPassword(user, password)) {
+					String msg = "Failed to authentication SSH user " + user + " on host " + host;
+					s_logger.error(msg);
+					throw new Exception(msg);
+				}
+			} else {
+				if(!conn.authenticateWithPublicKey(user, pemKeyFile, password)) {
+					String msg = "Failed to authentication SSH user " + user + " on host " + host;
+					s_logger.error(msg);
+					throw new Exception(msg);
+				}
+			}
+			
+			scpClient = conn.createSCPClient();
+			
+			if(fileMode != null)
+				scpClient.put(localFile, remoteTargetDirectory, fileMode);
+			else
+				scpClient.put(localFile, remoteTargetDirectory);
+		} finally {
+			if(conn != null)
+				conn.close();
+		}
+	}
+	
+	public static void scpTo(String host, int port, String user, File pemKeyFile, String password, String remoteTargetDirectory, 
+		byte[] data, String remoteFileName, String fileMode, int connectTimeoutInMs, int kexTimeoutInMs) throws Exception {
+		
+		com.trilead.ssh2.Connection conn = null;
+		com.trilead.ssh2.SCPClient scpClient = null;
+		
+		try {
+			conn = new com.trilead.ssh2.Connection(host, port);
+			conn.connect(null, connectTimeoutInMs, kexTimeoutInMs);
+			
+			if(pemKeyFile == null) {
+				if(!conn.authenticateWithPassword(user, password)) {
+					String msg = "Failed to authentication SSH user " + user + " on host " + host;
+					s_logger.error(msg);
+					throw new Exception(msg);
+				}
+			} else {
+				if(!conn.authenticateWithPublicKey(user, pemKeyFile, password)) {
+					String msg = "Failed to authentication SSH user " + user + " on host " + host;
+					s_logger.error(msg);
+					throw new Exception(msg);
+				}
+			}
+			
+			scpClient = conn.createSCPClient();
+			if(fileMode != null)
+				scpClient.put(data, remoteFileName, remoteTargetDirectory, fileMode);
+			else
+				scpClient.put(data, remoteFileName, remoteTargetDirectory);
+		} finally {
+			if(conn != null)
+				conn.close();
+		}
+	}
+	
+	public static Pair<Boolean, String> sshExecute(String host, int port, String user, File pemKeyFile, String password, String command, 
+		int connectTimeoutInMs, int kexTimeoutInMs, int waitResultTimeoutInMs) throws Exception {
+		
+		com.trilead.ssh2.Connection conn = null;
+		com.trilead.ssh2.Session sess = null; 
+		try {
+			conn = new com.trilead.ssh2.Connection(host, port);
+			conn.connect(null, connectTimeoutInMs, kexTimeoutInMs);
+
+			if(pemKeyFile == null) {
+				if(!conn.authenticateWithPassword(user, password)) {
+					String msg = "Failed to authentication SSH user " + user + " on host " + host;
+					s_logger.error(msg);
+					throw new Exception(msg);
+				}
+			} else {
+				if(!conn.authenticateWithPublicKey(user, pemKeyFile, password)) {
+					String msg = "Failed to authentication SSH user " + user + " on host " + host;
+					s_logger.error(msg);
+					throw new Exception(msg);
+				}
+			}
+			sess = conn.openSession();
+			
+			// There is a bug in Trilead library, wait a second before
+			// starting a shell and executing commands, from http://spci.st.ewi.tudelft.nl/chiron/xref/nl/tudelft/swerl/util/SSHConnection.html
+			Thread.sleep(1000);
+			
+			sess.execCommand(command);
+			
+			InputStream stdout = sess.getStdout();
+			InputStream stderr = sess.getStderr();
+	
+            byte[] buffer = new byte[8192];
+            StringBuffer sbResult = new StringBuffer();
+            
+            int currentReadBytes = 0;
+            while (true) {
+                if ((stdout.available() == 0) && (stderr.available() == 0)) {
+                    int conditions = sess.waitForCondition(ChannelCondition.STDOUT_DATA | ChannelCondition.STDERR_DATA | ChannelCondition.EOF, 
+                        waitResultTimeoutInMs);
+                    
+                    if ((conditions & ChannelCondition.TIMEOUT) != 0) {
+                        String msg = "Timed out in waiting SSH execution result";
+                        s_logger.error(msg);
+                        throw new Exception(msg);
+                    }
+
+                    if ((conditions & ChannelCondition.EOF) != 0) {
+                        if ((conditions & (ChannelCondition.STDOUT_DATA | ChannelCondition.STDERR_DATA)) == 0) {                            
+                            break;
+                        }
+                    }
+                }
+                            
+                while (stdout.available() > 0) {
+                    currentReadBytes = stdout.read(buffer);
+                    sbResult.append(new String(buffer, 0, currentReadBytes));
+                }
+            
+                while (stderr.available() > 0) {
+                    currentReadBytes = stderr.read(buffer);
+                    sbResult.append(new String(buffer, 0, currentReadBytes));
+                }
+            }
+            
+            String result = sbResult.toString();
+            if (sess.getExitStatus() != null && sess.getExitStatus().intValue() != 0) {
+                s_logger.error("SSH execution of command " + command + " has an error status code in return. result output: " + result);
+                return new Pair<Boolean, String>(false, result);
+            }
+            
+            return new Pair<Boolean, String>(true, result);
+		} finally {
+			if(sess != null)
+				sess.close();
+			
+			if(conn != null)
+				conn.close();
+		}
+	}
+}
diff --git a/core/src/com/cloud/hypervisor/vmware/resource/VmwareContextFactory.java b/core/src/com/cloud/hypervisor/vmware/resource/VmwareContextFactory.java
new file mode 100755
index 00000000000..d82aeda60c1
--- /dev/null
+++ b/core/src/com/cloud/hypervisor/vmware/resource/VmwareContextFactory.java
@@ -0,0 +1,53 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.resource;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.manager.VmwareManager;
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.cloud.utils.StringUtils;
+import com.cloud.utils.component.ComponentLocator;
+import com.vmware.apputils.version.ExtendedAppUtil;
+
+public class VmwareContextFactory {
+	
+    private static final Logger s_logger = Logger.getLogger(VmwareContextFactory.class);
+	
+	private static volatile int s_seq = 1;
+	private static VmwareManager s_vmwareMgr;
+	
+	static {
+		// skip certificate check
+		System.setProperty("axis.socketSecureFactory", "org.apache.axis.components.net.SunFakeTrustSocketFactory");
+		
+		ComponentLocator locator = ComponentLocator.getLocator("management-server");
+		s_vmwareMgr = locator.getManager(VmwareManager.class);
+	}
+
+	public static VmwareContext create(String vCenterAddress, String vCenterUserName, String vCenterPassword) throws Exception {
+		assert(vCenterAddress != null);
+		assert(vCenterUserName != null);
+		assert(vCenterPassword != null);
+
+		String serviceUrl = "https://" + vCenterAddress + "/sdk/vimService";
+		String[] params = new String[] {"--url", serviceUrl, "--username", vCenterUserName, "--password", vCenterPassword };
+
+		if(s_logger.isDebugEnabled())
+			s_logger.debug("initialize VmwareContext. url: " + serviceUrl + ", username: " + vCenterUserName + ", password: " + StringUtils.getMaskedPasswordForDisplay(vCenterPassword));
+			
+		ExtendedAppUtil appUtil = ExtendedAppUtil.initialize(vCenterAddress + "-" + s_seq++, params);
+		
+		appUtil.connect();
+		VmwareContext context = new VmwareContext(appUtil, vCenterAddress);
+		context.registerStockObject(VmwareManager.CONTEXT_STOCK_NAME, s_vmwareMgr);
+		
+		// this is ugly, it is relatively easier to let cleasses in vmware-base library to access
+		context.registerStockObject("serviceconsole", s_vmwareMgr.getServiceConsolePortGroupName());
+		context.registerStockObject("manageportgroup", s_vmwareMgr.getManagementPortGroupName());
+
+		return context;
+	}
+}
diff --git a/core/src/com/cloud/hypervisor/vmware/resource/VmwareResource.java b/core/src/com/cloud/hypervisor/vmware/resource/VmwareResource.java
new file mode 100755
index 00000000000..47051936fdf
--- /dev/null
+++ b/core/src/com/cloud/hypervisor/vmware/resource/VmwareResource.java
@@ -0,0 +1,3747 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.resource;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.ConnectException;
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.nio.channels.SocketChannel;
+import java.rmi.RemoteException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.TimeZone;
+import java.util.UUID;
+
+import javax.naming.ConfigurationException;
+
+import org.apache.log4j.Logger;
+import org.apache.log4j.NDC;
+
+import com.cloud.agent.IAgentControl;
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.AttachIsoCommand;
+import com.cloud.agent.api.AttachVolumeAnswer;
+import com.cloud.agent.api.AttachVolumeCommand;
+import com.cloud.agent.api.BackupSnapshotAnswer;
+import com.cloud.agent.api.BackupSnapshotCommand;
+import com.cloud.agent.api.CheckHealthAnswer;
+import com.cloud.agent.api.CheckHealthCommand;
+import com.cloud.agent.api.CheckOnHostAnswer;
+import com.cloud.agent.api.CheckOnHostCommand;
+import com.cloud.agent.api.CheckRouterAnswer;
+import com.cloud.agent.api.CheckRouterCommand;
+import com.cloud.agent.api.CheckVirtualMachineAnswer;
+import com.cloud.agent.api.CheckVirtualMachineCommand;
+import com.cloud.agent.api.Command;
+import com.cloud.agent.api.CreatePrivateTemplateFromSnapshotCommand;
+import com.cloud.agent.api.CreatePrivateTemplateFromVolumeCommand;
+import com.cloud.agent.api.CreateStoragePoolCommand;
+import com.cloud.agent.api.CreateVolumeFromSnapshotAnswer;
+import com.cloud.agent.api.CreateVolumeFromSnapshotCommand;
+import com.cloud.agent.api.DeleteSnapshotBackupAnswer;
+import com.cloud.agent.api.DeleteSnapshotBackupCommand;
+import com.cloud.agent.api.DeleteSnapshotsDirCommand;
+import com.cloud.agent.api.DeleteStoragePoolCommand;
+import com.cloud.agent.api.GetHostStatsAnswer;
+import com.cloud.agent.api.GetHostStatsCommand;
+import com.cloud.agent.api.GetStorageStatsAnswer;
+import com.cloud.agent.api.GetStorageStatsCommand;
+import com.cloud.agent.api.GetVmStatsAnswer;
+import com.cloud.agent.api.GetVmStatsCommand;
+import com.cloud.agent.api.GetVncPortAnswer;
+import com.cloud.agent.api.GetVncPortCommand;
+import com.cloud.agent.api.HostStatsEntry;
+import com.cloud.agent.api.MaintainAnswer;
+import com.cloud.agent.api.MaintainCommand;
+import com.cloud.agent.api.ManageSnapshotAnswer;
+import com.cloud.agent.api.ManageSnapshotCommand;
+import com.cloud.agent.api.MigrateAnswer;
+import com.cloud.agent.api.MigrateCommand;
+import com.cloud.agent.api.ModifySshKeysCommand;
+import com.cloud.agent.api.ModifyStoragePoolAnswer;
+import com.cloud.agent.api.ModifyStoragePoolCommand;
+import com.cloud.agent.api.NetworkUsageAnswer;
+import com.cloud.agent.api.NetworkUsageCommand;
+import com.cloud.agent.api.PingCommand;
+import com.cloud.agent.api.PingRoutingCommand;
+import com.cloud.agent.api.PingTestCommand;
+import com.cloud.agent.api.PoolEjectCommand;
+import com.cloud.agent.api.PrepareForMigrationAnswer;
+import com.cloud.agent.api.PrepareForMigrationCommand;
+import com.cloud.agent.api.ReadyAnswer;
+import com.cloud.agent.api.ReadyCommand;
+import com.cloud.agent.api.RebootAnswer;
+import com.cloud.agent.api.RebootCommand;
+import com.cloud.agent.api.RebootRouterCommand;
+import com.cloud.agent.api.SetupAnswer;
+import com.cloud.agent.api.SetupCommand;
+import com.cloud.agent.api.StartAnswer;
+import com.cloud.agent.api.StartCommand;
+import com.cloud.agent.api.StartupCommand;
+import com.cloud.agent.api.StartupRoutingCommand;
+import com.cloud.agent.api.StartupStorageCommand;
+import com.cloud.agent.api.StopAnswer;
+import com.cloud.agent.api.StopCommand;
+import com.cloud.agent.api.StoragePoolInfo;
+import com.cloud.agent.api.UpgradeSnapshotCommand;
+import com.cloud.agent.api.ValidateSnapshotAnswer;
+import com.cloud.agent.api.ValidateSnapshotCommand;
+import com.cloud.agent.api.VmStatsEntry;
+import com.cloud.agent.api.check.CheckSshAnswer;
+import com.cloud.agent.api.check.CheckSshCommand;
+import com.cloud.agent.api.routing.DhcpEntryCommand;
+import com.cloud.agent.api.routing.IpAssocAnswer;
+import com.cloud.agent.api.routing.IpAssocCommand;
+import com.cloud.agent.api.routing.LoadBalancerConfigCommand;
+import com.cloud.agent.api.routing.NetworkElementCommand;
+import com.cloud.agent.api.routing.RemoteAccessVpnCfgCommand;
+import com.cloud.agent.api.routing.SavePasswordCommand;
+import com.cloud.agent.api.routing.SetFirewallRulesAnswer;
+import com.cloud.agent.api.routing.SetFirewallRulesCommand;
+import com.cloud.agent.api.routing.SetPortForwardingRulesAnswer;
+import com.cloud.agent.api.routing.SetPortForwardingRulesCommand;
+import com.cloud.agent.api.routing.SetStaticNatRulesAnswer;
+import com.cloud.agent.api.routing.SetStaticNatRulesCommand;
+import com.cloud.agent.api.routing.VmDataCommand;
+import com.cloud.agent.api.routing.VpnUsersCfgCommand;
+import com.cloud.agent.api.storage.CopyVolumeAnswer;
+import com.cloud.agent.api.storage.CopyVolumeCommand;
+import com.cloud.agent.api.storage.CreateAnswer;
+import com.cloud.agent.api.storage.CreateCommand;
+import com.cloud.agent.api.storage.CreatePrivateTemplateAnswer;
+import com.cloud.agent.api.storage.DestroyCommand;
+import com.cloud.agent.api.storage.PrimaryStorageDownloadAnswer;
+import com.cloud.agent.api.storage.PrimaryStorageDownloadCommand;
+import com.cloud.agent.api.to.IpAddressTO;
+import com.cloud.agent.api.to.NicTO;
+import com.cloud.agent.api.to.PortForwardingRuleTO;
+import com.cloud.agent.api.to.StaticNatRuleTO;
+import com.cloud.agent.api.to.StorageFilerTO;
+import com.cloud.agent.api.to.VirtualMachineTO;
+import com.cloud.agent.api.to.VolumeTO;
+import com.cloud.dc.DataCenter.NetworkType;
+import com.cloud.dc.Vlan;
+import com.cloud.exception.InternalErrorException;
+import com.cloud.host.Host.Type;
+import com.cloud.hypervisor.Hypervisor.HypervisorType;
+import com.cloud.hypervisor.vmware.manager.VmwareHostService;
+import com.cloud.hypervisor.vmware.manager.VmwareManager;
+import com.cloud.hypervisor.vmware.mo.ClusterMO;
+import com.cloud.hypervisor.vmware.mo.CustomFieldConstants;
+import com.cloud.hypervisor.vmware.mo.CustomFieldsManagerMO;
+import com.cloud.hypervisor.vmware.mo.DatacenterMO;
+import com.cloud.hypervisor.vmware.mo.DatastoreMO;
+import com.cloud.hypervisor.vmware.mo.HostMO;
+import com.cloud.hypervisor.vmware.mo.HostVirtualNicType;
+import com.cloud.hypervisor.vmware.mo.HypervisorHostHelper;
+import com.cloud.hypervisor.vmware.mo.NetworkDetails;
+import com.cloud.hypervisor.vmware.mo.VirtualMachineMO;
+import com.cloud.hypervisor.vmware.mo.VmwareHypervisorHost;
+import com.cloud.hypervisor.vmware.mo.VmwareHypervisorHostNetworkSummary;
+import com.cloud.hypervisor.vmware.mo.VmwareHypervisorHostResourceSummary;
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.cloud.hypervisor.vmware.util.VmwareGuestOsMapper;
+import com.cloud.hypervisor.vmware.util.VmwareHelper;
+import com.cloud.network.HAProxyConfigurator;
+import com.cloud.network.LoadBalancerConfigurator;
+import com.cloud.network.Networks;
+import com.cloud.network.Networks.BroadcastDomainType;
+import com.cloud.resource.ServerResource;
+import com.cloud.serializer.GsonHelper;
+import com.cloud.storage.Storage;
+import com.cloud.storage.Storage.StoragePoolType;
+import com.cloud.storage.Volume;
+import com.cloud.storage.resource.StoragePoolResource;
+import com.cloud.storage.template.TemplateInfo;
+import com.cloud.utils.DateUtil;
+import com.cloud.utils.Pair;
+import com.cloud.utils.StringUtils;
+import com.cloud.utils.component.ComponentLocator;
+import com.cloud.utils.db.DB;
+import com.cloud.utils.exception.CloudRuntimeException;
+import com.cloud.utils.exception.ExceptionUtil;
+import com.cloud.utils.mgmt.JmxUtil;
+import com.cloud.utils.mgmt.PropertyMapDynamicBean;
+import com.cloud.utils.net.NetUtils;
+import com.cloud.vm.DiskProfile;
+import com.cloud.vm.VirtualMachine;
+import com.cloud.vm.VirtualMachine.State;
+import com.cloud.vm.VirtualMachineName;
+import com.google.gson.Gson;
+import com.vmware.vim25.ClusterDasConfigInfo;
+import com.vmware.vim25.ComputeResourceSummary;
+import com.vmware.vim25.DatastoreSummary;
+import com.vmware.vim25.DynamicProperty;
+import com.vmware.vim25.HostNetworkTrafficShapingPolicy;
+import com.vmware.vim25.HostPortGroupSpec;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.ObjectContent;
+import com.vmware.vim25.OptionValue;
+import com.vmware.vim25.PerfCounterInfo;
+import com.vmware.vim25.PerfEntityMetric;
+import com.vmware.vim25.PerfEntityMetricBase;
+import com.vmware.vim25.PerfMetricId;
+import com.vmware.vim25.PerfMetricIntSeries;
+import com.vmware.vim25.PerfMetricSeries;
+import com.vmware.vim25.PerfQuerySpec;
+import com.vmware.vim25.PerfSampleInfo;
+import com.vmware.vim25.RuntimeFault;
+import com.vmware.vim25.ToolsUnavailable;
+import com.vmware.vim25.VimPortType;
+import com.vmware.vim25.VirtualDevice;
+import com.vmware.vim25.VirtualDeviceConfigSpec;
+import com.vmware.vim25.VirtualDeviceConfigSpecOperation;
+import com.vmware.vim25.VirtualDisk;
+import com.vmware.vim25.VirtualEthernetCard;
+import com.vmware.vim25.VirtualLsiLogicController;
+import com.vmware.vim25.VirtualMachineConfigSpec;
+import com.vmware.vim25.VirtualMachineFileInfo;
+import com.vmware.vim25.VirtualMachineGuestOsIdentifier;
+import com.vmware.vim25.VirtualMachinePowerState;
+import com.vmware.vim25.VirtualMachineRuntimeInfo;
+import com.vmware.vim25.VirtualSCSISharing;
+
+public class VmwareResource implements StoragePoolResource, ServerResource, VmwareHostService {
+    private static final Logger s_logger = Logger.getLogger(VmwareResource.class);
+
+    protected String _name;
+
+    protected final long _ops_timeout = 900000; 		// 15 minutes time out to time
+    protected final int _shutdown_waitMs = 300000;		// wait up to 5 minutes for shutdown 
+    
+    // out an operation
+    protected final int _retry = 24;
+    protected final int _sleep = 10000;
+    protected final int DEFAULT_DOMR_SSHPORT = 3922;
+    protected final int MAX_CMD_MBEAN = 100;
+
+    protected String _url;
+    protected String _dcId;
+    protected String _pod;
+    protected String _cluster;
+    protected String _username;
+    protected String _password;
+    protected String _guid;
+    protected String _vCenterAddress;
+
+    protected String _privateNetworkVSwitchName;
+    protected String _publicNetworkVSwitchName;
+    protected String _guestNetworkVSwitchName;
+    protected float _cpuOverprovisioningFactor = 1;
+    protected boolean _reserveCpu = false;
+
+    protected ManagedObjectReference _morHyperHost;
+    protected VmwareContext _serviceContext;
+    protected String _hostName;
+
+    protected HashMap<String, State> _vms = new HashMap<String, State>(71);
+    protected List<PropertyMapDynamicBean> _cmdMBeans = new ArrayList<PropertyMapDynamicBean>();
+
+    protected Gson _gson;
+
+    protected volatile long _cmdSequence = 1;
+
+    protected static HashMap<VirtualMachinePowerState, State> s_statesTable;
+    static {
+        s_statesTable = new HashMap<VirtualMachinePowerState, State>();
+        s_statesTable.put(VirtualMachinePowerState.poweredOn, State.Running);
+        s_statesTable.put(VirtualMachinePowerState.poweredOff, State.Stopped);
+        s_statesTable.put(VirtualMachinePowerState.suspended, State.Stopped);
+    }
+
+    public VmwareResource() {
+        _gson = GsonHelper.getGsonLogger();
+    }
+
+    @Override
+    public Answer executeRequest(Command cmd) {
+    	if(s_logger.isTraceEnabled())
+    		s_logger.trace("Begin executeRequest(), cmd: " + cmd.getClass().getSimpleName());
+    	
+        Answer answer = null;
+        NDC.push(_hostName != null ? _hostName : _guid + "(" + ComponentLocator.class.getPackage().getImplementationVersion() + ")");
+        try {
+            long cmdSequence = _cmdSequence++;
+            Date startTime = DateUtil.currentGMTTime();
+            PropertyMapDynamicBean mbean = new PropertyMapDynamicBean();
+            mbean.addProp("StartTime", DateUtil.getDateDisplayString(TimeZone.getDefault(), startTime));
+            mbean.addProp("Command", _gson.toJson(cmd));
+            mbean.addProp("Sequence", String.valueOf(cmdSequence));
+            mbean.addProp("Name", cmd.getClass().getSimpleName());
+
+            if (cmd instanceof CreateCommand) {
+                answer = execute((CreateCommand) cmd);
+            } else if (cmd instanceof SetPortForwardingRulesCommand) {
+                answer = execute((SetPortForwardingRulesCommand) cmd);
+            } else if (cmd instanceof SetStaticNatRulesCommand) {
+                answer = execute((SetStaticNatRulesCommand) cmd);
+            } else if (cmd instanceof LoadBalancerConfigCommand) {
+                answer = execute((LoadBalancerConfigCommand) cmd);
+            } else if (cmd instanceof IpAssocCommand) {
+                answer = execute((IpAssocCommand) cmd);
+            } else if (cmd instanceof SavePasswordCommand) {
+                answer = execute((SavePasswordCommand) cmd);
+            } else if (cmd instanceof DhcpEntryCommand) {
+                answer = execute((DhcpEntryCommand) cmd);
+            } else if (cmd instanceof VmDataCommand) {
+                answer = execute((VmDataCommand) cmd);
+            } else if (cmd instanceof ReadyCommand) {
+                answer = execute((ReadyCommand) cmd);
+            } else if (cmd instanceof GetHostStatsCommand) {
+                answer = execute((GetHostStatsCommand) cmd);
+            } else if (cmd instanceof GetVmStatsCommand) {
+                answer = execute((GetVmStatsCommand) cmd);
+            } else if (cmd instanceof CheckHealthCommand) {
+                answer = execute((CheckHealthCommand) cmd);
+            } else if (cmd instanceof StopCommand) {
+                answer = execute((StopCommand) cmd);
+            } else if (cmd instanceof RebootRouterCommand) {
+                answer = execute((RebootRouterCommand) cmd);
+            } else if (cmd instanceof RebootCommand) {
+                answer = execute((RebootCommand) cmd);
+            } else if (cmd instanceof CheckVirtualMachineCommand) {
+                answer = execute((CheckVirtualMachineCommand) cmd);
+            } else if (cmd instanceof PrepareForMigrationCommand) {
+                answer = execute((PrepareForMigrationCommand) cmd);
+            } else if (cmd instanceof MigrateCommand) {
+                answer = execute((MigrateCommand) cmd);
+            } else if (cmd instanceof DestroyCommand) {
+                answer = execute((DestroyCommand) cmd);
+            } else if (cmd instanceof CreateStoragePoolCommand) {
+                return execute((CreateStoragePoolCommand) cmd);
+            } else if (cmd instanceof ModifyStoragePoolCommand) {
+                answer = execute((ModifyStoragePoolCommand) cmd);
+            } else if (cmd instanceof DeleteStoragePoolCommand) {
+                answer = execute((DeleteStoragePoolCommand) cmd);
+            } else if (cmd instanceof CopyVolumeCommand) {
+                answer = execute((CopyVolumeCommand) cmd);
+            } else if (cmd instanceof AttachVolumeCommand) {
+                answer = execute((AttachVolumeCommand) cmd);
+            } else if (cmd instanceof AttachIsoCommand) {
+                answer = execute((AttachIsoCommand) cmd);
+            } else if (cmd instanceof ValidateSnapshotCommand) {
+                answer = execute((ValidateSnapshotCommand) cmd);
+            } else if (cmd instanceof ManageSnapshotCommand) {
+                answer = execute((ManageSnapshotCommand) cmd);
+            } else if (cmd instanceof BackupSnapshotCommand) {
+                answer = execute((BackupSnapshotCommand) cmd);
+            } else if (cmd instanceof DeleteSnapshotBackupCommand) {
+                answer = execute((DeleteSnapshotBackupCommand) cmd);
+            } else if (cmd instanceof CreateVolumeFromSnapshotCommand) {
+                answer = execute((CreateVolumeFromSnapshotCommand) cmd);
+            } else if (cmd instanceof DeleteSnapshotsDirCommand) {
+                answer = execute((DeleteSnapshotsDirCommand) cmd);
+            } else if (cmd instanceof CreatePrivateTemplateFromVolumeCommand) {
+                answer = execute((CreatePrivateTemplateFromVolumeCommand) cmd);
+            } else if (cmd instanceof CreatePrivateTemplateFromSnapshotCommand) {
+                answer = execute((CreatePrivateTemplateFromSnapshotCommand) cmd);
+            } else if (cmd instanceof UpgradeSnapshotCommand) {
+                answer = execute((UpgradeSnapshotCommand) cmd);
+            } else if (cmd instanceof GetStorageStatsCommand) {
+                answer = execute((GetStorageStatsCommand) cmd);
+            } else if (cmd instanceof PrimaryStorageDownloadCommand) {
+                answer = execute((PrimaryStorageDownloadCommand) cmd);
+            } else if (cmd instanceof GetVncPortCommand) {
+                answer = execute((GetVncPortCommand) cmd);
+            } else if (cmd instanceof SetupCommand) {
+                answer = execute((SetupCommand) cmd);
+            } else if (cmd instanceof MaintainCommand) {
+                answer = execute((MaintainCommand) cmd);
+            } else if (cmd instanceof PingTestCommand) {
+                answer = execute((PingTestCommand) cmd);
+            } else if (cmd instanceof CheckOnHostCommand) {
+                answer = execute((CheckOnHostCommand) cmd);
+            } else if (cmd instanceof ModifySshKeysCommand) {
+                answer = execute((ModifySshKeysCommand) cmd);
+            } else if (cmd instanceof PoolEjectCommand) {
+                answer = execute((PoolEjectCommand) cmd);
+            } else if (cmd instanceof NetworkUsageCommand) {
+                answer = execute((NetworkUsageCommand) cmd);
+            } else if (cmd instanceof StartCommand) {
+                answer = execute((StartCommand) cmd);
+            } else if (cmd instanceof RemoteAccessVpnCfgCommand) {
+                answer = execute((RemoteAccessVpnCfgCommand) cmd);
+            } else if (cmd instanceof VpnUsersCfgCommand) {
+                answer = execute((VpnUsersCfgCommand) cmd);
+            } else if (cmd instanceof CheckSshCommand) {
+                answer = execute((CheckSshCommand) cmd);
+            } else if (cmd instanceof CheckRouterCommand) {
+                answer = execute((CheckRouterCommand) cmd);
+            } else  if (cmd instanceof SetFirewallRulesCommand) {
+            	answer = execute((SetFirewallRulesCommand)cmd);
+            } else {
+                answer = Answer.createUnsupportedCommandAnswer(cmd);
+            }
+
+            if(cmd.getContextParam("checkpoint") != null) {
+                answer.setContextParam("checkpoint", cmd.getContextParam("checkpoint"));
+            }
+
+            Date doneTime = DateUtil.currentGMTTime();
+            mbean.addProp("DoneTime", DateUtil.getDateDisplayString(TimeZone.getDefault(), doneTime));
+            mbean.addProp("Answer", _gson.toJson(answer));
+
+            synchronized (this) {
+                try {
+                    JmxUtil.registerMBean("VMware " + _morHyperHost.get_value(), "Command " + cmdSequence + "-" + cmd.getClass().getSimpleName(), mbean);
+                    _cmdMBeans.add(mbean);
+
+                    if (_cmdMBeans.size() >= MAX_CMD_MBEAN) {
+                        PropertyMapDynamicBean mbeanToRemove = _cmdMBeans.get(0);
+                        _cmdMBeans.remove(0);
+
+                        JmxUtil.unregisterMBean("VMware " + _morHyperHost.get_value(), "Command " + mbeanToRemove.getProp("Sequence") + "-" + mbeanToRemove.getProp("Name"));
+                    }
+                } catch (Exception e) {
+                	if(s_logger.isTraceEnabled())
+                		s_logger.trace("Unable to register JMX monitoring due to exception " + ExceptionUtil.toString(e));
+                }
+            }
+
+        } finally {
+            NDC.pop();
+        }
+
+    	if(s_logger.isTraceEnabled())
+    		s_logger.trace("End executeRequest(), cmd: " + cmd.getClass().getSimpleName());
+        
+        return answer;
+    }
+    
+    protected Answer execute(NetworkUsageCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource NetworkUsageCommand " + _gson.toJson(cmd));
+        }
+
+        long[] stats = getNetworkStats(cmd.getPrivateIP());
+
+        NetworkUsageAnswer answer = new NetworkUsageAnswer(cmd, "", stats[0], stats[1]);
+        return answer;
+    }
+
+    protected Answer execute(SetPortForwardingRulesCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource SetPortForwardingRulesCommand: " + _gson.toJson(cmd));
+        }
+
+        // String routerIp = cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP);
+        String controlIp = getRouterSshControlIp(cmd);
+        String args = "";
+        String[] results = new String[cmd.getRules().length];
+        int i = 0;
+        
+        boolean endResult = true;
+        for (PortForwardingRuleTO rule : cmd.getRules()) {
+            args += rule.revoked() ? " -D " : " -A ";
+            args += " -P " + rule.getProtocol().toLowerCase();
+            args += " -l " + rule.getSrcIp();
+            args += " -p " + rule.getStringSrcPortRange();
+            args += " -r " + rule.getDstIp();
+            args += " -d " + rule.getStringDstPortRange();
+
+            try {
+                VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+                Pair<Boolean, String> result = SshHelper.sshExecute(controlIp, DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null, "/root/firewall.sh " + args);
+
+                if (s_logger.isDebugEnabled())
+                    s_logger.debug("Executing script on domain router " + controlIp + ": /root/firewall.sh " + args);
+
+                if (!result.first()) {
+                    s_logger.error("SetPortForwardingRulesCommand failure on setting one rule. args: " + args);
+                    results[i++] = "Failed";
+                    endResult = false;
+                } else {
+                    results[i++] = null;
+                }
+            } catch (Throwable e) {
+                s_logger.error("SetPortForwardingRulesCommand(args: " + args + ") failed on setting one rule due to " + VmwareHelper.getExceptionMessage(e));
+                results[i++] = "Failed";
+                endResult = false;
+            }
+        }
+
+        return new SetPortForwardingRulesAnswer(cmd, results, endResult);
+    }
+    
+    protected SetFirewallRulesAnswer execute(SetFirewallRulesCommand cmd) {
+		String controlIp = getRouterSshControlIp(cmd);
+		String[] results = new String[cmd.getRules().length];
+
+		String[][] rules = cmd.generateFwRules();
+		String args = "";
+		args += " -F ";
+		StringBuilder sb = new StringBuilder();
+		String[] fwRules = rules[0];
+		if (fwRules.length > 0) {
+			for (int i = 0; i < fwRules.length; i++) {
+				sb.append(fwRules[i]).append(',');
+			}
+			args += " -a " + sb.toString();
+		}
+
+		try {
+			VmwareManager mgr = getServiceContext().getStockObject(
+					VmwareManager.CONTEXT_STOCK_NAME);
+			Pair<Boolean, String> result = SshHelper.sshExecute(controlIp,
+					DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(),
+					null, "/root/firewall_rule.sh " + args);
+
+			if (s_logger.isDebugEnabled())
+				s_logger.debug("Executing script on domain router " + controlIp
+						+ ": /root/firewall_rule.sh " + args);
+
+			if (!result.first()) {
+				s_logger.error("SetFirewallRulesCommand failure on setting one rule. args: "
+						+ args);
+				//FIXME - in the future we have to process each rule separately; now we temporarily set every rule to be false if single rule fails
+	            for (int i=0; i < results.length; i++) {
+	                results[i] = "Failed";
+	            }
+	            
+	            return new SetFirewallRulesAnswer(cmd, false, results);
+			} 
+		} catch (Throwable e) {
+			s_logger.error("SetFirewallRulesCommand(args: " + args
+					+ ") failed on setting one rule due to "
+					+ VmwareHelper.getExceptionMessage(e));
+			//FIXME - in the future we have to process each rule separately; now we temporarily set every rule to be false if single rule fails
+            for (int i=0; i < results.length; i++) {
+                results[i] = "Failed";
+            }
+			return new SetFirewallRulesAnswer(cmd, false, results);
+		} 
+
+		return new SetFirewallRulesAnswer(cmd, true, results);
+    }	
+    
+    protected Answer execute(SetStaticNatRulesCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource SetFirewallRuleCommand: " + _gson.toJson(cmd));
+        }
+
+        // String routerIp = cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP);
+        String args = null;
+        String[] results = new String[cmd.getRules().length];
+        int i = 0;
+        boolean endResult = true;
+        for (StaticNatRuleTO rule : cmd.getRules()) {
+            // 1:1 NAT needs instanceip;publicip;domrip;op
+            args = rule.revoked() ? " -D " : " -A ";
+
+            args += " -l " + rule.getSrcIp();
+            args += " -r " + rule.getDstIp();
+            
+            if (rule.getProtocol() != null) {
+                args += " -P " + rule.getProtocol().toLowerCase();
+            }
+            
+            args += " -d " + rule.getStringSrcPortRange();
+            args += " -G ";
+
+            try {
+                VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+                String controlIp = getRouterSshControlIp(cmd);
+                Pair<Boolean, String> result = SshHelper.sshExecute(controlIp, DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null, "/root/firewall.sh " + args);
+
+                if (s_logger.isDebugEnabled())
+                    s_logger.debug("Executing script on domain router " + controlIp + ": /root/firewall.sh " + args);
+
+                if (!result.first()) {
+                    s_logger.error("SetStaticNatRulesCommand failure on setting one rule. args: " + args);
+                    results[i++] = "Failed";
+                    endResult = false;
+                } else {
+                    results[i++] = null;
+                }
+            } catch (Throwable e) {
+                s_logger.error("SetStaticNatRulesCommand (args: " + args + ") failed on setting one rule due to " + VmwareHelper.getExceptionMessage(e));
+                results[i++] = "Failed";
+                endResult = false;
+            }
+        }
+        return new SetStaticNatRulesAnswer(cmd, results, endResult);
+    }
+
+    protected Answer execute(final LoadBalancerConfigCommand cmd) {
+        VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+        File keyFile = mgr.getSystemVMKeyFile();
+
+        String routerIp = cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP);
+        String controlIp = getRouterSshControlIp(cmd);
+        
+        assert(controlIp != null);
+
+        LoadBalancerConfigurator cfgtr = new HAProxyConfigurator();
+        String[] config = cfgtr.generateConfiguration(cmd);
+        String[][] rules = cfgtr.generateFwRules(cmd);
+        String tmpCfgFilePath = "/tmp/" + routerIp.replace('.', '_') + ".cfg";
+        String tmpCfgFileContents = "";
+        for (int i = 0; i < config.length; i++) {
+            tmpCfgFileContents += config[i];
+            tmpCfgFileContents += "\n";
+        }
+
+        try {
+            SshHelper.scpTo(controlIp, DEFAULT_DOMR_SSHPORT, "root", keyFile, null, "/tmp/", tmpCfgFileContents.getBytes(), routerIp.replace('.', '_') + ".cfg", null);
+
+            try {
+                String[] addRules = rules[LoadBalancerConfigurator.ADD];
+                String[] removeRules = rules[LoadBalancerConfigurator.REMOVE];
+
+                String args = "";
+                args += "-i " + routerIp;
+                args += " -f " + tmpCfgFilePath;
+
+                StringBuilder sb = new StringBuilder();
+                if (addRules.length > 0) {
+                    for (int i = 0; i < addRules.length; i++) {
+                        sb.append(addRules[i]).append(',');
+                    }
+
+                    args += " -a " + sb.toString();
+                }
+
+                sb = new StringBuilder();
+                if (removeRules.length > 0) {
+                    for (int i = 0; i < removeRules.length; i++) {
+                        sb.append(removeRules[i]).append(',');
+                    }
+
+                    args += " -d " + sb.toString();
+                }
+
+                Pair<Boolean, String> result = SshHelper.sshExecute(controlIp, DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null, "scp " + tmpCfgFilePath + " /etc/haproxy/haproxy.cfg.new");
+
+                if (!result.first()) {
+                    s_logger.error("Unable to copy haproxy configuration file");
+                    return new Answer(cmd, false, "LoadBalancerConfigCommand failed due to uanble to copy haproxy configuration file");
+                }
+
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug("Run command on domain router " + routerIp + ",  /root/loadbalancer.sh " + args);
+                }
+
+                result = SshHelper.sshExecute(controlIp, DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null, "/root/loadbalancer.sh " + args);
+
+                if (!result.first()) {
+                    String msg = "LoadBalancerConfigCommand on domain router " + routerIp + " failed. message: " + result.second();
+                    s_logger.error(msg);
+
+                    return new Answer(cmd, false, msg);
+                }
+
+                if (s_logger.isInfoEnabled()) {
+                    s_logger.info("LoadBalancerConfigCommand on domain router " + routerIp + " completed");
+                }
+            } finally {
+                SshHelper.sshExecute(controlIp, DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null, "rm " + tmpCfgFilePath);
+            }
+
+            return new Answer(cmd);
+        } catch (Throwable e) {
+            s_logger.error("Unexpected exception: " + e.toString(), e);
+            return new Answer(cmd, false, "LoadBalancerConfigCommand failed due to " + VmwareHelper.getExceptionMessage(e));
+        }
+    }
+
+    protected void assignPublicIpAddress(VirtualMachineMO vmMo, final String vmName, final String privateIpAddress, final String publicIpAddress, final boolean add, final boolean firstIP,
+            final boolean sourceNat, final String vlanId, final String vlanGateway, final String vlanNetmask, final String vifMacAddress, String guestIp) throws Exception {
+
+        String publicNeworkName = HypervisorHostHelper.getPublicNetworkNamePrefix(vlanId);
+        Pair<Integer, VirtualDevice> publicNicInfo = vmMo.getNicDeviceIndex(publicNeworkName);
+
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Find public NIC index, public network name: " + publicNeworkName + ", index: " + publicNicInfo.first());
+        }
+
+        boolean addVif = false;
+        boolean removeVif = false;
+        if (add && publicNicInfo.first().intValue() == -1) {
+            if (s_logger.isDebugEnabled()) {
+                s_logger.debug("Plug new NIC to associate" + privateIpAddress + " to " + publicIpAddress);
+            }
+
+            addVif = true;
+        } else if (!add && firstIP) {
+            removeVif = true;
+
+            if (s_logger.isDebugEnabled()) {
+                s_logger.debug("Unplug NIC " + publicNicInfo.first());
+            }
+        }
+
+        if (addVif) {
+            plugPublicNic(vmMo, vlanId, vifMacAddress);
+            publicNicInfo = vmMo.getNicDeviceIndex(publicNeworkName);
+            if (publicNicInfo.first().intValue() >= 0) {
+                networkUsage(privateIpAddress, "addVif", "eth" + publicNicInfo.first());
+            }
+        }
+
+        if (publicNicInfo.first().intValue() < 0) {
+            String msg = "Failed to find DomR VIF to associate/disassociate IP with.";
+            s_logger.error(msg);
+            throw new InternalErrorException(msg);
+        }
+
+        String args = null;
+
+        if (add) {
+            args = " -A ";
+        } else {
+            args = " -D ";
+        }
+        String cidrSize = Long.toString(NetUtils.getCidrSize(vlanNetmask));
+        if (sourceNat) {
+            args += " -f ";
+            args += " -l ";
+            args += publicIpAddress + "/" + cidrSize;
+        } else if (firstIP) {
+            args += " -f ";
+            args += " -l ";
+            args += publicIpAddress + "/" + cidrSize;
+        } else {
+            args += " -l ";
+            args += publicIpAddress;
+        }
+
+        args += " -c ";
+        args += "eth" + publicNicInfo.first();
+
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Run command on domain router " + privateIpAddress + ", /root/ipassoc.sh " + args);
+        }
+
+        VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+        Pair<Boolean, String> result = SshHelper.sshExecute(privateIpAddress, DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null, "/root/ipassoc.sh " + args);
+
+        if (!result.first()) {
+            s_logger.error("ipassoc command on domain router " + privateIpAddress + " failed. message: " + result.second());
+            throw new Exception("ipassoc failed due to " + result.second());
+        }
+
+        if (removeVif) {
+            vmMo.tearDownDevice(publicNicInfo.second());
+
+            HostMO hostMo = vmMo.getRunningHost();
+            List<NetworkDetails> networks = vmMo.getNetworksWithDetails();
+            for (NetworkDetails netDetails : networks) {
+                if (netDetails.getGCTag() != null && netDetails.getGCTag().equalsIgnoreCase("true")) {
+                    if (netDetails.getVMMorsOnNetwork() == null || netDetails.getVMMorsOnNetwork().length == 1) {
+                        cleanupNetwork(hostMo, netDetails);
+                    }
+                }
+            }
+        }
+
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("ipassoc command on domain router " + privateIpAddress + " completed");
+        }
+    }
+
+    private void plugPublicNic(VirtualMachineMO vmMo, final String vlanId, final String vifMacAddress) throws Exception {
+        // TODO : probably need to set traffic shaping
+        Pair<ManagedObjectReference, String> networkInfo = HypervisorHostHelper.preparePublicNetwork(this._publicNetworkVSwitchName, 
+        	vmMo.getRunningHost(), vlanId, null, null, this._ops_timeout, true);
+        
+        VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+
+        VirtualDevice nic = VmwareHelper.prepareNicDevice(vmMo, networkInfo.first(), mgr.getGuestNicDeviceType(), 
+        	networkInfo.second(), vifMacAddress, -1, 1, true, true);
+        vmMo.plugDevice(nic);
+    }
+
+    protected Answer execute(IpAssocCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource IPAssocCommand: " + _gson.toJson(cmd));
+        }
+
+        int i = 0;
+        String[] results = new String[cmd.getIpAddresses().length];
+
+        VmwareContext context = getServiceContext();
+        try {
+            VmwareHypervisorHost hyperHost = getHyperHost(context);
+
+            IpAddressTO[] ips = cmd.getIpAddresses();
+            String routerName = cmd.getAccessDetail(NetworkElementCommand.ROUTER_NAME);
+            // String routerIp = cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP);
+            String controlIp = VmwareResource.getRouterSshControlIp(cmd);
+
+            VirtualMachineMO vmMo = hyperHost.findVmOnHyperHost(routerName);
+            if (vmMo == null) {
+                String msg = "Router " + routerName + " no longer exists to execute IPAssoc command";
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+
+            for (IpAddressTO ip : ips) {
+                assignPublicIpAddress(vmMo, routerName, controlIp, ip.getPublicIp(), ip.isAdd(), ip.isFirstIP(), ip.isSourceNat(), ip.getVlanId(), ip.getVlanGateway(), ip.getVlanNetmask(),
+                        ip.getVifMacAddress(), ip.getGuestIp());
+                results[i++] = ip.getPublicIp() + " - success";
+            }
+        } catch (Throwable e) {
+            s_logger.error("Unexpected exception: " + e.toString() + " will shortcut rest of IPAssoc commands", e);
+
+            for (; i < cmd.getIpAddresses().length; i++) {
+                results[i++] = IpAssocAnswer.errorResult;
+            }
+        }
+
+        return new IpAssocAnswer(cmd, results);
+    }
+
+    protected Answer execute(SavePasswordCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource SavePasswordCommand. vmName: " + cmd.getVmName() + ", vmIp: " + cmd.getVmIpAddress() + ", password: " 
+            	+ StringUtils.getMaskedPasswordForDisplay(cmd.getPassword()));
+        }
+
+        String controlIp = getRouterSshControlIp(cmd);
+        final String password = cmd.getPassword();
+        final String vmIpAddress = cmd.getVmIpAddress();
+
+        // Run save_password_to_domr.sh
+        String args = " -v " + vmIpAddress;
+
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Run command on domain router " + controlIp + ", /root/savepassword.sh " + args + " -p " + StringUtils.getMaskedPasswordForDisplay(cmd.getPassword()));
+        }
+        
+        args += " -p " + password;
+
+
+        try {
+            VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+            Pair<Boolean, String> result = SshHelper.sshExecute(controlIp, DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null, "/root/savepassword.sh " + args);
+
+            if (!result.first()) {
+                s_logger.error("savepassword command on domain router " + controlIp + " failed, message: " + result.second());
+
+                return new Answer(cmd, false, "SavePassword failed due to " + result.second());
+            }
+
+            if (s_logger.isInfoEnabled()) {
+                s_logger.info("savepassword command on domain router " + controlIp + " completed");
+            }
+
+        } catch (Throwable e) {
+            String msg = "SavePasswordCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new Answer(cmd, false, msg);
+        }
+        return new Answer(cmd);
+    }
+
+    protected Answer execute(DhcpEntryCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource DhcpEntryCommand: " + _gson.toJson(cmd));
+        }
+
+        String args = " " + cmd.getVmMac();
+        args += " " + cmd.getVmIpAddress();
+        args += " " + cmd.getVmName();
+
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Run command on domR " + cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP) + ", /root/edithosts.sh " + args);
+        }
+
+        try {
+            VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+            String controlIp = getRouterSshControlIp(cmd);
+            Pair<Boolean, String> result = SshHelper.sshExecute(controlIp, DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null,
+                    "/root/edithosts.sh " + args);
+
+            if (!result.first()) {
+                s_logger.error("dhcp_entry command on domR " + controlIp + " failed, message: " + result.second());
+
+                return new Answer(cmd, false, "DhcpEntry failed due to " + result.second());
+            }
+
+            if (s_logger.isInfoEnabled()) {
+                s_logger.info("dhcp_entry command on domain router " + controlIp + " completed");
+            }
+
+        } catch (Throwable e) {
+            String msg = "DhcpEntryCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new Answer(cmd, false, msg);
+        }
+
+        return new Answer(cmd);
+    }
+    
+    protected Answer execute(CheckRouterCommand cmd) {
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Executing resource CheckRouterCommand: " + _gson.toJson(cmd));
+            s_logger.debug("Run command on domR " + cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP) + ", /root/checkrouter.sh ");
+        }
+
+        Pair<Boolean, String> result;
+        try {
+            VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+            result = SshHelper.sshExecute(cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP), DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null,
+                    "/root/checkrouter.sh ");
+
+            if (!result.first()) {
+                s_logger.error("check router command on domR " + cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP) + " failed, message: " + result.second());
+
+                return new CheckRouterAnswer(cmd, "CheckRouter failed due to " + result.second());
+            }
+
+            if (s_logger.isDebugEnabled()) {
+                s_logger.debug("check router command on domain router " + cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP) + " completed");
+            }
+        } catch (Throwable e) {
+            String msg = "CheckRouterCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new CheckRouterAnswer(cmd, msg);
+        }
+        return new CheckRouterAnswer(cmd, result.second().startsWith("Status: MASTER"), result.second());
+    }
+    
+    protected Answer execute(VmDataCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource VmDataCommand: " + _gson.toJson(cmd));
+        }
+
+        String routerPrivateIpAddress = cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP);
+        String controlIp = getRouterSshControlIp(cmd);
+        
+        String vmIpAddress = cmd.getVmIpAddress();
+        List<String[]> vmData = cmd.getVmData();
+        String[] vmDataArgs = new String[vmData.size() * 2 + 4];
+        vmDataArgs[0] = "routerIP";
+        vmDataArgs[1] = routerPrivateIpAddress;
+        vmDataArgs[2] = "vmIP";
+        vmDataArgs[3] = vmIpAddress;
+        int i = 4;
+        for (String[] vmDataEntry : vmData) {
+            String folder = vmDataEntry[0];
+            String file = vmDataEntry[1];
+            String contents = (vmDataEntry[2] != null) ? vmDataEntry[2] : "none";
+
+            vmDataArgs[i] = folder + "," + file;
+            vmDataArgs[i + 1] = contents;
+            i += 2;
+        }
+
+        String content = encodeDataArgs(vmDataArgs);
+        String tmpFileName = UUID.randomUUID().toString();
+
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Run vm_data command on domain router " + cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP) + ", data: " + content);
+        }
+
+        try {
+            VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+            SshHelper.scpTo(controlIp, DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null, "/tmp", content.getBytes(), tmpFileName, null);
+
+            try {
+                Pair<Boolean, String> result = SshHelper.sshExecute(controlIp, DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null,
+                        "/root/userdata.py " + tmpFileName);
+
+                if (!result.first()) {
+                    s_logger.error("vm_data command on domain router " + controlIp + " failed. messge: " + result.second());
+                    return new Answer(cmd, false, "VmDataCommand failed due to " + result.second());
+                }
+            } finally {
+
+                SshHelper.sshExecute(controlIp, DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null, "rm /tmp/" + tmpFileName);
+            }
+
+            if (s_logger.isInfoEnabled()) {
+                s_logger.info("vm_data command on domain router " + controlIp + " completed");
+            }
+
+        } catch (Throwable e) {
+            String msg = "VmDataCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new Answer(cmd, false, msg);
+        }
+        return new Answer(cmd);
+    }
+
+    private String encodeDataArgs(String[] dataArgs) {
+        StringBuilder sb = new StringBuilder();
+
+        for (String arg : dataArgs) {
+            sb.append(arg);
+            sb.append("\n");
+        }
+
+        return sb.toString();
+    }
+
+    protected CheckSshAnswer execute(CheckSshCommand cmd) {
+        String vmName = cmd.getName();
+        String privateIp = cmd.getIp();
+        int cmdPort = cmd.getPort();
+
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Ping command port, " + privateIp + ":" + cmdPort);
+        }
+
+        try {
+            String result = connect(cmd.getName(), privateIp, cmdPort);
+            if (result != null) {
+                s_logger.error("Can not ping System vm " + vmName + "due to:" + result);
+                return new CheckSshAnswer(cmd, "Can not ping System vm " + vmName + "due to:" + result);
+            }
+        } catch (Exception e) {
+            s_logger.error("Can not ping System vm " + vmName + "due to exception");
+            return new CheckSshAnswer(cmd, e);
+        }
+
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Ping command port succeeded for vm " + vmName);
+        }
+
+        if (VirtualMachineName.isValidRouterName(vmName)) {
+            if (s_logger.isDebugEnabled()) {
+                s_logger.debug("Execute network usage setup command on " + vmName);
+            }
+            networkUsage(privateIp, "create", null);
+        }
+
+        return new CheckSshAnswer(cmd);
+    }
+
+    private VolumeTO[] validateDisks(VolumeTO[] disks) {
+        List<VolumeTO> validatedDisks = new ArrayList<VolumeTO>();
+
+        for (VolumeTO vol : disks) {
+            if (vol.getPoolUuid() != null && !vol.getPoolUuid().isEmpty()) {
+                validatedDisks.add(vol);
+            } else if (vol.getPoolType() == StoragePoolType.ISO && (vol.getPath() != null && !vol.getPath().isEmpty())) {
+                validatedDisks.add(vol);
+            } else {
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug("Drop invalid disk option, volumeTO: " + _gson.toJson(vol));
+                }
+            }
+        }
+
+        return validatedDisks.toArray(new VolumeTO[0]);
+    }
+
+    protected StartAnswer execute(StartCommand cmd) {
+
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource StartCommand: " + _gson.toJson(cmd));
+        }
+
+        VirtualMachineTO vmSpec = cmd.getVirtualMachine();
+        String vmName = vmSpec.getName();
+
+        State state = State.Stopped;
+        VmwareContext context = getServiceContext();
+        try {
+            VmwareManager mgr = context.getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+
+            // mark VM as starting state so that sync() can know not to report stopped too early
+            synchronized (_vms) {
+                _vms.put(vmName, State.Starting);
+            }
+
+            VmwareHypervisorHost hyperHost = getHyperHost(context);
+            VolumeTO[] disks = validateDisks(vmSpec.getDisks());
+            assert (disks.length > 0);
+            NicTO[] nics = vmSpec.getNics();
+
+            HashMap<String, Pair<ManagedObjectReference, DatastoreMO>> dataStoresDetails = inferDatastoreDetailsFromDiskInfo(hyperHost, context, disks);
+            if ((dataStoresDetails == null) || (dataStoresDetails.isEmpty()) ){
+                String msg = "Unable to locate datastore details of the volumes to be attached";
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+
+            VirtualMachineMO vmMo = hyperHost.findVmOnHyperHost(vmName);
+            if (vmMo != null) {
+                s_logger.info("VM " + vmName + " already exists, tear down devices for reconfiguration");
+                if (getVmState(vmMo) != State.Stopped)
+                    vmMo.safePowerOff(_shutdown_waitMs);
+                vmMo.tearDownDevices(new Class<?>[] { VirtualDisk.class, VirtualEthernetCard.class });
+            } else {
+                ManagedObjectReference morDc = hyperHost.getHyperHostDatacenter();
+                assert (morDc != null);
+
+                vmMo = hyperHost.findVmOnPeerHyperHost(vmName);
+                if (vmMo != null) {
+                    if (s_logger.isInfoEnabled()) {
+                        s_logger.info("Found vm " + vmName + " at other host, relocate to " + hyperHost.getHyperHostName());
+                    }
+
+                    takeVmFromOtherHyperHost(hyperHost, vmName);
+
+                    if (getVmState(vmMo) != State.Stopped)
+                        vmMo.safePowerOff(_shutdown_waitMs);
+                    vmMo.tearDownDevices(new Class<?>[] { VirtualDisk.class, VirtualEthernetCard.class });
+                } else {
+                    int ramMb = (int) (vmSpec.getMinRam() / (1024 * 1024));
+                    Pair<ManagedObjectReference, DatastoreMO> rootDiskDataStoreDetails = null;
+                    for (VolumeTO vol : disks) {
+                        if (vol.getType() == Volume.Type.ROOT) {
+                        	rootDiskDataStoreDetails = dataStoresDetails.get(vol.getPoolUuid());
+                        }
+                    }
+
+                    assert (vmSpec.getSpeed() != null) && (rootDiskDataStoreDetails != null);
+                    if (!hyperHost.createBlankVm(vmName, vmSpec.getCpus(), vmSpec.getSpeed().intValue(), 
+                    		getReserveCpuMHz(vmSpec.getSpeed().intValue()), vmSpec.getLimitCpuUse(), ramMb, 
+                    	translateGuestOsIdentifier(vmSpec.getArch(), vmSpec.getOs()).toString(), rootDiskDataStoreDetails.first(), false)) {
+                        throw new Exception("Failed to create VM. vmName: " + vmName);
+                    }
+                }
+
+                vmMo = hyperHost.findVmOnHyperHost(vmName);
+                if (vmMo == null) {
+                    throw new Exception("Failed to find the newly create or relocated VM. vmName: " + vmName);
+                }
+            }
+
+            int totalChangeDevices = disks.length + nics.length;
+            VolumeTO volIso = null;
+            if (vmSpec.getType() != VirtualMachine.Type.User) {
+                // system VM needs a patch ISO
+                totalChangeDevices++;
+            } else {
+                for (VolumeTO vol : disks) {
+                    if (vol.getType() == Volume.Type.ISO) {
+                        volIso = vol;
+                        break;
+                    }
+                }
+
+                if (volIso == null)
+                    totalChangeDevices++;
+            }
+
+            VirtualMachineConfigSpec vmConfigSpec = new VirtualMachineConfigSpec();
+            int ramMb = (int) (vmSpec.getMinRam() / (1024 * 1024));
+            VmwareHelper.setBasicVmConfig(vmConfigSpec, vmSpec.getCpus(), vmSpec.getSpeed().intValue(), 
+            	getReserveCpuMHz(vmSpec.getSpeed().intValue()), ramMb, 
+        		translateGuestOsIdentifier(vmSpec.getArch(), vmSpec.getOs()).toString(), vmSpec.getLimitCpuUse());
+            
+            VirtualDeviceConfigSpec[] deviceConfigSpecArray = new VirtualDeviceConfigSpec[totalChangeDevices];
+            int i = 0;
+            int ideControllerKey = vmMo.getIDEDeviceControllerKey();
+            int scsiControllerKey = vmMo.getScsiDeviceControllerKey();
+            int controllerKey;
+            String datastoreDiskPath;
+
+            // prepare systemvm patch ISO
+            if (vmSpec.getType() != VirtualMachine.Type.User) {
+                // attach ISO (for patching of system VM)
+                String secStoreUrl = mgr.getSecondaryStorageStoreUrl(Long.parseLong(_dcId));
+                if(secStoreUrl == null) {
+                    String msg = "secondary storage for dc " + _dcId + " is not ready yet?";
+                    throw new Exception(msg);
+                }
+                mgr.prepareSecondaryStorageStore(secStoreUrl);
+                
+                ManagedObjectReference morSecDs = prepareSecondaryDatastoreOnHost(secStoreUrl);
+                if (morSecDs == null) {
+                    String msg = "Failed to prepare secondary storage on host, secondary store url: " + secStoreUrl;
+                    throw new Exception(msg);
+                }
+                DatastoreMO secDsMo = new DatastoreMO(hyperHost.getContext(), morSecDs);
+
+                deviceConfigSpecArray[i] = new VirtualDeviceConfigSpec();
+                Pair<VirtualDevice, Boolean> isoInfo = VmwareHelper.prepareIsoDevice(vmMo, String.format("[%s] systemvm/%s", secDsMo.getName(), mgr.getSystemVMIsoFileNameOnDatastore()), 
+                	secDsMo.getMor(), true, true, i, i + 1);
+                deviceConfigSpecArray[i].setDevice(isoInfo.first());
+                if (isoInfo.second()) {
+                	if(s_logger.isDebugEnabled())
+                		s_logger.debug("Prepare ISO volume at new device " + _gson.toJson(isoInfo.first()));
+                    deviceConfigSpecArray[i].setOperation(VirtualDeviceConfigSpecOperation.add);
+                } else {
+                	if(s_logger.isDebugEnabled())
+                		s_logger.debug("Prepare ISO volume at existing device " + _gson.toJson(isoInfo.first()));
+                    deviceConfigSpecArray[i].setOperation(VirtualDeviceConfigSpecOperation.edit);
+                }
+                i++;
+            } else {
+                // we will always plugin a CDROM device
+                if (volIso != null && volIso.getPath() != null && !volIso.getPath().isEmpty()) {
+                    Pair<String, ManagedObjectReference> isoDatastoreInfo = getIsoDatastoreInfo(hyperHost, volIso.getPath());
+                    assert (isoDatastoreInfo != null);
+                    assert (isoDatastoreInfo.second() != null);
+
+                    deviceConfigSpecArray[i] = new VirtualDeviceConfigSpec();
+                    Pair<VirtualDevice, Boolean> isoInfo = VmwareHelper.prepareIsoDevice(vmMo, isoDatastoreInfo.first(), isoDatastoreInfo.second(), true, true, i, i + 1);
+                    deviceConfigSpecArray[i].setDevice(isoInfo.first());
+                    if (isoInfo.second()) {
+                    	if(s_logger.isDebugEnabled())
+                    		s_logger.debug("Prepare ISO volume at new device " + _gson.toJson(isoInfo.first()));
+                    	deviceConfigSpecArray[i].setOperation(VirtualDeviceConfigSpecOperation.add);
+                    } else {
+                    	if(s_logger.isDebugEnabled())
+                    		s_logger.debug("Prepare ISO volume at existing device " + _gson.toJson(isoInfo.first()));
+                        deviceConfigSpecArray[i].setOperation(VirtualDeviceConfigSpecOperation.edit);
+                    }
+                } else {
+                    deviceConfigSpecArray[i] = new VirtualDeviceConfigSpec();
+                    Pair<VirtualDevice, Boolean> isoInfo = VmwareHelper.prepareIsoDevice(vmMo, null, null, true, true, i, i + 1);
+                    deviceConfigSpecArray[i].setDevice(isoInfo.first());
+                    if (isoInfo.second()) {
+                    	if(s_logger.isDebugEnabled())
+                    		s_logger.debug("Prepare ISO volume at existing device " + _gson.toJson(isoInfo.first()));
+                    	
+                        deviceConfigSpecArray[i].setOperation(VirtualDeviceConfigSpecOperation.add);
+                    } else {
+                    	if(s_logger.isDebugEnabled())
+                    		s_logger.debug("Prepare ISO volume at existing device " + _gson.toJson(isoInfo.first()));
+                    	
+                        deviceConfigSpecArray[i].setOperation(VirtualDeviceConfigSpecOperation.edit);
+                    }
+                }
+                i++;
+            }
+
+            for (VolumeTO vol : disks) {
+                deviceConfigSpecArray[i] = new VirtualDeviceConfigSpec();
+
+                if (vol.getType() == Volume.Type.ROOT || vol.getType() == Volume.Type.ISO) {
+                    controllerKey = ideControllerKey;
+                } else {
+                    controllerKey = scsiControllerKey;
+                }
+
+                if (vol.getType() != Volume.Type.ISO) {
+                    Pair<ManagedObjectReference, DatastoreMO> volumeDsDetails = dataStoresDetails.get(vol.getPoolUuid());
+                    assert (volumeDsDetails != null);
+                	VirtualDevice device;
+                    datastoreDiskPath = String.format("[%s] %s.vmdk", volumeDsDetails.second().getName(), vol.getPath());
+                    String chainInfo = vol.getChainInfo();
+
+                    if (chainInfo != null && !chainInfo.isEmpty()) {
+                        String[] diskChain = _gson.fromJson(chainInfo, String[].class);
+                        if (diskChain == null || diskChain.length < 1) {
+                            s_logger.warn("Empty previously-saved chain info, fall back to the original");
+                            device = VmwareHelper.prepareDiskDevice(vmMo, controllerKey, new String[] { datastoreDiskPath }, volumeDsDetails.first(), i, i + 1);
+                        } else {
+                            s_logger.info("Attach the disk with stored chain info: " + chainInfo);
+                            for (int j = 0; j < diskChain.length; j++) {
+                                diskChain[j] = String.format("[%s] %s", volumeDsDetails.second().getName(), diskChain[j]);
+                            }
+
+                            device = VmwareHelper.prepareDiskDevice(vmMo, controllerKey, diskChain, volumeDsDetails.first(), i, i + 1);
+                        }
+                    } else {
+                        device = VmwareHelper.prepareDiskDevice(vmMo, controllerKey, new String[] { datastoreDiskPath }, volumeDsDetails.first(), i, i + 1);
+                    }
+                    deviceConfigSpecArray[i].setDevice(device);
+                    deviceConfigSpecArray[i].setOperation(VirtualDeviceConfigSpecOperation.add);
+
+                	if(s_logger.isDebugEnabled())
+                		s_logger.debug("Prepare volume at new device " + _gson.toJson(device));
+                    
+                    i++;
+                }
+            }
+
+            VirtualDevice nic;
+            int nicDeviceNumber = -1;
+            for (NicTO nicTo : sortNicsByDeviceId(nics)) {
+                s_logger.info("Prepare NIC device based on NicTO: " + _gson.toJson(nicTo));
+
+                Pair<ManagedObjectReference, String> networkInfo = prepareNetworkFromNicInfo(vmMo.getRunningHost(), nicTo);
+                
+                nic = VmwareHelper.prepareNicDevice(vmMo, networkInfo.first(), mgr.getGuestNicDeviceType(), networkInfo.second(), nicTo.getMac(), nicDeviceNumber, i + 1, true, true);
+                nicDeviceNumber = nic.getUnitNumber() + 1;
+                deviceConfigSpecArray[i] = new VirtualDeviceConfigSpec();
+                deviceConfigSpecArray[i].setDevice(nic);
+                deviceConfigSpecArray[i].setOperation(VirtualDeviceConfigSpecOperation.add);
+                
+            	if(s_logger.isDebugEnabled())
+            		s_logger.debug("Prepare NIC at new device " + _gson.toJson(deviceConfigSpecArray[i]));
+                
+                i++;
+            }
+
+            vmConfigSpec.setDeviceChange(deviceConfigSpecArray);
+
+            // pass boot arguments through machine.id
+            OptionValue[] machineIdOptions = new OptionValue[1];
+            machineIdOptions[0] = new OptionValue();
+            machineIdOptions[0].setKey("machine.id");
+            machineIdOptions[0].setValue(vmSpec.getBootArgs());
+            
+            String keyboardLayout = null;
+            if(vmSpec.getDetails() != null)
+            	keyboardLayout = vmSpec.getDetails().get(VirtualMachine.PARAM_KEY_KEYBOARD);
+            vmConfigSpec.setExtraConfig(configureVnc(machineIdOptions, hyperHost, vmName, vmSpec.getVncPassword(), keyboardLayout));
+
+            if (!vmMo.configureVm(vmConfigSpec)) {
+                throw new Exception("Failed to configure VM before start. vmName: " + vmName);
+            }
+
+            if (!vmMo.powerOn()) {
+                throw new Exception("Failed to start VM. vmName: " + vmName);
+            }
+
+            state = State.Running;
+            return new StartAnswer(cmd);
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "StartCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.warn(msg, e);
+            return new StartAnswer(cmd, msg);
+        } finally {
+            synchronized (_vms) {
+                if (state != State.Stopped) {
+                    _vms.put(vmName, state);
+                } else {
+                    _vms.remove(vmName);
+                }
+            }
+        }
+    }
+
+    private int getReserveCpuMHz(int cpuMHz) {
+    	if(this._reserveCpu) {
+    		return (int)(cpuMHz / this._cpuOverprovisioningFactor);
+    	}
+    	
+    	return 0;
+    }
+    
+    private NicTO[] sortNicsByDeviceId(NicTO[] nics) {
+
+        List<NicTO> listForSort = new ArrayList<NicTO>();
+        for (NicTO nic : nics) {
+            listForSort.add(nic);
+        }
+        Collections.sort(listForSort, new Comparator<NicTO>() {
+
+            @Override
+            public int compare(NicTO arg0, NicTO arg1) {
+                if (arg0.getDeviceId() < arg1.getDeviceId()) {
+                    return -1;
+                } else if (arg0.getDeviceId() == arg1.getDeviceId()) {
+                    return 0;
+                }
+
+                return 1;
+            }
+        });
+
+        return listForSort.toArray(new NicTO[0]);
+    }
+
+    private HashMap<String, Pair<ManagedObjectReference, DatastoreMO>> inferDatastoreDetailsFromDiskInfo(VmwareHypervisorHost hyperHost, VmwareContext context, VolumeTO[] disks) throws Exception {
+        HashMap<String ,Pair<ManagedObjectReference, DatastoreMO>> poolMors = new HashMap<String, Pair<ManagedObjectReference, DatastoreMO>>();
+
+        assert (hyperHost != null) && (context != null);
+        for (VolumeTO vol : disks) {
+            if (vol.getType() != Volume.Type.ISO) {
+                String poolUuid = vol.getPoolUuid();
+                if(poolMors.get(poolUuid) == null) {
+                    ManagedObjectReference morDataStore = hyperHost.findDatastore(poolUuid);
+                    if (morDataStore == null) {
+                        String msg = "Failed to get the mounted datastore for the volume's pool " + poolUuid;
+                        s_logger.error(msg);
+                        throw new Exception(msg);
+                    }
+                    poolMors.put(vol.getPoolUuid(), new Pair<ManagedObjectReference, DatastoreMO> (morDataStore, new DatastoreMO(context, morDataStore)));
+                }
+            }
+        }
+        return poolMors;
+    }
+
+    private String getVlanInfo(NicTO nicTo) {
+        if (nicTo.getBroadcastType() == BroadcastDomainType.Native) {
+            return Vlan.UNTAGGED;
+        }
+
+        if (nicTo.getBroadcastType() == BroadcastDomainType.Vlan) {
+            if (nicTo.getBroadcastUri() != null) {
+                return nicTo.getBroadcastUri().getHost();
+            } else {
+                s_logger.warn("BroadcastType is not claimed as VLAN, but without vlan info in broadcast URI");
+                return Vlan.UNTAGGED;
+            }
+        }
+
+        s_logger.warn("Unrecognized broadcast type in VmwareResource, type: " + nicTo.getBroadcastType().toString());
+        return Vlan.UNTAGGED;
+    }
+
+    private Pair<ManagedObjectReference, String> prepareNetworkFromNicInfo(HostMO hostMo, NicTO nicTo) throws Exception {
+        if (nicTo.getType() == Networks.TrafficType.Guest) {
+            return prepareGuestNetwork(hostMo, getVlanInfo(nicTo), nicTo.getNetworkRateMbps(), nicTo.getNetworkRateMulticastMbps());
+        } else if (nicTo.getType() == Networks.TrafficType.Control || nicTo.getType() == Networks.TrafficType.Management) {
+            return preparePrivateNetwork(hostMo);
+        } else if (nicTo.getType() == Networks.TrafficType.Public) {
+            return preparePublicNetwork(hostMo, getVlanInfo(nicTo), nicTo.getNetworkRateMbps(), nicTo.getNetworkRateMulticastMbps());
+        } else if (nicTo.getType() == Networks.TrafficType.Storage) {
+            throw new Exception("Unsupported traffic type: " + nicTo.getType().toString());
+        } else if (nicTo.getType() == Networks.TrafficType.Vpn) {
+            throw new Exception("Unsupported traffic type: " + nicTo.getType().toString());
+        } else {
+            throw new Exception("Unsupported traffic type: " + nicTo.getType().toString());
+        }
+    }
+
+    protected synchronized Answer execute(final RemoteAccessVpnCfgCommand cmd) {
+        String routerIp = cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP);
+        String controlIp = getRouterSshControlIp(cmd);
+        StringBuffer argsBuf = new StringBuffer();
+        if (cmd.isCreate()) {
+            argsBuf.append(" -r ").append(cmd.getIpRange()).append(" -p ").append(cmd.getPresharedKey()).append(" -s ").append(cmd.getVpnServerIp()).append(" -l ").append(cmd.getLocalIp())
+            .append(" -c ");
+
+        } else {
+            argsBuf.append(" -d ").append(" -s ").append(cmd.getVpnServerIp());
+        }
+
+        try {
+            VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+
+            if (s_logger.isDebugEnabled()) {
+                s_logger.debug("Executing /opt/cloud/bin/vpn_lt2p.sh " + argsBuf.toString());
+            }
+
+            Pair<Boolean, String> result = SshHelper.sshExecute(controlIp, DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null, "/opt/cloud/bin/vpn_l2tp.sh " + argsBuf.toString());
+
+            if (!result.first()) {
+                s_logger.error("RemoteAccessVpnCfg command on domR " + argsBuf.toString() + " failed, message: " + result.second());
+
+                return new Answer(cmd, false, "RemoteAccessVpnCfg command failed due to " + result.second());
+            }
+
+            if (s_logger.isInfoEnabled()) {
+                s_logger.info("RemoteAccessVpnCfg command on domain router " + argsBuf.toString() + " completed");
+            }
+
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "RemoteAccessVpnCfg command failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new Answer(cmd, false, msg);
+        }
+
+        return new Answer(cmd);
+    }
+
+    protected synchronized Answer execute(final VpnUsersCfgCommand cmd) {
+        VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+
+        String routerIp = cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP);
+        String controlIp = getRouterSshControlIp(cmd);
+        for (VpnUsersCfgCommand.UsernamePassword userpwd : cmd.getUserpwds()) {
+            StringBuffer argsBuf = new StringBuffer();
+            if (!userpwd.isAdd()) {
+                argsBuf.append(" -U ").append(userpwd.getUsername());
+            } else {
+                argsBuf.append(" -u ").append(userpwd.getUsernamePassword());
+            }
+
+            try {
+
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug("Executing /opt/cloud/bin/vpn_lt2p.sh " + argsBuf.toString());
+                }
+
+                Pair<Boolean, String> result = SshHelper.sshExecute(controlIp, DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null, "/opt/cloud/bin/vpn_l2tp.sh " + argsBuf.toString());
+
+                if (!result.first()) {
+                    s_logger.error("VpnUserCfg command on domR " + argsBuf + " failed, message: " + result.second());
+
+                    return new Answer(cmd, false, "VpnUserCfg command failed due to " + result.second());
+                }
+            } catch (Throwable e) {
+                if (e instanceof RemoteException) {
+                    s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                    invalidateServiceContext();
+                }
+
+                String msg = "VpnUserCfg command failed due to " + VmwareHelper.getExceptionMessage(e);
+                s_logger.error(msg);
+                return new Answer(cmd, false, msg);
+            }
+        }
+
+        return new Answer(cmd);
+    }
+
+    private VirtualMachineMO takeVmFromOtherHyperHost(VmwareHypervisorHost hyperHost, String vmName) throws Exception {
+
+        VirtualMachineMO vmMo = hyperHost.findVmOnPeerHyperHost(vmName);
+        if (vmMo != null) {
+            ManagedObjectReference morTargetPhysicalHost = hyperHost.findMigrationTarget(vmMo);
+            if (morTargetPhysicalHost == null) {
+                String msg = "VM " + vmName + " is on other host and we have no resource available to migrate and start it here";
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+
+            prepareNetworkForVmTargetHost(new HostMO(hyperHost.getContext(), morTargetPhysicalHost), vmMo);
+            if (!vmMo.relocate(morTargetPhysicalHost)) {
+                String msg = "VM " + vmName + " is on other host and we failed to relocate it here";
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+
+            return vmMo;
+        }
+        return null;
+    }
+
+    // isoUrl sample content :
+    // nfs://192.168.10.231/export/home/kelven/vmware-test/secondary/template/tmpl/2/200//200-2-80f7ee58-6eff-3a2d-bcb0-59663edf6d26.iso
+    private Pair<String, ManagedObjectReference> getIsoDatastoreInfo(VmwareHypervisorHost hyperHost, String isoUrl) throws Exception {
+
+        assert (isoUrl != null);
+        int isoFileNameStartPos = isoUrl.lastIndexOf("/");
+        if (isoFileNameStartPos < 0) {
+            throw new Exception("Invalid ISO path info");
+        }
+
+        String isoFileName = isoUrl.substring(isoFileNameStartPos);
+
+        int templateRootPos = isoUrl.indexOf("template/tmpl");
+        if (templateRootPos < 0) {
+            throw new Exception("Invalid ISO path info");
+        }
+
+        String storeUrl = isoUrl.substring(0, templateRootPos - 1);
+        String isoPath = isoUrl.substring(templateRootPos, isoFileNameStartPos);
+
+        ManagedObjectReference morDs = prepareSecondaryDatastoreOnHost(storeUrl);
+        DatastoreMO dsMo = new DatastoreMO(getServiceContext(), morDs);
+
+        return new Pair<String, ManagedObjectReference>(String.format("[%s] %s%s", dsMo.getName(), isoPath, isoFileName), morDs);
+    }
+
+    protected Answer execute(ReadyCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource ReadyCommand: " + _gson.toJson(cmd));
+        }
+        
+        try {
+        	VmwareContext context = getServiceContext();
+        	VmwareHypervisorHost hyperHost = getHyperHost(context);
+        	if(hyperHost.isHyperHostConnected()) {
+                return new ReadyAnswer(cmd);
+        	} else {
+        		return new ReadyAnswer(cmd, "Host is not in connect state");
+        	}
+        } catch(Exception e) {
+        	s_logger.error("Unexpected exception: ", e);
+    		return new ReadyAnswer(cmd, VmwareHelper.getExceptionMessage(e));
+        }
+    }
+
+    protected Answer execute(GetHostStatsCommand cmd) {
+        if (s_logger.isTraceEnabled()) {
+            s_logger.trace("Executing resource GetHostStatsCommand: " + _gson.toJson(cmd));
+        }
+
+        VmwareContext context = getServiceContext();
+        VmwareHypervisorHost hyperHost = getHyperHost(context);
+        
+        HostStatsEntry hostStats = new HostStatsEntry(cmd.getHostId(), 0, 0, 0, "host", 0, 0, 0, 0);
+        Answer answer = new GetHostStatsAnswer(cmd, hostStats);
+        try {
+            HostStatsEntry entry = getHyperHostStats(hyperHost);
+            if(entry != null) {
+	            entry.setHostId(cmd.getHostId());
+	            answer = new GetHostStatsAnswer(cmd, entry);
+            }
+        } catch (Exception e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "Unable to execute GetHostStatsCommand due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg, e);
+        }
+
+        if (s_logger.isTraceEnabled()) {
+            s_logger.trace("GetHostStats Answer: " + _gson.toJson(answer));
+        }
+
+        return answer;
+    }
+
+    protected Answer execute(GetVmStatsCommand cmd) {
+        if (s_logger.isTraceEnabled()) {
+            s_logger.trace("Executing resource GetVmStatsCommand: " + _gson.toJson(cmd));
+        }
+
+        HashMap<String, VmStatsEntry> vmStatsMap = null;
+
+        try {
+            HashMap<String, State> newStates = getVmStates();
+
+            List<String> requestedVmNames = cmd.getVmNames();
+            List<String> vmNames = new ArrayList();
+
+            if (requestedVmNames != null) {
+                for (String vmName : requestedVmNames) {
+                     if (newStates.get(vmName) != null) {
+                         vmNames.add(vmName);
+        	         }
+                }
+            }
+
+            if (vmNames != null) {
+                vmStatsMap = getVmStats(vmNames);
+            }
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            s_logger.error("Unable to query host runtime info due to : " + VmwareHelper.getExceptionMessage(e));
+        }
+
+        Answer answer = new GetVmStatsAnswer(cmd, vmStatsMap);
+
+        if (s_logger.isTraceEnabled()) {
+            s_logger.trace("Report GetVmStatsAnswer: " + _gson.toJson(answer));
+        }
+        return answer;
+    }
+
+    protected Answer execute(CheckHealthCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource CheckHealthCommand: " + _gson.toJson(cmd));
+        }
+
+        try {
+            VmwareHypervisorHost hyperHost = getHyperHost(getServiceContext());
+            if (hyperHost.isHyperHostConnected()) {
+                return new CheckHealthAnswer(cmd, true);
+            }
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            s_logger.error("Unable to query host runtime info due to " + VmwareHelper.getExceptionMessage(e));
+        }
+        return new CheckHealthAnswer(cmd, false);
+    }
+
+    protected Answer execute(StopCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource StopCommand: " + _gson.toJson(cmd));
+        }
+
+        VmwareContext context = getServiceContext();
+        VmwareHypervisorHost hyperHost = getHyperHost(context);
+        try {
+            VirtualMachineMO vmMo = hyperHost.findVmOnHyperHost(cmd.getVmName());
+            if (vmMo != null) {
+
+                State state = null;
+                synchronized (_vms) {
+                    state = _vms.get(cmd.getVmName());
+                    _vms.put(cmd.getVmName(), State.Stopping);
+                }
+
+                try {
+                    if (getVmState(vmMo) != State.Stopped) {
+                        Long bytesSent = 0L;
+                        Long bytesRcvd = 0L;
+
+                        if (VirtualMachineName.isValidRouterName(cmd.getVmName())) {
+                            if (cmd.getPrivateRouterIpAddress() != null) {
+                                long[] stats = getNetworkStats(cmd.getPrivateRouterIpAddress());
+                                bytesSent = stats[0];
+                                bytesRcvd = stats[1];
+                            }
+                        }
+                        
+                        // before we stop VM, remove all possible snapshots on the VM to let
+                        // disk chain be collapsed
+                        s_logger.info("Remove all snapshot before stopping VM " + cmd.getVmName());
+                        vmMo.removeAllSnapshots();
+                        if (vmMo.safePowerOff(_shutdown_waitMs)) {
+                            state = State.Stopped;
+                            return new StopAnswer(cmd, "Stop VM " + cmd.getVmName() + " Succeed", 0, bytesSent, bytesRcvd);
+                        } else {
+                        	String msg = "Have problem in powering off VM " + cmd.getVmName() + ", let the process continue";
+                        	s_logger.warn(msg);
+                            return new StopAnswer(cmd, msg, 0, 0L, 0L);
+                        }
+                    } else {
+                        state = State.Stopped;
+                    }
+
+                    String msg = "VM " + cmd.getVmName() + " is already in stopped state";
+                    s_logger.info(msg);
+                    return new StopAnswer(cmd, msg, 0, 0L, 0L);
+                } finally {
+                    synchronized (_vms) {
+                        _vms.put(cmd.getVmName(), state);
+                    }
+                }
+            } else {
+                synchronized (_vms) {
+                    _vms.remove(cmd.getVmName());
+                }
+
+                String msg = "VM " + cmd.getVmName() + " is no longer in vSphere";
+                s_logger.info(msg);
+                return new StopAnswer(cmd, msg, 0, 0L, 0L);
+            }
+        } catch (Exception e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "StopCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new StopAnswer(cmd, msg);
+        }
+    }
+
+    protected Answer execute(RebootRouterCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource RebootRouterCommand: " + _gson.toJson(cmd));
+        }
+
+        Long bytesSent = 0L;
+        Long bytesRcvd = 0L;
+        if (VirtualMachineName.isValidRouterName(cmd.getVmName())) {
+            long[] stats = getNetworkStats(cmd.getPrivateIpAddress());
+            bytesSent = stats[0];
+            bytesRcvd = stats[1];
+        }
+
+        RebootAnswer answer = (RebootAnswer) execute((RebootCommand) cmd);
+        answer.setBytesSent(bytesSent);
+        answer.setBytesReceived(bytesRcvd);
+
+        if (answer.getResult()) {
+            String connectResult = connect(cmd.getVmName(), cmd.getPrivateIpAddress());
+            networkUsage(cmd.getPrivateIpAddress(), "create", null);
+            if (connectResult == null) {
+                return answer;
+            } else {
+                return new Answer(cmd, false, connectResult);
+            }
+        }
+        return answer;
+    }
+
+    protected Answer execute(RebootCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource RebootCommand: " + _gson.toJson(cmd));
+        }
+
+        VmwareContext context = getServiceContext();
+        VmwareHypervisorHost hyperHost = getHyperHost(context);
+        try {
+            VirtualMachineMO vmMo = hyperHost.findVmOnHyperHost(cmd.getVmName());
+            if (vmMo != null) {
+                try {
+                    vmMo.rebootGuest();
+                    return new RebootAnswer(cmd, "reboot succeeded", null, null);
+                } catch(ToolsUnavailable e) {
+                    s_logger.warn("VMware tools is not installed at guest OS, we will perform hard reset for reboot");
+                } catch(Exception e) {
+                    s_logger.warn("We are not able to perform gracefull guest reboot due to " + VmwareHelper.getExceptionMessage(e));
+                }
+
+                // continue to try with hard-reset
+                if (vmMo.reset()) {
+                    return new RebootAnswer(cmd, "reboot succeeded", null, null);
+                }
+
+                String msg = "Reboot failed in vSphere. vm: " + cmd.getVmName();
+                s_logger.warn(msg);
+                return new RebootAnswer(cmd, msg);
+            } else {
+                String msg = "Unable to find the VM in vSphere to reboot. vm: " + cmd.getVmName();
+                s_logger.warn(msg);
+                return new RebootAnswer(cmd, msg);
+            }
+        } catch (Exception e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "RebootCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new RebootAnswer(cmd, msg);
+        }
+    }
+
+    protected Answer execute(CheckVirtualMachineCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource CheckVirtualMachineCommand: " + _gson.toJson(cmd));
+        }
+
+        final String vmName = cmd.getVmName();
+        State state = State.Unknown;
+        Integer vncPort = null;
+
+        VmwareContext context = getServiceContext();
+        VmwareHypervisorHost hyperHost = getHyperHost(context);
+
+        try {
+            VirtualMachineMO vmMo = hyperHost.findVmOnHyperHost(vmName);
+            if (vmMo != null) {
+                state = getVmState(vmMo);
+                if (state == State.Running) {
+                    synchronized (_vms) {
+                        _vms.put(vmName, State.Running);
+                    }
+                }
+                return new CheckVirtualMachineAnswer(cmd, state, vncPort);
+            } else {
+                s_logger.warn("Can not find vm " + vmName + " to execute CheckVirtualMachineCommand");
+                return new CheckVirtualMachineAnswer(cmd, state, vncPort);
+            }
+
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+            s_logger.error("Unexpected exception: " + VmwareHelper.getExceptionMessage(e));
+
+            return new CheckVirtualMachineAnswer(cmd, state, vncPort);
+        }
+    }
+
+    protected Answer execute(PrepareForMigrationCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource PrepareForMigrationCommand: " + _gson.toJson(cmd));
+        }
+
+        VirtualMachineTO vm = cmd.getVirtualMachine();
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Preparing host for migrating " + vm);
+        }
+
+        final String vmName = vm.getName();
+        try {
+            VmwareHypervisorHost hyperHost = getHyperHost(getServiceContext());
+
+            // find VM through datacenter (VM is not at the target host yet)
+            VirtualMachineMO vmMo = hyperHost.findVmOnPeerHyperHost(vmName);
+            if (vmMo == null) {
+                String msg = "VM " + vmName + " does not exist in VMware datacenter";
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+
+            NicTO[] nics = vm.getNics();
+            for (NicTO nic : nics) {
+                // prepare network on the host
+                prepareNetworkFromNicInfo(new HostMO(getServiceContext(), _morHyperHost), nic);
+            }
+
+            synchronized (_vms) {
+                _vms.put(vm.getName(), State.Migrating);
+            }
+            return new PrepareForMigrationAnswer(cmd);
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "Unexcpeted exception " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new PrepareForMigrationAnswer(cmd, msg);
+        }
+    }
+
+    protected Answer execute(MigrateCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource MigrateCommand: " + _gson.toJson(cmd));
+        }
+
+        final String vmName = cmd.getVmName();
+
+        State state = null;
+        synchronized (_vms) {
+            state = _vms.get(vmName);
+            _vms.put(vmName, State.Stopping);
+        }
+
+        try {
+            VmwareHypervisorHost hyperHost = getHyperHost(getServiceContext());
+            ManagedObjectReference morDc = hyperHost.getHyperHostDatacenter();
+
+            // find VM through datacenter (VM is not at the target host yet)
+            VirtualMachineMO vmMo = hyperHost.findVmOnPeerHyperHost(vmName);
+            if (vmMo == null) {
+                String msg = "VM " + vmName + " does not exist in VMware datacenter";
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+
+            VmwareHypervisorHost destHyperHost = getTargetHyperHost(new DatacenterMO(hyperHost.getContext(), morDc), cmd.getDestinationIp());
+
+            ManagedObjectReference morTargetPhysicalHost = destHyperHost.findMigrationTarget(vmMo);
+            if (morTargetPhysicalHost == null) {
+                throw new Exception("Unable to find a target capable physical host");
+            }
+
+            prepareNetworkForVmTargetHost(new HostMO(hyperHost.getContext(), morTargetPhysicalHost), vmMo);
+            if (!vmMo.migrate(destHyperHost.getHyperHostOwnerResourcePool(), morTargetPhysicalHost)) {
+                throw new Exception("Migration failed");
+            }
+
+            state = State.Stopping;
+            return new MigrateAnswer(cmd, true, "migration succeeded", null);
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "MigrationCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.warn(msg);
+            return new MigrateAnswer(cmd, false, msg, null);
+        } finally {
+            synchronized (_vms) {
+                _vms.put(vmName, state);
+            }
+        }
+    }
+
+    private VmwareHypervisorHost getTargetHyperHost(DatacenterMO dcMo, String destIp) throws Exception {
+    	
+        VmwareManager mgr = dcMo.getContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+    	
+        ObjectContent[] ocs = dcMo.getHostPropertiesOnDatacenterHostFolder(new String[] { "name", "parent" });
+        if (ocs != null && ocs.length > 0) {
+            for (ObjectContent oc : ocs) {
+                HostMO hostMo = new HostMO(dcMo.getContext(), oc.getObj());
+                VmwareHypervisorHostNetworkSummary netSummary = hostMo.getHyperHostNetworkSummary(mgr.getManagementPortGroupByHost(hostMo));
+                if (destIp.equalsIgnoreCase(netSummary.getHostIp())) {
+                    return new HostMO(dcMo.getContext(), oc.getObj());
+                }
+            }
+        }
+
+        throw new Exception("Unable to locate dest host by " + destIp);
+    }
+
+    protected Answer execute(CreateStoragePoolCommand cmd) {
+        return new Answer(cmd, true, "success");
+    }
+
+    protected Answer execute(ModifyStoragePoolCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource ModifyStoragePoolCommand: " + _gson.toJson(cmd));
+        }
+
+        try {
+            VmwareHypervisorHost hyperHost = getHyperHost(getServiceContext());
+            StorageFilerTO pool = cmd.getPool();
+
+            if (pool.getType() != StoragePoolType.NetworkFilesystem && pool.getType() != StoragePoolType.VMFS) {
+                throw new Exception("Unsupported storage pool type " + pool.getType());
+            }
+
+            ManagedObjectReference morDatastore = hyperHost.mountDatastore(pool.getType() == StoragePoolType.VMFS, pool.getHost(), pool.getPort(), pool.getPath(), pool.getUuid());
+
+            assert (morDatastore != null);
+            DatastoreSummary summary = new DatastoreMO(getServiceContext(), morDatastore).getSummary();
+            long capacity = summary.getCapacity();
+            long available = summary.getFreeSpace();
+            Map<String, TemplateInfo> tInfo = new HashMap<String, TemplateInfo>();
+            ModifyStoragePoolAnswer answer = new ModifyStoragePoolAnswer(cmd, capacity, available, tInfo);
+            return answer;
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "ModifyStoragePoolCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new Answer(cmd, false, msg);
+        }
+    }
+
+    protected Answer execute(DeleteStoragePoolCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource DeleteStoragePoolCommand: " + _gson.toJson(cmd));
+        }
+
+        StorageFilerTO pool = cmd.getPool();
+        try {
+            VmwareHypervisorHost hyperHost = this.getHyperHost(getServiceContext());
+            hyperHost.unmountDatastore(pool.getUuid());
+            Answer answer = new Answer(cmd, true, "success");
+            return answer;
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "DeleteStoragePoolCommand (pool: " + pool.getHost() + ", path: " + pool.getPath() + ") failed due to " + VmwareHelper.getExceptionMessage(e);
+            return new Answer(cmd, false, msg);
+        }
+    }
+
+    protected Answer execute(AttachVolumeCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource AttachVolumeCommand: " + _gson.toJson(cmd));
+        }
+
+        /*
+         * AttachVolumeCommand { "attach":true,"vmName":"i-2-1-KY","pooltype":"NetworkFilesystem",
+         * "volumeFolder":"/export/home/kelven/vmware-test/primary", "volumePath":"uuid",
+         * "volumeName":"volume name","deviceId":1 }
+         */
+        try {
+            VmwareHypervisorHost hyperHost = getHyperHost(getServiceContext());
+            VirtualMachineMO vmMo = hyperHost.findVmOnHyperHost(cmd.getVmName());
+            if (vmMo == null) {
+                String msg = "Unable to find the VM to execute AttachVolumeCommand, vmName: " + cmd.getVmName();
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+
+            ManagedObjectReference morDs = hyperHost.findDatastore(cmd.getPoolUuid());
+            if (morDs == null) {
+                String msg = "Unable to find the mounted datastore to execute AttachVolumeCommand, vmName: " + cmd.getVmName();
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+
+            DatastoreMO dsMo = new DatastoreMO(getServiceContext(), morDs);
+            String datastoreVolumePath = String.format("[%s] %s.vmdk", dsMo.getName(), cmd.getVolumePath());
+
+            AttachVolumeAnswer answer = new AttachVolumeAnswer(cmd, cmd.getDeviceId());
+            if (cmd.getAttach()) {
+                vmMo.attachDisk(new String[] { datastoreVolumePath }, morDs);
+            } else {
+            	vmMo.removeAllSnapshots();
+                vmMo.detachDisk(datastoreVolumePath, false);
+            }
+
+            return answer;
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "AttachVolumeCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new AttachVolumeAnswer(cmd, msg);
+        }
+    }
+
+    protected Answer execute(AttachIsoCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource AttachIsoCommand: " + _gson.toJson(cmd));
+        }
+
+        try {
+            VmwareHypervisorHost hyperHost = getHyperHost(getServiceContext());
+            VirtualMachineMO vmMo = hyperHost.findVmOnHyperHost(cmd.getVmName());
+            if (vmMo == null) {
+                String msg = "Unable to find VM in vSphere to execute AttachIsoCommand, vmName: " + cmd.getVmName();
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+
+            String storeUrl = cmd.getStoreUrl();
+            if (storeUrl == null) {
+                if (!cmd.getIsoPath().equalsIgnoreCase("vmware-tools.iso")) {
+                    String msg = "ISO store root url is not found in AttachIsoCommand";
+                    s_logger.error(msg);
+                    throw new Exception(msg);
+                } else {
+                    if (cmd.isAttach()) {
+                        vmMo.mountToolsInstaller();
+                    } else {
+                        vmMo.unmountToolsInstaller();
+                    }
+
+                    return new Answer(cmd);
+                }
+            }
+
+            ManagedObjectReference morSecondaryDs = prepareSecondaryDatastoreOnHost(storeUrl);
+            String isoPath = cmd.getIsoPath();
+            if (!isoPath.startsWith(storeUrl)) {
+                assert (false);
+                String msg = "ISO path does not start with the secondary storage root";
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+
+            int isoNameStartPos = isoPath.lastIndexOf('/');
+            String isoFileName = isoPath.substring(isoNameStartPos + 1);
+            String isoStorePathFromRoot = isoPath.substring(storeUrl.length(), isoNameStartPos);
+
+            // TODO, check if iso is already attached, or if there is a previous
+            // attachment
+            String isoDatastorePath = String.format("[%s] %s%s", getSecondaryDatastoreUUID(storeUrl), isoStorePathFromRoot, isoFileName);
+
+            if (cmd.isAttach()) {
+                vmMo.attachIso(isoDatastorePath, morSecondaryDs, true, false);
+            } else {
+                vmMo.detachIso(isoDatastorePath);
+            }
+
+            return new Answer(cmd);
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            if(cmd.isAttach()) {
+	            String msg = "AttachIsoCommand(attach) failed due to " + VmwareHelper.getExceptionMessage(e);
+	            s_logger.error(msg);
+	            return new Answer(cmd, false, msg);
+            } else {
+	            String msg = "AttachIsoCommand(detach) failed due to " + VmwareHelper.getExceptionMessage(e);
+	            s_logger.warn(msg);
+	            s_logger.warn("For detachment failure, we will eventually continue on to allow deassociating it from CloudStack DB");
+	            return new Answer(cmd);
+            }
+        }
+    }
+
+    private synchronized ManagedObjectReference prepareSecondaryDatastoreOnHost(String storeUrl) throws Exception {
+        String storeName = getSecondaryDatastoreUUID(storeUrl);
+        URI uri = new URI(storeUrl);
+
+        VmwareHypervisorHost hyperHost = getHyperHost(getServiceContext());
+        ManagedObjectReference morDatastore = hyperHost.mountDatastore(false, uri.getHost(), 0, uri.getPath(), storeName);
+
+        if (morDatastore == null) {
+            throw new Exception("Unable to mount secondary storage on host. storeUrl: " + storeUrl);
+        }
+
+        return morDatastore;
+    }
+
+    private static String getSecondaryDatastoreUUID(String storeUrl) {
+        return UUID.nameUUIDFromBytes(storeUrl.getBytes()).toString();
+    }
+
+    protected Answer execute(ValidateSnapshotCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource ValidateSnapshotCommand: " + _gson.toJson(cmd));
+        }
+
+        // the command is no longer available
+        String expectedSnapshotBackupUuid = null;
+        String actualSnapshotBackupUuid = null;
+        String actualSnapshotUuid = null;
+        return new ValidateSnapshotAnswer(cmd, false, "ValidateSnapshotCommand is not supported for vmware yet", expectedSnapshotBackupUuid, actualSnapshotBackupUuid, actualSnapshotUuid);
+    }
+
+    protected Answer execute(ManageSnapshotCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource ManageSnapshotCommand: " + _gson.toJson(cmd));
+        }
+
+        long snapshotId = cmd.getSnapshotId();
+
+        /*
+         * "ManageSnapshotCommand",
+         * "{\"_commandSwitch\":\"-c\",\"_volumePath\":\"i-2-3-KY-ROOT\",\"_snapshotName\":\"i-2-3-KY_i-2-3-KY-ROOT_20101102203827\",\"_snapshotId\":1,\"_vmName\":\"i-2-3-KY\"}"
+         */
+        boolean success = false;
+        String cmdSwitch = cmd.getCommandSwitch();
+        String snapshotOp = "Unsupported snapshot command." + cmdSwitch;
+        if (cmdSwitch.equals(ManageSnapshotCommand.CREATE_SNAPSHOT)) {
+            snapshotOp = "create";
+        } else if (cmdSwitch.equals(ManageSnapshotCommand.DESTROY_SNAPSHOT)) {
+            snapshotOp = "destroy";
+        }
+
+        String details = "ManageSnapshotCommand operation: " + snapshotOp + " Failed for snapshotId: " + snapshotId;
+        String snapshotUUID = null;
+
+        try {
+            VmwareHypervisorHost hyperHost = getHyperHost(getServiceContext());
+            VirtualMachineMO vmMo = hyperHost.findVmOnHyperHost(cmd.getVmName());
+            if (vmMo == null) {
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug("Unable to find the owner VM for ManageSnapshotCommand on host " + hyperHost.getHyperHostName() + ", try within datacenter");
+                }
+
+                vmMo = hyperHost.findVmOnPeerHyperHost(cmd.getVmName());
+            }
+
+            if (vmMo == null) {
+                // when no vm instance attached fake as if snapshot is taken, and handle actual taking snapshot as part of BackupSnapshotCommand
+                snapshotUUID = UUID.randomUUID().toString();
+                success = true;
+                details = null;
+            } else {
+                if (cmdSwitch.equals(ManageSnapshotCommand.CREATE_SNAPSHOT)) {
+                    snapshotUUID = UUID.randomUUID().toString();
+                    if (!vmMo.createSnapshot(snapshotUUID, "Snapshot taken for " + cmd.getSnapshotName(), false, false)) {
+                        throw new Exception("Failed to take snapshot " + cmd.getSnapshotName() + " on vm: " + cmd.getVmName());
+                    }
+
+                    success = true;
+                    details = null;
+                } else if (cmd.getCommandSwitch().equals(ManageSnapshotCommand.DESTROY_SNAPSHOT)) {
+                    snapshotUUID = cmd.getSnapshotPath();
+
+                    if (!vmMo.removeSnapshot(snapshotUUID, false)) {
+                        throw new Exception("Failed to destroy snapshot: " + cmd.getSnapshotName());
+                    }
+
+                    success = true;
+                    details = null;
+                }                	
+            }
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            details = "ManageSnapshotCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(details);
+            return new ManageSnapshotAnswer(cmd, snapshotId, snapshotUUID, false, details);
+        }
+
+        return new ManageSnapshotAnswer(cmd, snapshotId, snapshotUUID, success, details);
+    }
+
+    protected Answer execute(BackupSnapshotCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource BackupSnapshotCommand: " + _gson.toJson(cmd));
+        }
+
+        try {
+            VmwareContext context = getServiceContext();
+            VmwareManager mgr = context.getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+
+            return mgr.getStorageManager().execute(this, cmd);
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String details = "BackupSnapshotCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(details);
+            return new BackupSnapshotAnswer(cmd, false, details, null, true);
+        }
+    }
+
+    protected Answer execute(DeleteSnapshotBackupCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource DeleteSnapshotBackupCommand: " + _gson.toJson(cmd));
+        }
+
+        try {
+            VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+            return mgr.getStorageManager().execute(this, cmd);
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String details = "DeleteSnapshotBackupCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(details);
+            return new DeleteSnapshotBackupAnswer(cmd, false, details);
+        }
+    }
+
+    protected Answer execute(CreateVolumeFromSnapshotCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource CreateVolumeFromSnapshotCommand: " + _gson.toJson(cmd));
+        }
+
+        String details = null;
+        boolean success = false;
+        String newVolumeName = UUID.randomUUID().toString();
+
+        try {
+            VmwareContext context = getServiceContext();
+            VmwareManager mgr = context.getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+            return mgr.getStorageManager().execute(this, cmd);
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            details = "CreateVolumeFromSnapshotCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(details);
+        }
+
+        return new CreateVolumeFromSnapshotAnswer(cmd, success, details, newVolumeName);
+    }
+
+    protected Answer execute(DeleteSnapshotsDirCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource DeleteSnapshotsDirCommand: " + _gson.toJson(cmd));
+        }
+
+        try {
+            VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+            return mgr.getStorageManager().execute(this, cmd);
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String details = "DeleteSnapshotDirCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(details);
+            return new Answer(cmd, false, details);
+        }
+    }
+
+    protected Answer execute(CreatePrivateTemplateFromVolumeCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource CreatePrivateTemplateFromVolumeCommand: " + _gson.toJson(cmd));
+        }
+
+        try {
+            VmwareContext context = getServiceContext();
+            VmwareManager mgr = context.getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+
+            return mgr.getStorageManager().execute(this, cmd);
+
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String details = "CreatePrivateTemplateFromVolumeCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(details);
+            return new CreatePrivateTemplateAnswer(cmd, false, details);
+        }
+    }
+
+    protected Answer execute(final UpgradeSnapshotCommand cmd) {
+        return new Answer(cmd, true, "success");
+    }
+
+    protected Answer execute(CreatePrivateTemplateFromSnapshotCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource CreatePrivateTemplateFromSnapshotCommand: " + _gson.toJson(cmd));
+        }
+
+        try {
+            VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+            return mgr.getStorageManager().execute(this, cmd);
+
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String details = "CreatePrivateTemplateFromSnapshotCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(details);
+            return new CreatePrivateTemplateAnswer(cmd, false, details);
+        }
+    }
+
+    protected Answer execute(GetStorageStatsCommand cmd) {
+        if (s_logger.isTraceEnabled()) {
+            s_logger.trace("Executing resource GetStorageStatsCommand: " + _gson.toJson(cmd));
+        }
+
+        try {
+            VmwareContext context = getServiceContext();
+            VmwareHypervisorHost hyperHost = getHyperHost(context);
+            ManagedObjectReference morDs = hyperHost.findDatastore(cmd.getStorageId());
+
+            if (morDs != null) {
+                DatastoreMO datastoreMo = new DatastoreMO(context, morDs);
+                DatastoreSummary summary = datastoreMo.getSummary();
+                assert (summary != null);
+
+                long capacity = summary.getCapacity();
+                long free = summary.getFreeSpace();
+                long used = capacity - free;
+
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug("Datastore summary info, storageId: " + cmd.getStorageId() + ", localPath: " + cmd.getLocalPath() + ", poolType: " + cmd.getPooltype() + ", capacity: " + capacity
+                            + ", free: " + free + ", used: " + used);
+                }
+
+                if (summary.getCapacity() <= 0) {
+                    s_logger.warn("Something is wrong with vSphere NFS datastore, rebooting ESX(ESXi) host should help");
+                }
+
+                return new GetStorageStatsAnswer(cmd, capacity, used);
+            } else {
+                String msg = "Could not find datastore for GetStorageStatsCommand storageId : " + cmd.getStorageId() + ", localPath: " + cmd.getLocalPath() + ", poolType: " + cmd.getPooltype();
+
+                s_logger.error(msg);
+                return new GetStorageStatsAnswer(cmd, msg);
+            }
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "Unable to execute GetStorageStatsCommand(storageId : " + cmd.getStorageId() + ", localPath: " + cmd.getLocalPath() + ", poolType: " + cmd.getPooltype() + ") due to "
+            + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new GetStorageStatsAnswer(cmd, msg);
+        }
+    }
+
+    protected Answer execute(GetVncPortCommand cmd) {
+        if (s_logger.isTraceEnabled()) {
+            s_logger.trace("Executing resource GetVncPortCommand: " + _gson.toJson(cmd));
+        }
+
+        try {
+            VmwareContext context = getServiceContext();
+            VmwareHypervisorHost hyperHost = getHyperHost(context);
+            assert(hyperHost instanceof HostMO);
+            VmwareManager mgr = context.getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+
+            VirtualMachineMO vmMo = hyperHost.findVmOnHyperHost(cmd.getName());
+            if (vmMo == null) {
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug("Unable to find the owner VM for GetVncPortCommand on host " + hyperHost.getHyperHostName() + ", try within datacenter");
+                }
+
+                vmMo = hyperHost.findVmOnPeerHyperHost(cmd.getName());
+
+                if (vmMo == null) {
+                    throw new Exception("Unable to find VM in vSphere, vm: " + cmd.getName());
+                }
+            }
+            
+            Pair<String, Integer> portInfo = vmMo.getVncPort(mgr.getManagementPortGroupByHost((HostMO)hyperHost));
+
+            if (s_logger.isTraceEnabled()) {
+                s_logger.trace("Found vnc port info. vm: " + cmd.getName() + " host: " + portInfo.first() + ", vnc port: " + portInfo.second());
+            }
+            return new GetVncPortAnswer(cmd, portInfo.first(), portInfo.second());
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "GetVncPortCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new GetVncPortAnswer(cmd, msg);
+        }
+    }
+
+    protected Answer execute(SetupCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource SetupCommand: " + _gson.toJson(cmd));
+        }
+
+        return new SetupAnswer(cmd, false);
+    }
+
+    protected Answer execute(MaintainCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource MaintainCommand: " + _gson.toJson(cmd));
+        }
+
+        return new MaintainAnswer(cmd, "Put host in maintaince");
+    }
+
+    protected Answer execute(PingTestCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource PingTestCommand: " + _gson.toJson(cmd));
+        }
+
+        return new Answer(cmd);
+    }
+
+    protected Answer execute(CheckOnHostCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource CheckOnHostCommand: " + _gson.toJson(cmd));
+        }
+
+        return new CheckOnHostAnswer(cmd, null, "Not Implmeneted");
+    }
+
+    protected Answer execute(ModifySshKeysCommand cmd) {
+        //do not log the command contents for this command. do NOT log the ssh keys
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource ModifySshKeysCommand.");
+        }
+
+        return new Answer(cmd);
+    }
+
+    protected Answer execute(PoolEjectCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource PoolEjectCommand: " + _gson.toJson(cmd));
+        }
+
+        return new Answer(cmd, false, "PoolEjectCommand is not available for vmware");
+    }
+
+    @Override
+    public PrimaryStorageDownloadAnswer execute(PrimaryStorageDownloadCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource PrimaryStorageDownloadCommand: " + _gson.toJson(cmd));
+        }
+
+        try {
+            VmwareContext context = getServiceContext();
+            VmwareManager mgr = context.getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+            return (PrimaryStorageDownloadAnswer) mgr.getStorageManager().execute(this, cmd);
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "PrimaryStorageDownloadCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new PrimaryStorageDownloadAnswer(msg);
+        }
+    }
+
+    @Override
+    public Answer execute(DestroyCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource DestroyCommand: " + _gson.toJson(cmd));
+        }
+
+        /*
+         * DestroyCommand content example
+         * 
+         * {"volume": {"id":5,"name":"Volume1", "mountPoint":"/export/home/kelven/vmware-test/primary",
+         * "path":"6bb8762f-c34c-453c-8e03-26cc246ceec4", "size":0,"type":"DATADISK","resourceType":
+         * "STORAGE_POOL","storagePoolType":"NetworkFilesystem", "poolId":0,"deviceId":0 } }
+         * 
+         * {"volume": {"id":1, "name":"i-2-1-KY-ROOT", "mountPoint":"/export/home/kelven/vmware-test/primary",
+         * "path":"i-2-1-KY-ROOT","size":0,"type":"ROOT", "resourceType":"STORAGE_POOL", "storagePoolType":"NetworkFilesystem",
+         * "poolId":0,"deviceId":0 } }
+         */
+
+        try {
+            VmwareContext context = getServiceContext();
+            VmwareHypervisorHost hyperHost = getHyperHost(context);
+            VolumeTO vol = cmd.getVolume();
+
+            ManagedObjectReference morDs = hyperHost.findDatastore(vol.getPoolUuid());
+            if (morDs == null) {
+                String msg = "Unable to find datastore based on volume mount point " + cmd.getVolume().getMountPoint();
+                s_logger.error(msg);
+                throw new Exception(msg);
+            }
+
+            DatastoreMO dsMo = new DatastoreMO(context, morDs);
+
+            ManagedObjectReference morDc = hyperHost.getHyperHostDatacenter();
+            ManagedObjectReference morCluster = hyperHost.getHyperHostCluster();
+            ClusterMO clusterMo = new ClusterMO(context, morCluster);
+            
+            if (cmd.getVolume().getType() == Volume.Type.ROOT) {
+                String vmName = cmd.getVmName();
+                if (vmName != null) {
+                    VirtualMachineMO vmMo = clusterMo.findVmOnHyperHost(vmName);
+                    if (vmMo != null) {
+                        if (s_logger.isInfoEnabled()) {
+                            s_logger.info("Destroy root volume and VM itself. vmName " + vmName);
+                        }
+
+                        HostMO hostMo = vmMo.getRunningHost();
+                        List<NetworkDetails> networks = vmMo.getNetworksWithDetails();
+                        
+                        // tear down all devices first before we destroy the VM to avoid accidently delete disk backing files
+                        vmMo.tearDownDevices(new Class<?>[] { VirtualDisk.class, VirtualEthernetCard.class });
+                        vmMo.destroy();
+                        
+                        for (NetworkDetails netDetails : networks) {
+                            if (netDetails.getGCTag() != null && netDetails.getGCTag().equalsIgnoreCase("true")) {
+                                if (netDetails.getVMMorsOnNetwork() == null || netDetails.getVMMorsOnNetwork().length == 1) {
+                                    cleanupNetwork(hostMo, netDetails);
+                                }
+                            }
+                        }
+                    } 
+                    
+                    if (s_logger.isInfoEnabled())
+                        s_logger.info("Destroy volume by original name: " + cmd.getVolume().getPath() + ".vmdk");
+                    dsMo.deleteFile(cmd.getVolume().getPath() + ".vmdk", morDc, true);
+                    return new Answer(cmd, true, "Success");
+                }
+
+                if (s_logger.isInfoEnabled()) {
+                    s_logger.info("Destroy root volume directly from datastore");
+                }
+            } else {
+            	// evitTemplate will be converted into DestroyCommand, test if we are running in this case
+                VirtualMachineMO vmMo = clusterMo.findVmOnHyperHost(cmd.getVolume().getPath());
+                if (vmMo != null) {
+                    if (s_logger.isInfoEnabled())
+                        s_logger.info("Destroy template volume " + cmd.getVolume().getPath());
+                	
+                	vmMo.destroy();
+                    return new Answer(cmd, true, "Success");
+                }
+            }
+
+            String chainInfo = cmd.getVolume().getChainInfo();
+            if (chainInfo != null && !chainInfo.isEmpty()) {
+                s_logger.info("Destroy volume by chain info: " + chainInfo);
+                String[] diskChain = _gson.fromJson(chainInfo, String[].class);
+
+                if (diskChain != null && diskChain.length > 0) {
+                    for (String backingName : diskChain) {
+                        if (s_logger.isInfoEnabled()) {
+                            s_logger.info("Delete volume backing file: " + backingName);
+                        }
+                        dsMo.deleteFile(backingName, morDc, true);
+                    }
+                } else {
+                    if (s_logger.isInfoEnabled()) {
+                        s_logger.info("Empty disk chain info, fall back to try to delete by original backing file name");
+                    }
+                    dsMo.deleteFile(cmd.getVolume().getPath() + ".vmdk", morDc, true);
+                }
+            } else {
+                if (s_logger.isInfoEnabled()) {
+                    s_logger.info("Destroy volume by original name: " + cmd.getVolume().getPath() + ".vmdk");
+                }
+                dsMo.deleteFile(cmd.getVolume().getPath() + ".vmdk", morDc, true);
+            }
+
+            return new Answer(cmd, true, "Success");
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "DestroyCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new Answer(cmd, false, msg);
+        }
+    }
+
+    private void cleanupNetwork(HostMO hostMo, NetworkDetails netDetails) {
+        // we will no longer cleanup VLAN networks in order to support native VMware HA
+        /*
+         * assert(netDetails.getName() != null); try { synchronized(this) { NetworkMO networkMo = new
+         * NetworkMO(hostMo.getContext(), netDetails.getNetworkMor()); ManagedObjectReference[] vms =
+         * networkMo.getVMsOnNetwork(); if(vms == null || vms.length == 0) { if(s_logger.isInfoEnabled()) {
+         * s_logger.info("Cleanup network as it is currently not in use: " + netDetails.getName()); }
+         * 
+         * hostMo.deletePortGroup(netDetails.getName()); } } } catch(Throwable e) {
+         * s_logger.warn("Unable to cleanup network due to exception, skip for next time"); }
+         */
+    }
+
+    @Override
+    public CopyVolumeAnswer execute(CopyVolumeCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource CopyVolumeCommand: " + _gson.toJson(cmd));
+        }
+
+        try {
+            VmwareContext context = getServiceContext();
+            VmwareManager mgr = context.getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+            return (CopyVolumeAnswer) mgr.getStorageManager().execute(this, cmd);
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "CopyVolumeCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new CopyVolumeAnswer(cmd, false, msg, null, null);
+        }
+    }
+
+    @Override
+    public synchronized CreateAnswer execute(CreateCommand cmd) {
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Executing resource CreateCommand: " + _gson.toJson(cmd));
+        }
+
+        StorageFilerTO pool = cmd.getPool();
+        DiskProfile dskch = cmd.getDiskCharacteristics();
+
+        try {
+            VmwareContext context = getServiceContext();
+            VmwareHypervisorHost hyperHost = getHyperHost(context);
+            DatacenterMO dcMo = new DatacenterMO(context, hyperHost.getHyperHostDatacenter());
+
+            VmwareManager vmwareMgr = context.getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+
+            ManagedObjectReference morDatastore = hyperHost.findDatastore(pool.getUuid());
+            if (morDatastore == null) {
+                throw new Exception("Unable to find datastore in vSphere");
+            }
+            DatastoreMO dsMo = new DatastoreMO(context, morDatastore);
+
+            if (cmd.getDiskCharacteristics().getType() == Volume.Type.ROOT) {
+                if (cmd.getTemplateUrl() == null) {
+                    // create a root volume for blank VM
+                    String dummyVmName = getWorkerName(context, cmd);
+                    VirtualMachineMO vmMo = null;
+
+                    try {
+                        vmMo = prepareVolumeHostDummyVm(hyperHost, dsMo, dummyVmName);
+                        if (vmMo == null) {
+                            throw new Exception("Unable to create a dummy VM for volume creation");
+                        }
+
+                        String volumeDatastorePath = String.format("[%s] %s.vmdk", dsMo.getName(), cmd.getDiskCharacteristics().getName());
+                        synchronized (this) {
+                            s_logger.info("Delete file if exists in datastore to clear the way for creating the volume. file: " + volumeDatastorePath);
+                            VmwareHelper.deleteVolumeVmdkFiles(dsMo, cmd.getDiskCharacteristics().getName(), dcMo);
+                            vmMo.createDisk(volumeDatastorePath, (int) (cmd.getDiskCharacteristics().getSize() / (1024L * 1024L)), morDatastore, -1);
+                            vmMo.detachDisk(volumeDatastorePath, false);
+                        }
+
+                        VolumeTO vol = new VolumeTO(cmd.getVolumeId(), dskch.getType(), pool.getType(), pool.getUuid(), cmd.getDiskCharacteristics().getName(), pool.getPath(), cmd
+                                .getDiskCharacteristics().getName(), cmd.getDiskCharacteristics().getSize(), null);
+                        return new CreateAnswer(cmd, vol);
+                    } finally {
+                        vmMo.detachAllDisks();
+
+                        s_logger.info("Destroy dummy VM after volume creation");
+                        vmMo.destroy();
+                    }
+                } else {
+                    VirtualMachineMO vmTemplate = VmwareHelper.pickOneVmOnRunningHost(dcMo.findVmByNameAndLabel(cmd.getTemplateUrl()), true);
+                    if (vmTemplate == null) {
+                        s_logger.warn("Template host in vSphere is not in connected state, request template reload");
+                        return new CreateAnswer(cmd, "Template host in vSphere is not in connected state, request template reload", true);
+                    }
+                    
+                    ManagedObjectReference morPool = hyperHost.getHyperHostOwnerResourcePool();
+                    ManagedObjectReference morCluster = hyperHost.getHyperHostCluster();
+                    ManagedObjectReference morBaseSnapshot = vmTemplate.getSnapshotMor("cloud.template.base");
+                    if (morBaseSnapshot == null) {
+                        String msg = "Unable to find template base snapshot, invalid template";
+                        s_logger.error(msg);
+                        throw new Exception(msg);
+                    }
+
+                    String name = cmd.getDiskCharacteristics().getName();
+                    if(dsMo.folderExists(String.format("[%s]", dsMo.getName()), name))
+                    	dsMo.deleteFile(String.format("[%s] %s/", dsMo.getName(), name), dcMo.getMor(), false);
+
+                    s_logger.info("create linked clone from template");
+                    if (!vmTemplate.createLinkedClone(name, morBaseSnapshot, dcMo.getVmFolder(), morPool, morDatastore)) {
+                        String msg = "Unable to clone from the template";
+                        s_logger.error(msg);
+                        throw new Exception(msg);
+                    }
+
+                    VirtualMachineMO vmMo = new ClusterMO(context, morCluster).findVmOnHyperHost(name);
+                    assert (vmMo != null);
+
+                    // we can't rely on un-offical API (VirtualMachineMO.moveAllVmDiskFiles() any more, use hard-coded disk names that we know
+                    // to move files
+                    s_logger.info("Move volume out of volume-wrapper VM ");
+                    dsMo.moveDatastoreFile(String.format("[%s] %s/%s.vmdk", dsMo.getName(), name, name), 
+                    	dcMo.getMor(), dsMo.getMor(), 
+                    	String.format("[%s] %s.vmdk", dsMo.getName(), name), dcMo.getMor(), true);
+                    
+                    dsMo.moveDatastoreFile(String.format("[%s] %s/%s-delta.vmdk", dsMo.getName(), name, name), 
+                        	dcMo.getMor(), dsMo.getMor(), 
+                        	String.format("[%s] %s-delta.vmdk", dsMo.getName(), name), dcMo.getMor(), true);
+
+                    s_logger.info("detach disks from volume-wrapper VM " + name);
+                    vmMo.detachAllDisks();
+
+                    s_logger.info("destroy volume-wrapper VM " + name);
+                    vmMo.destroy();
+
+                    String srcFile = String.format("[%s] %s/", dsMo.getName(), name);
+                    dsMo.deleteFile(srcFile, dcMo.getMor(), true);
+
+                    VolumeTO vol = new VolumeTO(cmd.getVolumeId(), dskch.getType(), pool.getType(), pool.getUuid(), name, pool.getPath(), name, cmd.getDiskCharacteristics().getSize(), null);
+                    return new CreateAnswer(cmd, vol);
+                }
+            } else {
+                // create data volume
+                VirtualMachineMO vmMo = null;
+                String volumeUuid = UUID.randomUUID().toString().replace("-", "");
+                String volumeDatastorePath = String.format("[%s] %s.vmdk", dsMo.getName(), volumeUuid);
+                String dummyVmName = getWorkerName(context, cmd);
+                try {
+                    vmMo = prepareVolumeHostDummyVm(hyperHost, dsMo, dummyVmName);
+                    if (vmMo == null) {
+                        throw new Exception("Unable to create a dummy VM for volume creation");
+                    }
+
+                    synchronized (this) {
+                        // s_logger.info("Delete file if exists in datastore to clear the way for creating the volume. file: " + volumeDatastorePath);
+                        VmwareHelper.deleteVolumeVmdkFiles(dsMo, volumeUuid.toString(), dcMo);
+
+                        vmMo.createDisk(volumeDatastorePath, (int) (cmd.getDiskCharacteristics().getSize() / (1024L * 1024L)), morDatastore, vmMo.getScsiDeviceControllerKey());
+                        vmMo.detachDisk(volumeDatastorePath, false);
+                    }
+
+                    VolumeTO vol = new VolumeTO(cmd.getVolumeId(), dskch.getType(), pool.getType(), pool.getUuid(), cmd.getDiskCharacteristics().getName(), pool.getPath(), volumeUuid, cmd
+                            .getDiskCharacteristics().getSize(), null);
+                    return new CreateAnswer(cmd, vol);
+                } finally {
+                    s_logger.info("Destroy dummy VM after volume creation");
+                    vmMo.detachAllDisks();
+                    vmMo.destroy();
+                }
+            }
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            String msg = "CreateCommand failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            return new CreateAnswer(cmd, new Exception(e));
+        }
+    }
+
+    protected VirtualMachineMO prepareVolumeHostDummyVm(VmwareHypervisorHost hyperHost, DatastoreMO dsMo, String vmName) throws Exception {
+        assert (hyperHost != null);
+
+        VirtualMachineMO vmMo = null;
+        VirtualMachineConfigSpec vmConfig = new VirtualMachineConfigSpec();
+        vmConfig.setName(vmName);
+        vmConfig.setMemoryMB((long) 4); // vmware request minimum of 4 MB
+        vmConfig.setNumCPUs(1);
+        vmConfig.setGuestId(VirtualMachineGuestOsIdentifier._otherGuest.toString());
+        VirtualMachineFileInfo fileInfo = new VirtualMachineFileInfo();
+        fileInfo.setVmPathName(String.format("[%s]", dsMo.getName()));
+        vmConfig.setFiles(fileInfo);
+
+        // Scsi controller
+        VirtualLsiLogicController scsiController = new VirtualLsiLogicController();
+        scsiController.setSharedBus(VirtualSCSISharing.noSharing);
+        scsiController.setBusNumber(0);
+        scsiController.setKey(1);
+        VirtualDeviceConfigSpec scsiControllerSpec = new VirtualDeviceConfigSpec();
+        scsiControllerSpec.setDevice(scsiController);
+        scsiControllerSpec.setOperation(VirtualDeviceConfigSpecOperation.add);
+
+        vmConfig.setDeviceChange(new VirtualDeviceConfigSpec[] { scsiControllerSpec });
+        hyperHost.createVm(vmConfig);
+        vmMo = hyperHost.findVmOnHyperHost(vmName);
+        return vmMo;
+    }
+
+    @Override
+    public void disconnected() {
+    }
+
+    @Override
+    public IAgentControl getAgentControl() {
+        return null;
+    }
+
+    @Override
+    public PingCommand getCurrentStatus(long id) {
+        HashMap<String, State> newStates = sync();
+        if (newStates == null) {
+            return null;
+        }
+
+        try {
+            // take the chance to do left-over dummy VM cleanup from previous run
+            VmwareContext context = getServiceContext();
+            VmwareHypervisorHost hyperHost = getHyperHost(context);
+            VmwareManager mgr = hyperHost.getContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+            
+            if(hyperHost.isHyperHostConnected()) {
+            	mgr.gcLeftOverVMs(context);
+            } else {
+                s_logger.error("Host is no longer connected.");
+            	return null;
+            }
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+                return null;
+            }
+        }
+
+        return new PingRoutingCommand(getType(), id, newStates);
+    }
+
+    @Override
+    public Type getType() {
+        return com.cloud.host.Host.Type.Routing;
+    }
+
+    @Override
+    public StartupCommand[] initialize() {
+        StartupRoutingCommand cmd = new StartupRoutingCommand();
+        fillHostInfo(cmd);
+
+        Map<String, State> changes = null;
+        synchronized (_vms) {
+            _vms.clear();
+            changes = sync();
+        }
+
+        cmd.setHypervisorType(HypervisorType.VMware);
+        cmd.setStateChanges(changes);
+        cmd.setCluster(_cluster);
+
+        List<StartupStorageCommand> storageCmds = initializeLocalStorage();
+        StartupCommand[] answerCmds = new StartupCommand[1 + storageCmds.size()];
+        answerCmds[0] = cmd;
+        for (int i = 0; i < storageCmds.size(); i++) {
+            answerCmds[i + 1] = storageCmds.get(i);
+        }
+
+        return answerCmds;
+    }
+
+    private List<StartupStorageCommand> initializeLocalStorage() {
+        List<StartupStorageCommand> storageCmds = new ArrayList<StartupStorageCommand>();
+        VmwareContext context = getServiceContext();
+
+        try {
+            VmwareHypervisorHost hyperHost = getHyperHost(context);
+            if (hyperHost instanceof HostMO) {
+                HostMO hostMo = (HostMO) hyperHost;
+
+                List<Pair<ManagedObjectReference, String>> dsList = hostMo.getLocalDatastoreOnHost();
+                for (Pair<ManagedObjectReference, String> dsPair : dsList) {
+                    DatastoreMO dsMo = new DatastoreMO(context, dsPair.first());
+
+                    String poolUuid = dsMo.getCustomFieldValue(CustomFieldConstants.CLOUD_UUID);
+                    if (poolUuid == null || poolUuid.isEmpty()) {
+                        poolUuid = UUID.randomUUID().toString();
+                        dsMo.setCustomFieldValue(CustomFieldConstants.CLOUD_UUID, poolUuid);
+                    }
+
+                    DatastoreSummary dsSummary = dsMo.getSummary();
+                    String address = hostMo.getHostName();
+                    StoragePoolInfo pInfo = new StoragePoolInfo(poolUuid, address, "", "", StoragePoolType.LVM, dsSummary.getCapacity(), dsSummary.getFreeSpace());
+                    StartupStorageCommand cmd = new StartupStorageCommand();
+                    cmd.setName(poolUuid + "@" + hostMo.getHostName());
+                    cmd.setPoolInfo(pInfo);
+                    cmd.setGuid(poolUuid); // give storage host the same UUID as the local storage pool itself
+                    cmd.setResourceType(Storage.StorageResourceType.STORAGE_POOL);
+                    cmd.setDataCenter(_dcId);
+                    cmd.setPod(_pod);
+                    cmd.setCluster(_cluster);
+
+                    s_logger.info("Add local storage startup command: " + _gson.toJson(cmd));
+                    storageCmds.add(cmd);
+                }
+
+            } else {
+                s_logger.info("Cluster host does not support local storage, skip it");
+            }
+        } catch (Exception e) {
+            String msg = "initializing local storage failed due to : " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            invalidateServiceContext();
+            throw new CloudRuntimeException(msg);
+        }
+
+        return storageCmds;
+    }
+
+    protected void fillHostInfo(StartupRoutingCommand cmd) {
+        VmwareContext serviceContext = getServiceContext();
+        Map<String, String> details = cmd.getHostDetails();
+        if (details == null) {
+            details = new HashMap<String, String>();
+        }
+
+        try {
+            fillHostHardwareInfo(serviceContext, cmd);
+            fillHostNetworkInfo(serviceContext, cmd);
+            fillHostDetailsInfo(serviceContext, details);
+        } catch (RuntimeFault e) {
+            s_logger.error("RuntimeFault while retrieving host info: " + e.toString(), e);
+            throw new CloudRuntimeException("RuntimeFault while retrieving host info");
+        } catch (RemoteException e) {
+            s_logger.error("RemoteException while retrieving host info: " + e.toString(), e);
+            invalidateServiceContext();
+            throw new CloudRuntimeException("RemoteException while retrieving host info");
+        } catch (Exception e) {
+            s_logger.error("Exception while retrieving host info: " + e.toString(), e);
+            invalidateServiceContext();
+            throw new CloudRuntimeException("Exception while retrieving host info: " + e.toString());
+        }
+
+        cmd.setHostDetails(details);
+        cmd.setName(_url);
+        cmd.setGuid(_guid);
+        cmd.setDataCenter(_dcId);
+        cmd.setPod(_pod);
+        cmd.setCluster(_cluster);
+        cmd.setVersion(VmwareResource.class.getPackage().getImplementationVersion());
+    }
+
+    private void fillHostHardwareInfo(VmwareContext serviceContext, StartupRoutingCommand cmd) throws RuntimeFault, RemoteException, Exception {
+
+        VmwareHypervisorHost hyperHost = getHyperHost(getServiceContext());
+        VmwareHypervisorHostResourceSummary summary = hyperHost.getHyperHostResourceSummary();
+
+        if (s_logger.isInfoEnabled()) {
+            s_logger.info("Startup report on host hardware info. " + _gson.toJson(summary));
+        }
+
+        cmd.setCaps("hvm");
+        cmd.setDom0MinMemory(0);
+        cmd.setSpeed(summary.getCpuSpeed());
+        cmd.setCpus((int) summary.getCpuCount());
+        cmd.setMemory(summary.getMemoryBytes());
+    }
+
+    private void fillHostNetworkInfo(VmwareContext serviceContext, StartupRoutingCommand cmd) throws RuntimeFault, RemoteException {
+
+        try {
+            VmwareHypervisorHost hyperHost = getHyperHost(getServiceContext());
+            
+            assert(hyperHost instanceof HostMO);
+            VmwareManager mgr = hyperHost.getContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+                        
+            VmwareHypervisorHostNetworkSummary summary = hyperHost.getHyperHostNetworkSummary(mgr.getManagementPortGroupByHost((HostMO)hyperHost));
+            if (summary == null) {
+                throw new Exception("No ESX(i) host found");
+            }
+
+            if (s_logger.isInfoEnabled()) {
+                s_logger.info("Startup report on host network info. " + _gson.toJson(summary));
+            }
+
+            cmd.setPrivateIpAddress(summary.getHostIp());
+            cmd.setPrivateNetmask(summary.getHostNetmask());
+            cmd.setPrivateMacAddress(summary.getHostMacAddress());
+
+            cmd.setStorageIpAddress(summary.getHostIp());
+            cmd.setStorageNetmask(summary.getHostNetmask());
+            cmd.setStorageMacAddress(summary.getHostMacAddress());
+
+        } catch (Throwable e) {
+            String msg = "querying host network info failed due to " + VmwareHelper.getExceptionMessage(e);
+            s_logger.error(msg);
+            throw new CloudRuntimeException(msg);
+        }
+    }
+
+    private void fillHostDetailsInfo(VmwareContext serviceContext, Map<String, String> details) throws Exception {
+        VmwareHypervisorHost hyperHost = getHyperHost(getServiceContext());
+
+        ClusterDasConfigInfo dasConfig = hyperHost.getDasConfig();
+        if (dasConfig != null && dasConfig.getEnabled() != null && dasConfig.getEnabled().booleanValue()) {
+            details.put("NativeHA", "true");
+        }
+    }
+
+    protected HashMap<String, State> sync() {
+        HashMap<String, State> changes = new HashMap<String, State>();
+        HashMap<String, State> oldStates = null;
+
+        try {
+            synchronized (_vms) {
+                HashMap<String, State> newStates = getVmStates();
+                oldStates = new HashMap<String, State>(_vms.size());
+                oldStates.putAll(_vms);
+
+                for (final Map.Entry<String, State> entry : newStates.entrySet()) {
+                    final String vm = entry.getKey();
+
+                    State newState = entry.getValue();
+                    final State oldState = oldStates.remove(vm);
+
+                    if (s_logger.isTraceEnabled()) {
+                        s_logger.trace("VM " + vm + ": vSphere has state " + newState + " and we have state " + (oldState != null ? oldState.toString() : "null"));
+                    }
+
+                    if (vm.startsWith("migrating")) {
+                        s_logger.debug("Migrating detected.  Skipping");
+                        continue;
+                    }
+
+                    if (oldState == null) {
+                        _vms.put(vm, newState);
+                        s_logger.debug("Detecting a new state but couldn't find a old state so adding it to the changes: " + vm);
+                        changes.put(vm, newState);
+                    } else if (oldState == State.Starting) {
+                        if (newState == State.Running) {
+                            _vms.put(vm, newState);
+                        } else if (newState == State.Stopped) {
+                            s_logger.debug("Ignoring vm " + vm + " because of a lag in starting the vm.");
+                        }
+                    } else if (oldState == State.Migrating) {
+                        if (newState == State.Running) {
+                            s_logger.debug("Detected that an migrating VM is now running: " + vm);
+                            _vms.put(vm, newState);
+                        }
+                    } else if (oldState == State.Stopping) {
+                        if (newState == State.Stopped) {
+                            _vms.put(vm, newState);
+                        } else if (newState == State.Running) {
+                            s_logger.debug("Ignoring vm " + vm + " because of a lag in stopping the vm. ");
+                        }
+                    } else if (oldState != newState) {
+                        _vms.put(vm, newState);
+                        if (newState == State.Stopped) {
+                            /*
+                             * if (_vmsKilled.remove(vm)) { s_logger.debug("VM " + vm + " has been killed for storage. ");
+                             * newState = State.Error; }
+                             */
+                        }
+                        changes.put(vm, newState);
+                    }
+                }
+
+                for (final Map.Entry<String, State> entry : oldStates.entrySet()) {
+                    final String vm = entry.getKey();
+                    final State oldState = entry.getValue();
+
+                    if (isVmInCluster(vm)) {
+                        if (s_logger.isDebugEnabled()) {
+                            s_logger.debug("VM " + vm + " is now missing from host report but we detected that it might be migrated to other host by vCenter");
+                        }
+                        _vms.remove(vm);
+                        continue;
+                    }
+
+                    if (s_logger.isDebugEnabled()) {
+                        s_logger.debug("VM " + vm + " is now missing from host report");
+                    }
+
+                    if (oldState == State.Stopping) {
+                        s_logger.debug("Ignoring VM " + vm + " in transition state stopping.");
+                        _vms.remove(vm);
+                    } else if (oldState == State.Starting) {
+                        s_logger.debug("Ignoring VM " + vm + " in transition state starting.");
+                    } else if (oldState == State.Stopped) {
+                        _vms.remove(vm);
+                    } else if (oldState == State.Migrating) {
+                        s_logger.debug("Ignoring VM " + vm + " in migrating state.");
+                    } else {
+                        State state = State.Stopped;
+                        changes.put(entry.getKey(), state);
+                    }
+                }
+            }
+        } catch (Throwable e) {
+            if (e instanceof RemoteException) {
+                s_logger.warn("Encounter remote exception to vCenter, invalidate VMware session context");
+                invalidateServiceContext();
+            }
+
+            s_logger.error("Unable to perform sync information collection process at this point due to " + VmwareHelper.getExceptionMessage(e));
+            return null;
+        }
+        return changes;
+    }
+
+    private boolean isVmInCluster(String vmName) throws Exception {
+        VmwareHypervisorHost hyperHost = getHyperHost(getServiceContext());
+
+        return hyperHost.findVmOnPeerHyperHost(vmName) != null;
+    }
+
+    protected OptionValue[] configureVnc(OptionValue[] optionsToMerge, VmwareHypervisorHost hyperHost, String vmName, 
+    	String vncPassword, String keyboardLayout) throws Exception {
+    	
+        VirtualMachineMO vmMo = hyperHost.findVmOnHyperHost(vmName);
+
+        VmwareManager mgr = hyperHost.getContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+        if(!mgr.beginExclusiveOperation(600))
+        	throw new Exception("Unable to begin exclusive operation, lock time out");
+        
+        try {
+	        int maxVncPorts = 64;
+	        int vncPort = 0;
+	        Random random = new Random();
+	
+	        HostMO vmOwnerHost = vmMo.getRunningHost();
+	
+	        ManagedObjectReference morParent = vmOwnerHost.getParentMor();
+	        HashMap<String, Integer> portInfo;
+	        if(morParent.getType().equalsIgnoreCase("ClusterComputeResource")) {
+	        	ClusterMO clusterMo = new ClusterMO(vmOwnerHost.getContext(), morParent);
+	        	portInfo = clusterMo.getVmVncPortsOnCluster();
+	        } else {
+	        	portInfo = vmOwnerHost.getVmVncPortsOnHost();
+	        }
+	        
+	        // allocate first at 5900 - 5964 range
+	        Collection<Integer> existingPorts = portInfo.values();
+	        int val = random.nextInt(maxVncPorts);
+	        int startVal = val;
+	        do {
+	            if (!existingPorts.contains(5900 + val)) {
+	                vncPort = 5900 + val;
+	                break;
+	            }
+	
+	            val = (++val) % maxVncPorts;
+	        } while (val != startVal);
+	        
+	        if(vncPort == 0) {
+	            s_logger.info("we've run out of range for ports between 5900-5964 for the cluster, we will try port range at 59000-60000");
+
+	            Pair<Integer, Integer> additionalRange = mgr.getAddiionalVncPortRange();
+	            maxVncPorts = additionalRange.second();
+	            val = random.nextInt(maxVncPorts);
+	            startVal = val;
+	            do {
+	                if (!existingPorts.contains(additionalRange.first() + val)) {
+	                    vncPort = additionalRange.first() + val;
+	                    break;
+	                }
+	
+	                val = (++val) % maxVncPorts;
+	            } while (val != startVal);
+	        }
+	
+	        if (vncPort == 0) {
+	            throw new Exception("Unable to find an available VNC port on host");
+	        }
+	
+	        if (s_logger.isInfoEnabled()) {
+	            s_logger.info("Configure VNC port for VM " + vmName + ", port: " + vncPort + ", host: " + vmOwnerHost.getHyperHostName());
+	        }
+	
+	        return VmwareHelper.composeVncOptions(optionsToMerge, true, vncPassword, vncPort, keyboardLayout);
+        } finally {
+        	try {
+        		mgr.endExclusiveOperation();
+        	} catch(Throwable e) {
+        		assert(false);
+        		s_logger.error("Unexpected exception ", e);
+        	}
+        }
+    }
+
+    private VirtualMachineGuestOsIdentifier translateGuestOsIdentifier(String cpuArchitecture, String cloudGuestOs) {
+        if (cpuArchitecture == null) {
+            s_logger.warn("CPU arch is not set, default to i386. guest os: " + cloudGuestOs);
+            cpuArchitecture = "i386";
+        }
+
+        VirtualMachineGuestOsIdentifier identifier = VmwareGuestOsMapper.getGuestOsIdentifier(cloudGuestOs);
+        if (identifier != null) {
+            return identifier;
+        }
+
+        if (cpuArchitecture.equalsIgnoreCase("x86_64")) {
+            return VirtualMachineGuestOsIdentifier.otherGuest64;
+        }
+        return VirtualMachineGuestOsIdentifier.otherGuest;
+    }
+
+    private synchronized Pair<ManagedObjectReference, String> prepareGuestNetwork(HostMO hostMo, String vlanId, Integer networkRateMbps, Integer networkRateMulticastMbps)
+    	throws Exception {
+
+        return HypervisorHostHelper.prepareGuestNetwork(_guestNetworkVSwitchName, hostMo, vlanId, networkRateMbps, networkRateMulticastMbps,
+                _ops_timeout, true);
+    }
+
+    private synchronized Pair<ManagedObjectReference, String> preparePrivateNetwork(HostMO hostMo) throws Exception {
+        String managementPortGroupName = hostMo.getPortGroupNameByNicType(HostVirtualNicType.management);
+        assert(managementPortGroupName != null);
+        HostPortGroupSpec spec = hostMo.getPortGroupSpec(managementPortGroupName);
+        Integer vlanId = null;
+        if(spec.getVlanId() != 0) {
+            vlanId = spec.getVlanId();
+        }
+
+        return HypervisorHostHelper.preparePrivateNetwork(_privateNetworkVSwitchName, hostMo, vlanId, _ops_timeout);
+    }
+
+    private synchronized Pair<ManagedObjectReference, String> preparePublicNetwork(HostMO hostMo, String vlanId, Integer networkRateMbps, Integer networkRateMulticastMbps) throws Exception {
+
+        return HypervisorHostHelper.preparePublicNetwork(_publicNetworkVSwitchName, hostMo, vlanId, networkRateMbps, networkRateMulticastMbps, _ops_timeout, true);
+    }
+
+    private void prepareNetworkForVmTargetHost(HostMO hostMo, VirtualMachineMO vmMo) throws Exception {
+        assert (vmMo != null);
+        assert (hostMo != null);
+
+        String[] networks = vmMo.getNetworks();
+        for (String networkName : networks) {
+            HostPortGroupSpec portGroupSpec = hostMo.getHostPortGroupSpec(networkName);
+            HostNetworkTrafficShapingPolicy shapingPolicy = null;
+            if (portGroupSpec != null) {
+                shapingPolicy = portGroupSpec.getPolicy().getShapingPolicy();
+            }
+
+            if (networkName.startsWith("cloud.private")) {
+                preparePrivateNetwork(hostMo);
+            } else if (networkName.startsWith("cloud.public")) {
+                String[] tokens = networkName.split("\\.");
+                if (tokens.length == 3) {
+                    Integer networkRateMbps = null;
+                    if (shapingPolicy != null && shapingPolicy.getEnabled() != null && shapingPolicy.getEnabled().booleanValue()) {
+                        networkRateMbps = (int) (shapingPolicy.getPeakBandwidth().longValue() / (1024 * 1024));
+                    }
+
+                    preparePublicNetwork(hostMo, tokens[2], networkRateMbps, null);
+                } else {
+                    s_logger.info("Skip suspecious cloud network " + networkName);
+                }
+            } else if (networkName.startsWith("cloud.guest")) {
+                String[] tokens = networkName.split("\\.");
+                if (tokens.length >= 3) {
+                    Integer networkRateMbps = null;
+                    if (shapingPolicy != null && shapingPolicy.getEnabled() != null && shapingPolicy.getEnabled().booleanValue()) {
+                        networkRateMbps = (int) (shapingPolicy.getPeakBandwidth().longValue() / (1024 * 1024));
+                    }
+
+                    prepareGuestNetwork(hostMo, tokens[2], networkRateMbps, null);
+                } else {
+                    s_logger.info("Skip suspecious cloud network " + networkName);
+                }
+            } else {
+                s_logger.info("Skip non-cloud network " + networkName + " when preparing target host");
+            }
+        }
+    }
+
+    private HashMap<String, State> getVmStates() throws Exception {
+        VmwareHypervisorHost hyperHost = getHyperHost(getServiceContext());
+        ObjectContent[] ocs = hyperHost.getVmPropertiesOnHyperHost(new String[] { "name", "runtime.powerState", "config.template" });
+
+        HashMap<String, State> newStates = new HashMap<String, State>();
+        if (ocs != null && ocs.length > 0) {
+            for (ObjectContent oc : ocs) {
+                DynamicProperty[] objProps = oc.getPropSet();
+                if (objProps != null) {
+
+                    boolean isTemplate = false;
+                    String name = null;
+                    VirtualMachinePowerState powerState = VirtualMachinePowerState.poweredOff;
+                    for (DynamicProperty objProp : objProps) {
+                        if (objProp.getName().equals("config.template")) {
+                            if (objProp.getVal().toString().equalsIgnoreCase("true")) {
+                                isTemplate = true;
+                            }
+                        } else if (objProp.getName().equals("name")) {
+                            name = (String) objProp.getVal();
+                        } else if (objProp.getName().equals("runtime.powerState")) {
+                            powerState = (VirtualMachinePowerState) objProp.getVal();
+                        } else {
+                            assert (false);
+                        }
+                    }
+
+                    if (!isTemplate) {
+                        newStates.put(name, convertState(powerState));
+                    }
+                }
+            }
+        }
+        return newStates;
+    }
+
+    private HashMap<String, VmStatsEntry> getVmStats(List<String> vmNames) throws Exception {
+        VmwareHypervisorHost hyperHost = getHyperHost(getServiceContext());
+        HashMap<String, VmStatsEntry> vmResponseMap = new HashMap<String, VmStatsEntry>();
+        ManagedObjectReference perfMgr = getServiceContext().getServiceConnection().getServiceContent().getPerfManager();
+        VimPortType service = getServiceContext().getServiceConnection().getService();
+        PerfCounterInfo rxPerfCounterInfo = null;
+        PerfCounterInfo txPerfCounterInfo = null;
+
+        PerfCounterInfo[] cInfo = (PerfCounterInfo[]) getServiceContext().getServiceUtil().getDynamicProperty(perfMgr, "perfCounter");
+        for(int i=0; i<cInfo.length; ++i) {
+            if ("net".equalsIgnoreCase(cInfo[i].getGroupInfo().getKey())) { 
+                if ("transmitted".equalsIgnoreCase(cInfo[i].getNameInfo().getKey())) {
+                    txPerfCounterInfo = cInfo[i];
+                }
+                if ("received".equalsIgnoreCase(cInfo[i].getNameInfo().getKey())) {
+                    rxPerfCounterInfo = cInfo[i];
+                }
+            }
+        }
+
+        ObjectContent[] ocs = hyperHost.getVmPropertiesOnHyperHost(new String[] {"name", "summary.config.numCpu", "summary.quickStats.overallCpuUsage"});
+        if (ocs != null && ocs.length > 0) {
+            for (ObjectContent oc : ocs) {
+                DynamicProperty[] objProps = oc.getPropSet();
+                if (objProps != null) {
+                    String name = null;
+                    String numberCPUs = null;
+                    String maxCpuUsage = null;
+
+                    for (DynamicProperty objProp : objProps) {
+                        if (objProp.getName().equals("name")) {
+                        	name = objProp.getVal().toString();
+                        } else if (objProp.getName().equals("summary.config.numCpu")) {
+                        	numberCPUs = objProp.getVal().toString();
+                        } else if (objProp.getName().equals("summary.quickStats.overallCpuUsage")) {
+                        	maxCpuUsage =  objProp.getVal().toString();
+                        }
+                    }
+
+                    if (!vmNames.contains(name)) {
+                        continue;
+                    }
+
+                    ManagedObjectReference vmMor = hyperHost.findVmOnHyperHost(name).getMor();
+                    assert(vmMor!=null);
+
+                    ArrayList vmNetworkMetrics = new ArrayList();
+                    // get all the metrics from the available sample period 
+                    PerfMetricId[] perfMetrics = service.queryAvailablePerfMetric(perfMgr, vmMor, null, null, null);
+                    if(perfMetrics != null) {
+                       for(int index=0; index < perfMetrics.length; ++index) {
+                           if ( ((rxPerfCounterInfo != null) && (perfMetrics[index].getCounterId() == rxPerfCounterInfo.getKey())) || 
+                                   ((txPerfCounterInfo != null) && (perfMetrics[index].getCounterId() == txPerfCounterInfo.getKey())) ) {
+                               vmNetworkMetrics.add(perfMetrics[index]);
+                          }
+                       }
+                    }
+
+                    double networkReadKBs=0;
+                    double networkWriteKBs=0;
+                    long sampleDuration=0;
+
+                    if (vmNetworkMetrics.size() != 0) {
+                        PerfQuerySpec qSpec = new PerfQuerySpec();
+                        qSpec.setEntity(vmMor);
+                        PerfMetricId[] availableMetricIds = (PerfMetricId[]) vmNetworkMetrics.toArray(new PerfMetricId[0]);
+                        qSpec.setMetricId(availableMetricIds);
+                        PerfQuerySpec[] qSpecs = new PerfQuerySpec[] {qSpec};
+                        PerfEntityMetricBase[] values = service.queryPerf(perfMgr, qSpecs);
+
+                        for(int i=0; i<values.length; ++i) {
+                            PerfSampleInfo[]  infos = ((PerfEntityMetric)values[i]).getSampleInfo();
+                            sampleDuration = (infos[infos.length-1].getTimestamp().getTimeInMillis() - infos[0].getTimestamp().getTimeInMillis()) /1000;
+                            PerfMetricSeries[] vals = ((PerfEntityMetric)values[i]).getValue();
+                            for(int vi = 0; ((vals!= null) && (vi < vals.length)); ++vi){
+                                if(vals[vi] instanceof PerfMetricIntSeries) {
+                                    PerfMetricIntSeries val = (PerfMetricIntSeries)vals[vi];
+                                    long[] perfValues = val.getValue();
+                                    if (vals[vi].getId().getCounterId() == rxPerfCounterInfo.getKey()) {
+                                        networkReadKBs = sampleDuration * perfValues[3]; //get the average RX rate multiplied by sampled duration
+                                    }
+                                    if (vals[vi].getId().getCounterId() == txPerfCounterInfo.getKey()) {
+                                        networkWriteKBs = sampleDuration * perfValues[3];//get the average TX rate multiplied by sampled duration
+                                    }
+                               }
+                            }
+                         }
+                    }
+                    vmResponseMap.put(name, new VmStatsEntry(Integer.parseInt(maxCpuUsage), networkReadKBs, networkWriteKBs, Integer.parseInt(numberCPUs), "vm"));
+                }
+            }
+        }
+        return vmResponseMap;    	
+    }    
+
+    protected String networkUsage(final String privateIpAddress, final String option, final String ethName) {
+        String args = null;
+        if (option.equals("get")) {
+            args = "-g";
+        } else if (option.equals("create")) {
+            args = "-c";
+        } else if (option.equals("reset")) {
+            args = "-r";
+        } else if (option.equals("addVif")) {
+            args = "-a";
+            args += ethName;
+        } else if (option.equals("deleteVif")) {
+            args = "-d";
+            args += ethName;
+        }
+
+        try {
+            if (s_logger.isTraceEnabled()) {
+                s_logger.trace("Executing /root/netusage.sh " + args + " on DomR " + privateIpAddress);
+            }
+
+            VmwareManager mgr = getServiceContext().getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+
+            Pair<Boolean, String> result = SshHelper.sshExecute(privateIpAddress, DEFAULT_DOMR_SSHPORT, "root", mgr.getSystemVMKeyFile(), null, "/root/netusage.sh " + args);
+
+            if (!result.first()) {
+                return null;
+            }
+
+            return result.second();
+        } catch (Throwable e) {
+            s_logger.error("Unable to execute NetworkUsage command on DomR (" + privateIpAddress + "), domR may not be ready yet. failure due to " + VmwareHelper.getExceptionMessage(e));
+        }
+
+        return null;
+    }
+
+    private long[] getNetworkStats(String privateIP) {
+        String result = networkUsage(privateIP, "get", null);
+        long[] stats = new long[2];
+        if (result != null) {
+            try {
+                String[] splitResult = result.split(":");
+                int i = 0;
+                while (i < splitResult.length - 1) {
+                    stats[0] += (new Long(splitResult[i++])).longValue();
+                    stats[1] += (new Long(splitResult[i++])).longValue();
+                }
+            } catch (Throwable e) {
+                s_logger.warn("Unable to parse return from script return of network usage command: " + e.toString());
+            }
+        }
+        return stats;
+    }
+
+    protected String connect(final String vmName, final String ipAddress, final int port) {
+        long startTick = System.currentTimeMillis();
+
+        // wait until we have at least been waiting for _ops_timeout time or
+        // at least have tried _retry times, this is to coordinate with system
+        // VM patching/rebooting time that may need
+        int retry = _retry;
+        while (System.currentTimeMillis() - startTick <= _ops_timeout || --retry > 0) {
+            SocketChannel sch = null;
+            try {
+                s_logger.info("Trying to connect to " + ipAddress);
+                sch = SocketChannel.open();
+                sch.configureBlocking(true);
+                sch.socket().setSoTimeout(5000);
+
+                InetSocketAddress addr = new InetSocketAddress(ipAddress, port);
+                sch.connect(addr);
+                return null;
+            } catch (IOException e) {
+                s_logger.info("Could not connect to " + ipAddress + " due to " + e.toString());
+                if (e instanceof ConnectException) {
+                    // if connection is refused because of VM is being started,
+                    // we give it more sleep time
+                    // to avoid running out of retry quota too quickly
+                    try {
+                        Thread.sleep(5000);
+                    } catch (InterruptedException ex) {
+                    }
+                }
+            } finally {
+                if (sch != null) {
+                    try {
+                        sch.close();
+                    } catch (IOException e) {
+                    }
+                }
+            }
+
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException ex) {
+            }
+        }
+
+        s_logger.info("Unable to logon to " + ipAddress);
+
+        return "Unable to connect";
+    }
+
+    protected String connect(final String vmname, final String ipAddress) {
+        return connect(vmname, ipAddress, 3922);
+    }
+
+    private static State convertState(VirtualMachinePowerState powerState) {
+        return s_statesTable.get(powerState);
+    }
+
+    private static State getVmState(VirtualMachineMO vmMo) throws Exception {
+        VirtualMachineRuntimeInfo runtimeInfo = vmMo.getRuntimeInfo();
+        return convertState(runtimeInfo.getPowerState());
+    }
+
+    private static HostStatsEntry getHyperHostStats(VmwareHypervisorHost hyperHost) throws Exception {
+        ComputeResourceSummary hardwareSummary = hyperHost.getHyperHostHardwareSummary();
+        if(hardwareSummary == null)
+        	return null;
+        
+        HostStatsEntry entry = new HostStatsEntry();
+
+        entry.setEntityType("host");
+        double cpuUtilization = ((double) (hardwareSummary.getTotalCpu() - hardwareSummary.getEffectiveCpu()) / (double) hardwareSummary.getTotalCpu() * 100);
+        entry.setCpuUtilization(cpuUtilization);
+        entry.setTotalMemoryKBs(hardwareSummary.getTotalMemory() / 1024);
+        entry.setFreeMemoryKBs(hardwareSummary.getEffectiveMemory() * 1024);
+
+        return entry;
+    }
+    
+    private static String getRouterSshControlIp(NetworkElementCommand cmd) {
+    	String routerIp = cmd.getAccessDetail(NetworkElementCommand.ROUTER_IP);
+    	String routerGuestIp = cmd.getAccessDetail(NetworkElementCommand.ROUTER_GUEST_IP);
+    	String zoneNetworkType = cmd.getAccessDetail(NetworkElementCommand.ZONE_NETWORK_TYPE);
+    	
+    	if(routerGuestIp != null && zoneNetworkType != null && NetworkType.valueOf(zoneNetworkType) == NetworkType.Basic) {
+    		if(s_logger.isDebugEnabled())
+    			s_logger.debug("In Basic zone mode, use router's guest IP for SSH control. guest IP : " + routerGuestIp);
+    		
+    		return routerGuestIp;
+    	}
+    	
+		if(s_logger.isDebugEnabled())
+			s_logger.debug("Use router's private IP for SSH control. IP : " + routerIp);
+    	return routerIp;
+    }
+
+    @Override
+    public void setAgentControl(IAgentControl agentControl) {
+    }
+
+    @Override
+    public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
+        _name = name;
+
+        _url = (String) params.get("url");
+        _username = (String) params.get("username");
+        _password = (String) params.get("password");
+        _dcId = (String) params.get("zone");
+        _pod = (String) params.get("pod");
+        _cluster = (String) params.get("cluster");
+        _guid = (String) params.get("guid");
+        
+        String value = (String) params.get("cpu.overprovisioning.factor");
+        if(value != null)
+        	_cpuOverprovisioningFactor = Float.parseFloat(value);
+        
+        value = (String) params.get("vmware.reserve.cpu");
+        if(value != null && value.equalsIgnoreCase("true"))
+        	_reserveCpu = true;
+
+        String[] tokens = _guid.split("@");
+        _vCenterAddress = tokens[1];
+        _morHyperHost = new ManagedObjectReference();
+        String[] hostTokens = tokens[0].split(":");
+        _morHyperHost.setType(hostTokens[0]);
+        _morHyperHost.set_value(hostTokens[1]);
+        
+        VmwareContext context = getServiceContext();
+        try {
+            VmwareManager mgr = context.getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+            mgr.setupResourceStartupParams(params);
+
+            CustomFieldsManagerMO cfmMo = new CustomFieldsManagerMO(context, context.getServiceContent().getCustomFieldsManager());
+            cfmMo.ensureCustomFieldDef("Datastore", CustomFieldConstants.CLOUD_UUID);
+            cfmMo.ensureCustomFieldDef("Network", CustomFieldConstants.CLOUD_GC);
+            cfmMo.ensureCustomFieldDef("VirtualMachine", CustomFieldConstants.CLOUD_UUID);
+
+            VmwareHypervisorHost hostMo = this.getHyperHost(context);
+            _hostName = hostMo.getHyperHostName();
+        } catch (Exception e) {
+            s_logger.error("Unexpected Exception ", e);
+        }
+
+        _privateNetworkVSwitchName = (String) params.get("private.network.vswitch.name");
+        _publicNetworkVSwitchName = (String) params.get("public.network.vswitch.name");
+        _guestNetworkVSwitchName = (String) params.get("guest.network.vswitch.name");
+
+        s_logger.info("VmwareResource network configuration info. private vSwitch: " + _privateNetworkVSwitchName + ", public vSwitch: " + _publicNetworkVSwitchName + ", guest network: "
+                + _guestNetworkVSwitchName);
+
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return _name;
+    }
+
+    @Override
+    public boolean start() {
+        return true;
+    }
+
+    @Override
+    public boolean stop() {
+        return true;
+    }
+
+    private VmwareContext getServiceContext() {
+        return getServiceContext(null);
+    }
+
+    private void invalidateServiceContext() {
+        invalidateServiceContext(null);
+    }
+
+    private VmwareHypervisorHost getHyperHost(VmwareContext context) {
+        return getHyperHost(context, null);
+    }
+
+    @Override
+    public synchronized VmwareContext getServiceContext(Command cmd) {
+        if (_serviceContext == null) {
+            try {
+                _serviceContext = VmwareContextFactory.create(_vCenterAddress, _username, _password);
+            } catch (Exception e) {
+                s_logger.error("Unable to connect to vSphere server: " + _vCenterAddress, e);
+                throw new CloudRuntimeException("Unable to connect to vSphere server: " + _vCenterAddress);
+            }
+        }
+
+        return _serviceContext;
+    }
+
+    @Override
+    public synchronized void invalidateServiceContext(VmwareContext context) {
+        if (_serviceContext == null) {
+            _serviceContext.close();
+        }
+        _serviceContext = null;
+    }
+
+    @Override
+    public VmwareHypervisorHost getHyperHost(VmwareContext context, Command cmd) {
+        if (_morHyperHost.getType().equalsIgnoreCase("HostSystem")) {
+            return new HostMO(context, _morHyperHost);
+        }
+        return new ClusterMO(context, _morHyperHost);
+    }
+
+    @Override
+    @DB
+    public String getWorkerName(VmwareContext context, Command cmd) {
+        VmwareManager mgr = context.getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+        String vmName = mgr.composeWorkerName();
+
+        assert(cmd != null);
+        VmwareManager vmwareMgr = context.getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+        long checkPointId = vmwareMgr.pushCleanupCheckpoint(this._guid, vmName);
+        cmd.setContextParam("checkpoint", String.valueOf(checkPointId));
+        return vmName;
+    }
+}
diff --git a/core/src/com/cloud/storage/resource/CifsSecondaryStorageResource.java b/core/src/com/cloud/storage/resource/CifsSecondaryStorageResource.java
new file mode 100755
index 00000000000..b3674a97ae4
--- /dev/null
+++ b/core/src/com/cloud/storage/resource/CifsSecondaryStorageResource.java
@@ -0,0 +1,715 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+
+package com.cloud.storage.resource;
+
+import java.io.File;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+import javax.naming.ConfigurationException;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.CheckHealthAnswer;
+import com.cloud.agent.api.CheckHealthCommand;
+import com.cloud.agent.api.Command;
+import com.cloud.agent.api.GetStorageStatsAnswer;
+import com.cloud.agent.api.GetStorageStatsCommand;
+import com.cloud.agent.api.PingCommand;
+import com.cloud.agent.api.PingStorageCommand;
+import com.cloud.agent.api.ReadyAnswer;
+import com.cloud.agent.api.ReadyCommand;
+import com.cloud.agent.api.SecStorageFirewallCfgCommand;
+import com.cloud.agent.api.SecStorageSetupCommand;
+import com.cloud.agent.api.SecStorageFirewallCfgCommand.PortConfig;
+import com.cloud.agent.api.SecStorageVMSetupCommand;
+import com.cloud.agent.api.StartupCommand;
+import com.cloud.agent.api.StartupStorageCommand;
+import com.cloud.agent.api.storage.CreateEntityDownloadURLCommand;
+import com.cloud.agent.api.storage.DeleteEntityDownloadURLCommand;
+import com.cloud.agent.api.storage.DeleteTemplateCommand;
+import com.cloud.agent.api.storage.DownloadCommand;
+import com.cloud.agent.api.storage.DownloadProgressCommand;
+import com.cloud.agent.api.storage.UploadCommand;
+import com.cloud.agent.api.storage.ssCommand;
+import com.cloud.host.Host;
+import com.cloud.host.Host.Type;
+import com.cloud.resource.ServerResource;
+import com.cloud.resource.ServerResourceBase;
+import com.cloud.storage.Storage;
+import com.cloud.storage.Storage.StoragePoolType;
+import com.cloud.storage.StorageLayer;
+import com.cloud.storage.template.DownloadManager;
+import com.cloud.storage.template.DownloadManagerImpl;
+import com.cloud.storage.template.TemplateInfo;
+import com.cloud.storage.template.UploadManager;
+import com.cloud.storage.template.UploadManagerImpl;
+import com.cloud.utils.NumbersUtil;
+import com.cloud.utils.component.ComponentLocator;
+import com.cloud.utils.exception.CloudRuntimeException;
+import com.cloud.utils.net.NetUtils;
+import com.cloud.utils.net.NfsUtils;
+import com.cloud.utils.script.Script;
+
+/**
+ * Implementation of Secondary Storage Resource to handle CIFS share
+ * 
+ * TODOD: After mount rest of the functionality should be similar to NfsSecondaryStroage.
+ * Move common functionality of NFS and CIFS secondary storage resource class to base class
+ **/
+
+public class CifsSecondaryStorageResource extends ServerResourceBase implements SecondaryStorageResource {
+    private static final Logger s_logger = Logger.getLogger(CifsSecondaryStorageResource.class);
+    int _timeout;
+    
+    String _instance;
+    String _parent;
+    
+    String _dc;
+    String _pod;
+    String _guid;
+    String _nfsPath;
+    String _mountParent;
+    Map<String, Object> _params;
+    StorageLayer _storage;
+    boolean _inSystemVM = false;
+    boolean _sslCopy = false;
+    
+    Random _rand = new Random(System.currentTimeMillis());
+    
+    DownloadManager _dlMgr;
+    UploadManager _upldMgr;
+	private String _configSslScr;
+	private String _configAuthScr;
+	private String _configIpFirewallScr;
+	private String _publicIp;
+	private String _hostname;
+	private String _localgw;
+	private String _eth1mask;
+	private String _eth1ip;
+    
+    @Override
+    public void disconnected() {
+        if (_parent != null && !_inSystemVM) {
+            Script script = new Script(!_inSystemVM, "umount", _timeout, s_logger);
+            script.add(_parent);
+            script.execute();
+            
+            File file = new File(_parent);
+            file.delete();
+        }
+    }
+
+    @Override
+    public Answer executeRequest(Command cmd) {
+        if (cmd instanceof DownloadProgressCommand) {
+            return _dlMgr.handleDownloadCommand(this, (DownloadProgressCommand)cmd);
+        } else if (cmd instanceof DownloadCommand) {
+            return _dlMgr.handleDownloadCommand(this, (DownloadCommand)cmd);
+        } else if (cmd instanceof UploadCommand) {        	
+            return _upldMgr.handleUploadCommand(this, (UploadCommand)cmd);
+        } else if (cmd instanceof CreateEntityDownloadURLCommand){
+            return _upldMgr.handleCreateEntityURLCommand((CreateEntityDownloadURLCommand)cmd);
+        } else if(cmd instanceof DeleteEntityDownloadURLCommand){
+            return _upldMgr.handleDeleteEntityDownloadURLCommand((DeleteEntityDownloadURLCommand)cmd);
+        } else if (cmd instanceof GetStorageStatsCommand) {
+        	return execute((GetStorageStatsCommand)cmd);
+        } else if (cmd instanceof CheckHealthCommand) {
+            return new CheckHealthAnswer((CheckHealthCommand)cmd, true);
+        } else if (cmd instanceof DeleteTemplateCommand) {
+        	return execute((DeleteTemplateCommand) cmd);
+        } else if (cmd instanceof ReadyCommand) {
+            return new ReadyAnswer((ReadyCommand)cmd);
+        } else if (cmd instanceof SecStorageFirewallCfgCommand){
+        	return execute((SecStorageFirewallCfgCommand)cmd);
+        } else if (cmd instanceof SecStorageVMSetupCommand){
+        	return execute((SecStorageVMSetupCommand)cmd);
+        } else if (cmd instanceof SecStorageSetupCommand){
+            return new Answer(cmd, true, "success");
+        } else {
+            return Answer.createUnsupportedCommandAnswer(cmd);
+        }
+    }
+    
+    private Answer execute(SecStorageVMSetupCommand cmd) {
+    	if (!_inSystemVM){
+			return new Answer(cmd, true, null);
+		}
+		boolean success = true;
+		StringBuilder result = new StringBuilder();
+		for (String cidr: cmd.getAllowedInternalSites()) {
+			String tmpresult = allowOutgoingOnPrivate(cidr);
+			if (tmpresult != null) {
+				result.append(", ").append(tmpresult);
+				success = false;
+			}
+		}
+		if (success) {
+			if (cmd.getCopyPassword() != null && cmd.getCopyUserName() != null) {
+				String tmpresult = configureAuth(cmd.getCopyUserName(), cmd.getCopyPassword());
+				if (tmpresult != null) {
+					result.append("Failed to configure auth for copy ").append(tmpresult);
+					success = false;
+				}
+			}
+		}
+		return new Answer(cmd, success, result.toString());
+
+	}
+    
+    private String allowOutgoingOnPrivate(String destCidr) {
+    	
+    	Script command = new Script("/bin/bash", s_logger);
+    	String intf = "eth1";
+    	command.add("-c");
+    	command.add("iptables -I OUTPUT -o " + intf + " -d " + destCidr + " -p tcp -m state --state NEW -m tcp  -j ACCEPT");
+
+    	String result = command.execute();
+    	if (result != null) {
+    		s_logger.warn("Error in allowing outgoing to " + destCidr + ", err=" + result );
+    		return "Error in allowing outgoing to " + destCidr + ", err=" + result;
+    	}
+    	addRouteToInternalIpOrCidr(_localgw, _eth1ip, _eth1mask, destCidr);
+    	return null;
+	}
+    
+    
+
+	private Answer execute(SecStorageFirewallCfgCommand cmd) {
+		if (!_inSystemVM){
+			return new Answer(cmd, true, null);
+		}
+
+		List<String> ipList = new ArrayList<String>();
+		
+		for (PortConfig pCfg:cmd.getPortConfigs()){
+			if (pCfg.isAdd()) {
+				ipList.add(pCfg.getSourceIp());		
+			}
+		}
+		boolean success = true;
+		String result;
+		result = configureIpFirewall(ipList);
+		if (result !=null)
+			success = false;
+
+		return new Answer(cmd, success, result);
+	}
+
+	protected GetStorageStatsAnswer execute(final GetStorageStatsCommand cmd) {
+        final long usedSize = getUsedSize();
+        final long totalSize = getTotalSize();
+        if (usedSize == -1 || totalSize == -1) {
+        	return new GetStorageStatsAnswer(cmd, "Unable to get storage stats");
+        } else {
+        	return new GetStorageStatsAnswer(cmd, totalSize, usedSize) ;
+        }
+    }
+    
+    @Override
+    public String getRootDir(ssCommand cmd){
+        return null;
+    }
+    
+    protected Answer execute(final DeleteTemplateCommand cmd) {
+        String relativeTemplatePath = cmd.getTemplatePath();
+        String parent = _parent;
+
+        if (relativeTemplatePath.startsWith(File.separator)) {
+            relativeTemplatePath = relativeTemplatePath.substring(1);
+        }
+
+        if (!parent.endsWith(File.separator)) {
+            parent += File.separator;
+        }
+        String absoluteTemplatePath = parent + relativeTemplatePath;
+        File tmpltParent = new File(absoluteTemplatePath).getParentFile();
+        String details = null;
+        if (!tmpltParent.exists()) {
+            details = "template parent directory " + tmpltParent.getName() + " doesn't exist";
+            s_logger.debug(details);
+            return new Answer(cmd, true, details);
+        }
+        File[] tmpltFiles = tmpltParent.listFiles();
+        if (tmpltFiles == null || tmpltFiles.length == 0) {
+            details = "No files under template parent directory " + tmpltParent.getName();
+            s_logger.debug(details);
+        } else {
+            boolean found = false;
+            for (File f : tmpltFiles) {
+                if (!found && f.getName().equals("template.properties")) {
+                    found = true;
+                }
+                if (!f.delete()) {
+                    return new Answer(cmd, false, "Unable to delete file " + f.getName() + " under Template path "
+                            + relativeTemplatePath);
+                }
+            }
+            if (!found) {
+                details = "Can not find template.properties under " + tmpltParent.getName();
+                s_logger.debug(details);
+            }
+        }
+        if (!tmpltParent.delete()) {
+            details = "Unable to delete directory " + tmpltParent.getName() + " under Template path "
+                    + relativeTemplatePath;
+            s_logger.debug(details);
+            return new Answer(cmd, false, details);
+        }
+        return new Answer(cmd, true, null);
+    }
+    
+    protected long getUsedSize() {
+    	return _storage.getUsedSpace(_parent);
+    }
+    
+    protected long getTotalSize() {
+      	return _storage.getTotalSpace(_parent);
+    }
+    
+    protected long convertFilesystemSize(final String size) {
+        if (size == null || size.isEmpty()) {
+            return -1;
+        }
+
+        long multiplier = 1;
+        if (size.endsWith("T")) {
+            multiplier = 1024l * 1024l * 1024l * 1024l;
+        } else if (size.endsWith("G")) {
+            multiplier = 1024l * 1024l * 1024l;
+        } else if (size.endsWith("M")) {
+            multiplier = 1024l * 1024l;
+        } else {
+            assert (false) : "Well, I have no idea what this is: " + size;
+        }
+
+        return (long)(Double.parseDouble(size.substring(0, size.length() - 1)) * multiplier);
+    }
+    
+
+    @Override
+    public Type getType() {
+        return Host.Type.SecondaryStorage;
+    }
+    
+    @Override
+    public PingCommand getCurrentStatus(final long id) {
+        return new PingStorageCommand(Host.Type.Storage, id, new HashMap<String, Boolean>());
+    }
+    
+    @Override
+    public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
+    	_eth1ip = (String)params.get("eth1ip");
+        if (_eth1ip != null) { //can only happen inside service vm
+        	params.put("private.network.device", "eth1");
+        } else {
+        	s_logger.warn("Wait, what's going on? eth1ip is null!!");
+        }
+        String eth2ip = (String) params.get("eth2ip");
+        if (eth2ip != null) {
+            params.put("public.network.device", "eth2");
+        }         
+        _publicIp = (String) params.get("eth2ip");
+        _hostname = (String) params.get("name");
+        
+        super.configure(name, params);
+        
+        _params = params;
+        String value = (String)params.get("scripts.timeout");
+        _timeout = NumbersUtil.parseInt(value, 1440) * 1000;
+        
+        _storage = (StorageLayer)params.get(StorageLayer.InstanceConfigKey);
+        if (_storage == null) {
+            value = (String)params.get(StorageLayer.ClassConfigKey);
+            if (value == null) {
+                value = "com.cloud.storage.JavaStorageLayer";
+            }
+            
+            try {
+                Class<?> clazz = Class.forName(value);
+                _storage = (StorageLayer)ComponentLocator.inject(clazz);
+                _storage.configure("StorageLayer", params);
+            } catch (ClassNotFoundException e) {
+                throw new ConfigurationException("Unable to find class " + value);
+            }
+        }
+        _configSslScr = Script.findScript(getDefaultScriptsDir(), "config_ssl.sh");
+        if (_configSslScr != null) {
+            s_logger.info("config_ssl.sh found in " + _configSslScr);
+        }
+
+        _configAuthScr = Script.findScript(getDefaultScriptsDir(), "config_auth.sh");
+        if (_configSslScr != null) {
+            s_logger.info("config_auth.sh found in " + _configAuthScr);
+        }
+        
+        _configIpFirewallScr = Script.findScript(getDefaultScriptsDir(), "ipfirewall.sh");
+        if (_configIpFirewallScr != null) {
+            s_logger.info("_configIpFirewallScr found in " + _configIpFirewallScr);
+        }
+        
+        _guid = (String)params.get("guid");
+        if (_guid == null) {
+            throw new ConfigurationException("Unable to find the guid");
+        }
+        
+        _dc = (String)params.get("zone");
+        if (_dc == null) {
+            throw new ConfigurationException("Unable to find the zone");
+        }
+        _pod = (String)params.get("pod");
+        
+        _instance = (String)params.get("instance");
+
+        _mountParent = (String)params.get("mount.parent");
+        if (_mountParent == null) {
+            _mountParent = File.separator + "mnt";
+        }
+        
+        if (_instance != null) {
+            _mountParent = _mountParent + File.separator + _instance;
+        }
+
+        _nfsPath = (String)params.get("mount.path");
+        if (_nfsPath == null) {
+            throw new ConfigurationException("Unable to find mount.path");
+        }
+        
+
+        
+        String inSystemVM = (String)params.get("secondary.storage.vm");
+        if (inSystemVM == null || "true".equalsIgnoreCase(inSystemVM)) {
+        	_inSystemVM = true;
+            _localgw = (String)params.get("localgw");
+            if (_localgw != null) { //can only happen inside service vm
+            	_eth1mask = (String)params.get("eth1mask");
+            	String internalDns1 = (String)params.get("dns1");
+            	String internalDns2 = (String)params.get("dns2");
+
+            	if (internalDns1 == null) {
+            		s_logger.warn("No DNS entry found during configuration of NfsSecondaryStorage");
+            	} else {
+            		addRouteToInternalIpOrCidr(_localgw, _eth1ip, _eth1mask, internalDns1);
+            	}
+            	
+            	String mgmtHost = (String)params.get("host");
+            	String nfsHost = NfsUtils.getHostPart(_nfsPath);
+            	if (nfsHost == null) {
+            		s_logger.error("Invalid or corrupt nfs url " + _nfsPath);
+            		throw new CloudRuntimeException("Unable to determine host part of nfs path");
+            	}
+            	try {
+            		InetAddress nfsHostAddr = InetAddress.getByName(nfsHost);
+            		nfsHost = nfsHostAddr.getHostAddress();
+            	} catch (UnknownHostException uhe) {
+            		s_logger.error("Unable to resolve nfs host " + nfsHost);
+            		throw new CloudRuntimeException("Unable to resolve nfs host to an ip address " + nfsHost);
+            	}
+            	addRouteToInternalIpOrCidr(_localgw, _eth1ip, _eth1mask, nfsHost);
+            	addRouteToInternalIpOrCidr(_localgw, _eth1ip, _eth1mask, mgmtHost);
+            	if (internalDns2 != null) {
+                	addRouteToInternalIpOrCidr(_localgw, _eth1ip, _eth1mask, internalDns2);
+            	}
+
+            }
+            String useSsl = (String)params.get("sslcopy");
+            if (useSsl != null) {
+            	_sslCopy = Boolean.parseBoolean(useSsl);
+            	if (_sslCopy) {
+            		configureSSL();
+            	}
+            }
+        	startAdditionalServices();
+        	_params.put("install.numthreads", "50");
+        	_params.put("secondary.storage.vm", "true");
+        }
+        _parent = mount(_nfsPath, _mountParent);
+        if (_parent == null) {
+            throw new ConfigurationException("Unable to create mount point");
+        }
+        
+        
+        s_logger.info("Mount point established at " + _parent);
+        
+        try {
+            _params.put("template.parent", _parent);
+            _params.put(StorageLayer.InstanceConfigKey, _storage);
+            _dlMgr = new DownloadManagerImpl();
+            _dlMgr.configure("DownloadManager", _params);
+            _upldMgr = new UploadManagerImpl();
+            _upldMgr.configure("UploadManager", params);
+        } catch (ConfigurationException e) {
+            s_logger.warn("Caught problem while configuring DownloadManager", e);
+            return false;
+        }
+        return true;
+    }
+    
+    private void startAdditionalServices() {
+    	Script command = new Script("/bin/bash", s_logger);
+		command.add("-c");
+    	command.add("if [ -f /etc/init.d/ssh ]; then service ssh restart; else service sshd restart; fi ");
+    	String result = command.execute();
+    	if (result != null) {
+    		s_logger.warn("Error in starting sshd service err=" + result );
+    	}
+		command = new Script("/bin/bash", s_logger);
+		command.add("-c");
+    	command.add("iptables -I INPUT -i eth1 -p tcp -m state --state NEW -m tcp --dport 3922 -j ACCEPT");
+    	result = command.execute();
+    	if (result != null) {
+    		s_logger.warn("Error in opening up ssh port err=" + result );
+    	}
+	}
+    
+    private void addRouteToInternalIpOrCidr(String localgw, String eth1ip, String eth1mask, String destIpOrCidr) {
+    	s_logger.debug("addRouteToInternalIp: localgw=" + localgw + ", eth1ip=" + eth1ip + ", eth1mask=" + eth1mask + ",destIp=" + destIpOrCidr);
+    	if (destIpOrCidr == null) {
+    		s_logger.debug("addRouteToInternalIp: destIp is null");
+			return;
+		}
+    	if (!NetUtils.isValidIp(destIpOrCidr) && !NetUtils.isValidCIDR(destIpOrCidr)){
+    		s_logger.warn(" destIp is not a valid ip address or cidr destIp=" + destIpOrCidr);
+    		return;
+    	}
+    	boolean inSameSubnet = false;
+    	if (NetUtils.isValidIp(destIpOrCidr)) {
+    		if (eth1ip != null && eth1mask != null) {
+    			inSameSubnet = NetUtils.sameSubnet(eth1ip, destIpOrCidr, eth1mask);
+    		} else {
+    			s_logger.warn("addRouteToInternalIp: unable to determine same subnet: _eth1ip=" + eth1ip + ", dest ip=" + destIpOrCidr + ", _eth1mask=" + eth1mask);
+    		}
+    	} else {
+            inSameSubnet = NetUtils.isNetworkAWithinNetworkB(destIpOrCidr, NetUtils.ipAndNetMaskToCidr(eth1ip, eth1mask));
+    	}
+    	if (inSameSubnet) {
+			s_logger.debug("addRouteToInternalIp: dest ip " + destIpOrCidr + " is in the same subnet as eth1 ip " + eth1ip);
+    		return;
+    	}
+    	Script command = new Script("/bin/bash", s_logger);
+		command.add("-c");
+    	command.add("ip route delete " + destIpOrCidr);
+    	command.execute();
+		command = new Script("/bin/bash", s_logger);
+		command.add("-c");
+    	command.add("ip route add " + destIpOrCidr + " via " + localgw);
+    	String result = command.execute();
+    	if (result != null) {
+    		s_logger.warn("Error in configuring route to internal ip err=" + result );
+    	} else {
+			s_logger.debug("addRouteToInternalIp: added route to internal ip=" + destIpOrCidr + " via " + localgw);
+    	}
+    }
+
+	private void configureSSL() {
+		Script command = new Script(_configSslScr);
+		command.add(_publicIp);
+		command.add(_hostname);
+		String result = command.execute();
+		if (result != null) {
+			s_logger.warn("Unable to configure httpd to use ssl");
+		}
+	}
+	
+	private String configureAuth(String user, String passwd) {
+		Script command = new Script(_configAuthScr);
+		command.add(user);
+		command.add(passwd);
+		String result = command.execute();
+		if (result != null) {
+			s_logger.warn("Unable to configure httpd to use auth");
+		}
+		return result;
+	}
+	
+	private String configureIpFirewall(List<String> ipList){
+		Script command = new Script(_configIpFirewallScr);		
+		for (String ip : ipList){
+			command.add(ip);
+		}		
+		
+		String result = command.execute();
+		if (result != null) {
+			s_logger.warn("Unable to configure firewall for command : " +command);
+		}
+		return result;
+	}
+	
+	protected String mount(String path, String parent) {
+        String mountPoint = null;
+        for (int i = 0; i < 10; i++) {
+            String mntPt = parent + File.separator + Integer.toHexString(_rand.nextInt(Integer.MAX_VALUE));
+            File file = new File(mntPt);
+            if (!file.exists()) {
+                if (_storage.mkdir(mntPt)) {
+                    mountPoint = mntPt;
+                    break;
+                }
+            }
+            s_logger.debug("Unable to create mount: " + mntPt);
+        }
+        
+        if (mountPoint == null) {
+            s_logger.warn("Unable to create a mount point");
+            return null;
+        }
+       
+        Script script = null;
+        String result = null;
+        script = new Script(!_inSystemVM, "umount", _timeout, s_logger);
+        script.add(path);
+        result = script.execute();
+        
+        if( _parent != null ) {
+            script = new Script("rmdir", _timeout, s_logger);
+            script.add(_parent);
+            result = script.execute();
+        }
+ 
+        Script command = new Script(!_inSystemVM, "mount", _timeout, s_logger);
+        command.add("-t", "cifs");
+        if (_inSystemVM) {
+        	//Fedora Core 12 errors out with any -o option executed from java
+        	//command.add("-o", "soft,timeo=133,retrans=2147483647,tcp,acdirmax=0,acdirmin=0");
+        }
+        String tok[] = path.split(":");
+        //command.add(path);
+        command.add("//"+tok[0]+tok[1]);
+        command.add(mountPoint);
+        result = command.execute();
+        if (result != null) {
+            s_logger.warn("Unable to mount " + path + " due to " + result);
+            File file = new File(mountPoint);
+            if (file.exists())
+            	file.delete();
+            return null;
+        }
+        
+        
+        
+        // XXX: Adding the check for creation of snapshots dir here. Might have to move it somewhere more logical later.
+        if (!checkForSnapshotsDir(mountPoint)) {
+        	return null;
+        }
+        
+        // Create the volumes dir
+        if (!checkForVolumesDir(mountPoint)) {
+        	return null;
+        }
+        
+        return mountPoint;
+    }
+    
+    @Override
+    public boolean start() {
+        return true;
+    }
+
+    @Override
+    public boolean stop() {
+        return true;
+    }
+
+    @Override
+    public StartupCommand[] initialize() {
+        /*disconnected();
+        
+        _parent = mount(_nfsPath, _mountParent);
+        
+        if( _parent == null ) {
+            s_logger.warn("Unable to mount the nfs server");
+            return null;
+        }
+        
+        try {
+            _params.put("template.parent", _parent);
+            _params.put(StorageLayer.InstanceConfigKey, _storage);
+            _dlMgr = new DownloadManagerImpl();
+            _dlMgr.configure("DownloadManager", _params);
+        } catch (ConfigurationException e) {
+            s_logger.warn("Caught problem while configuring folers", e);
+            return null;
+        }*/
+        
+        final StartupStorageCommand cmd = new StartupStorageCommand(_parent, StoragePoolType.NetworkFilesystem, getTotalSize(), new HashMap<String, TemplateInfo>());
+        
+        cmd.setResourceType(Storage.StorageResourceType.SECONDARY_STORAGE);
+        cmd.setIqn(null);
+        
+        fillNetworkInformation(cmd);
+        cmd.setDataCenter(_dc);
+        cmd.setPod(_pod);
+        cmd.setGuid(_guid);
+        cmd.setName(_guid);
+        cmd.setVersion(NfsSecondaryStorageResource.class.getPackage().getImplementationVersion());
+        cmd.getHostDetails().put("mount.parent", _mountParent);
+        cmd.getHostDetails().put("mount.path", _nfsPath);
+        String tok[] = _nfsPath.split(":");
+        cmd.setNfsShare("nfs://" + tok[0] + tok[1]);
+        if (cmd.getHostDetails().get("orig.url") == null) {
+            if (tok.length != 2) {
+                throw new CloudRuntimeException("Not valid NFS path" + _nfsPath);
+            }
+            String nfsUrl = "nfs://" + tok[0] + tok[1];
+            cmd.getHostDetails().put("orig.url", nfsUrl);
+        }
+        InetAddress addr;
+        try {
+            addr = InetAddress.getByName(tok[0]);
+            cmd.setPrivateIpAddress(addr.getHostAddress());
+        } catch (UnknownHostException e) {
+            cmd.setPrivateIpAddress(tok[0]);
+        }
+        return new StartupCommand [] {cmd};
+    }
+
+    protected boolean checkForSnapshotsDir(String mountPoint) {
+        String snapshotsDirLocation = mountPoint + File.separator + "snapshots";
+        return createDir("snapshots", snapshotsDirLocation, mountPoint);
+    }
+    
+    protected boolean checkForVolumesDir(String mountPoint) {
+    	String volumesDirLocation = mountPoint + "/" + "volumes";
+    	return createDir("volumes", volumesDirLocation, mountPoint);
+    }
+    
+    protected boolean createDir(String dirName, String dirLocation, String mountPoint) {
+    	boolean dirExists = false;
+    	
+    	File dir = new File(dirLocation);
+    	if (dir.exists()) {
+    		if (dir.isDirectory()) {
+    			s_logger.debug(dirName + " already exists on secondary storage, and is mounted at " + mountPoint);
+    			dirExists = true;
+    		} else {
+    			if (dir.delete() && _storage.mkdir(dirLocation)) {
+    				dirExists = true;
+    			}
+    		}
+    	} else if (_storage.mkdir(dirLocation)) {
+    		dirExists = true;
+    	}
+
+    	if (dirExists) {
+    		s_logger.info(dirName  + " directory created/exists on Secondary Storage.");
+    	} else {
+    		s_logger.info(dirName + " directory does not exist on Secondary Storage.");
+    	}
+    	
+    	return dirExists;
+    }
+    
+    @Override
+    protected String getDefaultScriptsDir() {
+        return "./scripts/storage/secondary";
+    }
+}
diff --git a/core/src/com/cloud/storage/resource/PremiumSecondaryStorageResource.java b/core/src/com/cloud/storage/resource/PremiumSecondaryStorageResource.java
new file mode 100644
index 00000000000..ade311abb5c
--- /dev/null
+++ b/core/src/com/cloud/storage/resource/PremiumSecondaryStorageResource.java
@@ -0,0 +1,93 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.storage.resource;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.naming.ConfigurationException;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.Command;
+import com.cloud.hypervisor.Hypervisor;
+
+public class PremiumSecondaryStorageResource extends NfsSecondaryStorageResource {
+
+    private static final Logger s_logger = Logger.getLogger(PremiumSecondaryStorageResource.class);
+
+    private Map<Hypervisor.HypervisorType, SecondaryStorageResourceHandler> _handlers = new HashMap<Hypervisor.HypervisorType, SecondaryStorageResourceHandler>();
+    
+    private Map<String, String> _activeOutgoingAddresses = new HashMap<String, String>();
+	
+    @Override
+    public Answer executeRequest(Command cmd) {
+    	String hypervisor = cmd.getContextParam("hypervisor");
+    	if(hypervisor != null) {
+    		Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.getType(hypervisor);
+    		if(hypervisorType == null) {
+    			s_logger.error("Unsupported hypervisor type in command context, hypervisor: " + hypervisor);
+    			return defaultAction(cmd);
+    		}
+    		
+    		SecondaryStorageResourceHandler handler = getHandler(hypervisorType);
+    		if(handler == null) {
+    			s_logger.error("No handler can be found for hypervisor type in command context, hypervisor: " + hypervisor);
+    			return defaultAction(cmd);
+    		}
+    		
+    		return handler.executeRequest(cmd);
+    	}
+
+        return defaultAction(cmd);
+    }
+    
+    public Answer defaultAction(Command cmd) {
+    	return super.executeRequest(cmd);
+    }
+    
+    public void ensureOutgoingRuleForAddress(String address) {
+    	if(address == null || address.isEmpty() || address.startsWith("0.0.0.0")) {
+    		if(s_logger.isInfoEnabled())
+    			s_logger.info("Drop invalid dynamic route/firewall entry " + address);
+    		return;
+    	}
+    	
+    	boolean needToSetRule = false;
+    	synchronized(_activeOutgoingAddresses) {
+    		if(!_activeOutgoingAddresses.containsKey(address)) {
+    			_activeOutgoingAddresses.put(address, address);
+    			needToSetRule = true;
+    		}
+    	}
+    	
+    	if(needToSetRule) {
+    		if(s_logger.isInfoEnabled())
+    			s_logger.info("Add dynamic route/firewall entry for " + address);
+    		allowOutgoingOnPrivate(address);
+    	}
+    }
+    
+    private void registerHandler(Hypervisor.HypervisorType hypervisorType, SecondaryStorageResourceHandler handler) {
+    	_handlers.put(hypervisorType, handler);
+    }
+    
+    private SecondaryStorageResourceHandler getHandler(Hypervisor.HypervisorType hypervisorType) {
+    	return _handlers.get(hypervisorType);
+    }
+    
+    @Override
+    public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
+    	super.configure(name, params);
+
+    	if(_inSystemVM) {
+    		VmwareSecondaryStorageContextFactory.initFactoryEnvironment();
+    	}
+    	
+    	registerHandler(Hypervisor.HypervisorType.VMware, new VmwareSecondaryStorageResourceHandler(this));
+    	return true;
+    }
+}
diff --git a/core/src/com/cloud/storage/resource/SecondaryStorageResourceHandler.java b/core/src/com/cloud/storage/resource/SecondaryStorageResourceHandler.java
new file mode 100644
index 00000000000..306d56d28d8
--- /dev/null
+++ b/core/src/com/cloud/storage/resource/SecondaryStorageResourceHandler.java
@@ -0,0 +1,12 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.storage.resource;
+
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.Command;
+
+public interface SecondaryStorageResourceHandler {
+	Answer executeRequest(Command cmd);
+}
diff --git a/core/src/com/cloud/storage/resource/VmwareSecondaryStorageContextFactory.java b/core/src/com/cloud/storage/resource/VmwareSecondaryStorageContextFactory.java
new file mode 100644
index 00000000000..4e69aadf615
--- /dev/null
+++ b/core/src/com/cloud/storage/resource/VmwareSecondaryStorageContextFactory.java
@@ -0,0 +1,60 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.storage.resource;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.vmware.apputils.version.ExtendedAppUtil;
+
+public class VmwareSecondaryStorageContextFactory {
+	private static volatile int s_seq = 1;
+	
+	private static Map<String, VmwareContext> s_contextMap = new HashMap<String, VmwareContext>();
+	
+	public static void initFactoryEnvironment() {
+		System.setProperty("axis.socketSecureFactory", "org.apache.axis.components.net.SunFakeTrustSocketFactory");
+	}
+	
+	public static VmwareContext create(String vCenterAddress, String vCenterUserName, String vCenterPassword) throws Exception {
+		assert(vCenterAddress != null);
+		assert(vCenterUserName != null);
+		assert(vCenterPassword != null);
+		
+		VmwareContext context = null;
+		
+		synchronized(s_contextMap) {
+			context = s_contextMap.get(vCenterAddress);
+			if(context == null) {
+				String serviceUrl = "https://" + vCenterAddress + "/sdk/vimService";
+				String[] params = new String[] {"--url", serviceUrl, "--username", vCenterUserName, "--password", vCenterPassword };
+				ExtendedAppUtil appUtil = ExtendedAppUtil.initialize(vCenterAddress + "-" + s_seq++, params);
+				
+				appUtil.connect();
+				context = new VmwareContext(appUtil, vCenterAddress);
+				context.registerStockObject("username", vCenterUserName);
+				context.registerStockObject("password", vCenterPassword);
+				
+				s_contextMap.put(vCenterAddress, context);
+			}
+		}
+		
+		assert(context != null);
+		return context;
+	}
+	
+	public static void invalidate(VmwareContext context) {
+		synchronized(s_contextMap) {
+			for(Map.Entry<String, VmwareContext> entry : s_contextMap.entrySet()) {
+				if(entry.getValue() == context) {
+					s_contextMap.remove(entry.getKey());
+				}
+			}
+		}
+		
+		context.close();
+	}
+}
diff --git a/core/src/com/cloud/storage/resource/VmwareSecondaryStorageResourceHandler.java b/core/src/com/cloud/storage/resource/VmwareSecondaryStorageResourceHandler.java
new file mode 100644
index 00000000000..8f5ccf45386
--- /dev/null
+++ b/core/src/com/cloud/storage/resource/VmwareSecondaryStorageResourceHandler.java
@@ -0,0 +1,292 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.storage.resource;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.BackupSnapshotCommand;
+import com.cloud.agent.api.Command;
+import com.cloud.agent.api.CreatePrivateTemplateFromSnapshotCommand;
+import com.cloud.agent.api.CreatePrivateTemplateFromVolumeCommand;
+import com.cloud.agent.api.CreateVolumeFromSnapshotCommand;
+import com.cloud.agent.api.DeleteSnapshotBackupCommand;
+import com.cloud.agent.api.DeleteSnapshotsDirCommand;
+import com.cloud.agent.api.storage.CopyVolumeCommand;
+import com.cloud.agent.api.storage.PrimaryStorageDownloadCommand;
+import com.cloud.hypervisor.vmware.manager.VmwareHostService;
+import com.cloud.hypervisor.vmware.manager.VmwareStorageManager;
+import com.cloud.hypervisor.vmware.manager.VmwareStorageManagerImpl;
+import com.cloud.hypervisor.vmware.manager.VmwareStorageMount;
+import com.cloud.hypervisor.vmware.mo.ClusterMO;
+import com.cloud.hypervisor.vmware.mo.HostMO;
+import com.cloud.hypervisor.vmware.mo.VmwareHostType;
+import com.cloud.hypervisor.vmware.mo.VmwareHypervisorHost;
+import com.cloud.hypervisor.vmware.mo.VmwareHypervisorHostNetworkSummary;
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.cloud.hypervisor.vmware.util.VmwareHelper;
+import com.cloud.serializer.GsonHelper;
+import com.google.gson.Gson;
+import com.vmware.vim25.ManagedObjectReference;
+
+public class VmwareSecondaryStorageResourceHandler implements SecondaryStorageResourceHandler, VmwareHostService, VmwareStorageMount {
+    private static final Logger s_logger = Logger.getLogger(VmwareSecondaryStorageResourceHandler.class);
+
+    private final PremiumSecondaryStorageResource _resource;
+    private final VmwareStorageManager _storageMgr;
+
+    private final Gson _gson;
+
+    /*
+	private Map<String, HostMO> _activeHosts = new HashMap<String, HostMO>();
+     */
+
+    public VmwareSecondaryStorageResourceHandler(PremiumSecondaryStorageResource resource) {
+        _resource = resource;
+        _storageMgr = new VmwareStorageManagerImpl(this);
+        _gson = GsonHelper.getGsonLogger();
+    }
+
+    @Override
+    public Answer executeRequest(Command cmd) {
+        Answer answer;
+        if (cmd instanceof PrimaryStorageDownloadCommand) {
+            answer = execute((PrimaryStorageDownloadCommand)cmd);
+        } else if(cmd instanceof BackupSnapshotCommand) {
+            answer = execute((BackupSnapshotCommand)cmd);
+        } else if(cmd instanceof DeleteSnapshotsDirCommand) {
+            answer = execute((DeleteSnapshotsDirCommand)cmd);
+        } else if(cmd instanceof DeleteSnapshotBackupCommand) {
+            answer = execute((DeleteSnapshotBackupCommand)cmd);
+        } else if(cmd instanceof CreatePrivateTemplateFromVolumeCommand) {
+            answer = execute((CreatePrivateTemplateFromVolumeCommand)cmd);
+        } else if(cmd instanceof CreatePrivateTemplateFromSnapshotCommand) {
+            answer = execute((CreatePrivateTemplateFromSnapshotCommand)cmd);
+        } else if(cmd instanceof CopyVolumeCommand) {
+            answer = execute((CopyVolumeCommand)cmd);
+        } else if(cmd instanceof CreateVolumeFromSnapshotCommand) {
+            answer = execute((CreateVolumeFromSnapshotCommand)cmd);
+        } else {
+            answer =  _resource.defaultAction(cmd);
+        }
+
+        if(cmd.getContextParam("execid") != null) {
+            answer.setContextParam("execid", cmd.getContextParam("execid"));
+        }
+        if(cmd.getContextParam("checkpoint") != null) {
+            answer.setContextParam("checkpoint", cmd.getContextParam("checkpoint"));
+        }
+
+        return answer;
+    }
+
+    private Answer execute(PrimaryStorageDownloadCommand cmd) {
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Executing resource PrimaryStorageDownloadCommand: " + _gson.toJson(cmd));
+        }
+
+        return _storageMgr.execute(this, cmd);
+    }
+
+    private Answer execute(BackupSnapshotCommand cmd) {
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Executing resource BackupSnapshotCommand: " + _gson.toJson(cmd));
+        }
+
+        return _storageMgr.execute(this, cmd);
+    }
+
+    private Answer execute(DeleteSnapshotsDirCommand cmd) {
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Executing resource DeleteSnapshotsDirCommand: " + _gson.toJson(cmd));
+        }
+
+        return _storageMgr.execute(this, cmd);
+    }
+
+    private Answer execute(DeleteSnapshotBackupCommand cmd) {
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Executing resource DeleteSnapshotBackupCommand: " + _gson.toJson(cmd));
+        }
+
+        return _storageMgr.execute(this, cmd);
+    }
+
+    private Answer execute(CreatePrivateTemplateFromVolumeCommand cmd) {
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Executing resource CreatePrivateTemplateFromVolumeCommand: " + _gson.toJson(cmd));
+        }
+
+        return _storageMgr.execute(this, cmd);
+    }
+
+    private Answer execute(CreatePrivateTemplateFromSnapshotCommand cmd) {
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Executing resource CreatePrivateTemplateFromVolumeCommand: " + _gson.toJson(cmd));
+        }
+
+        return _storageMgr.execute(this, cmd);
+    }
+
+    private Answer execute(CopyVolumeCommand cmd) {
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Executing resource CopyVolumeCommand: " + _gson.toJson(cmd));
+        }
+
+        return _storageMgr.execute(this, cmd);
+    }
+
+    private Answer execute(CreateVolumeFromSnapshotCommand cmd) {
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Executing resource CreateVolumeFromSnapshotCommand: " + _gson.toJson(cmd));
+        }
+
+        return _storageMgr.execute(this, cmd);
+    }
+
+    @Override
+    public VmwareContext getServiceContext(Command cmd) {
+        String guid = cmd.getContextParam("guid");
+        if(guid == null || guid.isEmpty()) {
+            s_logger.error("Invalid command context parameter guid");
+            return null;
+        }
+
+        String username = cmd.getContextParam("username");
+        if(username == null || username.isEmpty()) {
+            s_logger.error("Invalid command context parameter username");
+            return null;
+        }
+
+        String password = cmd.getContextParam("password");
+
+        // validate command guid parameter
+        String[] tokens = guid.split("@");
+        if(tokens == null || tokens.length != 2) {
+            s_logger.error("Invalid content in command context parameter guid");
+            return null;
+        }
+
+        String vCenterAddress = tokens[1];
+        String[] hostTokens = tokens[0].split(":");
+        if(hostTokens == null || hostTokens.length != 2) {
+            s_logger.error("Invalid content in command context parameter guid");
+            return null;
+        }
+
+        try {
+            _resource.ensureOutgoingRuleForAddress(vCenterAddress);
+            VmwareContext context = null;
+
+            // cached VmwareContext may be timed out in vCenter, give it a chance to reclaim a new context from factory
+            for(int i = 0; i < 2; i++) {
+                context = VmwareSecondaryStorageContextFactory.create(vCenterAddress, username, password);
+                if(!validateContext(context, cmd)) {
+                    invalidateServiceContext(context);
+                }
+            }
+
+            if(context != null) {
+                context.registerStockObject("serviceconsole", cmd.getContextParam("serviceconsole"));
+                context.registerStockObject("manageportgroup", cmd.getContextParam("manageportgroup"));
+            }
+            return context;
+        } catch(Exception e) {
+            s_logger.error("Unexpected exception " + e.toString(), e);
+            return null;
+        }
+    }
+
+    @Override
+    public void invalidateServiceContext(VmwareContext context) {
+        VmwareSecondaryStorageContextFactory.invalidate(context);
+    }
+
+    @Override
+    public VmwareHypervisorHost getHyperHost(VmwareContext context, Command cmd) {
+        String guid = cmd.getContextParam("guid");
+        assert(guid != null);
+
+        String[] tokens = guid.split("@");
+        assert(tokens != null && tokens.length == 2);
+
+        ManagedObjectReference morHyperHost = new ManagedObjectReference();
+        String[] hostTokens = tokens[0].split(":");
+        if(hostTokens == null || hostTokens.length != 2) {
+            s_logger.error("Invalid content in command context parameter guid");
+            return null;
+        }
+
+        morHyperHost.setType(hostTokens[0]);
+        morHyperHost.set_value(hostTokens[1]);
+
+        if(morHyperHost.getType().equalsIgnoreCase("HostSystem")) {
+            HostMO hostMo =  new HostMO(context, morHyperHost);
+
+            try {
+                VmwareHypervisorHostNetworkSummary netSummary = hostMo.getHyperHostNetworkSummary(
+                	hostMo.getHostType() == VmwareHostType.ESXi ? cmd.getContextParam("manageportgroup") : cmd.getContextParam("serviceconsole"));
+                _resource.ensureOutgoingRuleForAddress(netSummary.getHostIp());
+            } catch(Throwable e) {
+                s_logger.warn("Unable to retrive host network information due to exception " + e.toString() + ", host: " + hostTokens[0] + "-" + hostTokens[1]);
+            }
+
+            return hostMo;
+        }
+
+        assert(false);
+        return new ClusterMO(context, morHyperHost);
+    }
+
+    @Override
+    public String getWorkerName(VmwareContext context, Command cmd) {
+        assert(cmd.getContextParam("worker") != null);
+        return cmd.getContextParam("worker");
+    }
+
+    @Override
+    public String getMountPoint(String storageUrl) {
+        return _resource.getRootDir(storageUrl);
+    }
+
+    private boolean validateContext(VmwareContext context, Command cmd) {
+        String guid = cmd.getContextParam("guid");
+        assert(guid != null);
+
+        String[] tokens = guid.split("@");
+        assert(tokens != null && tokens.length == 2);
+
+        ManagedObjectReference morHyperHost = new ManagedObjectReference();
+        String[] hostTokens = tokens[0].split(":");
+        assert(hostTokens.length == 2);
+
+        morHyperHost.setType(hostTokens[0]);
+        morHyperHost.set_value(hostTokens[1]);
+
+        if(morHyperHost.getType().equalsIgnoreCase("HostSystem")) {
+            HostMO hostMo =  new HostMO(context, morHyperHost);
+            try {
+                VmwareHypervisorHostNetworkSummary netSummary = hostMo.getHyperHostNetworkSummary(
+                	hostMo.getHostType() == VmwareHostType.ESXi ? cmd.getContextParam("manageportgroup") : cmd.getContextParam("serviceconsole"));
+                assert(netSummary != null);
+                if(netSummary.getHostIp() != null && !netSummary.getHostIp().isEmpty()) {
+                    if(s_logger.isDebugEnabled()) {
+                        s_logger.debug("Context validation succeeded. Validated via host: " + netSummary.getHostIp() + ", guid: " + guid);
+                    }
+                    return true;
+                }
+
+                s_logger.warn("Context validation failed due to invalid host network summary");
+                return false;
+            } catch(Throwable e) {
+                s_logger.warn("Context validation failed due to " + VmwareHelper.getExceptionMessage(e));
+                return false;
+            }
+        }
+
+        assert(false);
+        return true;
+    }
+}
diff --git a/core/test/com/cloud/hypervisor/vmware/mo/TestVmwareContextFactory.java b/core/test/com/cloud/hypervisor/vmware/mo/TestVmwareContextFactory.java
new file mode 100644
index 00000000000..b467af44b46
--- /dev/null
+++ b/core/test/com/cloud/hypervisor/vmware/mo/TestVmwareContextFactory.java
@@ -0,0 +1,31 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.vmware.apputils.version.ExtendedAppUtil;
+
+public class TestVmwareContextFactory {
+	private static volatile int s_seq = 1;
+	
+	static {
+		// skip certificate check
+		System.setProperty("axis.socketSecureFactory", "org.apache.axis.components.net.SunFakeTrustSocketFactory");
+	}
+
+	public static VmwareContext create(String vCenterAddress, String vCenterUserName, String vCenterPassword) throws Exception {
+		assert(vCenterAddress != null);
+		assert(vCenterUserName != null);
+		assert(vCenterPassword != null);
+
+		String serviceUrl = "https://" + vCenterAddress + "/sdk/vimService";
+		String[] params = new String[] {"--url", serviceUrl, "--username", vCenterUserName, "--password", vCenterPassword };
+		ExtendedAppUtil appUtil = ExtendedAppUtil.initialize(vCenterAddress + "-" + s_seq++, params);
+		
+		appUtil.connect();
+		VmwareContext context = new VmwareContext(appUtil, vCenterAddress);
+		return context;
+	}
+}
diff --git a/core/test/com/cloud/hypervisor/vmware/mo/TestVmwareMO.java b/core/test/com/cloud/hypervisor/vmware/mo/TestVmwareMO.java
new file mode 100755
index 00000000000..b5be56ff0de
--- /dev/null
+++ b/core/test/com/cloud/hypervisor/vmware/mo/TestVmwareMO.java
@@ -0,0 +1,35 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.cloud.utils.testcase.Log4jEnabledTestCase;
+import com.google.gson.Gson;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.VirtualMachineConfigSpec;
+
+// This test case needs a particular setup, only used for my own test
+public class TestVmwareMO extends Log4jEnabledTestCase {
+    private static final Logger s_logger = Logger.getLogger(TestVmwareMO.class);
+    
+    public void test() {
+		try {
+			VmwareContext context = TestVmwareContextFactory.create(
+					"192.168.190.18", "Administrator", "Suite219");
+			
+			VirtualMachineMO vmMo = new VirtualMachineMO(context, "VirtualMachine", "vm-700");
+			
+			System.out.println("state " + vmMo.getPowerState().toString());
+			
+			
+			context.close();
+		} catch(Exception e) {
+			s_logger.error("Unexpected exception : ", e);
+		}
+    }
+}
+
diff --git a/core/test/com/cloud/hypervisor/vmware/util/TestVmwareUtil.java b/core/test/com/cloud/hypervisor/vmware/util/TestVmwareUtil.java
new file mode 100755
index 00000000000..4e1d3fdd33c
--- /dev/null
+++ b/core/test/com/cloud/hypervisor/vmware/util/TestVmwareUtil.java
@@ -0,0 +1,96 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.util;
+import java.io.File;
+
+import junit.framework.Assert;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.resource.SshHelper;
+import com.cloud.hypervisor.vmware.resource.VmwareContextFactory;
+import com.cloud.utils.Pair;
+import com.cloud.utils.testcase.Log4jEnabledTestCase;
+import com.vmware.vim25.ManagedObjectReference;
+
+// This test case needs a particular setup, only used for my own test
+public class TestVmwareUtil extends Log4jEnabledTestCase {
+    private static final Logger s_logger = Logger.getLogger(TestVmwareUtil.class);
+
+	public void testContextCreation() {
+		try {
+			VmwareContext context = VmwareContextFactory.create("vsphere-1.lab.vmops.com", "Administrator", "Suite219");
+			Assert.assertTrue(true);
+			context.close();
+		} catch(Exception e) {
+			s_logger.error("Unexpected exception : ", e);
+		}
+	}
+	
+	public void testSearchIndex() {
+		try {
+			VmwareContext context = VmwareContextFactory.create("vsphere-1.lab.vmops.com", "Administrator", "Suite219");
+			Assert.assertTrue(true);
+			
+			ManagedObjectReference morHost = context.getService().findByDnsName(context.getServiceContent().getSearchIndex(), 
+				null, "esxhost-1.lab.vmops.com", false);
+			Assert.assertTrue(morHost.getType().equalsIgnoreCase("HostSystem"));
+			
+			morHost = context.getService().findByIp(context.getServiceContent().getSearchIndex(), 
+				null, "192.168.1.168", false);
+			Assert.assertTrue(morHost == null);
+			context.close();
+		} catch(Exception e) {
+			s_logger.error("Unexpected exception : ", e);
+		}
+	}
+	
+	public void testVmxFileDownload() {
+		try {
+			VmwareContext context = VmwareContextFactory.create("vsphere-1.lab.vmops.com", "Administrator", "Suite219");
+			byte[] vmxContent = context.getResourceContent("https://vsphere-1.lab.vmops.com/folder/ServerRoom-Fedora32/ServerRoom-Fedora32.vmx?dcPath=cupertino&dsName=NFS%20datastore");
+			System.out.print(new String(vmxContent));
+			context.close();
+		} catch(Exception e) {
+			s_logger.error("Unexpected exception : ", e);
+		}
+	}
+	
+	public void testVmxFileParser() {
+		String[] tokens = "[NFS datastore] Fedora-clone-test/Fedora-clone-test.vmx".split("\\[|\\]|/");
+		
+		for(String str : tokens) {
+			System.out.println("Token " + str);
+		}
+	}
+	
+	public void testSsh() {
+		try {
+			File file = new File("c:\\temp\\id_rsa.kelven");
+			if(!file.exists()) {
+				System.out.println("key file does not exist!");
+			}
+			
+			Pair<Boolean, String> result = SshHelper.sshExecute("192.168.1.107", 22, "kelven", file, null, "ls -al");
+			System.out.println("Result: " + result.second());
+		} catch(Exception e) {
+			s_logger.error("Unexpected exception : ", e);
+		}
+	}
+	
+	public void testScp() {
+		try {
+			File file = new File("c:\\temp\\id_rsa.kelven");
+			if(!file.exists()) {
+				System.out.println("key file does not exist!");
+			}
+			
+			SshHelper.scpTo("192.168.1.107", 22, "kelven", file, null, "~", "Hello, world".getBytes(), 
+				"hello.txt", null);
+		} catch(Exception e) {
+			s_logger.error("Unexpected exception : ", e);
+		}
+	}
+}
diff --git a/core/test/com/cloud/vmware/TestVMWare.java b/core/test/com/cloud/vmware/TestVMWare.java
new file mode 100644
index 00000000000..da1e357666e
--- /dev/null
+++ b/core/test/com/cloud/vmware/TestVMWare.java
@@ -0,0 +1,1128 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.vmware;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.rmi.RemoteException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.SSLSession;
+
+import org.apache.log4j.xml.DOMConfigurator;
+
+import com.cloud.utils.PropertiesUtil;
+import com.vmware.apputils.version.ExtendedAppUtil;
+import com.vmware.vim25.HostIpConfig;
+import com.vmware.vim25.HostVirtualNicSpec;
+import com.vmware.vim25.HostConfigManager;
+import com.vmware.vim25.HostPortGroupSpec;
+import com.vmware.vim25.HttpNfcLeaseDeviceUrl;
+import com.vmware.vim25.HttpNfcLeaseInfo;
+import com.vmware.vim25.HttpNfcLeaseState;
+import com.vmware.vim25.OvfCreateImportSpecParams;
+import com.vmware.vim25.OvfCreateImportSpecResult;
+import com.vmware.vim25.OvfFileItem;
+import com.vmware.vim25.OvfNetworkMapping;
+import com.vmware.vim25.VirtualMachineConfigSpec;
+import com.vmware.vim25.VirtualDeviceConfigSpecOperation;
+import com.vmware.vim25.VirtualEthernetCard;
+import com.vmware.vim25.VirtualEthernetCardNetworkBackingInfo;
+import com.vmware.vim25.VirtualNicManagerNetConfig;
+import com.vmware.vim25.VirtualPCNet32;
+import com.vmware.vim25.VirtualDeviceConfigSpec;
+import com.vmware.vim25.VirtualMachineCloneSpec;
+import com.vmware.vim25.VirtualMachineRelocateSpec;
+import com.vmware.vim25.ArrayOfManagedObjectReference;
+import com.vmware.vim25.DatastoreInfo;
+import com.vmware.vim25.DynamicProperty;
+import com.vmware.vim25.InvalidProperty;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.ObjectContent;
+import com.vmware.vim25.ObjectSpec;
+import com.vmware.vim25.PropertyFilterSpec;
+import com.vmware.vim25.PropertySpec;
+import com.vmware.vim25.RuntimeFault;
+import com.vmware.vim25.SelectionSpec;
+import com.vmware.vim25.TraversalSpec;
+
+public class TestVMWare {
+	private static ExtendedAppUtil cb;
+	
+	static {
+		try {
+			javax.net.ssl.TrustManager[] trustAllCerts = new javax.net.ssl.TrustManager[1]; 
+			javax.net.ssl.TrustManager tm = new TrustAllManager(); 
+			trustAllCerts[0] = tm; 
+			javax.net.ssl.SSLContext sc = javax.net.ssl.SSLContext.getInstance("SSL"); 
+			sc.init(null, trustAllCerts, null); 
+			javax.net.ssl.HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
+		} catch (Exception e) {
+		}
+	}
+	
+	private static void setupLog4j() {
+	   File file = PropertiesUtil.findConfigFile("log4j-cloud.xml");
+
+	   if(file != null) {
+		   System.out.println("Log4j configuration from : " + file.getAbsolutePath());
+		   DOMConfigurator.configureAndWatch(file.getAbsolutePath(), 10000);
+	   } else {
+		   System.out.println("Configure log4j with default properties");
+	   }
+	}
+	
+	private void getAndPrintInventoryContents() throws Exception {
+      TraversalSpec resourcePoolTraversalSpec = new TraversalSpec();
+      resourcePoolTraversalSpec.setName("resourcePoolTraversalSpec");
+      resourcePoolTraversalSpec.setType("ResourcePool");
+      resourcePoolTraversalSpec.setPath("resourcePool");
+      resourcePoolTraversalSpec.setSkip(new Boolean(false));
+      resourcePoolTraversalSpec.setSelectSet(
+      new SelectionSpec [] { new SelectionSpec(null,null,"resourcePoolTraversalSpec") });
+
+      TraversalSpec computeResourceRpTraversalSpec = new TraversalSpec();
+      computeResourceRpTraversalSpec.setName("computeResourceRpTraversalSpec");
+      computeResourceRpTraversalSpec.setType("ComputeResource");
+      computeResourceRpTraversalSpec.setPath("resourcePool");
+      computeResourceRpTraversalSpec.setSkip(new Boolean(false));
+      computeResourceRpTraversalSpec.setSelectSet(
+      new SelectionSpec [] { new SelectionSpec(null,null,"resourcePoolTraversalSpec") });
+
+      TraversalSpec computeResourceHostTraversalSpec = new TraversalSpec();
+      computeResourceHostTraversalSpec.setName("computeResourceHostTraversalSpec");
+      computeResourceHostTraversalSpec.setType("ComputeResource");
+      computeResourceHostTraversalSpec.setPath("host");
+      computeResourceHostTraversalSpec.setSkip(new Boolean(false));
+
+      TraversalSpec datacenterHostTraversalSpec = new TraversalSpec();
+      datacenterHostTraversalSpec.setName("datacenterHostTraversalSpec");
+      datacenterHostTraversalSpec.setType("Datacenter");
+      datacenterHostTraversalSpec.setPath("hostFolder");
+      datacenterHostTraversalSpec.setSkip(new Boolean(false));
+      datacenterHostTraversalSpec.setSelectSet(
+      new SelectionSpec [] { new SelectionSpec(null,null,"folderTraversalSpec") });
+
+      TraversalSpec datacenterVmTraversalSpec = new TraversalSpec();
+      datacenterVmTraversalSpec.setName("datacenterVmTraversalSpec");
+      datacenterVmTraversalSpec.setType("Datacenter");
+      datacenterVmTraversalSpec.setPath("vmFolder");
+      datacenterVmTraversalSpec.setSkip(new Boolean(false));
+      datacenterVmTraversalSpec.setSelectSet(
+      new SelectionSpec [] { new SelectionSpec(null,null,"folderTraversalSpec") });
+
+      TraversalSpec folderTraversalSpec = new TraversalSpec();
+      folderTraversalSpec.setName("folderTraversalSpec");
+      folderTraversalSpec.setType("Folder");
+      folderTraversalSpec.setPath("childEntity");
+      folderTraversalSpec.setSkip(new Boolean(false));
+      folderTraversalSpec.setSelectSet(
+      new SelectionSpec [] { new SelectionSpec(null,null,"folderTraversalSpec"),
+                             datacenterHostTraversalSpec,
+                             datacenterVmTraversalSpec,
+                             computeResourceRpTraversalSpec,
+                             computeResourceHostTraversalSpec,
+                             resourcePoolTraversalSpec });      
+
+      PropertySpec[] propspecary = new PropertySpec[] { new PropertySpec() };
+      propspecary[0].setAll(new Boolean(false));
+      propspecary[0].setPathSet(new String[] { "name" });
+      propspecary[0].setType("ManagedEntity");
+
+      PropertyFilterSpec spec = new PropertyFilterSpec();
+      spec.setPropSet(propspecary);
+      spec.setObjectSet(new ObjectSpec[] { new ObjectSpec() });
+      spec.getObjectSet(0).setObj(cb.getServiceConnection3().getRootFolder());
+      spec.getObjectSet(0).setSkip(new Boolean(false));
+      spec.getObjectSet(0).setSelectSet(
+      new SelectionSpec[] { folderTraversalSpec });      
+
+      // Recursively get all ManagedEntity ManagedObjectReferences 
+      // and the "name" property for all ManagedEntities retrieved
+      ObjectContent[] ocary = 
+        cb.getServiceConnection3().getService().retrieveProperties(
+        cb.getServiceConnection3().getServiceContent().getPropertyCollector(), 
+           new PropertyFilterSpec[] { spec }
+      );
+
+      // If we get contents back. print them out.
+      if (ocary != null) {
+         ObjectContent oc = null;
+         ManagedObjectReference mor = null;
+         DynamicProperty[] pcary = null;
+         DynamicProperty pc = null;
+         for (int oci = 0; oci < ocary.length; oci++) {
+            oc = ocary[oci];
+            mor = oc.getObj();
+            pcary = oc.getPropSet();
+
+            System.out.println("Object Type : " + mor.getType());
+            System.out.println("Reference Value : " + mor.get_value());
+
+            if (pcary != null) {
+               for (int pci = 0; pci < pcary.length; pci++) {
+                  pc = pcary[pci];
+                  System.out.println("   Property Name : " + pc.getName());
+                  if (pc != null) {
+                     if (!pc.getVal().getClass().isArray()) {
+                        System.out.println("   Property Value : " + pc.getVal());
+                     } 
+                     else {
+                        Object[] ipcary = (Object[])pc.getVal();
+                        System.out.println("Val : " + pc.getVal());
+                        for (int ii = 0; ii < ipcary.length; ii++) {
+                           Object oval = ipcary[ii];
+                           if (oval.getClass().getName().indexOf("ManagedObjectReference") >= 0) {
+                              ManagedObjectReference imor = (ManagedObjectReference)oval;
+
+                              System.out.println("Inner Object Type : " + imor.getType());
+                              System.out.println("Inner Reference Value : " + imor.get_value());
+                           } 
+                           else {
+                              System.out.println("Inner Property Value : " + oval);
+                           }
+                        }
+                     }
+                  }
+               }
+            }
+         }
+      } else {
+         System.out.println("No Managed Entities retrieved!");
+      }
+	}
+	
+	private void listDataCenters() {
+		try { 
+			ManagedObjectReference[] morDatacenters = getDataCenterMors();
+			if(morDatacenters != null) {
+				for(ManagedObjectReference mor : morDatacenters) {
+					System.out.println("Datacenter : " + mor.get_value());
+					
+					Map<String, Object> properites = new HashMap<String, Object>();
+					properites.put("name", null);
+					properites.put("vmFolder", null);
+					properites.put("hostFolder", null);
+					
+					getProperites(mor, properites);
+					for(Map.Entry<String, Object> entry : properites.entrySet()) {
+						if(entry.getValue() instanceof ManagedObjectReference) {
+							ManagedObjectReference morProp = (ManagedObjectReference)entry.getValue();
+							System.out.println("\t" + entry.getKey() + ":(" + morProp.getType() + ", " + morProp.get_value() + ")");
+						} else {
+							System.out.println("\t" + entry.getKey() + ":" + entry.getValue());
+						}
+					}
+					
+					System.out.println("Datacenter clusters");
+					ManagedObjectReference[] clusters = getDataCenterClusterMors(mor);
+					if(clusters != null) {
+						for(ManagedObjectReference morCluster : clusters) {
+							Object[] props = this.getProperties(morCluster, new String[] {"name"});
+							System.out.println("cluster : " + props[0]);
+							
+							System.out.println("cluster hosts");
+							ManagedObjectReference[] hosts = getClusterHostMors(morCluster);
+							if(hosts != null) {
+								for(ManagedObjectReference morHost : hosts) {
+									Object[] props2 = this.getProperties(morHost, new String[] {"name"});
+									System.out.println("host : " + props2[0]);
+								}
+							}
+						}
+					}
+					
+					System.out.println("Datacenter standalone hosts");
+					ManagedObjectReference[] hosts = getDataCenterStandaloneHostMors(mor);
+					if(hosts != null) {
+						for(ManagedObjectReference morHost : hosts) {
+							Object[] props = this.getProperties(morHost, new String[] {"name"});
+							System.out.println("host : " + props[0]);
+						}
+					}
+					
+					System.out.println("Datacenter datastores");
+					ManagedObjectReference[] stores = getDataCenterDatastoreMors(mor);
+					if(stores != null) {
+						for(ManagedObjectReference morStore : stores) {
+							// data store name property does not work for some reason
+							Object[] props = getProperties(morStore, new String[] {"info" });
+							
+							System.out.println(morStore.getType() + ": " + ((DatastoreInfo)props[0]).getName());
+						}
+					}
+					
+					System.out.println("Datacenter VMs");
+					ManagedObjectReference[] vms = getDataCenterVMMors(mor);
+					if(stores != null) {
+						for(ManagedObjectReference morVm : vms) {
+							Object[] props = this.getProperties(morVm, new String[] {"name"});
+							System.out.println("VM name: " + props[0] + ", ref val: " + morVm.get_value());
+						}
+					}
+				}
+			}
+		} catch(RuntimeFault e) {
+			e.printStackTrace();
+		} catch(RemoteException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	private void listInventoryFolders() {
+	    TraversalSpec folderTraversalSpec = new TraversalSpec();
+	    folderTraversalSpec.setName("folderTraversalSpec");
+	    folderTraversalSpec.setType("Folder");
+	    folderTraversalSpec.setPath("childEntity");
+	    folderTraversalSpec.setSkip(new Boolean(false));
+	    folderTraversalSpec.setSelectSet(
+	    	new SelectionSpec [] { new SelectionSpec(null, null, "folderTraversalSpec")} 
+	    );
+	    
+	    PropertySpec[] propSpecs = new PropertySpec[] { new PropertySpec() };
+	    propSpecs[0].setAll(new Boolean(false));
+	    propSpecs[0].setPathSet(new String[] { "name" });
+	    propSpecs[0].setType("ManagedEntity");
+	    
+	    PropertyFilterSpec filterSpec = new PropertyFilterSpec();
+	    filterSpec.setPropSet(propSpecs);
+	    filterSpec.setObjectSet(new ObjectSpec[] { new ObjectSpec() });
+	    filterSpec.getObjectSet(0).setObj(cb.getServiceConnection3().getRootFolder());
+	    filterSpec.getObjectSet(0).setSkip(new Boolean(false));
+	    filterSpec.getObjectSet(0).setSelectSet(
+    		new SelectionSpec[] { folderTraversalSpec }
+    	);      
+	    
+	    try {
+			ObjectContent[] objContent = cb.getServiceConnection3().getService().retrieveProperties(
+				cb.getServiceConnection3().getServiceContent().getPropertyCollector(), 
+				new PropertyFilterSpec[] { filterSpec } 
+			);
+			printContent(objContent);
+		} catch (InvalidProperty e) {
+			e.printStackTrace();
+		} catch (RuntimeFault e) {
+			e.printStackTrace();
+		} catch (RemoteException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	private TraversalSpec getFolderRecursiveTraversalSpec() {
+	    SelectionSpec recurseFolders = new SelectionSpec();
+	    recurseFolders.setName("folder2childEntity");
+	      
+	    TraversalSpec folder2childEntity = new TraversalSpec();
+	    folder2childEntity.setType("Folder");
+	    folder2childEntity.setPath("childEntity");
+	    folder2childEntity.setName(recurseFolders.getName());
+	    folder2childEntity.setSelectSet(new SelectionSpec[] { recurseFolders });
+	    
+	    return folder2childEntity;
+	}
+	
+	private ManagedObjectReference[] getDataCenterMors() throws RuntimeFault, RemoteException {
+		PropertySpec pSpec = new PropertySpec();
+	    pSpec.setType("Datacenter");
+	    pSpec.setPathSet(new String[] { "name"} );
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(cb.getServiceConnection3().getRootFolder());
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { getFolderRecursiveTraversalSpec() });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	      
+	    ObjectContent[] ocs = cb.getServiceConnection3().getService().retrieveProperties(
+            cb.getServiceConnection3().getServiceContent().getPropertyCollector(),
+            new PropertyFilterSpec[] { pfSpec });
+	    
+	    if(ocs != null) {
+	    	ManagedObjectReference[] morDatacenters = new ManagedObjectReference[ocs.length];
+	    	for(int i = 0; i < ocs.length; i++)
+	    		morDatacenters[i] = ocs[i].getObj();
+	    	
+	    	return morDatacenters;
+	    }
+	    return null;
+	}
+	
+	private ManagedObjectReference[] getDataCenterVMMors(ManagedObjectReference morDatacenter) throws RuntimeFault, RemoteException {
+		PropertySpec pSpec = new PropertySpec();
+	    pSpec.setType("VirtualMachine");
+	    pSpec.setPathSet(new String[] { "name"} );
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(morDatacenter);
+	    oSpec.setSkip(Boolean.TRUE);
+
+	    TraversalSpec tSpec = new TraversalSpec();
+	    tSpec.setName("dc2VMFolder");
+	    tSpec.setType("Datacenter");
+	    tSpec.setPath("vmFolder");
+	    tSpec.setSelectSet(new SelectionSpec[] { getFolderRecursiveTraversalSpec() } );
+	    
+	    oSpec.setSelectSet(new SelectionSpec[] { tSpec });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	      
+	    ObjectContent[] ocs = cb.getServiceConnection3().getService().retrieveProperties(
+            cb.getServiceConnection3().getServiceContent().getPropertyCollector(),
+            new PropertyFilterSpec[] { pfSpec });
+	    
+	    if(ocs != null) {
+	    	ManagedObjectReference[] morVMs = new ManagedObjectReference[ocs.length];
+	    	for(int i = 0; i < ocs.length; i++)
+	    		morVMs[i] = ocs[i].getObj();
+	    	
+	    	return morVMs;
+	    }
+	    return null;
+	}
+	
+	private ManagedObjectReference[] getDataCenterDatastoreMors(ManagedObjectReference morDatacenter) throws RuntimeFault, RemoteException {
+		Object[] stores = getProperties(morDatacenter, new String[] { "datastore" });
+		if(stores != null && stores.length == 1) {
+			return ((ArrayOfManagedObjectReference)stores[0]).getManagedObjectReference();
+		}
+		return null;
+	}
+	
+	private ManagedObjectReference[] getDataCenterClusterMors(ManagedObjectReference morDatacenter) throws RuntimeFault, RemoteException {
+		PropertySpec pSpec = new PropertySpec();
+	    pSpec.setType("ClusterComputeResource");
+	    pSpec.setPathSet(new String[] { "name"} );
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(morDatacenter);
+	    oSpec.setSkip(Boolean.TRUE);
+	    
+	    TraversalSpec tSpec = new TraversalSpec();
+	    tSpec.setName("traversalHostFolder");
+	    tSpec.setType("Datacenter");
+	    tSpec.setPath("hostFolder");
+	    tSpec.setSkip(false);
+	    tSpec.setSelectSet(new SelectionSpec[] { getFolderRecursiveTraversalSpec() });
+	    
+	    oSpec.setSelectSet(new TraversalSpec[] { tSpec });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	      
+	    ObjectContent[] ocs = cb.getServiceConnection3().getService().retrieveProperties(
+            cb.getServiceConnection3().getServiceContent().getPropertyCollector(),
+            new PropertyFilterSpec[] { pfSpec });
+	    
+	    if(ocs != null) {
+	    	ManagedObjectReference[] morDatacenters = new ManagedObjectReference[ocs.length];
+	    	for(int i = 0; i < ocs.length; i++)
+	    		morDatacenters[i] = ocs[i].getObj();
+	    	
+	    	return morDatacenters;
+	    }
+	    return null;
+	}
+	
+	private ManagedObjectReference[] getDataCenterStandaloneHostMors(ManagedObjectReference morDatacenter) throws RuntimeFault, RemoteException {
+		PropertySpec pSpec = new PropertySpec();
+	    pSpec.setType("ComputeResource");
+	    pSpec.setPathSet(new String[] { "name"} );
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(morDatacenter);
+	    oSpec.setSkip(Boolean.TRUE);
+	    
+	    TraversalSpec tSpec = new TraversalSpec();
+	    tSpec.setName("traversalHostFolder");
+	    tSpec.setType("Datacenter");
+	    tSpec.setPath("hostFolder");
+	    tSpec.setSkip(false);
+	    tSpec.setSelectSet(new SelectionSpec[] { getFolderRecursiveTraversalSpec() });
+	    
+	    oSpec.setSelectSet(new TraversalSpec[] { tSpec });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	      
+	    ObjectContent[] ocs = cb.getServiceConnection3().getService().retrieveProperties(
+            cb.getServiceConnection3().getServiceContent().getPropertyCollector(),
+            new PropertyFilterSpec[] { pfSpec });
+	    
+	    if(ocs != null) {
+	    	List<ManagedObjectReference> listComputeResources = new ArrayList<ManagedObjectReference>();
+	    	for(ObjectContent oc : ocs) {
+	    		if(oc.getObj().getType().equalsIgnoreCase("ComputeResource"))
+	    			listComputeResources.add(oc.getObj());
+	    	}
+	    	
+	    	List<ManagedObjectReference> listHosts = new ArrayList<ManagedObjectReference>();
+	    	for(ManagedObjectReference morComputeResource : listComputeResources) {
+	    		ManagedObjectReference[] hosts = getComputeResourceHostMors(morComputeResource);
+	    		if(hosts != null) {
+	    			for(ManagedObjectReference host: hosts)
+	    				listHosts.add(host);
+	    		}
+	    	}
+	    	
+	    	return listHosts.toArray(new ManagedObjectReference[0]);
+	    }
+	    return null;
+	}
+	
+	private ManagedObjectReference[] getComputeResourceHostMors(ManagedObjectReference morCompute) throws RuntimeFault, RemoteException {
+		PropertySpec pSpec = new PropertySpec();
+	    pSpec.setType("HostSystem");
+	    pSpec.setPathSet(new String[] { "name"} );
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(morCompute);
+	    oSpec.setSkip(true);
+	    
+	    TraversalSpec tSpec = new TraversalSpec();
+	    tSpec.setName("computeResource2Host");
+	    tSpec.setType("ComputeResource");
+	    tSpec.setPath("host");
+	    tSpec.setSkip(false);
+	    oSpec.setSelectSet(new TraversalSpec[] { tSpec });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    ObjectContent[] ocs = cb.getServiceConnection3().getService().retrieveProperties(
+            cb.getServiceConnection3().getServiceContent().getPropertyCollector(),
+            new PropertyFilterSpec[] { pfSpec });
+	    
+	    if(ocs != null) {
+	    	ManagedObjectReference[] morDatacenters = new ManagedObjectReference[ocs.length];
+	    	for(int i = 0; i < ocs.length; i++)
+	    		morDatacenters[i] = ocs[i].getObj();
+	    	
+	    	return morDatacenters;
+	    }
+	    return null;
+	}
+	
+	private ManagedObjectReference[] getClusterHostMors(ManagedObjectReference morCluster) throws RuntimeFault, RemoteException {
+		// ClusterComputeResource inherits from ComputeResource
+		return getComputeResourceHostMors(morCluster);
+	}
+	
+	private ObjectContent[] getDataCenterProperites(String[] properites) throws RuntimeFault, RemoteException {
+		PropertySpec pSpec = new PropertySpec();
+	    pSpec.setType("Datacenter");
+	    pSpec.setPathSet(properites );
+
+	    SelectionSpec recurseFolders = new SelectionSpec();
+	    recurseFolders.setName("folder2childEntity");
+	      
+	    TraversalSpec folder2childEntity = new TraversalSpec();
+	    folder2childEntity.setType("Folder");
+	    folder2childEntity.setPath("childEntity");
+	    folder2childEntity.setName(recurseFolders.getName());
+	    folder2childEntity.setSelectSet(new SelectionSpec[] { recurseFolders });
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(cb.getServiceConnection3().getRootFolder());
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { folder2childEntity });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	      
+	    return cb.getServiceConnection3().getService().retrieveProperties(
+            cb.getServiceConnection3().getServiceContent().getPropertyCollector(),
+            new PropertyFilterSpec[] { pfSpec });
+	}
+	
+	private void printContent(ObjectContent[] objContent) {
+		if(objContent != null) {
+			for(ObjectContent oc : objContent) {
+				ManagedObjectReference mor = oc.getObj();
+		        DynamicProperty[] objProps = oc.getPropSet();
+
+		        System.out.println("Object type: " + mor.getType());
+		        if(objProps != null) {
+		        	for(DynamicProperty objProp : objProps) {
+		        		if(!objProp.getClass().isArray()) {
+		        			System.out.println("\t" + objProp.getName() + "=" + objProp.getVal());
+		        		} else {
+	                        Object[] ipcary = (Object[])objProp.getVal();
+	                        System.out.print("\t" + objProp.getName() + "=[");
+	                        int i = 0;
+	                        for(Object item : ipcary) {
+	                            if (item.getClass().getName().indexOf("ManagedObjectReference") >= 0) {
+	                                ManagedObjectReference imor = (ManagedObjectReference)item;
+	                            	System.out.print("(" + imor.getType() + "," + imor.get_value() + ")");
+	                            } else {
+	                            	System.out.print(item);
+	                            }
+	                            
+	                            if(i < ipcary.length - 1)
+	                            	System.out.print(", ");
+	                            i++;
+	                        }
+	                        
+	                        System.out.println("]");
+		        		}
+		        	}
+		        }
+			}
+		}
+	}
+	
+	private void getProperites(ManagedObjectReference mor, Map<String, Object> properties) throws RuntimeFault, RemoteException {
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType(mor.getType());
+		pSpec.setPathSet(properties.keySet().toArray(new String[0]));
+		
+		ObjectSpec oSpec = new ObjectSpec();
+		oSpec.setObj(mor);
+		
+		PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+		pfSpec.setPropSet(new PropertySpec[] {pSpec} );
+		pfSpec.setObjectSet(new ObjectSpec[] {oSpec} );
+		
+		ObjectContent[] ocs = cb.getServiceConnection3().getService().retrieveProperties(
+	         cb.getServiceConnection3().getServiceContent().getPropertyCollector(),
+	         new PropertyFilterSpec[] {pfSpec} );
+		
+		if(ocs != null) {
+			for(ObjectContent oc : ocs) {
+				DynamicProperty[] propSet = oc.getPropSet();
+				if(propSet != null) {
+					for(DynamicProperty prop : propSet) {
+						properties.put(prop.getName(), prop.getVal());
+					}
+				}
+			}
+		}
+	}
+	
+	private Object[] getProperties(ManagedObjectReference moRef, String[] properties) throws RuntimeFault, RemoteException {
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType(moRef.getType());
+		pSpec.setPathSet(properties);
+
+		ObjectSpec oSpec = new ObjectSpec();
+		// Set the starting object
+		oSpec.setObj(moRef);
+		
+		PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+		pfSpec.setPropSet(new PropertySpec[] {pSpec} );
+		pfSpec.setObjectSet(new ObjectSpec[] {oSpec} );
+		ObjectContent[] ocs = cb.getServiceConnection3().getService().retrieveProperties(
+	         cb.getServiceConnection3().getServiceContent().getPropertyCollector(),
+	         new PropertyFilterSpec[] {pfSpec} );
+
+		Object[] ret = new Object[properties.length];
+		if(ocs != null) {
+			for(int i = 0; i< ocs.length; ++i) {
+				ObjectContent oc = ocs[i];
+				DynamicProperty[] dps = oc.getPropSet();
+				if(dps != null) {
+					for(int j = 0; j < dps.length; ++j) {
+						DynamicProperty dp = dps[j];
+						for(int p = 0; p < ret.length; ++p) {
+							if(properties[p].equals(dp.getName())) {
+								ret[p] = dp.getVal();
+							}
+						}
+					}
+				}
+			}
+		}
+		return ret;
+	}
+
+	private void powerOnVm() throws Exception {
+		ManagedObjectReference morVm = new ManagedObjectReference();
+		morVm.setType("VirtualMachine");
+		morVm.set_value("vm-480");
+		
+		cb.getServiceConnection3().getService().powerOnVM_Task(morVm, null);
+	}
+	
+	private void powerOffVm() throws Exception {
+		ManagedObjectReference morVm = new ManagedObjectReference();
+		morVm.setType("VirtualMachine");
+		morVm.set_value("vm-66");
+		
+		cb.getServiceConnection3().getService().powerOffVM_Task(morVm);
+	}
+	
+	private void createSnapshot() throws Exception {
+		ManagedObjectReference morVm = new ManagedObjectReference();
+		morVm.setType("VirtualMachine");
+		morVm.set_value("vm-66");
+		cb.getServiceConnection3().getService().createSnapshot_Task(morVm, "RunningSnapshotProg", "", false, false);
+	}
+	
+	private void registerTemplate() throws Exception {
+      ManagedObjectReference morFolder = new ManagedObjectReference();
+      morFolder.setType("Folder");
+      morFolder.set_value("group-v3");
+      
+      ManagedObjectReference morHost = new ManagedObjectReference();
+      morHost.setType("HostSystem");
+      morHost.set_value("host-48");
+
+      System.out.println("Begin registerVM_Task");
+      ManagedObjectReference taskmor = cb.getServiceConnection3().getService().registerVM_Task(
+    		  morFolder, "[NFS datastore] Template-Fedora/Template-Fedora.vmtx", "Template-Fedora", true, 
+		  null, morHost);
+      System.out.println("End registerVM_Task");
+
+      String result = cb.getServiceUtil3().waitForTask(taskmor);
+      if (result.equalsIgnoreCase("Sucess")) {
+    	  System.out.println("Registering The Virtual Machine ..........Done");
+      } else {
+    	  System.out.println("Some Exception While Registering The VM");
+      }
+	}
+	
+	private void createVmFromTemplate() throws Exception {
+	     VirtualMachineCloneSpec cloneSpec = new VirtualMachineCloneSpec();
+	     
+	     ManagedObjectReference morDatastore = new ManagedObjectReference();
+	     morDatastore.setType("Datastore");
+	     morDatastore.set_value("datastore-30");
+	     
+	     ManagedObjectReference morHost = new ManagedObjectReference();
+	     morHost.setType("HostSystem");
+	     morHost.set_value("host-48");
+	     
+	     ManagedObjectReference morPool = new ManagedObjectReference();
+	     morPool.setType("ResourcePool");
+	     morPool.set_value("resgroup-41");
+	     
+	     VirtualMachineRelocateSpec relocSpec = new VirtualMachineRelocateSpec();
+	     cloneSpec.setLocation(relocSpec);
+	     cloneSpec.setPowerOn(false);
+	     cloneSpec.setTemplate(false);
+	     
+	     relocSpec.setDatastore(morDatastore);
+	     relocSpec.setHost(morHost);
+	     relocSpec.setPool(morPool);
+	     
+	     ManagedObjectReference morTemplate = new ManagedObjectReference();
+	     morTemplate.setType("VirtualMachine");
+	     morTemplate.set_value("vm-76");
+	     
+	     ManagedObjectReference morFolder = new ManagedObjectReference();
+	     morFolder.setType("Folder");
+	     morFolder.set_value("group-v3");
+	      
+         ManagedObjectReference cloneTask 
+            = cb.getServiceConnection3().getService().cloneVM_Task(morTemplate, morFolder, 
+            	"Fedora-clone-test", cloneSpec);
+         
+         String status = cb.getServiceUtil3().waitForTask(cloneTask);
+         if(status.equalsIgnoreCase("failure")) {
+            System.out.println("Failure -: Virtual Machine cannot be cloned");
+         }
+                  
+         if(status.equalsIgnoreCase("sucess")) {
+            System.out.println("Virtual Machine Cloned  successfully.");
+         }
+	}
+	
+	private void addNic() throws Exception {
+		ManagedObjectReference morVm = new ManagedObjectReference();
+		morVm.setType("VirtualMachine");
+		morVm.set_value("vm-77");
+		
+		ManagedObjectReference morNetwork = new ManagedObjectReference();
+		morNetwork.setType("DistributedVirtualPortgroup");
+		morNetwork.set_value("dvportgroup-56");
+		
+		VirtualDeviceConfigSpec nicSpec = new VirtualDeviceConfigSpec();
+        nicSpec.setOperation(VirtualDeviceConfigSpecOperation.add);
+        VirtualEthernetCard nic =  new VirtualPCNet32();
+        VirtualEthernetCardNetworkBackingInfo nicBacking 
+           = new VirtualEthernetCardNetworkBackingInfo();
+        nicBacking.setDeviceName("Adapter to dSwitch-vlan26");
+        nicBacking.setNetwork(morNetwork);
+        
+        nic.setAddressType("generated");
+        nic.setBacking(nicBacking);
+        nic.setKey(4);
+        nicSpec.setDevice(nic);
+        
+        VirtualMachineConfigSpec vmConfigSpec = new VirtualMachineConfigSpec();
+        VirtualDeviceConfigSpec [] nicSpecArray = {nicSpec};                     
+        vmConfigSpec.setDeviceChange(nicSpecArray);
+        
+        ManagedObjectReference tmor 
+        	= cb.getServiceConnection3().getService().reconfigVM_Task(
+            morVm, vmConfigSpec);
+        
+        String status = cb.getServiceUtil3().waitForTask(tmor);
+        if(status.equalsIgnoreCase("failure")) {
+           System.out.println("Failure -: Virtual Machine cannot be cloned");
+        }
+                 
+        if(status.equalsIgnoreCase("sucess")) {
+           System.out.println("Virtual Machine Cloned  successfully.");
+        }
+	}
+	
+	// add virtual NIC to vmkernel
+	private void addNicToNetwork() throws Exception {
+		ManagedObjectReference morHost = new ManagedObjectReference();
+		morHost.setType("HostSystem");
+		morHost.set_value("host-48");
+		
+        HostPortGroupSpec portgrp = new HostPortGroupSpec();
+        portgrp.setName("VM Network vlan26");
+		
+        Object cmobj = cb.getServiceUtil3().getDynamicProperty(morHost, "configManager");
+        HostConfigManager configMgr = (HostConfigManager)cmobj;
+        ManagedObjectReference nwSystem = configMgr.getNetworkSystem();
+        
+        HostVirtualNicSpec vNicSpec = new HostVirtualNicSpec();
+        HostIpConfig ipConfig = new HostIpConfig();
+        ipConfig.setDhcp(false);
+        ipConfig.setIpAddress("192.168.26.177");
+        ipConfig.setSubnetMask("255.255.255.0");
+        
+        vNicSpec.setIp(ipConfig);
+        vNicSpec.setPortgroup("VM Network vlan26");
+        
+        cb.getServiceConnection3().getService().addVirtualNic(nwSystem, 
+        		"dvPortGroup-vlan26", vNicSpec);
+	}
+	
+	private void createDatacenter() throws Exception {
+		cb.getServiceConnection3().getService().createDatacenter(
+			cb.getServiceConnection3().getRootFolder(), 
+			"cloud.dc.test");
+	}
+	
+	private void getPropertyWithPath() throws Exception {
+		ManagedObjectReference morHost = new ManagedObjectReference();
+		morHost.setType("HostSystem");
+		morHost.set_value("host-161");
+		
+		VirtualNicManagerNetConfig[] netConfigs = (VirtualNicManagerNetConfig[])cb.getServiceUtil3().getDynamicProperty(morHost, "config.virtualNicManagerInfo.netConfig");
+	}
+	
+	private void getHostVMs() throws Exception {
+		ManagedObjectReference morHost = new ManagedObjectReference();
+		morHost.setType("HostSystem");
+		morHost.set_value("host-48");
+		
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("VirtualMachine");
+		pSpec.setPathSet(new String[] { "name", "runtime.powerState", "config.template" });
+		
+	    TraversalSpec host2VmTraversal = new TraversalSpec();
+	    host2VmTraversal.setType("HostSystem");
+	    host2VmTraversal.setPath("vm");
+	    host2VmTraversal.setName("host2VmTraversal");
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(morHost);
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { host2VmTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+		      
+	    ObjectContent[] ocs = cb.getServiceConnection3().getService().retrieveProperties(
+            cb.getServiceConnection3().getServiceContent().getPropertyCollector(),
+            new PropertyFilterSpec[] { pfSpec });
+	    this.printContent(ocs);
+	}
+	
+	private void testFT() throws Exception {
+		
+		ManagedObjectReference morVm = new ManagedObjectReference();
+		morVm.setType("VirtualMachine");
+		morVm.set_value("vm-480");
+		
+		ManagedObjectReference morHost = new ManagedObjectReference();
+		morHost.setType("HostSystem");
+		morHost.set_value("host-470");
+
+		System.out.println("Create secondary VM");
+		ManagedObjectReference morTask = cb.getServiceConnection3().getService().createSecondaryVM_Task(morVm, morHost);
+		String result = cb.getServiceUtil3().waitForTask(morTask);
+		
+		System.out.println("Create secondary VM resutl : " + result);
+	}
+	
+	private void testFTEnable() throws Exception {
+		ManagedObjectReference morVm = new ManagedObjectReference();
+		morVm.setType("VirtualMachine");
+		morVm.set_value("vm-480");
+		
+		ManagedObjectReference morHost = new ManagedObjectReference();
+		morHost.setType("HostSystem");
+		morHost.set_value("host-470");
+
+		ManagedObjectReference morSecondaryVm = new ManagedObjectReference();
+		morSecondaryVm.setType("VirtualMachine");
+		morSecondaryVm.set_value("vm-485");
+		
+		System.out.println("Enable FT");
+		ManagedObjectReference morTask = cb.getServiceConnection3().getService().enableSecondaryVM_Task(morVm, 
+			morSecondaryVm, morHost);
+		String result = cb.getServiceUtil3().waitForTask(morTask);
+		
+		System.out.println("Enable FT resutl : " + result);
+	}
+	
+	private void importOVF() throws Exception {
+		ManagedObjectReference morHost = new ManagedObjectReference();
+		morHost.setType("HostSystem");
+		morHost.set_value("host-223");
+		
+		ManagedObjectReference morRp = new ManagedObjectReference();
+		morRp.setType("ResourcePool");
+		morRp.set_value("resgroup-222");
+		
+		ManagedObjectReference morDs = new ManagedObjectReference();
+		morDs.setType("Datastore");
+		morDs.set_value("datastore-30");
+		
+		ManagedObjectReference morVmFolder = new ManagedObjectReference();
+		morVmFolder.setType("Folder");
+		morVmFolder.set_value("group-v3");
+		
+		ManagedObjectReference morNetwork = new ManagedObjectReference();
+		morNetwork.setType("Network");
+		morNetwork.set_value("network-32");
+		
+		ManagedObjectReference morOvf = cb.getServiceConnection3().getServiceContent().getOvfManager();
+		
+		OvfCreateImportSpecParams importSpecParams = new OvfCreateImportSpecParams();  
+		importSpecParams.setHostSystem(morHost);  
+		importSpecParams.setLocale("US");  
+		importSpecParams.setEntityName("winxpsp3-ovf-deployed");  
+		importSpecParams.setDeploymentOption("");
+		importSpecParams.setDiskProvisioning("thin");
+
+/*		
+		OvfNetworkMapping networkMapping = new OvfNetworkMapping();  
+		networkMapping.setName("VM Network");  
+		networkMapping.setNetwork(morNetwork); // network);  
+		importSpecParams.setNetworkMapping(new OvfNetworkMapping[] { networkMapping });
+*/		
+		importSpecParams.setPropertyMapping(null);
+		
+		String ovfDescriptor = readOvfContent("C:\\research\\vmware\\winxpsp3-ovf\\winxpsp3-ovf.ovf");
+		OvfCreateImportSpecResult ovfImportResult = cb.getServiceConnection3().getService().createImportSpec(
+			morOvf, ovfDescriptor, morRp, morDs, importSpecParams);
+		
+		if(ovfImportResult != null) {
+			long totalBytes = addTotalBytes(ovfImportResult);
+			
+			ManagedObjectReference morLease = cb.getServiceConnection3().getService().importVApp(morRp, 
+				ovfImportResult.getImportSpec(), morVmFolder, morHost);
+			
+			HttpNfcLeaseState state;
+			for(;;) {
+				state = (HttpNfcLeaseState)cb.getServiceUtil3().getDynamicProperty(morLease, "state");
+				if(state == HttpNfcLeaseState.ready || state == HttpNfcLeaseState.error)
+					break;
+			}
+			
+			if(state == HttpNfcLeaseState.ready) {
+				HttpNfcLeaseInfo httpNfcLeaseInfo = (HttpNfcLeaseInfo)cb.getServiceUtil3().getDynamicProperty(morLease, "info");
+		        HttpNfcLeaseDeviceUrl[] deviceUrls = httpNfcLeaseInfo.getDeviceUrl();  
+		        long bytesAlreadyWritten = 0;  
+		        for (HttpNfcLeaseDeviceUrl deviceUrl : deviceUrls) {
+		        	
+		        	String deviceKey = deviceUrl.getImportKey();  
+		        	for (OvfFileItem ovfFileItem : ovfImportResult.getFileItem()) {  
+		        		if (deviceKey.equals(ovfFileItem.getDeviceId())) {  
+		        			System.out.println("Import key==OvfFileItem device id: " + deviceKey);
+		        			System.out.println("device URL: " + deviceUrl.getUrl());
+		        			
+		        			String absoluteFile = "C:\\research\\vmware\\winxpsp3-ovf\\" + ovfFileItem.getPath();
+		        			String urlToPost = deviceUrl.getUrl().replace("*", "esxhost-1.lab.vmops.com");  
+		        			  	
+	        			  	uploadVmdkFile(ovfFileItem.isCreate(), absoluteFile, urlToPost, bytesAlreadyWritten, totalBytes);  
+	        			  	bytesAlreadyWritten += ovfFileItem.getSize();  
+	        			  	System.out.println("Completed uploading the VMDK file:" + absoluteFile);  
+	        			 }  
+		        	 }  
+		         }
+		         cb.getServiceConnection3().getService().httpNfcLeaseProgress(morLease, 100);
+		         cb.getServiceConnection3().getService().httpNfcLeaseComplete(morLease);
+			}
+		}
+	}
+	
+	 private static void uploadVmdkFile(boolean put, String diskFilePath, String urlStr, long bytesAlreadyWritten, long totalBytes) throws IOException {  
+		 HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {  
+			 public boolean verify(String urlHostName, SSLSession session) {  
+				 return true;  
+			 }  
+		 });  
+
+		 HttpsURLConnection conn = (HttpsURLConnection) new URL(urlStr).openConnection();
+		 
+		 conn.setDoOutput(true);  
+		 conn.setUseCaches(false);
+		 
+		 int CHUCK_LEN = 64*1024;
+		 conn.setChunkedStreamingMode(CHUCK_LEN);  
+		 conn.setRequestMethod(put? "PUT" : "POST"); // Use a post method to write the file.  
+		 conn.setRequestProperty("Connection", "Keep-Alive");  
+		 conn.setRequestProperty("Content-Type", "application/x-vnd.vmware-streamVmdk");  
+		 conn.setRequestProperty("Content-Length", Long.toString(new File(diskFilePath).length()));  
+		 BufferedOutputStream bos = new BufferedOutputStream(conn.getOutputStream());  
+		 BufferedInputStream diskis = new BufferedInputStream(new FileInputStream(diskFilePath));  
+		 int bytesAvailable = diskis.available();  
+		 int bufferSize = Math.min(bytesAvailable, CHUCK_LEN);  
+		 byte[] buffer = new byte[bufferSize];  
+		 long totalBytesWritten = 0;  
+		 while (true) {  
+			 int bytesRead = diskis.read(buffer, 0, bufferSize);  
+			 if (bytesRead == -1)  
+			 {  
+				 System.out.println("Total bytes written: " + totalBytesWritten);  
+				 break;  
+			 }  
+			 totalBytesWritten += bytesRead;  
+			 bos.write(buffer, 0, bufferSize);  
+			 bos.flush();  
+			 System.out.println("Total bytes written: " + totalBytesWritten);
+			 
+/*			 
+			int progressPercent = (int) (((bytesAlreadyWritten + totalBytesWritten) * 100) / totalBytes);  
+			 	leaseUpdater.setPercent(progressPercent);  
+*/			  
+		}
+	 	diskis.close();  
+	 	bos.flush();  
+	 	bos.close();  
+	 	conn.disconnect();  
+	}
+	
+	public static long addTotalBytes(OvfCreateImportSpecResult ovfImportResult) {  
+		OvfFileItem[] fileItemArr = ovfImportResult.getFileItem();  
+		long totalBytes = 0;  
+		if (fileItemArr != null) {  
+			for (OvfFileItem fi : fileItemArr) {  
+				printOvfFileItem(fi);  
+				totalBytes += fi.getSize();  
+			}  
+		}  
+		return totalBytes;  
+	}
+	
+	private static void printOvfFileItem(OvfFileItem fi) {  
+		System.out.println("================ OvfFileItem ================");  
+		System.out.println("chunkSize: " + fi.getChunkSize());  
+		System.out.println("create: " + fi.isCreate());  
+		System.out.println("deviceId: " + fi.getDeviceId());  
+		System.out.println("path: " + fi.getPath());  
+		System.out.println("size: " + fi.getSize());  
+		System.out.println("==============================================");  
+	}  
+	
+	public static String readOvfContent(String ovfFilePath) throws IOException	 {  
+		StringBuffer strContent = new StringBuffer();  
+		BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(ovfFilePath)));  
+		String lineStr;  
+		while ((lineStr = in.readLine()) != null) {  
+			strContent.append(lineStr);  
+		}  
+
+		in.close();  
+		return strContent.toString();  
+	}
+	
+	public static String escapeSpecialChars(String str)	{  
+		str = str.replaceAll("<", "&lt;");  
+		return str.replaceAll(">", "&gt;"); // do not escape "&" -> "&amp;", "\"" -> "&quot;"  
+	}  
+	
+	public static void main(String[] args) throws Exception {
+		setupLog4j();
+		TestVMWare client = new TestVMWare();
+	   
+		// skip certificate check
+		System.setProperty("axis.socketSecureFactory", "org.apache.axis.components.net.SunFakeTrustSocketFactory");
+		 
+		String serviceUrl = "https://" + args[0] + "/sdk/vimService";
+		
+		try {
+			String[] params = new String[] {"--url", serviceUrl, "--username", args[1], "--password", args[2] };
+		 
+			cb = ExtendedAppUtil.initialize("Connect", params);
+			cb.connect();
+			System.out.println("Connection Succesful.");
+
+			// client.listInventoryFolders();
+			// client.listDataCenters();
+			// client.powerOnVm();
+			// client.createSnapshot();
+			// client.registerTemplate();
+			// client.createVmFromTemplate();
+			// client.addNic();
+			// client.addNicToNetwork();
+
+			// client.createDatacenter();
+			// client.getPropertyWithPath();
+			// client.getHostVMs();
+			// client.testFT();
+			// client.testFTEnable();
+			
+			client.importOVF();
+		
+			cb.disConnect();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public static class TrustAllManager implements javax.net.ssl.TrustManager, javax.net.ssl.X509TrustManager {
+		
+		public java.security.cert.X509Certificate[] getAcceptedIssuers() {
+			return null;
+		}
+		
+		public boolean isServerTrusted(java.security.cert.X509Certificate[] certs) {
+			return true;
+		}
+		
+		public boolean isClientTrusted(java.security.cert.X509Certificate[] certs) {
+			return true;
+		}
+		
+		public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType)
+	      	throws java.security.cert.CertificateException {
+			return;
+		} 
+		public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType)
+	      	throws java.security.cert.CertificateException {
+			return;
+		}
+	}
+}
+
diff --git a/deps/.classpath b/deps/.classpath
index 73897f769d4..f17e9e1a581 100644
--- a/deps/.classpath
+++ b/deps/.classpath
@@ -35,5 +35,21 @@
 	<classpathentry exported="true" kind="lib" path="cloud-log4j-extras.jar"/>
 	<classpathentry exported="true" kind="lib" path="cloud-iControl.jar"/>
 	<classpathentry exported="true" kind="lib" path="cloud-manageontap.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-apputils.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-credstore.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-lib-activation.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-lib-jaxen-core.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-lib-jaxen-jdom.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-lib-jaxrpc.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-lib-jdom.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-lib-mailapi.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-lib-saxpath.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-lib-smtp.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-lib-wbem.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-lib-xalan.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-lib-xerces.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-lib-xml-apis.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-vim.jar"/>
+	<classpathentry exported="true" kind="lib" path="vmware-vim25.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/deps/vmware-apputils.jar b/deps/vmware-apputils.jar
new file mode 100644
index 00000000000..f93d46eba06
Binary files /dev/null and b/deps/vmware-apputils.jar differ
diff --git a/deps/vmware-credstore.jar b/deps/vmware-credstore.jar
new file mode 100644
index 00000000000..b661fd878b6
Binary files /dev/null and b/deps/vmware-credstore.jar differ
diff --git a/deps/vmware-lib-activation.jar b/deps/vmware-lib-activation.jar
new file mode 100644
index 00000000000..8cbef16f485
Binary files /dev/null and b/deps/vmware-lib-activation.jar differ
diff --git a/deps/vmware-lib-jaxen-core.jar b/deps/vmware-lib-jaxen-core.jar
new file mode 100644
index 00000000000..e52bf679cc0
Binary files /dev/null and b/deps/vmware-lib-jaxen-core.jar differ
diff --git a/deps/vmware-lib-jaxen-jdom.jar b/deps/vmware-lib-jaxen-jdom.jar
new file mode 100644
index 00000000000..978bd026919
Binary files /dev/null and b/deps/vmware-lib-jaxen-jdom.jar differ
diff --git a/deps/vmware-lib-jaxrpc.jar b/deps/vmware-lib-jaxrpc.jar
new file mode 100644
index 00000000000..a2c13d9a212
Binary files /dev/null and b/deps/vmware-lib-jaxrpc.jar differ
diff --git a/deps/vmware-lib-jdom.jar b/deps/vmware-lib-jdom.jar
new file mode 100644
index 00000000000..288e64cb5c4
Binary files /dev/null and b/deps/vmware-lib-jdom.jar differ
diff --git a/deps/vmware-lib-mailapi.jar b/deps/vmware-lib-mailapi.jar
new file mode 100644
index 00000000000..2f8620b6d4a
Binary files /dev/null and b/deps/vmware-lib-mailapi.jar differ
diff --git a/deps/vmware-lib-saxpath.jar b/deps/vmware-lib-saxpath.jar
new file mode 100644
index 00000000000..2b43955babc
Binary files /dev/null and b/deps/vmware-lib-saxpath.jar differ
diff --git a/deps/vmware-lib-smtp.jar b/deps/vmware-lib-smtp.jar
new file mode 100644
index 00000000000..145d302d28a
Binary files /dev/null and b/deps/vmware-lib-smtp.jar differ
diff --git a/deps/vmware-lib-wbem.jar b/deps/vmware-lib-wbem.jar
new file mode 100644
index 00000000000..a4b806df469
Binary files /dev/null and b/deps/vmware-lib-wbem.jar differ
diff --git a/deps/vmware-lib-xalan.jar b/deps/vmware-lib-xalan.jar
new file mode 100644
index 00000000000..b8f25753260
Binary files /dev/null and b/deps/vmware-lib-xalan.jar differ
diff --git a/deps/vmware-lib-xerces.jar b/deps/vmware-lib-xerces.jar
new file mode 100644
index 00000000000..e9fe08ad452
Binary files /dev/null and b/deps/vmware-lib-xerces.jar differ
diff --git a/deps/vmware-lib-xml-apis.jar b/deps/vmware-lib-xml-apis.jar
new file mode 100644
index 00000000000..2dd83771445
Binary files /dev/null and b/deps/vmware-lib-xml-apis.jar differ
diff --git a/deps/vmware-vim.jar b/deps/vmware-vim.jar
new file mode 100644
index 00000000000..c9831af675f
Binary files /dev/null and b/deps/vmware-vim.jar differ
diff --git a/deps/vmware-vim25.jar b/deps/vmware-vim25.jar
new file mode 100644
index 00000000000..01ba127da12
Binary files /dev/null and b/deps/vmware-vim25.jar differ
diff --git a/server/.classpath b/server/.classpath
index a533b6c64e4..a4df474268d 100644
--- a/server/.classpath
+++ b/server/.classpath
@@ -8,5 +8,6 @@
 	<classpathentry combineaccessrules="false" kind="src" path="/api"/>
 	<classpathentry combineaccessrules="false" kind="src" path="/deps"/>
 	<classpathentry combineaccessrules="false" kind="src" path="/tools"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/vmware-base"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/server/src/com/cloud/hypervisor/guru/HypervGuru.java b/server/src/com/cloud/hypervisor/guru/HypervGuru.java
new file mode 100644
index 00000000000..204066895e1
--- /dev/null
+++ b/server/src/com/cloud/hypervisor/guru/HypervGuru.java
@@ -0,0 +1,63 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.guru;
+
+import javax.ejb.Local;
+
+import com.cloud.agent.api.Command;
+import com.cloud.agent.api.to.VirtualMachineTO;
+import com.cloud.host.dao.HostDetailsDao;
+import com.cloud.host.dao.HostDao;
+import com.cloud.hypervisor.HypervisorGuru;
+import com.cloud.hypervisor.HypervisorGuruBase;
+import com.cloud.hypervisor.Hypervisor.HypervisorType;
+import com.cloud.storage.GuestOSVO;
+import com.cloud.storage.dao.GuestOSDao;
+import com.cloud.template.VirtualMachineTemplate.BootloaderType;
+import com.cloud.utils.component.Inject;
+import com.cloud.vm.VirtualMachine;
+import com.cloud.vm.VirtualMachineProfile;
+
+/**
+ * Implementation of Hypervisor guru for Hyper-Vr
+ **/
+
+@Local(value=HypervisorGuru.class)
+public class HypervGuru extends HypervisorGuruBase implements HypervisorGuru {
+
+    @Inject GuestOSDao _guestOsDao;
+    @Inject HostDao _hostDao;
+    @Inject HostDetailsDao _hostDetailsDao;
+
+    protected HypervGuru() {
+    	super();
+    }
+    
+    @Override
+    public HypervisorType getHypervisorType() {
+        return HypervisorType.Hyperv;
+    }
+
+    @Override
+    public <T extends VirtualMachine> VirtualMachineTO implement(VirtualMachineProfile<T> vm) {
+        VirtualMachineTO to = toVirtualMachineTO(vm);
+        to.setBootloader(BootloaderType.HVM);
+
+        // Determine the VM's OS description
+        GuestOSVO guestOS = _guestOsDao.findById(vm.getVirtualMachine().getGuestOSId());
+        to.setOs(guestOS.getDisplayName());
+        return to;
+    }
+    
+    @Override
+    public long getCommandHostDelegation(long hostId, Command cmd) {
+    	return hostId;
+    }   
+    
+    @Override
+    public boolean trackVmHostChange() {
+    	return false;
+    }
+}
diff --git a/server/src/com/cloud/hypervisor/guru/VMwareGuru.java b/server/src/com/cloud/hypervisor/guru/VMwareGuru.java
new file mode 100644
index 00000000000..19f92ee5b0d
--- /dev/null
+++ b/server/src/com/cloud/hypervisor/guru/VMwareGuru.java
@@ -0,0 +1,153 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+package com.cloud.hypervisor.guru;
+
+import java.util.Map;
+
+import javax.ejb.Local;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.agent.api.BackupSnapshotCommand;
+import com.cloud.agent.api.Command;
+import com.cloud.agent.api.CreatePrivateTemplateFromSnapshotCommand;
+import com.cloud.agent.api.CreatePrivateTemplateFromVolumeCommand;
+import com.cloud.agent.api.CreateVolumeFromSnapshotCommand;
+import com.cloud.agent.api.DeleteSnapshotBackupCommand;
+import com.cloud.agent.api.DeleteSnapshotsDirCommand;
+import com.cloud.agent.api.storage.CopyVolumeCommand;
+import com.cloud.agent.api.storage.PrimaryStorageDownloadCommand;
+import com.cloud.agent.api.to.VirtualMachineTO;
+import com.cloud.cluster.CheckPointManager;
+import com.cloud.cluster.ClusterManager;
+import com.cloud.host.HostVO;
+import com.cloud.host.dao.HostDetailsDao;
+import com.cloud.host.dao.HostDao;
+import com.cloud.hypervisor.Hypervisor.HypervisorType;
+import com.cloud.hypervisor.HypervisorGuru;
+import com.cloud.hypervisor.HypervisorGuruBase;
+import com.cloud.hypervisor.vmware.VmwareCleanupMaid;
+import com.cloud.hypervisor.vmware.manager.VmwareManager;
+import com.cloud.secstorage.CommandExecLogDao;
+import com.cloud.secstorage.CommandExecLogVO;
+import com.cloud.storage.GuestOSVO;
+import com.cloud.storage.dao.GuestOSDao;
+import com.cloud.storage.secondary.SecondaryStorageVmManager;
+import com.cloud.template.VirtualMachineTemplate.BootloaderType;
+import com.cloud.utils.Pair;
+import com.cloud.utils.component.Inject;
+import com.cloud.utils.db.DB;
+import com.cloud.utils.net.NetUtils;
+import com.cloud.vm.SecondaryStorageVmVO;
+import com.cloud.vm.VirtualMachine;
+import com.cloud.vm.VirtualMachineProfile;
+
+@Local(value=HypervisorGuru.class)
+public class VMwareGuru extends HypervisorGuruBase implements HypervisorGuru {
+	private static final Logger s_logger = Logger.getLogger(VMwareGuru.class);
+
+	@Inject GuestOSDao _guestOsDao;
+    @Inject HostDao _hostDao;
+    @Inject HostDetailsDao _hostDetailsDao;
+    @Inject CommandExecLogDao _cmdExecLogDao;
+    @Inject ClusterManager _clusterMgr;
+    @Inject VmwareManager _vmwareMgr;
+    @Inject SecondaryStorageVmManager _secStorageMgr;
+    @Inject CheckPointManager _checkPointMgr;
+
+    protected VMwareGuru() {
+    	super();
+    }
+    
+    @Override
+    public HypervisorType getHypervisorType() {
+        return HypervisorType.VMware;
+    }
+
+    @Override
+    public <T extends VirtualMachine> VirtualMachineTO implement(VirtualMachineProfile<T> vm) {
+        VirtualMachineTO to = toVirtualMachineTO(vm);
+        to.setBootloader(BootloaderType.HVM);
+
+        // Determine the VM's OS description
+        GuestOSVO guestOS = _guestOsDao.findById(vm.getVirtualMachine().getGuestOSId());
+        to.setOs(guestOS.getDisplayName());
+        return to;
+    }
+    
+    @Override @DB
+    public long getCommandHostDelegation(long hostId, Command cmd) {
+    	boolean needDelegation = false;
+    	
+    	if(cmd instanceof PrimaryStorageDownloadCommand || 
+    		cmd instanceof BackupSnapshotCommand ||
+    		cmd instanceof DeleteSnapshotsDirCommand ||
+    		cmd instanceof DeleteSnapshotBackupCommand ||
+    		cmd instanceof CreatePrivateTemplateFromVolumeCommand ||
+    		cmd instanceof CreatePrivateTemplateFromSnapshotCommand ||
+    		cmd instanceof CopyVolumeCommand ||
+    		cmd instanceof CreateVolumeFromSnapshotCommand) {
+    		needDelegation = true;
+    	}
+
+    	if(needDelegation) {
+    		HostVO host = _hostDao.findById(hostId);
+    		assert(host != null);
+    		assert(host.getHypervisorType() == HypervisorType.VMware);
+    		long dcId = host.getDataCenterId();
+    		
+    		Pair<HostVO, SecondaryStorageVmVO> cmdTarget = _secStorageMgr.assignSecStorageVm(dcId, cmd);
+    		if(cmdTarget != null) {
+    			// TODO, we need to make sure agent is actually connected too
+    			cmd.setContextParam("hypervisor", HypervisorType.VMware.toString());
+    		    Map<String, String> hostDetails = _hostDetailsDao.findDetails(hostId);
+    		    cmd.setContextParam("guid", resolveNameInGuid(hostDetails.get("guid")));
+    		    cmd.setContextParam("username", hostDetails.get("username"));
+    		    cmd.setContextParam("password", hostDetails.get("password"));
+    			cmd.setContextParam("serviceconsole", _vmwareMgr.getServiceConsolePortGroupName());
+    			cmd.setContextParam("manageportgroup", _vmwareMgr.getManagementPortGroupName());
+    			
+    			CommandExecLogVO execLog = new CommandExecLogVO(cmdTarget.first().getId(), cmdTarget.second().getId(), cmd.getClass().getSimpleName(), 1);
+    			_cmdExecLogDao.persist(execLog);
+    			cmd.setContextParam("execid", String.valueOf(execLog.getId()));
+    			
+    			if(cmd instanceof BackupSnapshotCommand || 
+    				cmd instanceof CreatePrivateTemplateFromVolumeCommand || 
+    				cmd instanceof CreatePrivateTemplateFromSnapshotCommand ||
+    				cmd instanceof CopyVolumeCommand ||
+    				cmd instanceof CreateVolumeFromSnapshotCommand) {
+    				
+    				String workerName = _vmwareMgr.composeWorkerName();
+    				long checkPointId = _checkPointMgr.pushCheckPoint(new VmwareCleanupMaid(hostDetails.get("guid"), workerName));
+    				cmd.setContextParam("worker", workerName);
+    				cmd.setContextParam("checkpoint", String.valueOf(checkPointId));
+    			}
+    			
+    			return cmdTarget.first().getId();
+    		}
+    	}
+  
+    	return hostId;
+    }
+    
+    public boolean trackVmHostChange() {
+    	return true;
+    }
+    
+    private static String resolveNameInGuid(String guid) {
+    	String tokens[] = guid.split("@");
+    	assert(tokens.length == 2);
+
+    	String vCenterIp = NetUtils.resolveToIp(tokens[1]);
+    	if(vCenterIp == null) {
+    		s_logger.error("Fatal : unable to resolve vCenter address " + tokens[1] + ", please check your DNS configuration");
+    		return guid;
+    	}
+    	
+    	if(vCenterIp.equals(tokens[1]))
+    		return guid;
+    	
+    	return tokens[0] + "@" + vCenterIp;
+    }
+}
diff --git a/server/src/com/cloud/hypervisor/vmware/VmwareCleanupMaid.java b/server/src/com/cloud/hypervisor/vmware/VmwareCleanupMaid.java
new file mode 100644
index 00000000000..918d069efd4
--- /dev/null
+++ b/server/src/com/cloud/hypervisor/vmware/VmwareCleanupMaid.java
@@ -0,0 +1,131 @@
+package com.cloud.hypervisor.vmware;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.cluster.CheckPointManager;
+import com.cloud.cluster.CleanupMaid;
+import com.cloud.hypervisor.vmware.manager.VmwareManager;
+import com.cloud.hypervisor.vmware.mo.ClusterMO;
+import com.cloud.hypervisor.vmware.mo.DatacenterMO;
+import com.cloud.hypervisor.vmware.mo.HostMO;
+import com.cloud.hypervisor.vmware.mo.VirtualMachineMO;
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+
+public class VmwareCleanupMaid implements CleanupMaid {
+    private static final Logger s_logger = Logger.getLogger(VmwareCleanupMaid.class);
+    
+    private static Map<String, List<VmwareCleanupMaid>> s_leftoverDummyVMs = new HashMap<String, List<VmwareCleanupMaid>>();
+    
+    private String _vCenterAddress;
+    private String _dcMorValue;
+    private String _hostMorValue;
+    private String _vmName;
+    private long _checkPoint;
+    
+	public VmwareCleanupMaid() {
+	}
+	
+	public VmwareCleanupMaid(String hostGuid, String vmName) {
+		String[] tokens = hostGuid.split("@");
+		assert(tokens != null);
+		assert(tokens.length == 2);
+		_vCenterAddress = tokens[1];
+		
+		String[] hostTokens = tokens[0].split(":");
+		assert(hostTokens != null);
+		assert(hostTokens.length == 2);
+		
+		_hostMorValue = hostTokens[1];
+		
+		_vmName = vmName;
+	}
+	
+	public VmwareCleanupMaid(String vCenterAddress, String dcMorValue, String vmName) {
+		_vCenterAddress = vCenterAddress;
+		_dcMorValue = dcMorValue;
+		_vmName = vmName;
+	}
+	
+	@Override
+	public int cleanup(CheckPointManager checkPointMgr) {
+		
+		// save a check-point in case we crash at current run so that we won't lose it
+		_checkPoint = checkPointMgr.pushCheckPoint(new VmwareCleanupMaid(_vCenterAddress, _dcMorValue, _vmName));
+		addLeftOverVM(this);
+		return 0;
+	}
+
+	@Override
+	public String getCleanupProcedure() {
+		return null;
+	}
+	
+	public String getVCenterServer() {
+		return _vCenterAddress;
+	}
+	
+	public String getDatacenterMorValue() {
+		return _dcMorValue;
+	}
+	
+	public String getHostMorValue() {
+		return _hostMorValue;
+	}
+	
+	public String getVmName() {
+		return _vmName;
+	}
+	
+	public long getCheckPoint() {
+		return _checkPoint;
+	}
+	
+    private synchronized static void addLeftOverVM(VmwareCleanupMaid cleanupMaid) {
+        List<VmwareCleanupMaid> l = s_leftoverDummyVMs.get(cleanupMaid.getVCenterServer());
+        if(l == null) {
+            l = new ArrayList<VmwareCleanupMaid>();
+            s_leftoverDummyVMs.put(cleanupMaid.getVCenterServer(), l);
+        }
+        
+        l.add(cleanupMaid);
+    }
+    
+    public synchronized static void gcLeftOverVMs(VmwareContext context) {
+        List<VmwareCleanupMaid> l = s_leftoverDummyVMs.get(context.getServerAddress());
+        VmwareManager mgr = context.getStockObject(VmwareManager.CONTEXT_STOCK_NAME);
+        assert(mgr != null);
+        
+        if(l != null && l.size() > 0) {
+            for(VmwareCleanupMaid cleanupMaid : l) {
+                try {
+                    VirtualMachineMO vmMo = null;
+                    if(cleanupMaid.getDatacenterMorValue() != null) {
+                    	DatacenterMO dcMo = new DatacenterMO(context, "Datacenter", cleanupMaid.getDatacenterMorValue());
+                    	vmMo = dcMo.findVm(cleanupMaid.getVmName());
+                    } else {
+                    	assert(cleanupMaid.getHostMorValue() != null);
+                    	HostMO hostMo = new HostMO(context, "HostSystem", cleanupMaid.getHostMorValue());
+                    	ClusterMO clusterMo = new ClusterMO(context, hostMo.getHyperHostCluster());
+                    	vmMo = clusterMo.findVmOnHyperHost(cleanupMaid.getVmName());
+                    }
+                    
+                    if(vmMo != null) {
+                        s_logger.info("Found left over dummy VM " + cleanupMaid.getVmName() + ", destroy it");
+                        vmMo.destroy();
+                    }
+                } catch(Throwable e) {
+                    s_logger.warn("Unable to destroy left over dummy VM " + cleanupMaid.getVmName());
+                } finally {
+                	mgr.popCleanupCheckpoint(cleanupMaid.getCheckPoint());
+                }
+            }
+            
+            l.clear();
+        }
+    }
+}
diff --git a/server/src/com/cloud/hypervisor/vmware/VmwareManagerImpl.java b/server/src/com/cloud/hypervisor/vmware/VmwareManagerImpl.java
new file mode 100755
index 00000000000..e2ead1b8a65
--- /dev/null
+++ b/server/src/com/cloud/hypervisor/vmware/VmwareManagerImpl.java
@@ -0,0 +1,860 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.UUID;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import javax.ejb.Local;
+import javax.naming.ConfigurationException;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.agent.AgentManager;
+import com.cloud.agent.Listener;
+import com.cloud.agent.api.AgentControlAnswer;
+import com.cloud.agent.api.AgentControlCommand;
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.Command;
+import com.cloud.agent.api.StartupCommand;
+import com.cloud.agent.api.StartupRoutingCommand;
+import com.cloud.cluster.CheckPointManager;
+import com.cloud.cluster.ClusterManager;
+import com.cloud.configuration.Config;
+import com.cloud.configuration.dao.ConfigurationDao;
+import com.cloud.dc.ClusterDetailsDao;
+import com.cloud.dc.ClusterVO;
+import com.cloud.dc.dao.ClusterDao;
+import com.cloud.exception.ConcurrentOperationException;
+import com.cloud.exception.DiscoveredWithErrorException;
+import com.cloud.exception.ResourceUnavailableException;
+import com.cloud.host.HostVO;
+import com.cloud.host.Status;
+import com.cloud.host.dao.HostDao;
+import com.cloud.hypervisor.Hypervisor.HypervisorType;
+import com.cloud.hypervisor.vmware.manager.VmwareManager;
+import com.cloud.hypervisor.vmware.manager.VmwareStorageManager;
+import com.cloud.hypervisor.vmware.manager.VmwareStorageManagerImpl;
+import com.cloud.hypervisor.vmware.manager.VmwareStorageMount;
+import com.cloud.hypervisor.vmware.mo.HostFirewallSystemMO;
+import com.cloud.hypervisor.vmware.mo.HostMO;
+import com.cloud.hypervisor.vmware.mo.HostVirtualNicType;
+import com.cloud.hypervisor.vmware.mo.HypervisorHostHelper;
+import com.cloud.hypervisor.vmware.mo.TaskMO;
+import com.cloud.hypervisor.vmware.mo.VirtualEthernetCardType;
+import com.cloud.hypervisor.vmware.mo.VmwareHostType;
+import com.cloud.hypervisor.vmware.resource.SshHelper;
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.cloud.network.router.VirtualNetworkApplianceManager;
+import com.cloud.org.Cluster.ClusterType;
+import com.cloud.secstorage.CommandExecLogDao;
+import com.cloud.serializer.GsonHelper;
+import com.cloud.storage.StorageLayer;
+import com.cloud.user.UserContext;
+import com.cloud.utils.FileUtil;
+import com.cloud.utils.NumbersUtil;
+import com.cloud.utils.Pair;
+import com.cloud.utils.component.ComponentLocator;
+import com.cloud.utils.component.Inject;
+import com.cloud.utils.component.Manager;
+import com.cloud.utils.concurrency.NamedThreadFactory;
+import com.cloud.utils.db.DB;
+import com.cloud.utils.db.GlobalLock;
+import com.cloud.utils.exception.CloudRuntimeException;
+import com.cloud.utils.script.Script;
+import com.cloud.vm.DomainRouterVO;
+import com.cloud.vm.VirtualMachine.State;
+import com.cloud.vm.dao.DomainRouterDao;
+import com.google.gson.Gson;
+import com.vmware.apputils.vim25.ServiceUtil;
+import com.vmware.vim25.HostConnectSpec;
+import com.vmware.vim25.HostPortGroupSpec;
+import com.vmware.vim25.ManagedObjectReference;
+
+@Local(value = {VmwareManager.class})
+public class VmwareManagerImpl implements VmwareManager, VmwareStorageMount, Listener, Manager {
+    private static final Logger s_logger = Logger.getLogger(VmwareManagerImpl.class);
+
+    private static final int STARTUP_DELAY = 60000; 				// 60 seconds
+    private static final long DEFAULT_HOST_SCAN_INTERVAL = 600000; 	// every 10 minutes
+
+    private long _hostScanInterval = DEFAULT_HOST_SCAN_INTERVAL;
+    int _timeout;
+
+    private String _name;
+    private String _instance;
+
+    @Inject AgentManager _agentMgr;
+    @Inject HostDao _hostDao;
+    @Inject ClusterDao _clusterDao;
+    @Inject ClusterDetailsDao _clusterDetailsDao;
+    @Inject CommandExecLogDao _cmdExecLogDao;
+    @Inject ClusterManager _clusterMgr;
+    @Inject CheckPointManager _checkPointMgr;
+    @Inject VirtualNetworkApplianceManager _routerMgr;
+    @Inject DomainRouterDao _routerDao;
+
+    String _mountParent;
+    StorageLayer _storage;
+
+    String _privateNetworkVSwitchName;
+    String _publicNetworkVSwitchName;
+    String _guestNetworkVSwitchName;
+    String _serviceConsoleName;
+    String _managemetPortGroupName;
+    int _additionalPortRangeStart;
+    int _additionalPortRangeSize;
+    VirtualEthernetCardType _guestNicDeviceType;
+    int _maxHostsPerCluster;
+    
+    String _cpuOverprovisioningFactor = "1";
+    String _reserveCpu = "false";
+    
+    Map<String, String> _storageMounts = new HashMap<String, String>();
+
+    Random _rand = new Random(System.currentTimeMillis());
+    Gson _gson;
+
+    VmwareStorageManager _storageMgr;
+    GlobalLock _exclusiveOpLock = GlobalLock.getInternLock("vmware.exclusive.op");
+
+    private final ScheduledExecutorService _hostScanScheduler = Executors.newScheduledThreadPool(
+            1, new NamedThreadFactory("Vmware-Host-Scan"));
+
+    public VmwareManagerImpl() {
+        _gson = GsonHelper.getGsonLogger();
+        _storageMgr = new VmwareStorageManagerImpl(this);
+    }
+
+    @Override
+    public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
+        s_logger.info("Configure VmwareManagerImpl, manager name: " + name);
+
+        _name = name;
+
+        ComponentLocator locator = ComponentLocator.getCurrentLocator();
+        ConfigurationDao configDao = locator.getDao(ConfigurationDao.class);
+        if (configDao == null) {
+            throw new ConfigurationException("Unable to get the configuration dao.");
+        }
+
+        if(!configDao.isPremium()) {
+            s_logger.error("Vmware component can only run under premium distribution");
+            throw new ConfigurationException("Vmware component can only run under premium distribution");
+        }
+
+        _instance = configDao.getValue(Config.InstanceName.key());
+        if (_instance == null) {
+            _instance = "DEFAULT";
+        }
+        s_logger.info("VmwareManagerImpl config - instance.name: " + _instance);
+
+        _mountParent = configDao.getValue(Config.MountParent.key());
+        if (_mountParent == null) {
+            _mountParent = File.separator + "mnt";
+        }
+
+        if (_instance != null) {
+            _mountParent = _mountParent + File.separator + _instance;
+        }
+        s_logger.info("VmwareManagerImpl config - _mountParent: " + _mountParent);
+
+        String value = (String)params.get("scripts.timeout");
+        _timeout = NumbersUtil.parseInt(value, 1440) * 1000;
+
+        _storage = (StorageLayer)params.get(StorageLayer.InstanceConfigKey);
+        if (_storage == null) {
+            value = (String)params.get(StorageLayer.ClassConfigKey);
+            if (value == null) {
+                value = "com.cloud.storage.JavaStorageLayer";
+            }
+
+            try {
+                Class<?> clazz = Class.forName(value);
+                _storage = (StorageLayer)ComponentLocator.inject(clazz);
+                _storage.configure("StorageLayer", params);
+            } catch (ClassNotFoundException e) {
+                throw new ConfigurationException("Unable to find class " + value);
+            }
+        }
+
+        _privateNetworkVSwitchName = configDao.getValue(Config.VmwarePrivateNetworkVSwitch.key());
+        if(_privateNetworkVSwitchName == null) {
+            _privateNetworkVSwitchName = "vSwitch0";
+        }
+
+        _publicNetworkVSwitchName = configDao.getValue(Config.VmwarePublicNetworkVSwitch.key());
+        if(_publicNetworkVSwitchName == null) {
+            _publicNetworkVSwitchName = "vSwitch0";
+        }
+
+        _guestNetworkVSwitchName =  configDao.getValue(Config.VmwareGuestNetworkVSwitch.key());
+        if(_guestNetworkVSwitchName == null) {
+            _guestNetworkVSwitchName = "vSwitch0";
+        }
+
+        _serviceConsoleName = configDao.getValue(Config.VmwareServiceConsole.key());
+        if(_serviceConsoleName == null) {
+            _serviceConsoleName = "Service Console";
+        }
+        
+        _managemetPortGroupName = configDao.getValue(Config.VmwareManagementPortGroup.key());
+        if(_managemetPortGroupName == null) {
+        	_managemetPortGroupName = "Management Network";
+        }
+        
+        configDao.getValue(Config.VmwareServiceConsole.key());
+        _additionalPortRangeStart = NumbersUtil.parseInt(configDao.getValue(Config.VmwareAdditionalVncPortRangeStart.key()), 59000);
+        if(_additionalPortRangeStart > 65535) {
+        	s_logger.warn("Invalid port range start port (" + _additionalPortRangeStart + ") for additional VNC port allocation, reset it to default start port 59000");
+        	_additionalPortRangeStart = 59000;
+        }
+        
+        _additionalPortRangeSize = NumbersUtil.parseInt(configDao.getValue(Config.VmwareAdditionalVncPortRangeSize.key()), 1000);
+        if(_additionalPortRangeSize < 0 || _additionalPortRangeStart + _additionalPortRangeSize > 65535) {
+        	s_logger.warn("Invalid port range size (" + _additionalPortRangeSize + " for range starts at " + _additionalPortRangeStart);
+        	_additionalPortRangeSize = Math.min(1000, 65535 - _additionalPortRangeStart);
+        }
+        
+        _maxHostsPerCluster = NumbersUtil.parseInt(configDao.getValue(Config.VmwarePerClusterHostMax.key()), VmwareManager.MAX_HOSTS_PER_CLUSTER);
+        _cpuOverprovisioningFactor = configDao.getValue(Config.CPUOverprovisioningFactor.key());
+        if(_cpuOverprovisioningFactor == null || _cpuOverprovisioningFactor.isEmpty())
+        	_cpuOverprovisioningFactor = "1";
+        
+        _reserveCpu = configDao.getValue(Config.VmwareReserveCpu.key());
+        if(_reserveCpu == null || _reserveCpu.isEmpty())
+        	_reserveCpu = "false";
+        
+    	s_logger.info("Additional VNC port allocation range is settled at " + _additionalPortRangeStart + " to " + (_additionalPortRangeStart + _additionalPortRangeSize));
+
+    	value = configDao.getValue(Config.VmwareGuestNicDeviceType.key());
+    	if(value == null || "E1000".equalsIgnoreCase(value))
+    		this._guestNicDeviceType = VirtualEthernetCardType.E1000;
+    	else if("PCNet32".equalsIgnoreCase(value))
+    		this._guestNicDeviceType = VirtualEthernetCardType.PCNet32;
+    	else if("Vmxnet2".equalsIgnoreCase(value))
+    		this._guestNicDeviceType = VirtualEthernetCardType.Vmxnet2;
+    	else if("Vmxnet3".equalsIgnoreCase(value))
+    		this._guestNicDeviceType = VirtualEthernetCardType.Vmxnet3;
+    	else
+    		this._guestNicDeviceType = VirtualEthernetCardType.E1000;
+    	
+        value = configDao.getValue("vmware.host.scan.interval");
+        _hostScanInterval = NumbersUtil.parseLong(value, DEFAULT_HOST_SCAN_INTERVAL);
+        s_logger.info("VmwareManagerImpl config - vmware.host.scan.interval: " + _hostScanInterval);
+
+        ((VmwareStorageManagerImpl)_storageMgr).configure(params);
+
+        _agentMgr.registerForHostEvents(this, true, true, true);
+
+        s_logger.info("VmwareManagerImpl has been successfully configured");
+        return true;
+    }
+
+    @Override
+    public boolean start() {
+        _hostScanScheduler.scheduleAtFixedRate(getHostScanTask(),
+                STARTUP_DELAY, _hostScanInterval, TimeUnit.MILLISECONDS);
+
+        startupCleanup(_mountParent);
+        return true;
+    }
+
+    @Override
+    public boolean stop() {
+        _hostScanScheduler.shutdownNow();
+        try {
+            _hostScanScheduler.awaitTermination(3000, TimeUnit.MILLISECONDS);
+        } catch (InterruptedException e) {
+        }
+
+        shutdownCleanup();
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return _name;
+    }
+
+    @Override
+    public String composeWorkerName() {
+        return "cloud.worker." + _clusterMgr.getManagementNodeId() + "." + _clusterMgr.getCurrentRunId() + "." + UUID.randomUUID().toString();
+    }
+
+    @Override
+    public List<ManagedObjectReference> addHostToPodCluster(VmwareContext serviceContext, long dcId, Long podId, Long clusterId,
+            String hostInventoryPath) throws Exception {
+        ManagedObjectReference mor = serviceContext.getHostMorByPath(hostInventoryPath);
+        if(mor != null) {
+            List<ManagedObjectReference> returnedHostList = new ArrayList<ManagedObjectReference>();
+
+            if(mor.getType().equals("ComputeResource")) {
+                ManagedObjectReference[] hosts = (ManagedObjectReference[])serviceContext.getServiceUtil().getDynamicProperty(mor, "host");
+                assert(hosts != null);
+
+                // For ESX host, we need to enable host firewall to allow VNC access
+                HostMO hostMo = new HostMO(serviceContext, hosts[0]);
+                HostFirewallSystemMO firewallMo = hostMo.getHostFirewallSystemMO();
+                if(firewallMo != null) {
+                    firewallMo.enableRuleset("vncServer");
+                    firewallMo.refreshFirewall();
+                }
+
+                // prepare at least one network on the vswitch to enable OVF importing
+                String managementPortGroupName = hostMo.getPortGroupNameByNicType(HostVirtualNicType.management);
+                assert(managementPortGroupName != null);
+                HostPortGroupSpec spec = hostMo.getPortGroupSpec(managementPortGroupName);
+                Integer vlanId = null;
+                if(spec.getVlanId() != 0) {
+                    vlanId = spec.getVlanId();
+                }
+
+                HypervisorHostHelper.preparePrivateNetwork(_privateNetworkVSwitchName, hostMo, vlanId, 180000);
+                returnedHostList.add(hosts[0]);
+                return returnedHostList;
+            } else if(mor.getType().equals("ClusterComputeResource")) {
+                ManagedObjectReference[] hosts = (ManagedObjectReference[])serviceContext.getServiceUtil().getDynamicProperty(mor, "host");
+                assert(hosts != null);
+                
+                if(hosts.length > _maxHostsPerCluster) {
+                	String msg = "vCenter cluster size is too big (current configured cluster size: " + _maxHostsPerCluster + ")";
+                	s_logger.error(msg);
+                	throw new DiscoveredWithErrorException(msg);
+                }
+                
+                for(ManagedObjectReference morHost: hosts) {
+                    // For ESX host, we need to enable host firewall to allow VNC access
+                    HostMO hostMo = new HostMO(serviceContext, morHost);
+                    HostFirewallSystemMO firewallMo = hostMo.getHostFirewallSystemMO();
+                    if(firewallMo != null) {
+                        firewallMo.enableRuleset("vncServer");
+                        firewallMo.refreshFirewall();
+                    }
+
+                    String managementPortGroupName = hostMo.getPortGroupNameByNicType(HostVirtualNicType.management);
+                    assert(managementPortGroupName != null);
+                    HostPortGroupSpec spec = hostMo.getPortGroupSpec(managementPortGroupName);
+                    Integer vlanId = null;
+                    if(spec.getVlanId() != 0) {
+                        vlanId = spec.getVlanId();
+                    }
+
+                    // prepare at least one network on the vswitch to enable OVF importing
+                    HypervisorHostHelper.preparePrivateNetwork(_privateNetworkVSwitchName, hostMo, vlanId, 180000);
+                    returnedHostList.add(morHost);
+                }
+                return returnedHostList;
+            } else if(mor.getType().equals("HostSystem")) {
+                // For ESX host, we need to enable host firewall to allow VNC access
+                HostMO hostMo = new HostMO(serviceContext, mor);
+                HostFirewallSystemMO firewallMo = hostMo.getHostFirewallSystemMO();
+                if(firewallMo != null) {
+                    firewallMo.enableRuleset("vncServer");
+                    firewallMo.refreshFirewall();
+                }
+
+                String managementPortGroupName = hostMo.getPortGroupNameByNicType(HostVirtualNicType.management);
+                assert(managementPortGroupName != null);
+                HostPortGroupSpec spec = hostMo.getPortGroupSpec(managementPortGroupName);
+                Integer vlanId = null;
+                if(spec.getVlanId() != 0) {
+                    vlanId = spec.getVlanId();
+                }
+
+                // prepare at least one network on the vswitch to enable OVF importing
+                HypervisorHostHelper.preparePrivateNetwork(_privateNetworkVSwitchName, hostMo, vlanId, 180000);
+                returnedHostList.add(mor);
+                return returnedHostList;
+            } else {
+                s_logger.error("Unsupport host type " + mor.getType() + ":" + mor.get_value() + " from inventory path: " + hostInventoryPath);
+                return null;
+            }
+        }
+
+        s_logger.error("Unable to find host from inventory path: " + hostInventoryPath);
+        return null;
+    }
+
+    @Deprecated
+    private ManagedObjectReference addHostToVCenterCluster(VmwareContext serviceContext, ManagedObjectReference morCluster,
+            String host, String userName, String password) throws Exception {
+
+        ServiceUtil serviceUtil = serviceContext.getServiceUtil();
+        ManagedObjectReference morHost = serviceUtil.getDecendentMoRef(morCluster, "HostSystem", host);
+        if(morHost == null) {
+            HostConnectSpec hostSpec = new HostConnectSpec();
+            hostSpec.setUserName(userName);
+            hostSpec.setPassword(password);
+            hostSpec.setHostName(host);
+            hostSpec.setForce(true);		// forcely take over the host
+
+            ManagedObjectReference morTask = serviceContext.getService().addHost_Task(morCluster, hostSpec, true, null, null);
+            String taskResult = serviceUtil.waitForTask(morTask);
+            if(!taskResult.equals("sucess")) {
+                s_logger.error("Unable to add host " + host + " to vSphere cluster due to " + TaskMO.getTaskFailureInfo(serviceContext, morTask));
+                throw new CloudRuntimeException("Unable to add host " + host + " to vSphere cluster due to " + taskResult);
+            }
+            serviceContext.waitForTaskProgressDone(morTask);
+
+            // init morHost after it has been created
+            morHost = serviceUtil.getDecendentMoRef(morCluster, "HostSystem", host);
+            if(morHost == null) {
+                throw new CloudRuntimeException("Successfully added host into vSphere but unable to find it later on?!. Please make sure you are either using IP address or full qualified domain name for host");
+            }
+        }
+
+        // For ESX host, we need to enable host firewall to allow VNC access
+        HostMO hostMo = new HostMO(serviceContext, morHost);
+        HostFirewallSystemMO firewallMo = hostMo.getHostFirewallSystemMO();
+        if(firewallMo != null) {
+            firewallMo.enableRuleset("vncServer");
+            firewallMo.refreshFirewall();
+        }
+        return morHost;
+    }
+
+    @Override
+    public String getSecondaryStorageStoreUrl(long dcId) {
+    	List<HostVO> secStorageHosts = _hostDao.listSecondaryStorageHosts(dcId);
+    	if(secStorageHosts.size() > 0)
+    		return secStorageHosts.get(0).getStorageUrl();
+    	
+        return null;
+    }
+
+	public String getServiceConsolePortGroupName() {
+		return _serviceConsoleName;
+	}
+	
+	public String getManagementPortGroupName() {
+		return _managemetPortGroupName;
+	}
+    
+    @Override
+    public String getManagementPortGroupByHost(HostMO hostMo) throws Exception {
+    	if(hostMo.getHostType() == VmwareHostType.ESXi)
+    		return  this._managemetPortGroupName;
+        return this._serviceConsoleName;
+    }
+    
+    @Override
+    public void setupResourceStartupParams(Map<String, Object> params) {
+        params.put("private.network.vswitch.name", _privateNetworkVSwitchName);
+        params.put("public.network.vswitch.name", _publicNetworkVSwitchName);
+        params.put("guest.network.vswitch.name", _guestNetworkVSwitchName);
+        params.put("service.console.name", _serviceConsoleName);
+        params.put("management.portgroup.name", _managemetPortGroupName);
+        params.put("cpu.overprovisioning.factor", _cpuOverprovisioningFactor);
+        params.put("vmware.reserve.cpu", _reserveCpu);
+    }
+
+    @Override
+    public VmwareStorageManager getStorageManager() {
+        return _storageMgr;
+    }
+
+    
+    @Override
+	public long pushCleanupCheckpoint(String hostGuid, String vmName) {
+        return _checkPointMgr.pushCheckPoint(new VmwareCleanupMaid(hostGuid, vmName));
+    }
+    
+    @Override
+	public void popCleanupCheckpoint(long checkpoint) {
+    	_checkPointMgr.popCheckPoint(checkpoint);
+    }
+    
+    @Override
+	public void gcLeftOverVMs(VmwareContext context) {
+    	VmwareCleanupMaid.gcLeftOverVMs(context);
+    }
+
+    @Override
+    public void prepareSecondaryStorageStore(String storageUrl) {
+        String mountPoint = getMountPoint(storageUrl);
+
+        GlobalLock lock = GlobalLock.getInternLock("prepare.systemvm");
+        try {
+            if(lock.lock(3600)) {
+                try {
+                    File patchFolder = new File(mountPoint + "/systemvm");
+                    if(!patchFolder.exists()) {
+                        if(!patchFolder.mkdirs()) {
+                            String msg = "Unable to create systemvm folder on secondary storage. location: " + patchFolder.toString();
+                            s_logger.error(msg);
+                            throw new CloudRuntimeException(msg);
+                        }
+                    }
+
+                    File srcIso = getSystemVMPatchIsoFile();
+                    File destIso = new File(mountPoint + "/systemvm/" + getSystemVMIsoFileNameOnDatastore());
+                    if(!destIso.exists()) {
+	                    try {
+	                        FileUtil.copyfile(srcIso, destIso);
+	                    } catch(IOException e) {
+	                    	s_logger.error("Unexpected exception ", e);
+	                    	
+	                        String msg = "Unable to copy systemvm ISO on secondary storage. src location: " + srcIso.toString() + ", dest location: " + destIso;
+	                        s_logger.error(msg);
+	                        throw new CloudRuntimeException(msg);
+	                    }
+                    } else {
+                    	if(s_logger.isTraceEnabled())
+                    		s_logger.trace("SystemVM ISO file " + destIso.getPath() + " already exists");
+                    }
+                } finally {
+                    lock.unlock();
+                }
+            }
+        } finally {
+            lock.releaseRef();
+        }
+    }
+   
+    @Override
+    public String getSystemVMIsoFileNameOnDatastore() {
+        String version = ComponentLocator.class.getPackage().getImplementationVersion();
+        String fileName = "systemvm-" + version + ".iso";
+        return fileName.replace(':', '-');
+    }
+    
+    private File getSystemVMPatchIsoFile() {
+        // locate systemvm.iso
+        URL url = ComponentLocator.class.getProtectionDomain().getCodeSource().getLocation();
+        File file = new File(url.getFile());
+        File isoFile = new File(file.getParent() + "/vms/systemvm.iso");
+        if (!isoFile.exists()) {
+            isoFile = new File("/usr/lib64/cloud/agent/" + "/vms/systemvm.iso");
+            if (!isoFile.exists()) {
+                isoFile = new File("/usr/lib/cloud/agent/" + "/vms/systemvm.iso");
+            }
+        }
+        return isoFile;
+    }
+
+    @Override
+    public File getSystemVMKeyFile() {
+        URL url = ComponentLocator.class.getProtectionDomain().getCodeSource().getLocation();
+        File file = new File(url.getFile());
+
+        File keyFile = new File(file.getParent(), "/scripts/vm/systemvm/id_rsa.cloud");
+        if (!keyFile.exists()) {
+            keyFile = new File("/usr/lib64/cloud/agent" + "/scripts/vm/systemvm/id_rsa.cloud");
+            if (!keyFile.exists()) {
+                keyFile = new File("/usr/lib/cloud/agent" + "/scripts/vm/systemvm/id_rsa.cloud");
+            }
+        }
+        return keyFile;
+    }
+
+    private Runnable getHostScanTask() {
+        return new Runnable() {
+            @Override
+            public void run() {
+                // TODO scan vSphere for newly added hosts.
+                // we are going to both support adding host from Cloud.com UI and
+                // adding host via vSphere server
+                //
+                // will implement host scanning later
+            }
+        };
+    }
+
+    @Override
+    public String getMountPoint(String storageUrl) {
+        String mountPoint = null;
+        synchronized(_storageMounts) {
+            mountPoint = _storageMounts.get(storageUrl);
+            if(mountPoint != null) {
+                return mountPoint;
+            }
+
+            URI uri;
+            try {
+                uri = new URI(storageUrl);
+            } catch (URISyntaxException e) {
+                s_logger.error("Invalid storage URL format ", e);
+                throw new CloudRuntimeException("Unable to create mount point due to invalid storage URL format " + storageUrl);
+            }
+            mountPoint = mount(uri.getHost() + ":" + uri.getPath(), _mountParent);
+            if(mountPoint == null) {
+                s_logger.error("Unable to create mount point for " + storageUrl);
+                throw new CloudRuntimeException("Unable to create mount point for " + storageUrl);
+            }
+
+            _storageMounts.put(storageUrl, mountPoint);
+            return mountPoint;
+        }
+    }
+
+    private String setupMountPoint(String parent) {
+        String mountPoint = null;
+        long mshostId = _clusterMgr.getManagementNodeId();
+        for (int i = 0; i < 10; i++) {
+            String mntPt = parent + File.separator + String.valueOf(mshostId) + "." + Integer.toHexString(_rand.nextInt(Integer.MAX_VALUE));
+            File file = new File(mntPt);
+            if (!file.exists()) {
+                if (_storage.mkdir(mntPt)) {
+                    mountPoint = mntPt;
+                    break;
+                }
+            }
+            s_logger.error("Unable to create mount: " + mntPt);
+        }
+
+        return mountPoint;
+    }
+
+    private void startupCleanup(String parent) {
+        s_logger.info("Cleanup mounted NFS mount points used in previous session");
+
+        long mshostId = _clusterMgr.getManagementNodeId();
+
+        // cleanup left-over NFS mounts from previous session
+        String[] mounts = _storage.listFiles(parent + File.separator + String.valueOf(mshostId) + ".*");
+        if(mounts != null && mounts.length > 0) {
+            for(String mountPoint : mounts) {
+                s_logger.info("umount NFS mount from previous session: " + mountPoint);
+
+                String result = null;
+                Script command = new Script(true, "umount", _timeout, s_logger);
+                command.add(mountPoint);
+                result = command.execute();
+                if (result != null) {
+                    s_logger.warn("Unable to umount " + mountPoint + " due to " + result);
+                }
+                File file = new File(mountPoint);
+                if (file.exists()) {
+                    file.delete();
+                }
+            }
+        }
+    }
+
+    private void shutdownCleanup() {
+        s_logger.info("Cleanup mounted NFS mount points used in current session");
+
+        for(String mountPoint : _storageMounts.values()) {
+            s_logger.info("umount NFS mount: " + mountPoint);
+
+            String result = null;
+            Script command = new Script(true, "umount", _timeout, s_logger);
+            command.add(mountPoint);
+            result = command.execute();
+            if (result != null) {
+                s_logger.warn("Unable to umount " + mountPoint + " due to " + result);
+            }
+            File file = new File(mountPoint);
+            if (file.exists()) {
+                file.delete();
+            }
+        }
+    }
+
+    protected String mount(String path, String parent) {
+        String mountPoint = setupMountPoint(parent);
+        if (mountPoint == null) {
+            s_logger.warn("Unable to create a mount point");
+            return null;
+        }
+
+        Script script = null;
+        String result = null;
+        Script command = new Script(true, "mount", _timeout, s_logger);
+        command.add("-t", "nfs");
+        // command.add("-o", "soft,timeo=133,retrans=2147483647,tcp,acdirmax=0,acdirmin=0");
+        command.add(path);
+        command.add(mountPoint);
+        result = command.execute();
+        if (result != null) {
+            s_logger.warn("Unable to mount " + path + " due to " + result);
+            File file = new File(mountPoint);
+            if (file.exists()) {
+                file.delete();
+            }
+            return null;
+        }
+
+        // Change permissions for the mountpoint
+        script = new Script(true, "chmod", _timeout, s_logger);
+        script.add("777", mountPoint);
+        result = script.execute();
+        if (result != null) {
+            s_logger.warn("Unable to set permissions for " + mountPoint + " due to " + result);
+            return null;
+        }
+        return mountPoint;
+    }
+
+    @DB
+    private void updateClusterNativeHAState(HostVO host, StartupCommand cmd) {
+        ClusterVO cluster = _clusterDao.findById(host.getClusterId());
+        if(cluster.getClusterType() == ClusterType.ExternalManaged) {
+            if(cmd instanceof StartupRoutingCommand) {
+                StartupRoutingCommand hostStartupCmd = (StartupRoutingCommand)cmd;
+                Map<String, String> details = hostStartupCmd.getHostDetails();
+
+                if(details.get("NativeHA") != null && details.get("NativeHA").equalsIgnoreCase("true")) {
+                    _clusterDetailsDao.persist(host.getClusterId(), "NativeHA", "true");
+                } else {
+                    _clusterDetailsDao.persist(host.getClusterId(), "NativeHA", "false");
+                }
+            }
+        }
+    }
+
+    @Override @DB
+    public boolean processAnswers(long agentId, long seq, Answer[] answers) {
+        if(answers != null) {
+            for(Answer answer : answers) {
+                String execIdStr = answer.getContextParam("execid");
+                if(execIdStr != null) {
+                    long execId = 0;
+                    try {
+                        execId = Long.parseLong(execIdStr);
+                    } catch(NumberFormatException e) {
+                        assert(false);
+                    }
+
+                    _cmdExecLogDao.expunge(execId);
+                }
+
+                String checkPointIdStr = answer.getContextParam("checkpoint");
+                if(checkPointIdStr != null) {
+                    _checkPointMgr.popCheckPoint(Long.parseLong(checkPointIdStr));
+                }
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public boolean processCommands(long agentId, long seq, Command[] commands) {
+        return false;
+    }
+
+    @Override
+    public AgentControlAnswer processControlCommand(long agentId, AgentControlCommand cmd) {
+        return null;
+    }
+
+    @Override
+    public void processConnect(HostVO host, StartupCommand cmd, boolean forRebalance) {
+        if(cmd instanceof StartupCommand) {
+            if(host.getHypervisorType() == HypervisorType.VMware) {
+                updateClusterNativeHAState(host, cmd);
+            } else {
+                return;
+            }
+        }
+    }
+    
+    protected final int DEFAULT_DOMR_SSHPORT = 3922;
+    
+    protected boolean shutdownRouterVM(DomainRouterVO router) {
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Try to shutdown router VM " + router.getInstanceName() + " directly.");
+        }
+
+        Pair<Boolean, String> result;
+        try {
+            result = SshHelper.sshExecute(router.getPrivateIpAddress(), DEFAULT_DOMR_SSHPORT, "root", getSystemVMKeyFile(), null,
+                    "poweroff -f");
+
+            if (!result.first()) {
+                s_logger.debug("Unable to shutdown " + router.getInstanceName() + " directly");
+                return false;
+            }
+        } catch (Throwable e) {
+            s_logger.warn("Unable to shutdown router " + router.getInstanceName() + " directly.");
+            return false;
+        }
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Shutdown router " + router.getInstanceName() + " successful.");
+        }
+        return true;
+    }
+
+    @Override
+    public boolean processDisconnect(long agentId, Status state) {
+        UserContext context = UserContext.current();
+        context.setAccountId(1);
+        /* Stopped VMware Host's virtual routers */
+        HostVO host = _hostDao.findById(agentId);
+        if (host.getHypervisorType() != HypervisorType.VMware) {
+            return true;
+        }
+        List<DomainRouterVO> routers = _routerDao.listByHostId(agentId);
+        for (DomainRouterVO router : routers) {
+            try {
+                State oldState = router.getState();
+                _routerMgr.stopRouter(router.getId(), true);
+                //In case only vCenter is disconnected, we want to shut down router directly
+                if (oldState == State.Running) {
+                    shutdownRouterVM(router);
+                }
+            } catch (ResourceUnavailableException e) {
+                s_logger.warn("Fail to stop router " + router.getInstanceName() + " when host disconnected!", e);
+            } catch (ConcurrentOperationException e) {
+                s_logger.warn("Fail to stop router " + router.getInstanceName() + " when host disconnected!", e);
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean isRecurring() {
+        return false;
+    }
+
+    @Override
+    public int getTimeout() {
+        return 0;
+    }
+
+    @Override
+    public boolean processTimeout(long agentId, long seq) {
+        return false;
+    }
+    
+    @Override
+    public boolean beginExclusiveOperation(int timeOutSeconds) {
+        return _exclusiveOpLock.lock(timeOutSeconds);
+    }
+    
+    @Override
+    public void endExclusiveOperation() {
+        _exclusiveOpLock.unlock();
+    }
+    
+    @Override
+	public Pair<Integer, Integer> getAddiionalVncPortRange() {
+    	return new Pair<Integer, Integer>(_additionalPortRangeStart, _additionalPortRangeSize);
+    }
+    
+    @Override
+	public VirtualEthernetCardType getGuestNicDeviceType() {
+    	return this._guestNicDeviceType;
+    }
+    
+    @Override
+    public int getMaxHostsPerCluster() {
+    	return this._maxHostsPerCluster;
+    }
+}
diff --git a/server/src/com/cloud/hypervisor/vmware/VmwareServerDiscoverer.java b/server/src/com/cloud/hypervisor/vmware/VmwareServerDiscoverer.java
new file mode 100755
index 00000000000..2b692ee571c
--- /dev/null
+++ b/server/src/com/cloud/hypervisor/vmware/VmwareServerDiscoverer.java
@@ -0,0 +1,250 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware;
+
+import java.net.URI;
+import java.net.URLDecoder;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import javax.ejb.Local;
+import javax.naming.ConfigurationException;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.alert.AlertManager;
+import com.cloud.configuration.dao.ConfigurationDao;
+import com.cloud.dc.ClusterDetailsDao;
+import com.cloud.dc.ClusterVO;
+import com.cloud.dc.dao.ClusterDao;
+import com.cloud.exception.DiscoveredWithErrorException;
+import com.cloud.exception.DiscoveryException;
+import com.cloud.host.HostVO;
+import com.cloud.host.dao.HostDao;
+import com.cloud.hypervisor.Hypervisor;
+import com.cloud.hypervisor.Hypervisor.HypervisorType;
+import com.cloud.hypervisor.vmware.manager.VmwareManager;
+import com.cloud.hypervisor.vmware.mo.ClusterMO;
+import com.cloud.hypervisor.vmware.mo.HostMO;
+import com.cloud.hypervisor.vmware.resource.VmwareContextFactory;
+import com.cloud.hypervisor.vmware.resource.VmwareResource;
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.cloud.resource.Discoverer;
+import com.cloud.resource.DiscovererBase;
+import com.cloud.resource.ServerResource;
+import com.cloud.storage.Storage.ImageFormat;
+import com.cloud.storage.Storage.TemplateType;
+import com.cloud.storage.VMTemplateVO;
+import com.cloud.storage.dao.VMTemplateDao;
+import com.cloud.user.Account;
+import com.cloud.utils.UriUtils;
+import com.cloud.utils.component.ComponentLocator;
+import com.cloud.utils.component.Inject;
+import com.vmware.vim25.ClusterDasConfigInfo;
+import com.vmware.vim25.ManagedObjectReference;
+
+@Local(value=Discoverer.class)
+public class VmwareServerDiscoverer extends DiscovererBase implements Discoverer {
+	private static final Logger s_logger = Logger.getLogger(VmwareServerDiscoverer.class);
+	
+	@Inject ClusterDao _clusterDao;
+	@Inject VmwareManager _vmwareMgr;
+    @Inject AlertManager _alertMgr;
+    @Inject VMTemplateDao _tmpltDao;
+    @Inject ClusterDetailsDao _clusterDetailsDao;
+    @Inject HostDao _hostDao;
+    
+    @Override
+    public Map<? extends ServerResource, Map<String, String>> find(long dcId, Long podId, Long clusterId, URI url, 
+    	String username, String password, List<String> hostTags) throws DiscoveryException {
+    	
+    	if(s_logger.isInfoEnabled())
+    		s_logger.info("Discover host. dc: " + dcId + ", pod: " + podId + ", cluster: " + clusterId + ", uri host: " + url.getHost());
+    	
+    	if(podId == null) {
+        	if(s_logger.isInfoEnabled())
+        		s_logger.info("No pod is assigned, assuming that it is not for vmware and skip it to next discoverer"); 
+    		return null;
+    	}
+    	
+        ClusterVO cluster = _clusterDao.findById(clusterId);
+        if(cluster == null || cluster.getHypervisorType() != HypervisorType.VMware) {
+        	if(s_logger.isInfoEnabled())
+        		s_logger.info("invalid cluster id or cluster is not for VMware hypervisors"); 
+    		return null;
+        }
+        
+        List<HostVO> hosts = _hostDao.listByCluster(clusterId);
+        if(hosts.size() >= _vmwareMgr.getMaxHostsPerCluster()) {
+        	String msg = "VMware cluster " + cluster.getName() + " is too big to add new host now. (current configured cluster size: " + _vmwareMgr.getMaxHostsPerCluster() + ")";
+        	s_logger.error(msg);
+        	throw new DiscoveredWithErrorException(msg);
+        }
+    	
+		VmwareContext context = null;
+		try {
+			context = VmwareContextFactory.create(url.getHost(), username, password);
+			List<ManagedObjectReference> morHosts = _vmwareMgr.addHostToPodCluster(context, dcId, podId, clusterId,
+				URLDecoder.decode(url.getPath()));
+			if(morHosts == null) {
+				s_logger.error("Unable to find host or cluster based on url: " + URLDecoder.decode(url.getPath()));
+				return null;
+			}
+			
+			ManagedObjectReference morCluster = null;
+			Map<String, String> clusterDetails = _clusterDetailsDao.findDetails(clusterId);
+			if(clusterDetails.get("url") != null) {
+				URI uriFromCluster = new URI(UriUtils.encodeURIComponent(clusterDetails.get("url")));
+				morCluster = context.getHostMorByPath(URLDecoder.decode(uriFromCluster.getPath()));
+				
+				if(morCluster == null || !morCluster.getType().equalsIgnoreCase("ClusterComputeResource")) {
+					s_logger.warn("Cluster url does not point to a valid vSphere cluster, url: " + clusterDetails.get("url"));
+					return null;
+				} else {
+					ClusterMO clusterMo = new ClusterMO(context, morCluster);
+					ClusterDasConfigInfo dasConfig = clusterMo.getDasConfig();
+					if(dasConfig != null && dasConfig.getEnabled() != null && dasConfig.getEnabled().booleanValue()) {
+						clusterDetails.put("NativeHA", "true");
+						_clusterDetailsDao.persist(clusterId, clusterDetails);
+					}
+				}
+			}
+			
+			if(!validateDiscoveredHosts(context, morCluster, morHosts)) {
+				if(morCluster == null)
+					s_logger.warn("The discovered host is not standalone host, can not be added to a standalone cluster");
+				else
+					s_logger.warn("The discovered host does not belong to the cluster");
+				return null;
+			}
+			
+            Map<VmwareResource, Map<String, String>> resources = new HashMap<VmwareResource, Map<String, String>>();
+			for(ManagedObjectReference morHost : morHosts) {
+	            Map<String, String> details = new HashMap<String, String>();
+	            Map<String, Object> params = new HashMap<String, Object>();
+	            
+	            HostMO hostMo = new HostMO(context, morHost);
+	            details.put("url", hostMo.getHostName());
+	            details.put("username", username);
+	            details.put("password", password);
+	            String guid = morHost.getType() + ":" + morHost.get_value() + "@"+ url.getHost();
+	            details.put("guid", guid);
+	            
+	            params.put("url", hostMo.getHostName());
+	            params.put("username", username);
+	            params.put("password", password);
+	            params.put("zone", Long.toString(dcId));
+	            params.put("pod", Long.toString(podId));
+	            params.put("cluster", Long.toString(clusterId));
+	            params.put("guid", guid);
+	            
+	            VmwareResource resource = new VmwareResource(); 
+	            try {
+	                resource.configure("VMware", params);
+	            } catch (ConfigurationException e) {
+	                _alertMgr.sendAlert(AlertManager.ALERT_TYPE_HOST, dcId, podId, "Unable to add " + url.getHost(), "Error is " + e.getMessage());
+	                s_logger.warn("Unable to instantiate " + url.getHost(), e);
+	            }
+	            resource.start();
+	            
+	            resources.put(resource, details);
+			}
+            
+            // place a place holder guid derived from cluster ID
+            cluster.setGuid(UUID.nameUUIDFromBytes(String.valueOf(clusterId).getBytes()).toString());
+            _clusterDao.update(clusterId, cluster);
+            
+            return resources;
+		} catch (DiscoveredWithErrorException e) {
+			throw e;
+		} catch (Exception e) {
+			s_logger.warn("Unable to connect to Vmware vSphere server. service address: " + url.getHost());
+			return null;
+		} finally {
+			if(context != null)
+				context.close();
+		}
+    }
+    
+    private boolean validateDiscoveredHosts(VmwareContext context, ManagedObjectReference morCluster, List<ManagedObjectReference> morHosts) throws Exception {
+    	if(morCluster == null) {
+    		for(ManagedObjectReference morHost : morHosts) {
+    			ManagedObjectReference morParent = (ManagedObjectReference)context.getServiceUtil().getDynamicProperty(morHost, "parent");
+    			if(morParent.getType().equalsIgnoreCase("ClusterComputeResource"))
+    				return false;
+    		}
+    	} else {
+    		for(ManagedObjectReference morHost : morHosts) {
+    			ManagedObjectReference morParent = (ManagedObjectReference)context.getServiceUtil().getDynamicProperty(morHost, "parent");
+    			if(!morParent.getType().equalsIgnoreCase("ClusterComputeResource"))
+    				return false;
+    			
+    			if(!morParent.get_value().equals(morCluster.get_value()))
+    				return false;
+    		}
+    	}
+    	
+    	return true;
+    }
+    
+    @Override
+    public void postDiscovery(List<HostVO> hosts, long msId) {
+        // do nothing
+    }
+    
+    @Override
+	public boolean matchHypervisor(String hypervisor) {
+    	if(hypervisor == null)
+    		return true;
+    	
+    	return Hypervisor.HypervisorType.VMware.toString().equalsIgnoreCase(hypervisor);
+    }
+    
+    @Override
+	public Hypervisor.HypervisorType getHypervisorType() {
+    	return Hypervisor.HypervisorType.VMware;
+    }
+    
+    @Override
+    public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
+        if(s_logger.isInfoEnabled())
+        	s_logger.info("Configure VmwareServerDiscoverer, discover name: " + name);
+        
+        super.configure(name, params);
+        
+        ComponentLocator locator = ComponentLocator.getCurrentLocator();
+        ConfigurationDao configDao = locator.getDao(ConfigurationDao.class);
+        if (configDao == null) {
+            throw new ConfigurationException("Unable to get the configuration dao.");
+        }
+        
+        createVmwareToolsIso();
+
+		if(s_logger.isInfoEnabled())
+			s_logger.info("VmwareServerDiscoverer has been successfully configured");
+        return true;
+    }
+    
+    private void createVmwareToolsIso() {
+        String isoName = "vmware-tools.iso";
+        VMTemplateVO tmplt = _tmpltDao.findByTemplateName(isoName);
+        Long id;
+        if (tmplt == null) {
+            id = _tmpltDao.getNextInSequence(Long.class, "id");
+            VMTemplateVO template = new VMTemplateVO(id, isoName, isoName, ImageFormat.ISO, true, true,
+                    TemplateType.PERHOST, null, null, true, 64,
+                    Account.ACCOUNT_ID_SYSTEM, null, "VMware Tools Installer ISO", false, 1, false, HypervisorType.VMware);
+            _tmpltDao.persist(template);
+        } else {
+            id = tmplt.getId();
+            tmplt.setTemplateType(TemplateType.PERHOST);
+            tmplt.setUrl(null);
+            _tmpltDao.update(id, tmplt);
+        }
+    }
+}
+
diff --git a/server/src/com/cloud/secstorage/CommandExecLogDao.java b/server/src/com/cloud/secstorage/CommandExecLogDao.java
new file mode 100644
index 00000000000..5087cc51aec
--- /dev/null
+++ b/server/src/com/cloud/secstorage/CommandExecLogDao.java
@@ -0,0 +1,13 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.secstorage;
+
+import java.util.Date;
+
+import com.cloud.utils.db.GenericDao;
+
+public interface CommandExecLogDao extends GenericDao<CommandExecLogVO, Long> {
+	public void expungeExpiredRecords(Date cutTime);
+}
diff --git a/server/src/com/cloud/secstorage/CommandExecLogDaoImpl.java b/server/src/com/cloud/secstorage/CommandExecLogDaoImpl.java
new file mode 100644
index 00000000000..d3badf390c7
--- /dev/null
+++ b/server/src/com/cloud/secstorage/CommandExecLogDaoImpl.java
@@ -0,0 +1,34 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.secstorage;
+
+import java.util.Date;
+
+import javax.ejb.Local;
+
+import com.cloud.utils.db.GenericDaoBase;
+import com.cloud.utils.db.SearchBuilder;
+import com.cloud.utils.db.SearchCriteria;
+import com.cloud.utils.db.SearchCriteria.Op;
+
+@Local(value={CommandExecLogDao.class})
+public class CommandExecLogDaoImpl extends GenericDaoBase<CommandExecLogVO, Long> implements CommandExecLogDao {
+
+    protected final SearchBuilder<CommandExecLogVO> ExpungeSearch;
+	
+	public CommandExecLogDaoImpl() {
+		ExpungeSearch = createSearchBuilder();
+		ExpungeSearch.and("created", ExpungeSearch.entity().getCreated(), Op.LT);
+		ExpungeSearch.done();
+	}
+	
+	@Override
+	public void expungeExpiredRecords(Date cutTime) {
+		SearchCriteria<CommandExecLogVO> sc = ExpungeSearch.create();
+		sc.setParameters("created", cutTime);
+		expunge(sc);
+	}
+}
+
diff --git a/server/src/com/cloud/secstorage/CommandExecLogVO.java b/server/src/com/cloud/secstorage/CommandExecLogVO.java
new file mode 100644
index 00000000000..ab14fb7edbd
--- /dev/null
+++ b/server/src/com/cloud/secstorage/CommandExecLogVO.java
@@ -0,0 +1,99 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.secstorage;
+
+import java.util.Date;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Temporal;
+import javax.persistence.TemporalType;
+
+import com.cloud.utils.DateUtil;
+
+@Entity
+@Table(name="cmd_exec_log")
+public class CommandExecLogVO {
+	
+    @Id
+    @GeneratedValue(strategy=GenerationType.IDENTITY)
+    @Column(name="id")
+	private long id;
+    
+    @Column(name="host_id")
+	private long hostId;
+    
+    @Column(name="instance_id")
+	private long instanceId;
+	
+    @Column(name="command_name")
+	private String commandName;
+    
+    @Column(name="weight")
+    private int weight;
+	
+    @Column(name="created")
+    @Temporal(value=TemporalType.TIMESTAMP)
+    private Date created;
+    
+    public CommandExecLogVO() {
+    }
+    
+    public CommandExecLogVO(long hostId, long instanceId, String commandName, int weight) {
+    	this.hostId = hostId;
+    	this.instanceId = instanceId;
+    	this.commandName = commandName;
+    	this.weight = weight;
+    	this.created = DateUtil.currentGMTTime();
+    }
+    
+    public long getId() {
+    	return this.id;
+    }
+    
+    public long getHostId() {
+    	return this.hostId;
+    }
+    
+    public void setHostId(long hostId) {
+    	this.hostId = hostId;
+    }
+    
+    public long getInstanceId() {
+    	return this.instanceId;
+    }
+    
+    public void setInstanceId(long instanceId) {
+    	this.instanceId = instanceId;
+    }
+    
+    public String getCommandName() {
+    	return this.commandName;
+    }
+    
+    public void setCommandName(String commandName) {
+    	this.commandName = commandName;
+    }
+    
+    public int getWeight() {
+    	return weight;
+    }
+    
+    public void setWeight(int weight) {
+    	this.weight = weight;
+    }
+    
+    public Date getCreated() {
+    	return this.created;
+    }
+    
+    public void setCreated(Date created) {
+    	this.created = created;
+    }
+}
diff --git a/server/src/com/cloud/secstorage/PremiumSecondaryStorageManagerImpl.java b/server/src/com/cloud/secstorage/PremiumSecondaryStorageManagerImpl.java
new file mode 100644
index 00000000000..3a3d7d4fde6
--- /dev/null
+++ b/server/src/com/cloud/secstorage/PremiumSecondaryStorageManagerImpl.java
@@ -0,0 +1,164 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.secstorage;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+import javax.ejb.Local;
+import javax.naming.ConfigurationException;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.agent.api.Command;
+import com.cloud.configuration.Config;
+import com.cloud.host.HostVO;
+import com.cloud.host.Status;
+import com.cloud.host.dao.HostDao;
+import com.cloud.storage.secondary.SecondaryStorageManagerImpl;
+import com.cloud.storage.secondary.SecondaryStorageVmManager;
+import com.cloud.utils.DateUtil;
+import com.cloud.utils.NumbersUtil;
+import com.cloud.utils.Pair;
+import com.cloud.utils.component.Inject;
+import com.cloud.utils.db.JoinBuilder.JoinType;
+import com.cloud.utils.db.SearchBuilder;
+import com.cloud.utils.db.SearchCriteria;
+import com.cloud.utils.db.SearchCriteria.Op;
+import com.cloud.vm.SecondaryStorageVm;
+import com.cloud.vm.SecondaryStorageVmVO;
+import com.cloud.vm.SystemVmLoadScanner.AfterScanAction;
+import com.cloud.vm.VirtualMachine.State;
+import com.cloud.vm.dao.SecondaryStorageVmDao;
+
+@Local(value = { SecondaryStorageVmManager.class })
+public class PremiumSecondaryStorageManagerImpl extends SecondaryStorageManagerImpl {
+    private static final Logger s_logger = Logger.getLogger(PremiumSecondaryStorageManagerImpl.class);
+
+    private int _capacityPerSSVM = SecondaryStorageVmManager.DEFAULT_SS_VM_CAPACITY;
+    private int _standbyCapacity = SecondaryStorageVmManager.DEFAULT_STANDBY_CAPACITY;
+    private int _maxExecutionTimeMs = 1800000;
+    
+    @Inject SecondaryStorageVmDao _secStorageVmDao;
+    @Inject CommandExecLogDao _cmdExecLogDao;
+    @Inject HostDao _hostDao;
+    protected SearchBuilder<CommandExecLogVO> ActiveCommandSearch;
+    protected SearchBuilder<HostVO> HostSearch;
+    
+    @Override
+    public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
+    	super.configure(name, params);
+    	
+    	_capacityPerSSVM = NumbersUtil.parseInt(_configDao.getValue(Config.SecStorageSessionMax.key()), DEFAULT_SS_VM_CAPACITY);
+        _standbyCapacity = NumbersUtil.parseInt(_configDao.getValue(Config.SecStorageCapacityStandby.key()), DEFAULT_STANDBY_CAPACITY);
+    	
+        int nMaxExecutionMinutes = NumbersUtil.parseInt(_configDao.getValue(Config.SecStorageCmdExecutionTimeMax.key()), 30);
+        _maxExecutionTimeMs = nMaxExecutionMinutes*60*1000;
+
+		HostSearch = _hostDao.createSearchBuilder();
+		HostSearch.and("dc", HostSearch.entity().getDataCenterId(), Op.EQ);
+		HostSearch.and("status", HostSearch.entity().getStatus(), Op.EQ);
+		
+		ActiveCommandSearch = _cmdExecLogDao.createSearchBuilder();
+		ActiveCommandSearch.and("created", ActiveCommandSearch.entity().getCreated(), Op.GTEQ);
+		ActiveCommandSearch.join("hostSearch", HostSearch, ActiveCommandSearch.entity().getInstanceId(), HostSearch.entity().getId(), JoinType.INNER);
+
+		HostSearch.done();
+		ActiveCommandSearch.done();
+        
+    	return true;
+    }
+    
+    @Override
+	public Pair<AfterScanAction, Object> scanPool(Long pool) {
+		long dataCenterId = pool.longValue();
+		Date cutTime = new Date(DateUtil.currentGMTTime().getTime() - _maxExecutionTimeMs);
+
+		_cmdExecLogDao.expungeExpiredRecords(cutTime);
+		
+		boolean suspendAutoLoading = !reserveStandbyCapacity();
+		if(!suspendAutoLoading) {
+	        // this is a hacking, has nothing to do with console proxy, it is just a flag that primary storage is being under maintenance mode
+	        String restart = _configDao.getValue("consoleproxy.restart");
+	        if (restart != null && restart.equalsIgnoreCase("false")) {
+	            s_logger.debug("Capacity scan disabled purposefully, consoleproxy.restart = false. This happens when the primarystorage is in maintenance mode");
+	            suspendAutoLoading = true;
+	        }
+		}
+		
+        List<SecondaryStorageVmVO> alreadyRunning = _secStorageVmDao.getSecStorageVmListInStates(SecondaryStorageVm.Role.templateProcessor, dataCenterId, State.Running,
+                State.Migrating, State.Starting);
+        if (alreadyRunning.size() == 0) {
+            s_logger.info("No running secondary storage vms found in datacenter id=" + dataCenterId + ", starting one");
+            
+            List<SecondaryStorageVmVO> stopped = _secStorageVmDao.getSecStorageVmListInStates(SecondaryStorageVm.Role.templateProcessor, dataCenterId, State.Stopped,
+                    State.Stopping);
+            if(stopped.size() == 0 || !suspendAutoLoading) {
+                List<SecondaryStorageVmVO> stopping = _secStorageVmDao.getSecStorageVmListInStates(SecondaryStorageVm.Role.templateProcessor,  State.Stopping);
+                if(stopping.size() > 0) {
+                	s_logger.info("Found SSVMs that are currently at stopping state, wait until they are settled");
+    	            return new Pair<AfterScanAction, Object>(AfterScanAction.nop, null);
+                }
+            	
+            	expandPool(pool, SecondaryStorageVm.Role.templateProcessor);
+            }
+        }
+        
+        if(!suspendAutoLoading) {
+        	// this is to avoid surprises that people may accidently see two SSVMs being launched, capacity expanding only happens when we have at least the primary SSVM is up
+	        if(alreadyRunning.size() == 0) {
+	        	s_logger.info("Primary secondary storage is not even started, wait until next turn");
+	            return new Pair<AfterScanAction, Object>(AfterScanAction.nop, null);
+	        }
+
+        	alreadyRunning = _secStorageVmDao.getSecStorageVmListInStates(null, dataCenterId, State.Running,
+	                State.Migrating, State.Starting);
+	
+	        List<CommandExecLogVO> activeCmds = listActiveCommands(dataCenterId, cutTime);
+	        if(alreadyRunning.size()*_capacityPerSSVM - activeCmds.size() < _standbyCapacity) {
+	            s_logger.info("secondary storage command execution standby capactiy low (running VMs: " + alreadyRunning.size() + ", active cmds: " + activeCmds.size() + "), starting a new one");
+	        	return new Pair<AfterScanAction, Object>(AfterScanAction.expand, SecondaryStorageVm.Role.commandExecutor);
+	        }
+        }
+        
+        return new Pair<AfterScanAction, Object>(AfterScanAction.nop, null);
+	}
+
+    @Override
+	public Pair<HostVO, SecondaryStorageVmVO> assignSecStorageVm(long zoneId, Command cmd) {
+		
+		// TODO, need performance optimization
+		List<Long> vms = _secStorageVmDao.listRunningSecStorageOrderByLoad(null, zoneId);
+		for(Long vmId : vms) {
+			SecondaryStorageVmVO secStorageVm = _secStorageVmDao.findById(vmId);
+			HostVO host;
+			host = _hostDao.findByName(secStorageVm.getHostName());
+			if(host != null && host.getStatus() == Status.Up)
+				return new Pair<HostVO, SecondaryStorageVmVO>(host, secStorageVm);
+		}
+		
+		return null;
+	}
+	
+	private List<CommandExecLogVO> listActiveCommands(long dcId, Date cutTime) {
+		SearchCriteria<CommandExecLogVO> sc = ActiveCommandSearch.create();
+		
+		sc.setParameters("created", cutTime);
+		sc.setJoinParameters("hostSearch", "dc", dcId);
+		sc.setJoinParameters("hostSearch", "status", Status.Up);
+		
+		return _cmdExecLogDao.search(sc, null);
+	}
+	
+    private boolean reserveStandbyCapacity() {
+        String value = _configDao.getValue(Config.SystemVMAutoReserveCapacity.key());
+        if(value != null && value.equalsIgnoreCase("true")) {
+            return true;
+        }
+        
+        return false;
+    }
+}
diff --git a/vmware-base/.classpath b/vmware-base/.classpath
new file mode 100644
index 00000000000..eaaa5b54255
--- /dev/null
+++ b/vmware-base/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/deps"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/utils"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/vmware-base/.project b/vmware-base/.project
new file mode 100644
index 00000000000..09cdadca8e7
--- /dev/null
+++ b/vmware-base/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>vmware-base</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/BaseMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/BaseMO.java
new file mode 100644
index 00000000000..f3757ecfce9
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/BaseMO.java
@@ -0,0 +1,138 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.vmware.vim25.CustomFieldDef;
+import com.vmware.vim25.CustomFieldStringValue;
+import com.vmware.vim25.ManagedObjectReference;
+
+public class BaseMO {
+    private static final Logger s_logger = Logger.getLogger(BaseMO.class);
+	
+	protected VmwareContext _context;
+	protected ManagedObjectReference _mor;
+
+	// cached name for the vCenter managed entity object
+	private String _name;
+	
+	public BaseMO(VmwareContext context, ManagedObjectReference mor) {
+		assert(context != null);
+		
+		_context = context;
+		_mor = mor;
+	}
+	
+	public BaseMO(VmwareContext context, String morType, String morValue) {
+		assert(context != null);
+		assert(morType != null);
+		assert(morValue != null);
+		
+		_context = context;
+		_mor = new ManagedObjectReference();
+		_mor.setType(morType);
+		_mor.set_value(morValue);
+	}
+	
+	public VmwareContext getContext() {
+		return _context;
+	}
+	
+	public ManagedObjectReference getMor() {
+		assert(_mor != null);
+		return _mor;
+	}
+	
+	public ManagedObjectReference getParentMor() throws Exception {
+		return (ManagedObjectReference)_context.getServiceUtil().getDynamicProperty(_mor, "parent");
+	}
+
+	public String getName() throws Exception {
+		if(_name == null)
+			_name = (String)_context.getServiceUtil().getDynamicProperty(_mor, "name");
+		
+		return _name;
+	}
+	
+	public boolean destroy() throws Exception {
+        ManagedObjectReference morTask = _context.getService().destroy_Task(_mor);
+        
+        String result = _context.getServiceUtil().waitForTask(morTask);
+        if(result.equals("sucess")) {
+            _context.waitForTaskProgressDone(morTask);
+            return true;
+        } else {
+        	s_logger.error("VMware destroy_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+        }
+        return false;
+	}
+	
+	public void reload() throws Exception {
+	    _context.getService().reload(_mor);
+	}
+	
+	public boolean rename(String newName) throws Exception {
+	    ManagedObjectReference morTask = _context.getService().rename_Task(_mor, newName);
+	    
+        String result = _context.getServiceUtil().waitForTask(morTask);
+        if(result.equals("sucess")) {
+            _context.waitForTaskProgressDone(morTask);
+            return true;
+        } else {
+        	s_logger.error("VMware rename_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+        }
+        return false;
+	}
+	
+	public void setCustomFieldValue(String fieldName, String value) throws Exception {
+		CustomFieldsManagerMO cfmMo = new CustomFieldsManagerMO(_context, 
+			_context.getServiceContent().getCustomFieldsManager());
+		
+		int key = getCustomFieldKey(fieldName);
+		if(key == 0) {
+			try {
+				CustomFieldDef field = cfmMo.addCustomerFieldDef(fieldName, getMor().getType(), null, null);
+				key = field.getKey();
+			} catch (Exception e) {
+				// assuming the exception is caused by concurrent operation from other places
+				// so we retieve the key again
+				key = getCustomFieldKey(fieldName);
+			}
+		}
+		
+		if(key == 0)
+			throw new Exception("Unable to setup custom field facility");
+		
+		cfmMo.setField(getMor(), key, value);
+	}
+	
+	public String getCustomFieldValue(String fieldName) throws Exception {
+		int key = getCustomFieldKey(fieldName);
+		if(key == 0)
+			return null;
+		
+		CustomFieldStringValue cfValue = (CustomFieldStringValue)_context.getServiceUtil().getDynamicProperty(getMor(), 
+			String.format("value[%d]", key));
+		if(cfValue != null)
+			return cfValue.getValue();
+		
+		return null;
+	}
+	
+	public int getCustomFieldKey(String fieldName) throws Exception {
+		return getCustomFieldKey(getMor().getType(), fieldName);
+	}
+	
+	public int getCustomFieldKey(String morType, String fieldName) throws Exception {
+		assert(morType != null);
+		
+		CustomFieldsManagerMO cfmMo = new CustomFieldsManagerMO(_context, 
+				_context.getServiceContent().getCustomFieldsManager());
+		
+		return cfmMo.getCustomFieldKey(morType, fieldName);
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/ClusterMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/ClusterMO.java
new file mode 100755
index 00000000000..be44e89ca3b
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/ClusterMO.java
@@ -0,0 +1,566 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.cloud.utils.Pair;
+import com.google.gson.Gson;
+import com.vmware.apputils.vim25.ServiceUtil;
+import com.vmware.vim25.ArrayOfHostIpRouteEntry;
+import com.vmware.vim25.ClusterComputeResourceSummary;
+import com.vmware.vim25.ClusterConfigInfoEx;
+import com.vmware.vim25.ClusterDasConfigInfo;
+import com.vmware.vim25.ClusterHostRecommendation;
+import com.vmware.vim25.ComputeResourceSummary;
+import com.vmware.vim25.CustomFieldStringValue;
+import com.vmware.vim25.DatastoreInfo;
+import com.vmware.vim25.DynamicProperty;
+import com.vmware.vim25.HostHardwareSummary;
+import com.vmware.vim25.HostIpRouteEntry;
+import com.vmware.vim25.HostRuntimeInfo;
+import com.vmware.vim25.HostSystemConnectionState;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.NasDatastoreInfo;
+import com.vmware.vim25.ObjectContent;
+import com.vmware.vim25.ObjectSpec;
+import com.vmware.vim25.OptionValue;
+import com.vmware.vim25.PropertyFilterSpec;
+import com.vmware.vim25.PropertySpec;
+import com.vmware.vim25.SelectionSpec;
+import com.vmware.vim25.TraversalSpec;
+import com.vmware.vim25.VirtualMachineConfigSpec;
+
+//
+// TODO : ClusterMO was designed to be able to work as a special host before, therefore it implements VmwareHypervisorHost
+// interface. This has changed as ClusterMO no longer works as a special host anymore. Need to refactor accordingly
+//
+public class ClusterMO extends BaseMO implements VmwareHypervisorHost {
+    private static final Logger s_logger = Logger.getLogger(ClusterMO.class);
+	
+	public ClusterMO(VmwareContext context, ManagedObjectReference morCluster) {
+		super(context, morCluster);
+	}
+	
+	public ClusterMO(VmwareContext context, String morType, String morValue) {
+		super(context, morType, morValue);
+	}
+	
+	@Override
+	public String getHyperHostName() throws Exception {
+		return getName();
+	}
+
+	@Override
+	public ClusterDasConfigInfo getDasConfig() throws Exception {
+		// Note getDynamicProperty() with "configurationEx.dasConfig" does not work here because of that dasConfig is a property in subclass
+		ClusterConfigInfoEx configInfo = (ClusterConfigInfoEx)_context.getServiceUtil().getDynamicProperty(_mor, "configurationEx");
+		return configInfo.getDasConfig();
+	}
+	
+	@Override
+	public ManagedObjectReference getHyperHostDatacenter() throws Exception {
+		Pair<DatacenterMO, String> dcPair = DatacenterMO.getOwnerDatacenter(getContext(), getMor());
+		assert(dcPair != null);
+		return dcPair.first().getMor();
+	}
+	
+	@Override
+	public ManagedObjectReference getHyperHostOwnerResourcePool() throws Exception {
+		ServiceUtil serviceUtil = _context.getServiceUtil();
+		return (ManagedObjectReference)serviceUtil.getDynamicProperty(getMor(), "resourcePool"); 
+	}
+	
+	@Override
+	public ManagedObjectReference getHyperHostCluster() throws Exception {
+		return _mor;
+	}
+	
+	@Override
+	public VirtualMachineMO findVmOnHyperHost(String name) throws Exception {
+		ObjectContent[] ocs = getVmPropertiesOnHyperHost(new String[] { "name" });
+		return HypervisorHostHelper.findVmFromObjectContent(_context, ocs, name);
+	}
+	
+	@Override
+	public VirtualMachineMO findVmOnPeerHyperHost(String name) throws Exception {
+		ObjectContent[] ocs = getVmPropertiesOnHyperHost(new String[] { "name" });
+		if(ocs != null && ocs.length > 0) {
+			for(ObjectContent oc : ocs) {
+				DynamicProperty[] props = oc.getPropSet();
+				if(props != null) {
+					for(DynamicProperty prop : props) {
+						if(prop.getVal().toString().equals(name))
+							return new VirtualMachineMO(_context, oc.getObj());
+					}
+				}
+			}
+		}
+		return null;
+	}
+	
+	@Override
+	public ObjectContent[] getVmPropertiesOnHyperHost(String[] propertyPaths) throws Exception {
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - retrieveProperties() for VM properties. target MOR: " + _mor.get_value() + ", properties: " + new Gson().toJson(propertyPaths));
+		
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("VirtualMachine");
+		pSpec.setPathSet(propertyPaths);
+
+	    TraversalSpec host2VmFolderTraversal = new TraversalSpec();
+	    host2VmFolderTraversal.setType("HostSystem");
+	    host2VmFolderTraversal.setPath("vm");
+	    host2VmFolderTraversal.setName("host2VmFolderTraversal");
+		
+	    TraversalSpec cluster2HostFolderTraversal = new TraversalSpec();
+	    cluster2HostFolderTraversal.setType("ClusterComputeResource");
+	    cluster2HostFolderTraversal.setPath("host");
+	    cluster2HostFolderTraversal.setName("cluster2HostFolderTraversal");
+	    cluster2HostFolderTraversal.setSelectSet(new SelectionSpec[] { host2VmFolderTraversal });
+	    
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(getMor());
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { cluster2HostFolderTraversal });
+	    
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    ObjectContent[] properties = _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec });
+	    
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - retrieveProperties() done");
+	    return properties;
+	}
+
+	@Override
+	public ObjectContent[] getDatastorePropertiesOnHyperHost(String[] propertyPaths) throws Exception {
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - retrieveProperties() on Datastore properties. target MOR: " + _mor.get_value() + ", properties: " + new Gson().toJson(propertyPaths));
+		
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("Datastore");
+		pSpec.setPathSet(propertyPaths);
+		
+	    TraversalSpec cluster2DatastoreTraversal = new TraversalSpec();
+	    cluster2DatastoreTraversal.setType("ClusterComputeResource");
+	    cluster2DatastoreTraversal.setPath("datastore");
+	    cluster2DatastoreTraversal.setName("cluster2DatastoreTraversal");
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(_mor);
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { cluster2DatastoreTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    ObjectContent[] properties = _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec }); 
+	    
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - retrieveProperties() done");
+	    return properties;
+	}
+	
+	private ObjectContent[] getHostPropertiesOnCluster(String[] propertyPaths) throws Exception {
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - retrieveProperties() on Host properties. target MOR: " + _mor.get_value() + ", properties: " + new Gson().toJson(propertyPaths));
+
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("HostSystem");
+		pSpec.setPathSet(propertyPaths);
+		
+	    TraversalSpec cluster2HostTraversal = new TraversalSpec();
+	    cluster2HostTraversal.setType("ClusterComputeResource");
+	    cluster2HostTraversal.setPath("host");
+	    cluster2HostTraversal.setName("cluster2HostTraversal");
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(_mor);
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { cluster2HostTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    ObjectContent[] properties = _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec });
+
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - retrieveProperties() done");
+	    return properties;
+	}
+
+	@Override
+	public boolean createVm(VirtualMachineConfigSpec vmSpec) throws Exception {
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - createVM_Task(). target MOR: " + _mor.get_value() + ", VirtualMachineConfigSpec: " + new Gson().toJson(vmSpec));
+		
+		assert(vmSpec != null);
+		DatacenterMO dcMo = new DatacenterMO(_context, getHyperHostDatacenter());
+        ManagedObjectReference morPool = getHyperHostOwnerResourcePool();
+		
+	    ManagedObjectReference morTask = _context.getService().createVM_Task(
+	    	dcMo.getVmFolder(), vmSpec, morPool, null);
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			
+		    if(s_logger.isTraceEnabled())
+				s_logger.trace("vCenter API trace - createVM_Task() done(successfully)");
+			return true;
+		} else {
+        	s_logger.error("VMware createVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - createVM_Task() done(failed)");
+		return false;
+	}
+	
+	@Override
+	public void importVmFromOVF(String ovfFilePath, String vmName, DatastoreMO dsMo, String diskOption) throws Exception {
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - importVmFromOVF(). target MOR: " + _mor.get_value() + ", ovfFilePath: " + ovfFilePath + ", vmName: " + vmName 
+				+ ", datastore: " + dsMo.getMor().get_value() + ", diskOption: " + diskOption);
+
+		ManagedObjectReference morRp = getHyperHostOwnerResourcePool();
+		assert(morRp != null);
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - importVmFromOVF(). resource pool: " + morRp.get_value()); 
+					
+		HypervisorHostHelper.importVmFromOVF(this, ovfFilePath, vmName, dsMo, diskOption, morRp, null);
+		
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - importVmFromOVF() done");
+	}
+
+	@Override
+	public boolean createBlankVm(String vmName, int cpuCount, int cpuSpeedMHz, int cpuReservedMHz, boolean limitCpuUse, int memoryMB, 
+		String guestOsIdentifier, ManagedObjectReference morDs, boolean snapshotDirToParent) throws Exception {
+		
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - createBlankVm(). target MOR: " + _mor.get_value() + ", vmName: " + vmName + ", cpuCount: " + cpuCount
+				+ ", cpuSpeedMhz: " + cpuSpeedMHz + ", cpuReservedMHz: " + cpuReservedMHz + ", limitCpu: " + limitCpuUse + ", memoryMB: " + memoryMB 
+				+ ", guestOS: " + guestOsIdentifier + ", datastore: " + morDs.get_value() + ", snapshotDirToParent: " + snapshotDirToParent);
+		
+		boolean result = HypervisorHostHelper.createBlankVm(this, vmName, cpuCount, cpuSpeedMHz, cpuReservedMHz, limitCpuUse,
+			memoryMB, guestOsIdentifier, morDs, snapshotDirToParent);
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - createBlankVm() done");
+			
+		return result;
+	}
+
+	@Override
+	public ManagedObjectReference mountDatastore(boolean vmfsDatastore, String poolHostAddress, 
+		int poolHostPort, String poolPath, String poolUuid) throws Exception {
+
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - mountDatastore(). target MOR: " + _mor.get_value() + ", vmfs: " + vmfsDatastore + ", poolHost: " + poolHostAddress
+				+ ", poolHostPort: " + poolHostPort + ", poolPath: " + poolPath + ", poolUuid: " + poolUuid);
+		
+		ManagedObjectReference morDs = null;
+		ManagedObjectReference morDsFirst = null;
+		ManagedObjectReference[] hosts = (ManagedObjectReference[])_context.getServiceUtil().getDynamicProperty(_mor, "host");
+		if(hosts != null && hosts.length > 0) {
+			for(ManagedObjectReference morHost : hosts) {
+				HostMO hostMo = new HostMO(_context, morHost);
+				morDs = hostMo.mountDatastore(vmfsDatastore, poolHostAddress, poolHostPort, poolPath, poolUuid);
+				if(morDsFirst == null)
+					morDsFirst = morDs;
+				
+				// assume datastore is in scope of datacenter
+				assert(morDsFirst.get_value().equals(morDs.get_value()));
+			}
+		}
+		
+		if(morDs == null) {
+			String msg = "Failed to mount datastore in all hosts within the cluster";
+			s_logger.error(msg);
+			
+			if(s_logger.isTraceEnabled())
+				s_logger.trace("vCenter API trace - mountDatastore() done(failed)");
+			throw new Exception(msg);
+		}
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - mountDatastore() done(successfully)");
+		
+		return morDs;
+	}
+	
+	@Override
+	public void unmountDatastore(String poolUuid) throws Exception {
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - unmountDatastore(). target MOR: " + _mor.get_value() + ", poolUuid: " + poolUuid);
+		
+		ManagedObjectReference[] hosts = (ManagedObjectReference[])_context.getServiceUtil().getDynamicProperty(_mor, "host");
+		if(hosts != null && hosts.length > 0) {
+			for(ManagedObjectReference morHost : hosts) {
+				HostMO hostMo = new HostMO(_context, morHost);
+				hostMo.unmountDatastore(poolUuid);
+			}
+		}
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - unmountDatastore() done");
+	}
+	
+	@Override
+	public ManagedObjectReference findDatastore(String poolUuid) throws Exception {
+
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - findDatastore(). target MOR: " + _mor.get_value() + ", poolUuid: " + poolUuid);
+		
+		CustomFieldsManagerMO cfmMo = new CustomFieldsManagerMO(_context, 
+				_context.getServiceContent().getCustomFieldsManager());
+		int key = cfmMo.getCustomFieldKey("Datastore", CustomFieldConstants.CLOUD_UUID);
+		assert(key != 0);
+
+		ObjectContent[] ocs = getDatastorePropertiesOnHyperHost(new String[] {"name", String.format("value[%d]", key)});
+		if(ocs != null) {
+			for(ObjectContent oc : ocs) {
+				if(oc.getPropSet(0).getVal().equals(poolUuid))
+					return oc.getObj();
+				
+				if(oc.getPropSet().length > 1) {
+					DynamicProperty prop = oc.getPropSet(1);
+					if(prop != null && prop.getVal() != null) {
+						if(prop.getVal() instanceof CustomFieldStringValue) {
+							String val = ((CustomFieldStringValue)prop.getVal()).getValue();
+							if(val.equalsIgnoreCase(poolUuid)) {
+								
+							    if(s_logger.isTraceEnabled())
+									s_logger.trace("vCenter API trace - findDatastore() done(successfully)");
+								return oc.getObj();
+							}
+						}
+					}
+				}
+			}
+		}
+		
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - findDatastore() done(failed)");
+		return null;
+	}
+	
+	@Override
+	public ManagedObjectReference findDatastoreByExportPath(String exportPath) throws Exception {
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - findDatastoreByExportPath(). target MOR: " + _mor.get_value() + ", exportPath: " + exportPath);
+		
+		ObjectContent[] ocs = getDatastorePropertiesOnHyperHost(new String[] {"info"});
+		if(ocs != null && ocs.length > 0) {
+			for(ObjectContent oc : ocs) {
+				DatastoreInfo dsInfo = (DatastoreInfo)oc.getPropSet(0).getVal();
+				if(dsInfo != null && dsInfo instanceof NasDatastoreInfo) {
+					NasDatastoreInfo info = (NasDatastoreInfo)dsInfo;
+					if(info != null) {
+						String vmwareUrl = info.getUrl();
+						if(vmwareUrl.charAt(vmwareUrl.length() - 1) == '/')
+							vmwareUrl = vmwareUrl.substring(0, vmwareUrl.length() - 1);
+						
+						URI uri = new URI(vmwareUrl);
+						if(uri.getPath().equals("/" + exportPath)) {
+							
+						    if(s_logger.isTraceEnabled())
+								s_logger.trace("vCenter API trace - findDatastoreByExportPath() done(successfully)");
+							return oc.getObj();
+						}
+					}
+				}
+			}
+		}
+		
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - findDatastoreByExportPath() done(failed)");
+		return null;
+	}
+	
+	@Override
+	public ManagedObjectReference findMigrationTarget(VirtualMachineMO vmMo) throws Exception {
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - findMigrationTarget(). target MOR: " + _mor.get_value() + ", vm: " + vmMo.getName());
+
+		ClusterHostRecommendation[] candidates = recommendHostsForVm(vmMo);
+		if(candidates != null && candidates.length > 0) {
+		    if(s_logger.isTraceEnabled())
+				s_logger.trace("vCenter API trace - findMigrationTarget() done(successfully)");
+			return candidates[0].getHost();
+		}
+
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - findMigrationTarget() done(failed)");
+		return null;
+	}
+	
+	@Override
+	public boolean isHyperHostConnected() throws Exception {
+		ObjectContent[] ocs = getHostPropertiesOnCluster(new String[] {"runtime"});
+		if(ocs != null && ocs.length > 0) {
+			for(ObjectContent oc : ocs) {
+				HostRuntimeInfo runtimeInfo = (HostRuntimeInfo)oc.getPropSet(0).getVal();
+				// as long as we have one host connected, we assume the cluster is up 
+				if(runtimeInfo.getConnectionState() == HostSystemConnectionState.connected)
+					return true;
+			}
+		}
+		return false;
+	}
+	
+	@Override
+	public String getHyperHostDefaultGateway() throws Exception {
+		ObjectContent[] ocs = getHostPropertiesOnCluster(new String[] {"config.network.routeTableInfo.ipRoute"});
+		if(ocs != null && ocs.length > 0) {
+			for(ObjectContent oc : ocs) {
+				ArrayOfHostIpRouteEntry entries = (ArrayOfHostIpRouteEntry)oc.getPropSet(0).getVal();
+				if(entries != null) {
+					for(HostIpRouteEntry entry : entries.getHostIpRouteEntry()) {
+						if(entry.getNetwork().equalsIgnoreCase("0.0.0.0"))
+							return entry.getGateway();
+					}
+				}
+			}
+		}
+		
+		throw new Exception("Could not find host default gateway, host is not properly configured?");
+	}
+	
+	@Override
+	public VmwareHypervisorHostResourceSummary getHyperHostResourceSummary() throws Exception {
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - getHyperHostResourceSummary(). target MOR: " + _mor.get_value());
+
+		VmwareHypervisorHostResourceSummary summary = new VmwareHypervisorHostResourceSummary();
+	
+		ComputeResourceSummary vmwareSummary = (ComputeResourceSummary)_context.getServiceUtil().getDynamicProperty(
+			_mor, "summary");
+		
+		// TODO, need to use traversal to optimize retrieve of 
+		int cpuNumInCpuThreads = 1;
+		ManagedObjectReference[] hosts = (ManagedObjectReference[])_context.getServiceUtil().getDynamicProperty(_mor, "host");
+		if(hosts != null && hosts.length > 0) {
+			for(ManagedObjectReference morHost : hosts) {
+				HostMO hostMo = new HostMO(_context, morHost);
+				HostHardwareSummary hardwareSummary = hostMo.getHostHardwareSummary();
+				
+				if(hardwareSummary.getNumCpuCores()*hardwareSummary.getNumCpuThreads() > cpuNumInCpuThreads)
+					cpuNumInCpuThreads = hardwareSummary.getNumCpuCores()*hardwareSummary.getNumCpuThreads();
+			}
+		}
+		summary.setCpuCount(cpuNumInCpuThreads);
+		summary.setCpuSpeed(vmwareSummary.getTotalCpu());
+		summary.setMemoryBytes(vmwareSummary.getTotalMemory());
+		
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - getHyperHostResourceSummary() done");
+		return summary;
+	}
+	
+	@Override
+	public VmwareHypervisorHostNetworkSummary getHyperHostNetworkSummary(String esxServiceConsolePort) throws Exception {
+
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - getHyperHostNetworkSummary(). target MOR: " + _mor.get_value() + ", mgmtPortgroup: " + esxServiceConsolePort);
+		
+		ManagedObjectReference[] hosts = (ManagedObjectReference[])_context.getServiceUtil().getDynamicProperty(_mor, "host");
+		if(hosts != null && hosts.length > 0) {
+			VmwareHypervisorHostNetworkSummary summary = new HostMO(_context, hosts[0]).getHyperHostNetworkSummary(esxServiceConsolePort);
+			
+		    if(s_logger.isTraceEnabled())
+				s_logger.trace("vCenter API trace - getHyperHostResourceSummary() done(successfully)");
+			return summary;
+		}
+		
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - getHyperHostResourceSummary() done(failed)");
+		return null;
+	}
+	
+	@Override
+	public ComputeResourceSummary getHyperHostHardwareSummary() throws Exception {
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - getHyperHostHardwareSummary(). target MOR: " + _mor.get_value());
+
+		ClusterComputeResourceSummary hardwareSummary = (ClusterComputeResourceSummary)
+			_context.getServiceUtil().getDynamicProperty(_mor, "summary");
+
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - getHyperHostHardwareSummary() done");
+		return hardwareSummary;
+	}
+
+	public ClusterHostRecommendation[] recommendHostsForVm(VirtualMachineMO vmMo) throws Exception {
+		return _context.getService().recommendHostsForVm(_mor, vmMo.getMor(), 
+			getHyperHostOwnerResourcePool());
+	}
+	
+	public List<Pair<ManagedObjectReference, String>> getClusterHosts() throws Exception {
+		List<Pair<ManagedObjectReference, String>> hosts = new ArrayList<Pair<ManagedObjectReference, String>>();
+		
+		ObjectContent[] ocs = getHostPropertiesOnCluster(new String[] {"name"});
+		if(ocs != null) {
+			for(ObjectContent oc : ocs) {
+				ManagedObjectReference morHost = oc.getObj();
+				String name = (String)oc.getPropSet(0).getVal();
+				
+				hosts.add(new Pair<ManagedObjectReference, String>(morHost, name));
+			}
+		}
+		return hosts;
+	}
+	
+	public HashMap<String, Integer> getVmVncPortsOnCluster() throws Exception {
+    	ObjectContent[] ocs = getVmPropertiesOnHyperHost(
+        		new String[] { "name", "config.extraConfig[\"RemoteDisplay.vnc.port\"]" }
+        	);
+		
+        HashMap<String, Integer> portInfo = new HashMap<String, Integer>();
+    	if(ocs != null && ocs.length > 0) {
+    		for(ObjectContent oc : ocs) {
+		        DynamicProperty[] objProps = oc.getPropSet();
+		        if(objProps != null) {
+		        	String name = null;
+		        	String value = null;
+		        	for(DynamicProperty objProp : objProps) {
+		        		if(objProp.getName().equals("name")) {
+		        			name = (String)objProp.getVal();
+		        		} else {
+		        			OptionValue optValue = (OptionValue)objProp.getVal();
+		        			value = (String)optValue.getValue();
+		        		} 
+		        	}
+		        	
+		        	if(name != null && value != null) {
+		        		portInfo.put(name, Integer.parseInt(value));
+		        	}
+		        }
+    		}
+    	}
+    	
+    	return portInfo;
+	}
+}
+
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/CustomFieldConstants.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/CustomFieldConstants.java
new file mode 100644
index 00000000000..2d6e2bc9a1f
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/CustomFieldConstants.java
@@ -0,0 +1,10 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+public interface CustomFieldConstants {
+	public final static String CLOUD_UUID = "cloud.uuid";
+	public final static String CLOUD_GC = "cloud.gc";
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/CustomFieldsManagerMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/CustomFieldsManagerMO.java
new file mode 100644
index 00000000000..322c09babba
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/CustomFieldsManagerMO.java
@@ -0,0 +1,72 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.vmware.vim25.CustomFieldDef;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.PrivilegePolicyDef;
+
+public class CustomFieldsManagerMO extends BaseMO {
+
+	public CustomFieldsManagerMO(VmwareContext context, ManagedObjectReference mor) {
+		super(context, mor);
+	}
+	
+	public CustomFieldsManagerMO(VmwareContext context, String morType, String morValue) {
+		super(context, morType, morValue);
+	}
+	
+	public CustomFieldDef addCustomerFieldDef(String fieldName, String morType, 
+		PrivilegePolicyDef fieldDefPolicy, PrivilegePolicyDef fieldPolicy) throws Exception {
+		return _context.getService().addCustomFieldDef(getMor(), fieldName, morType, fieldDefPolicy, fieldPolicy);
+	}
+	
+	public void removeCustomFieldDef(int key) throws Exception {
+		_context.getService().removeCustomFieldDef(getMor(), key);
+	}
+	
+	public void renameCustomFieldDef(int key, String name) throws Exception {
+		_context.getService().renameCustomFieldDef(getMor(), key, name);
+	}
+	
+	public void setField(ManagedObjectReference morEntity, int key, String value) throws Exception {
+		_context.getService().setField(getMor(), morEntity, key, value);
+	}
+	
+	public CustomFieldDef[] getFields() throws Exception {
+		return (CustomFieldDef[])_context.getServiceUtil().getDynamicProperty(getMor(), "field");
+	}
+	
+	public int getCustomFieldKey(String morType, String fieldName) throws Exception {
+		CustomFieldDef[] fields = getFields();
+		if(fields != null) {
+			for(CustomFieldDef field : fields) {
+				if(field.getName().equals(fieldName) && field.getManagedObjectType().equals(morType))
+					return field.getKey();
+			}
+		}
+		return 0;
+	}
+	
+	public int ensureCustomFieldDef(String morType, String fieldName) throws Exception {
+		int key = getCustomFieldKey(morType, fieldName);
+		if(key > 0)
+			return key;
+		
+		try {
+			CustomFieldDef field = addCustomerFieldDef(fieldName, morType, null, null);
+			return field.getKey();
+		} catch(Exception e) {
+			// assuming that someone is adding it
+			key = getCustomFieldKey(morType, fieldName);
+		}
+		
+		if(key == 0)
+			throw new Exception("Unable to setup custom field facility for " + morType + ":" + fieldName);
+			
+		return key;
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/DatacenterMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/DatacenterMO.java
new file mode 100755
index 00000000000..d8a75c7a9f0
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/DatacenterMO.java
@@ -0,0 +1,295 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.cloud.utils.Pair;
+import com.vmware.apputils.vim25.ServiceUtil;
+import com.vmware.vim25.CustomFieldStringValue;
+import com.vmware.vim25.DynamicProperty;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.ObjectContent;
+import com.vmware.vim25.ObjectSpec;
+import com.vmware.vim25.PropertyFilterSpec;
+import com.vmware.vim25.PropertySpec;
+import com.vmware.vim25.SelectionSpec;
+import com.vmware.vim25.TraversalSpec;
+
+public class DatacenterMO extends BaseMO {
+	
+	public DatacenterMO(VmwareContext context, ManagedObjectReference morDc) {
+		super(context, morDc);
+	}
+	
+	public DatacenterMO(VmwareContext context, String morType, String morValue) {
+		super(context, morType, morValue);
+	}
+	
+	public DatacenterMO(VmwareContext context, String dcName) throws Exception {
+		super(context, null);
+		
+		_mor = _context.getServiceUtil().getDecendentMoRef(_context.getRootFolder(), "Datacenter", dcName);
+		assert(_mor != null);
+	}
+	
+	public String getName() throws Exception {
+		return (String)_context.getServiceUtil().getDynamicProperty(_mor, "name");
+	}
+	
+	public void registerTemplate(ManagedObjectReference morHost, String datastoreName, 
+		String templateName, String templateFileName) throws Exception {
+		
+		ServiceUtil serviceUtil = _context.getServiceUtil();
+		
+		ManagedObjectReference morFolder = (ManagedObjectReference)serviceUtil.getDynamicProperty(
+			_mor, "vmFolder");
+		assert(morFolder != null);
+		
+		ManagedObjectReference morTask = _context.getService().registerVM_Task(
+    		 morFolder, 
+    		 String.format("[%s] %s/%s", datastoreName, templateName, templateFileName),
+    		 templateName, true, 
+    		 null, morHost);
+		
+		String result = serviceUtil.waitForTask(morTask);
+		if (!result.equalsIgnoreCase("Sucess")) {
+			throw new Exception("Unable to register template due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		} else {
+			_context.waitForTaskProgressDone(morTask);
+		}
+	}
+	
+	public VirtualMachineMO findVm(String vmName) throws Exception {
+		ObjectContent[] ocs = getVmPropertiesOnDatacenterVmFolder(new String[] { "name" });
+		if(ocs != null && ocs.length > 0) {
+			for(ObjectContent oc : ocs) {
+				DynamicProperty[] props = oc.getPropSet();
+				if(props != null) {
+					for(DynamicProperty prop : props) {
+						if(prop.getVal().toString().equals(vmName))
+							return new VirtualMachineMO(_context, oc.getObj());
+					}
+				}
+			}
+		}
+		return null;
+	}
+	
+	public List<VirtualMachineMO> findVmByNameAndLabel(String vmLabel) throws Exception {
+		CustomFieldsManagerMO cfmMo = new CustomFieldsManagerMO(_context, 
+				_context.getServiceContent().getCustomFieldsManager());
+		int key = cfmMo.getCustomFieldKey("VirtualMachine", CustomFieldConstants.CLOUD_UUID);
+		assert(key != 0);
+		
+		List<VirtualMachineMO> list = new ArrayList<VirtualMachineMO>();
+		
+		ObjectContent[] ocs = getVmPropertiesOnDatacenterVmFolder(new String[] { "name",  String.format("value[%d]", key)});
+		if(ocs != null && ocs.length > 0) {
+			for(ObjectContent oc : ocs) {
+				DynamicProperty[] props = oc.getPropSet();
+				if(props != null) {
+					for(DynamicProperty prop : props) {
+						if(prop.getVal() != null) {
+							if(prop.getName().equalsIgnoreCase("name")) {
+								if(prop.getVal().toString().equals(vmLabel)) {
+									list.add(new VirtualMachineMO(_context, oc.getObj()));
+									break;		// break out inner loop
+								}
+							} else if(prop.getVal() instanceof CustomFieldStringValue) {
+								String val = ((CustomFieldStringValue)prop.getVal()).getValue();
+								if(val.equals(vmLabel)) {
+									list.add(new VirtualMachineMO(_context, oc.getObj()));
+									break;		// break out inner loop
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		return list;
+	}
+	
+	public List<Pair<ManagedObjectReference, String>> getAllVmsOnDatacenter() throws Exception {
+	    List<Pair<ManagedObjectReference, String>> vms = new ArrayList<Pair<ManagedObjectReference, String>>();
+	    
+	    ObjectContent[] ocs = getVmPropertiesOnDatacenterVmFolder(new String[] { "name" });
+	    if(ocs != null) {
+	        for(ObjectContent oc : ocs) {
+	            String vmName = oc.getPropSet(0).getVal().toString();
+	            vms.add(new Pair<ManagedObjectReference, String>(oc.getObj(), vmName));
+	        }
+	    }
+	    
+	    return vms;
+	}	
+	
+	public ManagedObjectReference findDatastore(String name) throws Exception {
+		assert(name != null);
+		
+		ObjectContent[] ocs = getDatastorePropertiesOnDatacenter(new String[] { "name" });
+		if(ocs != null) {
+			for(ObjectContent oc : ocs) {
+				if(oc.getPropSet(0).getVal().toString().equals(name)) {
+					return oc.getObj();
+				}
+			}
+		}
+		return null;
+	}
+	
+	public ManagedObjectReference findHost(String name) throws Exception {
+		ObjectContent[] ocs= getHostPropertiesOnDatacenterHostFolder(new String[] { "name" });
+		
+		if(ocs != null) {
+			for(ObjectContent oc : ocs) {
+				if(oc.getPropSet(0).getVal().toString().equals(name)) {
+					return oc.getObj();
+				}
+			}
+		}
+		return null;
+	}
+	
+	public ManagedObjectReference getVmFolder() throws Exception {
+		return (ManagedObjectReference)_context.getServiceUtil().getDynamicProperty(_mor, "vmFolder");
+	}
+	
+	public ObjectContent[] getHostPropertiesOnDatacenterHostFolder(String[] propertyPaths) throws Exception {
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("HostSystem");
+		pSpec.setPathSet(propertyPaths);
+		
+	    TraversalSpec computeResource2HostTraversal = new TraversalSpec();
+	    computeResource2HostTraversal.setType("ComputeResource");
+	    computeResource2HostTraversal.setPath("host");
+	    computeResource2HostTraversal.setName("computeResource2HostTraversal");
+		
+	    SelectionSpec recurseFolders = new SelectionSpec();
+	    recurseFolders.setName("folder2childEntity");
+	      
+	    TraversalSpec folder2childEntity = new TraversalSpec();
+	    folder2childEntity.setType("Folder");
+	    folder2childEntity.setPath("childEntity");
+	    folder2childEntity.setName(recurseFolders.getName());
+	    folder2childEntity.setSelectSet(new SelectionSpec[] { recurseFolders, computeResource2HostTraversal });
+	    
+	    TraversalSpec dc2HostFolderTraversal = new TraversalSpec();
+	    dc2HostFolderTraversal.setType("Datacenter");
+	    dc2HostFolderTraversal.setPath("hostFolder");
+	    dc2HostFolderTraversal.setName("dc2HostFolderTraversal");
+	    dc2HostFolderTraversal.setSelectSet(new SelectionSpec[] { folder2childEntity } );
+	    
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(_mor);
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { dc2HostFolderTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    return _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec }); 
+	}
+	
+	public ObjectContent[] getDatastorePropertiesOnDatacenter(String[] propertyPaths) throws Exception {
+		
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("Datastore");
+		pSpec.setPathSet(propertyPaths);
+		
+	    TraversalSpec dc2DatastoreTraversal = new TraversalSpec();
+	    dc2DatastoreTraversal.setType("Datacenter");
+	    dc2DatastoreTraversal.setPath("datastore");
+	    dc2DatastoreTraversal.setName("dc2DatastoreTraversal");
+	    
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(_mor);
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { dc2DatastoreTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    return _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec }); 
+	}
+	
+	public ObjectContent[] getVmPropertiesOnDatacenterVmFolder(String[] propertyPaths) throws Exception {
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("VirtualMachine");
+		pSpec.setPathSet(propertyPaths);
+		
+	    TraversalSpec dc2VmFolderTraversal = new TraversalSpec();
+	    dc2VmFolderTraversal.setType("Datacenter");
+	    dc2VmFolderTraversal.setPath("vmFolder");
+	    dc2VmFolderTraversal.setName("dc2VmFolderTraversal");
+	    
+	    SelectionSpec recurseFolders = new SelectionSpec();
+	    recurseFolders.setName("folder2childEntity");
+	      
+	    TraversalSpec folder2childEntity = new TraversalSpec();
+	    folder2childEntity.setType("Folder");
+	    folder2childEntity.setPath("childEntity");
+	    folder2childEntity.setName(recurseFolders.getName());
+	    folder2childEntity.setSelectSet(new SelectionSpec[] { recurseFolders });
+	    dc2VmFolderTraversal.setSelectSet(new SelectionSpec[] { folder2childEntity } );
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(_mor);
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { dc2VmFolderTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    return _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec }); 
+	}
+	
+	public static Pair<DatacenterMO, String> getOwnerDatacenter(VmwareContext context, 
+		ManagedObjectReference morEntity) throws Exception {
+		
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("Datacenter");
+		pSpec.setPathSet(new String[] { "name" });
+		
+	    TraversalSpec entityParentTraversal = new TraversalSpec();
+	    entityParentTraversal.setType("ManagedEntity");
+	    entityParentTraversal.setPath("parent");
+	    entityParentTraversal.setName("entityParentTraversal");
+	    entityParentTraversal.setSelectSet(new SelectionSpec[] { new SelectionSpec(null, null, "entityParentTraversal") });
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(morEntity);
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { entityParentTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    ObjectContent[] ocs = context.getService().retrieveProperties(
+	    	context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec });
+	    
+	    assert(ocs != null);
+	    assert(ocs[0].getObj() != null);
+	    assert(ocs[0].getPropSet(0) != null);
+	    assert(ocs[0].getPropSet(0).getVal() != null);
+	    
+	    String dcName = ocs[0].getPropSet(0).getVal().toString(); 
+	    return new Pair<DatacenterMO, String>(new DatacenterMO(context, ocs[0].getObj()), dcName); 
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/DatastoreFile.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/DatastoreFile.java
new file mode 100755
index 00000000000..ce9c4194920
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/DatastoreFile.java
@@ -0,0 +1,125 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+public class DatastoreFile {
+	private String _path;
+	
+	public DatastoreFile(String path) {
+		assert(path != null);
+		_path = path;
+	}
+	
+	public DatastoreFile(String datastoreName, String pathWithoutDatastoreName) {
+		_path = String.format("[%s] %s", datastoreName, pathWithoutDatastoreName);
+	}
+	
+	public DatastoreFile(String datastoreName, String dir, String fileName) {
+		if(dir == null || dir.isEmpty())
+			_path = String.format("[%s] %s", datastoreName, fileName);
+		else
+			_path = String.format("[%s] %s/%s", datastoreName, dir, fileName);
+	}
+	
+	public String getDatastoreName() {
+		return getDatastoreNameFromPath(_path);
+	}
+	
+	public String getPath() {
+		return _path;
+	}
+	
+	public String getRelativePath() {
+		int pos = _path.indexOf(']');
+		if(pos < 0) 
+			pos = 0; 
+		else 
+			pos++;
+		
+		return _path.substring(pos).trim();
+	}
+	
+	public String getDir() {
+		int startPos = _path.indexOf("]");
+		if(startPos < 0)
+			startPos = 0;
+		
+		int endPos = _path.lastIndexOf('/');
+		if(endPos < 0)
+			endPos = 0;
+		
+		if(endPos > startPos) {
+			return _path.substring(startPos + 1, endPos).trim();
+		}
+		
+		return "";
+	}
+	
+	public String getFileName() {
+		int startPos = _path.indexOf("]");
+		if(startPos < 0)
+			startPos = 0;
+		else
+			startPos++;
+		
+		int endPos = _path.lastIndexOf('/');
+		if(endPos < 0) {
+			return _path.substring(startPos).trim();
+		} else {
+			return _path.substring(endPos + 1);
+		}
+	}
+	
+	public String getFileBaseName() {
+		String name = getFileName();
+		int endPos = name.lastIndexOf('.');
+		if(endPos < 0)
+			return name;
+		return name.substring(0, endPos);
+	}
+	
+	public String getFileExtName() {
+		String name = getFileName();
+		int endPos = name.lastIndexOf('.');
+		if(endPos < 0)
+			return "";
+		
+		return name.substring(endPos); 
+	}
+	
+	public String getCompanionPath(String companionFileName) {
+		return getCompanionDatastorePath(_path, companionFileName);
+	}
+	
+	public static boolean isFullDatastorePath(String path) {
+		return path.matches("^\\[.*\\].*");
+	}
+	
+	public static String getDatastoreNameFromPath(String path) {
+		if(isFullDatastorePath(path)) {
+			int endPos = path.indexOf("]");
+			return path.substring(1, endPos).trim();
+		}
+		return null;
+	}
+	
+	public static String getCompanionDatastorePath(String path, String companionFileName) {
+		if(isFullDatastorePath(path)) {
+			int endPos = path.indexOf("]");
+			String dsName = path.substring(1, endPos);
+			String dsRelativePath = path.substring(endPos + 1).trim();
+			
+			int fileNamePos = dsRelativePath.lastIndexOf('/');
+			if(fileNamePos < 0) {
+				return String.format("[%s] %s", dsName, companionFileName);
+			} else {
+				return String.format("[%s] %s/%s", dsName, 
+					dsRelativePath.substring(0, fileNamePos),
+					companionFileName);
+			}
+		}
+		return companionFileName;
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/DatastoreMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/DatastoreMO.java
new file mode 100755
index 00000000000..056c2eb7b88
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/DatastoreMO.java
@@ -0,0 +1,305 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.cloud.utils.Pair;
+import com.vmware.vim25.DatastoreSummary;
+import com.vmware.vim25.FileInfo;
+import com.vmware.vim25.HostDatastoreBrowserSearchResults;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.ObjectContent;
+import com.vmware.vim25.ObjectSpec;
+import com.vmware.vim25.PropertyFilterSpec;
+import com.vmware.vim25.PropertySpec;
+import com.vmware.vim25.SelectionSpec;
+import com.vmware.vim25.TraversalSpec;
+
+public class DatastoreMO extends BaseMO {
+	private static final Logger s_logger = Logger.getLogger(DatastoreMO.class);
+	
+	// cache copy to reduce calls to vCenter
+	private String _name;							
+	private Pair<DatacenterMO, String> _ownerDc;	
+	
+	public DatastoreMO(VmwareContext context, ManagedObjectReference morDatastore) {
+		super(context, morDatastore);
+	}
+	
+	public DatastoreMO(VmwareContext context, String morType, String morValue) {
+		super(context, morType, morValue);
+	}
+
+	public String getName() throws Exception {
+		if(_name == null) 
+			_name = (String)_context.getServiceUtil().getDynamicProperty(_mor, "name");
+		
+		return _name;
+	}
+	
+	public DatastoreSummary getSummary() throws Exception {
+		return (DatastoreSummary)_context.getServiceUtil().getDynamicProperty(_mor, "summary");
+	}
+	
+	public HostDatastoreBrowserMO getHostDatastoreBrowserMO() throws Exception {
+		return new HostDatastoreBrowserMO(_context, 
+				(ManagedObjectReference)_context.getServiceUtil().getDynamicProperty(_mor, "browser"));
+	}
+	
+	public String getInventoryPath() throws Exception {
+		Pair<DatacenterMO, String> dcInfo = getOwnerDatacenter();
+		return dcInfo.second() + "/" + getName();
+	}
+	
+	public Pair<DatacenterMO, String> getOwnerDatacenter() throws Exception {
+		if(_ownerDc != null)
+			return _ownerDc;
+		
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("Datacenter");
+		pSpec.setPathSet(new String[] { "name" });
+		
+	    TraversalSpec folderParentTraversal = new TraversalSpec();
+	    folderParentTraversal.setType("Folder");
+	    folderParentTraversal.setPath("parent");
+	    folderParentTraversal.setName("folderParentTraversal");
+	    folderParentTraversal.setSelectSet(new SelectionSpec[] { new SelectionSpec(null, null, "folderParentTraversal") });
+	    
+	    TraversalSpec dsParentTraversal = new TraversalSpec();
+	    dsParentTraversal.setType("Datastore");
+	    dsParentTraversal.setPath("parent");
+	    dsParentTraversal.setName("dsParentTraversal");
+	    dsParentTraversal.setSelectSet(new SelectionSpec[] { folderParentTraversal });
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(getMor());
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { dsParentTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    ObjectContent[] ocs = _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec });
+	    
+	    assert(ocs != null);
+	    assert(ocs[0].getObj() != null);
+	    assert(ocs[0].getPropSet() != null);
+	    String dcName = ocs[0].getPropSet()[0].getVal().toString(); 
+	    _ownerDc = new Pair<DatacenterMO, String>(new DatacenterMO(_context, ocs[0].getObj()), dcName);
+	    return _ownerDc;
+	}
+	
+	public void makeDirectory(String path, ManagedObjectReference morDc) throws Exception {
+		String datastoreName = getName();
+		ManagedObjectReference morFileManager = _context.getServiceContent().getFileManager();
+		
+		String fullPath = path;
+		if(!DatastoreFile.isFullDatastorePath(fullPath)) 
+			fullPath = String.format("[%s] %s", datastoreName, path);
+		
+		_context.getService().makeDirectory(morFileManager, fullPath, morDc, true);
+	}
+	
+	public boolean deleteFile(String path, ManagedObjectReference morDc, boolean testExistence) throws Exception {
+		String datastoreName = getName();
+		ManagedObjectReference morFileManager = _context.getServiceContent().getFileManager();
+		
+		String fullPath = path;
+		if(!DatastoreFile.isFullDatastorePath(fullPath))
+			fullPath = String.format("[%s] %s", datastoreName, path);
+
+		try {
+			if(testExistence && !fileExists(fullPath))
+				return true;
+		} catch(Exception e) {
+			s_logger.info("Unable to test file existence due to exception " + e.getClass().getName() + ", skip deleting of it");
+			return true;
+		}
+		
+		ManagedObjectReference morTask = _context.getService().deleteDatastoreFile_Task(morFileManager, 
+			fullPath, morDc);
+		
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware deleteDatastoreFile_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		return false;
+	}
+	
+	public boolean copyDatastoreFile(String srcFilePath, ManagedObjectReference morSrcDc,
+		ManagedObjectReference morDestDs, String destFilePath, ManagedObjectReference morDestDc, 
+		boolean forceOverwrite) throws Exception {
+		
+		String srcDsName = getName();
+		DatastoreMO destDsMo = new DatastoreMO(_context, morDestDs);
+		String destDsName = destDsMo.getName();
+		
+		ManagedObjectReference morFileManager = _context.getServiceContent().getFileManager();
+		String srcFullPath = srcFilePath;
+		if(!DatastoreFile.isFullDatastorePath(srcFullPath))
+			srcFullPath = String.format("[%s] %s", srcDsName, srcFilePath);
+		
+		String destFullPath = destFilePath;
+		if(!DatastoreFile.isFullDatastorePath(destFullPath))
+			destFullPath = String.format("[%s] %s", destDsName, destFilePath);
+		
+		ManagedObjectReference morTask = _context.getService().copyDatastoreFile_Task(morFileManager, 
+			srcFullPath, morSrcDc, destFullPath, morDestDc, forceOverwrite);
+		
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware copyDatastoreFile_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		return false;
+	}
+	
+	public boolean moveDatastoreFile(String srcFilePath, ManagedObjectReference morSrcDc,
+		ManagedObjectReference morDestDs, String destFilePath, ManagedObjectReference morDestDc, 
+		boolean forceOverwrite) throws Exception {
+		
+		String srcDsName = getName();
+		DatastoreMO destDsMo = new DatastoreMO(_context, morDestDs);
+		String destDsName = destDsMo.getName();
+		
+		ManagedObjectReference morFileManager = _context.getServiceContent().getFileManager();
+		String srcFullPath = srcFilePath;
+		if(!DatastoreFile.isFullDatastorePath(srcFullPath))
+			srcFullPath = String.format("[%s] %s", srcDsName, srcFilePath);
+		
+		String destFullPath = destFilePath;
+		if(!DatastoreFile.isFullDatastorePath(destFullPath))
+			destFullPath = String.format("[%s] %s", destDsName, destFilePath);
+		
+		ManagedObjectReference morTask = _context.getService().moveDatastoreFile_Task(morFileManager, 
+			srcFullPath, morSrcDc, destFullPath, morDestDc, forceOverwrite);
+		
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware moveDatgastoreFile_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		return false;
+	}
+	
+	public String[] getVmdkFileChain(String rootVmdkDatastoreFullPath) throws Exception {
+		Pair<DatacenterMO, String> dcPair = getOwnerDatacenter();
+		
+		List<String> files = new ArrayList<String>();
+		files.add(rootVmdkDatastoreFullPath);
+		
+		String currentVmdkFullPath = rootVmdkDatastoreFullPath;
+		while(true) {
+			String url = getContext().composeDatastoreBrowseUrl(dcPair.second(), currentVmdkFullPath);
+			byte[] content = getContext().getResourceContent(url);
+			if(content == null || content.length == 0)
+				break;
+			
+			VmdkFileDescriptor descriptor = new VmdkFileDescriptor();
+			descriptor.parse(content);
+			
+			String parentFileName = descriptor.getParentFileName();
+			if(parentFileName == null)
+				break;
+
+			if(parentFileName.startsWith("/")) {
+				// when parent file is not at the same directory as it is, assume it is at parent directory
+				// this is only valid in cloud.com primary storage deployment
+				DatastoreFile dsFile = new DatastoreFile(currentVmdkFullPath);
+				String dir = dsFile.getDir();
+				if(dir != null && dir.lastIndexOf('/') > 0)
+					dir = dir.substring(0, dir.lastIndexOf('/'));
+				else
+					dir = "";
+				
+				currentVmdkFullPath = new DatastoreFile(dsFile.getDatastoreName(), dir, 
+					parentFileName.substring(parentFileName.lastIndexOf('/') + 1)).getPath();
+				files.add(currentVmdkFullPath);
+			} else {
+				currentVmdkFullPath = DatastoreFile.getCompanionDatastorePath(currentVmdkFullPath, parentFileName);
+				files.add(currentVmdkFullPath);
+			}
+		}
+		
+		return files.toArray(new String[0]);
+	}
+
+	@Deprecated
+	public String[] listDirContent(String path) throws Exception {
+		String fullPath = path;
+		if(!DatastoreFile.isFullDatastorePath(fullPath))
+			fullPath = String.format("[%s] %s", getName(), fullPath);
+		
+		Pair<DatacenterMO, String> dcPair = getOwnerDatacenter();
+		String url = getContext().composeDatastoreBrowseUrl(dcPair.second(), fullPath);
+		
+		// TODO, VMware currently does not have a formal API to list Datastore directory content,
+		// folloing hacking may have performance hit if datastore has a large number of files
+		return _context.listDatastoreDirContent(url);
+	}
+	
+	public boolean fileExists(String fileFullPath) throws Exception {
+		DatastoreFile file = new DatastoreFile(fileFullPath);
+		DatastoreFile dirFile = new DatastoreFile(file.getDatastoreName(), file.getDir());
+		
+		HostDatastoreBrowserMO browserMo = getHostDatastoreBrowserMO();
+	
+		s_logger.info("Search file " + file.getFileName() + " on " + dirFile.getPath());
+		HostDatastoreBrowserSearchResults results = browserMo.searchDatastore(dirFile.getPath(), file.getFileName(), true);
+		if(results != null) {
+			FileInfo[] info = results.getFile();
+			if(info != null && info.length > 0) {
+				s_logger.info("File " + fileFullPath + " exists on datastore");
+				return true;
+			}
+		}
+		
+		s_logger.info("File " + fileFullPath + " does not exist on datastore");
+		return false;
+
+/*		
+		String[] fileNames = listDirContent(dirFile.getPath());
+		
+		String fileName = file.getFileName();
+		for(String name : fileNames) {
+			if(name.equalsIgnoreCase(fileName))
+				return true;
+		} 
+		
+		return false;
+*/		
+	}
+	
+	public boolean folderExists(String folderParentDatastorePath, String folderName) throws Exception {
+		HostDatastoreBrowserMO browserMo = getHostDatastoreBrowserMO();
+		
+		HostDatastoreBrowserSearchResults results = browserMo.searchDatastore(folderParentDatastorePath, folderName, true);
+		if(results != null) {
+			FileInfo[] info = results.getFile();
+			if(info != null && info.length > 0) {
+				s_logger.info("Folder " + folderName + " exists on datastore");
+				return true;
+			}
+		}
+		
+		s_logger.info("Folder " + folderName + " does not exist on datastore");
+		return false;
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostDatastoreBrowserMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostDatastoreBrowserMO.java
new file mode 100644
index 00000000000..e655299cb75
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostDatastoreBrowserMO.java
@@ -0,0 +1,112 @@
+/* *  Copyright (C) 2011 Citrix Systems, Inc.  All rights reserved
+ *
+ *
+ * This software is licensed under the GNU General Public License v3 or later.
+ *
+ * It is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+ 
+package com.cloud.hypervisor.vmware.mo;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.vmware.vim25.HostDatastoreBrowserSearchResults;
+import com.vmware.vim25.HostDatastoreBrowserSearchSpec;
+import com.vmware.vim25.ManagedObjectReference;
+
+public class HostDatastoreBrowserMO extends BaseMO {
+	
+    private static final Logger s_logger = Logger.getLogger(HostDatastoreBrowserMO.class);
+	
+	public HostDatastoreBrowserMO(VmwareContext context, ManagedObjectReference morHostDatastoreBrowser) {
+		super(context, morHostDatastoreBrowser);
+	}
+	
+	public HostDatastoreBrowserMO(VmwareContext context, String morType, String morValue) {
+		super(context, morType, morValue);
+	}
+	
+	public void DeleteFile(String datastoreFullPath) throws Exception {
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - deleteFile(). target mor: " + _mor.get_value() + ", file datastore path: " + datastoreFullPath);
+		
+		_context.getService().deleteFile(_mor, datastoreFullPath);
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - deleteFile() done");
+	}
+	
+	public HostDatastoreBrowserSearchResults searchDatastore(String datastorePath, HostDatastoreBrowserSearchSpec searchSpec) throws Exception {
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - searchDatastore(). target mor: " + _mor.get_value() + ", file datastore path: " + datastorePath);
+
+		try {
+			ManagedObjectReference morTask = _context.getService().searchDatastore_Task(_mor, datastorePath, searchSpec);
+			
+			String result = _context.getServiceUtil().waitForTask(morTask);
+			if(result.equals("sucess")) {
+				_context.waitForTaskProgressDone(morTask);
+				
+				return (HostDatastoreBrowserSearchResults)_context.getServiceUtil().getDynamicProperty(morTask, "info.result");
+			} else {
+	        	s_logger.error("VMware searchDaastore_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+			}
+		} finally {
+			if(s_logger.isTraceEnabled())
+				s_logger.trace("vCenter API trace - searchDatastore() done");
+		}
+		
+		return null;
+	}
+	
+	public HostDatastoreBrowserSearchResults searchDatastore(String datastorePath, String fileName, boolean caseInsensitive) throws Exception {
+		HostDatastoreBrowserSearchSpec spec = new HostDatastoreBrowserSearchSpec();
+		spec.setSearchCaseInsensitive(caseInsensitive);
+		spec.setMatchPattern(new String[] { fileName });
+
+		return searchDatastore(datastorePath, spec);
+	}
+	
+	public HostDatastoreBrowserSearchResults searchDatastoreSubFolders(String datastorePath, HostDatastoreBrowserSearchSpec searchSpec) throws Exception {
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - searchDatastoreSubFolders(). target mor: " + _mor.get_value() + ", file datastore path: " + datastorePath);
+
+		try {
+			ManagedObjectReference morTask = _context.getService().searchDatastoreSubFolders_Task(_mor, datastorePath, searchSpec);
+			
+			String result = _context.getServiceUtil().waitForTask(morTask);
+			if(result.equals("sucess")) {
+				_context.waitForTaskProgressDone(morTask);
+				
+				return (HostDatastoreBrowserSearchResults)_context.getServiceUtil().getDynamicProperty(morTask, "info.result");
+			} else {
+	        	s_logger.error("VMware searchDaastoreSubFolders_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+			}
+		} finally {
+			if(s_logger.isTraceEnabled())
+				s_logger.trace("vCenter API trace - searchDatastore() done");
+		}
+		
+		return null;
+	}
+	
+	public HostDatastoreBrowserSearchResults searchDatastoreSubFolders(String datastorePath, String folderName, boolean caseInsensitive) throws Exception {
+		HostDatastoreBrowserSearchSpec spec = new HostDatastoreBrowserSearchSpec();
+		spec.setSearchCaseInsensitive(caseInsensitive);
+		spec.setMatchPattern(new String[] { folderName });
+
+		return searchDatastore(datastorePath, spec);
+	}
+}
+
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostDatastoreSystemMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostDatastoreSystemMO.java
new file mode 100755
index 00000000000..39d67607b82
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostDatastoreSystemMO.java
@@ -0,0 +1,173 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import java.net.URI;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.vmware.vim25.CustomFieldStringValue;
+import com.vmware.vim25.DatastoreInfo;
+import com.vmware.vim25.DynamicProperty;
+import com.vmware.vim25.HostNasVolumeSpec;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.NasDatastoreInfo;
+import com.vmware.vim25.ObjectContent;
+import com.vmware.vim25.ObjectSpec;
+import com.vmware.vim25.PropertyFilterSpec;
+import com.vmware.vim25.PropertySpec;
+import com.vmware.vim25.SelectionSpec;
+import com.vmware.vim25.TraversalSpec;
+
+public class HostDatastoreSystemMO extends BaseMO {
+
+	public HostDatastoreSystemMO(VmwareContext context, ManagedObjectReference morHostDatastore) {
+		super(context, morHostDatastore);
+	}
+	
+	public HostDatastoreSystemMO(VmwareContext context, String morType, String morValue) {
+		super(context, morType, morValue);
+	}
+	
+	public ManagedObjectReference findDatastore(String name) throws Exception {
+		// added cloud.com specific name convention, we will use custom field "cloud.uuid" as datastore name as well
+		CustomFieldsManagerMO cfmMo = new CustomFieldsManagerMO(_context, 
+			_context.getServiceContent().getCustomFieldsManager());
+		int key = cfmMo.getCustomFieldKey("Datastore", CustomFieldConstants.CLOUD_UUID);
+		assert(key != 0);
+
+		ObjectContent[] ocs = getDatastorePropertiesOnHostDatastoreSystem(
+			new String[] { "name", String.format("value[%d]", key) });
+		if(ocs != null) {
+			for(ObjectContent oc : ocs) {
+				if(oc.getPropSet(0).getVal().equals(name))
+					return oc.getObj();
+				
+				if(oc.getPropSet().length > 1) {
+					DynamicProperty prop = oc.getPropSet(1);
+					if(prop != null && prop.getVal() != null) {
+						if(prop.getVal() instanceof CustomFieldStringValue) {
+							String val = ((CustomFieldStringValue)prop.getVal()).getValue();
+							if(val.equalsIgnoreCase(name))
+								return oc.getObj();
+						}
+					}
+				}
+			}
+		}
+		return null;
+	}
+	
+	// storeUrl in nfs://host/exportpath format
+	public ManagedObjectReference findDatastoreByUrl(String storeUrl) throws Exception {
+		assert(storeUrl != null);
+		
+		ManagedObjectReference[] datastores = getDatastores();
+		if(datastores != null && datastores.length > 0) {
+			for(ManagedObjectReference morDatastore : datastores) {
+				NasDatastoreInfo info = getNasDatastoreInfo(morDatastore);
+				if(info != null) {
+					URI uri = new URI(storeUrl);
+					String vmwareStyleUrl = "netfs://" + uri.getHost() + "/" + uri.getPath() + "/";
+					if(info.getUrl().equals(vmwareStyleUrl))
+						return morDatastore;
+				}
+			}
+		}
+		
+		return null;
+	}
+
+	// TODO this is a hacking helper method, when we can pass down storage pool info along with volume
+	// we should be able to find the datastore by name
+	public ManagedObjectReference findDatastoreByExportPath(String exportPath) throws Exception {
+		assert(exportPath != null);
+		
+		ManagedObjectReference[] datastores = getDatastores();
+		if(datastores != null && datastores.length > 0) {
+			for(ManagedObjectReference morDatastore : datastores) {
+				DatastoreMO dsMo = new DatastoreMO(_context, morDatastore);
+				if(dsMo.getInventoryPath().equals(exportPath)) 
+					return morDatastore;
+				
+				NasDatastoreInfo info = getNasDatastoreInfo(morDatastore);
+				if(info != null) {
+					String vmwareUrl = info.getUrl();
+					if(vmwareUrl.charAt(vmwareUrl.length() - 1) == '/')
+						vmwareUrl = vmwareUrl.substring(0, vmwareUrl.length() - 1);
+					
+					URI uri = new URI(vmwareUrl);
+					if(uri.getPath().equals("/" + exportPath))
+						return morDatastore;
+				}
+			}
+		}
+		
+		return null;
+	}
+	
+	public boolean deleteDatastore(String name) throws Exception {
+		ManagedObjectReference morDatastore = findDatastore(name);
+		if(morDatastore != null) {
+			_context.getService().removeDatastore(_mor, morDatastore);
+			return true;
+		}
+		return false;
+	}
+	
+	public ManagedObjectReference createNfsDatastore(String host, int port, 
+		String exportPath, String uuid) throws Exception {
+		
+		HostNasVolumeSpec spec = new HostNasVolumeSpec();
+		spec.setRemoteHost(host);
+		spec.setRemotePath(exportPath);
+		spec.setType("nfs");
+		spec.setLocalPath(uuid);
+		
+		// readOnly/readWrite
+		spec.setAccessMode("readWrite");
+		return _context.getService().createNasDatastore(_mor, spec);
+	}
+	
+	public ManagedObjectReference[] getDatastores() throws Exception {
+		return (ManagedObjectReference[])_context.getServiceUtil().getDynamicProperty(
+			_mor, "datastore");
+	}
+	
+	public DatastoreInfo getDatastoreInfo(ManagedObjectReference morDatastore) throws Exception {
+		return (DatastoreInfo)_context.getServiceUtil().getDynamicProperty(morDatastore, "info");
+	}
+	
+	public NasDatastoreInfo getNasDatastoreInfo(ManagedObjectReference morDatastore) throws Exception {
+		DatastoreInfo info = (DatastoreInfo)_context.getServiceUtil().getDynamicProperty(morDatastore, "info");
+		if(info instanceof NasDatastoreInfo)
+			return (NasDatastoreInfo)info;
+		return null;
+	}
+	
+	public ObjectContent[] getDatastorePropertiesOnHostDatastoreSystem(String[] propertyPaths) throws Exception {
+		
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("Datastore");
+		pSpec.setPathSet(propertyPaths);
+		
+	    TraversalSpec hostDsSys2DatastoreTraversal = new TraversalSpec();
+	    hostDsSys2DatastoreTraversal.setType("HostDatastoreSystem");
+	    hostDsSys2DatastoreTraversal.setPath("datastore");
+	    hostDsSys2DatastoreTraversal.setName("hostDsSys2DatastoreTraversal");
+	    
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(_mor);
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { hostDsSys2DatastoreTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    return _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec }); 
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostFirewallSystemMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostFirewallSystemMO.java
new file mode 100755
index 00000000000..2d222eaf24d
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostFirewallSystemMO.java
@@ -0,0 +1,34 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.vmware.vim25.ManagedObjectReference;
+
+public class HostFirewallSystemMO extends BaseMO {
+    private static final Logger s_logger = Logger.getLogger(HostFirewallSystemMO.class);
+
+	public HostFirewallSystemMO(VmwareContext context, ManagedObjectReference morFirewallSystem) {
+		super(context, morFirewallSystem);
+	}
+	
+	public HostFirewallSystemMO(VmwareContext context, String morType, String morValue) {
+		super(context, morType, morValue);
+	}
+	
+	public void enableRuleset(String rulesetName) throws Exception {
+		_context.getService().enableRuleset(_mor, rulesetName);
+	}
+	
+	public void disableRuleset(String rulesetName) throws Exception {
+		_context.getService().disableRuleset(_mor, rulesetName);
+	}
+	
+	public void refreshFirewall() throws Exception {
+		_context.getService().refreshFirewall(_mor);
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostMO.java
new file mode 100755
index 00000000000..b937a66cf62
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostMO.java
@@ -0,0 +1,887 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.cloud.hypervisor.vmware.util.VmwareHelper;
+import com.cloud.utils.Pair;
+import com.google.gson.Gson;
+import com.vmware.apputils.vim25.ServiceUtil;
+import com.vmware.vim25.AboutInfo;
+import com.vmware.vim25.ClusterDasConfigInfo;
+import com.vmware.vim25.ComputeResourceSummary;
+import com.vmware.vim25.DatastoreSummary;
+import com.vmware.vim25.DynamicProperty;
+import com.vmware.vim25.HostConfigManager;
+import com.vmware.vim25.HostConnectInfo;
+import com.vmware.vim25.HostHardwareSummary;
+import com.vmware.vim25.HostHyperThreadScheduleInfo;
+import com.vmware.vim25.HostIpRouteEntry;
+import com.vmware.vim25.HostListSummaryQuickStats;
+import com.vmware.vim25.HostNetworkInfo;
+import com.vmware.vim25.HostNetworkPolicy;
+import com.vmware.vim25.HostNetworkTrafficShapingPolicy;
+import com.vmware.vim25.HostPortGroup;
+import com.vmware.vim25.HostPortGroupSpec;
+import com.vmware.vim25.HostRuntimeInfo;
+import com.vmware.vim25.HostSystemConnectionState;
+import com.vmware.vim25.HostVirtualNic;
+import com.vmware.vim25.HostVirtualSwitch;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.ObjectContent;
+import com.vmware.vim25.ObjectSpec;
+import com.vmware.vim25.OptionValue;
+import com.vmware.vim25.PropertyFilterSpec;
+import com.vmware.vim25.PropertySpec;
+import com.vmware.vim25.SelectionSpec;
+import com.vmware.vim25.TraversalSpec;
+import com.vmware.vim25.VirtualMachineConfigSpec;
+import com.vmware.vim25.VirtualNicManagerNetConfig;
+
+public class HostMO extends BaseMO implements VmwareHypervisorHost {
+    private static final Logger s_logger = Logger.getLogger(HostMO.class);
+    Map<String, VirtualMachineMO> _vmCache = new HashMap<String, VirtualMachineMO>();
+	
+	public HostMO (VmwareContext context, ManagedObjectReference morHost) {
+		super(context, morHost);
+	}
+	
+	public HostMO (VmwareContext context, String morType, String morValue) {
+		super(context, morType, morValue);
+	}
+	
+	public HostHardwareSummary getHostHardwareSummary() throws Exception {
+		HostConnectInfo hostInfo = _context.getService().queryHostConnectionInfo(_mor);
+		HostHardwareSummary hardwareSummary = hostInfo.getHost().getHardware();
+		return hardwareSummary;
+	}
+	
+	public HostConfigManager getHostConfigManager() throws Exception {
+		return (HostConfigManager)_context.getServiceUtil().getDynamicProperty(_mor, "configManager");
+	}
+	
+	public VirtualNicManagerNetConfig[] getHostVirtualNicManagerNetConfig() throws Exception {
+		VirtualNicManagerNetConfig[] netConfigs = (VirtualNicManagerNetConfig[])_context.getServiceUtil().getDynamicProperty(_mor, 
+			"config.virtualNicManagerInfo.netConfig");
+		return netConfigs; 
+	}
+	
+	public HostIpRouteEntry[] getHostIpRouteEntries() throws Exception {
+		HostIpRouteEntry[] entries = (HostIpRouteEntry[])_context.getServiceUtil().getDynamicProperty(_mor, 
+			"config.network.routeTableInfo.ipRoute");
+		return entries; 
+	}
+	
+	public HostListSummaryQuickStats getHostQuickStats() throws Exception {
+		return (HostListSummaryQuickStats)_context.getServiceUtil().getDynamicProperty(_mor, "summary.quickStats");
+	}
+	
+	public HostHyperThreadScheduleInfo getHostHyperThreadInfo() throws Exception {
+		return (HostHyperThreadScheduleInfo)_context.getServiceUtil().getDynamicProperty(_mor, "config.hyperThread");
+	}
+	
+	public HostNetworkInfo getHostNetworkInfo() throws Exception {
+		return (HostNetworkInfo)_context.getServiceUtil().getDynamicProperty(_mor, "config.network");
+	}
+	
+	public HostPortGroupSpec getHostPortGroupSpec(String portGroupName) throws Exception {
+		
+		HostNetworkInfo hostNetInfo = getHostNetworkInfo();
+		
+		HostPortGroup[] portGroups = hostNetInfo.getPortgroup();
+		if(portGroups != null) {
+			for(HostPortGroup portGroup : portGroups) {
+				HostPortGroupSpec spec = portGroup.getSpec();
+				if(spec.getName().equals(portGroupName))
+					return spec;
+			}
+		}
+		
+		return null;
+	}
+	
+	@Override
+	public String getHyperHostName() throws Exception {
+		return getName();
+	}
+	
+	@Override
+	public ClusterDasConfigInfo getDasConfig() throws Exception {
+		ManagedObjectReference morParent = getParentMor();
+		if(morParent.getType().equals("ClusterComputeResource")) {
+			ClusterMO clusterMo = new ClusterMO(_context, morParent);
+			return clusterMo.getDasConfig();
+		}
+		
+		return null;
+	}
+	
+	@Override
+	public String getHyperHostDefaultGateway() throws Exception {
+		HostIpRouteEntry[] entries = getHostIpRouteEntries();
+		for(HostIpRouteEntry entry : entries) {
+			if(entry.getNetwork().equalsIgnoreCase("0.0.0.0"))
+				return entry.getGateway();
+		}
+		
+		throw new Exception("Could not find host default gateway, host is not properly configured?");
+	}
+	
+	public HostDatastoreSystemMO getHostDatastoreSystemMO() throws Exception {
+		return new HostDatastoreSystemMO(_context,
+			(ManagedObjectReference)_context.getServiceUtil().getDynamicProperty(
+				_mor, "configManager.datastoreSystem")
+		);
+	}
+	
+	public HostDatastoreBrowserMO getHostDatastoreBrowserMO() throws Exception {
+		return new HostDatastoreBrowserMO(_context,
+				(ManagedObjectReference)_context.getServiceUtil().getDynamicProperty(
+					_mor, "datastoreBrowser")
+			);
+	}
+
+	private DatastoreMO getHostDatastoreMO(String datastoreName) throws Exception {
+		ObjectContent[] ocs = getDatastorePropertiesOnHyperHost(new String[] { "name"} );
+		if(ocs != null && ocs.length > 0) {
+    		for(ObjectContent oc : ocs) {
+		        DynamicProperty[] objProps = oc.getPropSet();
+		        if(objProps != null) {
+		        	for(DynamicProperty objProp : objProps) {
+		        		if(objProp.getVal().toString().equals(datastoreName))
+		        			return new DatastoreMO(_context, oc.getObj());
+		        	}
+		        }
+    		}
+		}
+		return null;
+	}
+	
+	public HostNetworkSystemMO getHostNetworkSystemMO() throws Exception {
+		HostConfigManager configMgr = getHostConfigManager();
+		return new HostNetworkSystemMO(_context, configMgr.getNetworkSystem());
+	}
+	
+	public HostFirewallSystemMO getHostFirewallSystemMO() throws Exception {
+		HostConfigManager configMgr = getHostConfigManager();
+		ManagedObjectReference morFirewall = configMgr.getFirewallSystem();
+		
+		// only ESX hosts have firewall manager
+		if(morFirewall != null)
+			return new HostFirewallSystemMO(_context, morFirewall);
+		return null;
+	}
+	
+	@Override
+	public ManagedObjectReference getHyperHostDatacenter() throws Exception {
+		Pair<DatacenterMO, String> dcPair = DatacenterMO.getOwnerDatacenter(getContext(), getMor());
+		assert(dcPair != null);
+		return dcPair.first().getMor();
+	}
+
+	@Override
+	public ManagedObjectReference getHyperHostOwnerResourcePool() throws Exception {
+		ServiceUtil serviceUtil = _context.getServiceUtil();
+		ManagedObjectReference morComputerResource = (ManagedObjectReference)serviceUtil.getDynamicProperty(_mor, "parent");
+		return (ManagedObjectReference)serviceUtil.getDynamicProperty(morComputerResource, "resourcePool"); 
+	}
+
+	@Override
+	public ManagedObjectReference getHyperHostCluster() throws Exception {
+		ServiceUtil serviceUtil = _context.getServiceUtil();
+		ManagedObjectReference morParent = (ManagedObjectReference)serviceUtil.getDynamicProperty(_mor, "parent");
+		
+		if(morParent.getType().equalsIgnoreCase("ClusterComputeResource")) {
+			return morParent;
+		}
+		
+		assert(false);
+		throw new Exception("Standalone host is not supported");
+	}
+	
+	public ManagedObjectReference[] getHostLocalDatastore() throws Exception {
+		ServiceUtil serviceUtil = _context.getServiceUtil();
+		ManagedObjectReference[] datastores = (ManagedObjectReference[])serviceUtil.getDynamicProperty(
+			_mor, "datastore");
+		List<ManagedObjectReference> l = new ArrayList<ManagedObjectReference>();
+		if(datastores != null) {
+			for(ManagedObjectReference mor : datastores) {
+				DatastoreSummary summary = (DatastoreSummary)serviceUtil.getDynamicProperty(mor, "summary");
+				if(summary.getType().equalsIgnoreCase("VMFS") && !summary.getMultipleHostAccess())
+					l.add(mor);
+			}
+		}
+		return l.toArray(new ManagedObjectReference[1]);
+	}
+	
+	public HostVirtualSwitch getHostVirtualSwitchByName(String name) throws Exception {
+		HostVirtualSwitch[] switches = (HostVirtualSwitch[])_context.getServiceUtil().getDynamicProperty(
+			_mor, "config.network.vswitch");
+		
+		if(switches != null) {
+			for(HostVirtualSwitch vswitch : switches) {
+				if(vswitch.getName().equals(name))
+					return vswitch;
+			}
+		}
+		return null;
+	}
+	
+	public HostVirtualSwitch[] getHostVirtualSwitch() throws Exception {
+		return (HostVirtualSwitch[])_context.getServiceUtil().getDynamicProperty(_mor, "config.network.vswitch");
+	}
+	
+	public AboutInfo getHostAboutInfo() throws Exception {
+		return (AboutInfo)_context.getServiceUtil().getDynamicProperty(_mor, "config.product");
+	}
+	
+	public VmwareHostType getHostType() throws Exception {
+		AboutInfo aboutInfo = getHostAboutInfo();
+		if("VMware ESXi".equals(aboutInfo.getName()))
+			return VmwareHostType.ESXi;
+		else if("VMware ESX".equals(aboutInfo.getName()))
+			return VmwareHostType.ESX;
+		
+		throw new Exception("Unrecognized VMware host type " + aboutInfo.getName());
+	}
+	
+	// default virtual switch is which management network residents on
+	public HostVirtualSwitch getHostDefaultVirtualSwitch() throws Exception {
+		String managementPortGroup = getPortGroupNameByNicType(HostVirtualNicType.management);
+		if(managementPortGroup != null)
+			return getPortGroupVirtualSwitch(managementPortGroup);
+		
+		return null;
+	}
+	
+	public HostVirtualSwitch getPortGroupVirtualSwitch(String portGroupName) throws Exception {
+		String vSwitchName = getPortGroupVirtualSwitchName(portGroupName);
+		if(vSwitchName != null)
+			return getVirtualSwitchByName(vSwitchName);
+		
+		return null;
+	}
+	
+	public HostVirtualSwitch getVirtualSwitchByName(String vSwitchName) throws Exception {
+		
+		HostVirtualSwitch[] vSwitchs = getHostVirtualSwitch();
+		if(vSwitchs != null) {
+			for(HostVirtualSwitch vSwitch: vSwitchs) {
+				if(vSwitch.getName().equals(vSwitchName))
+					return vSwitch;
+			}
+		}
+		
+		return null;
+	}
+	
+	public String getPortGroupVirtualSwitchName(String portGroupName) throws Exception {
+		HostNetworkInfo hostNetInfo = getHostNetworkInfo();
+		HostPortGroup[] portGroups = hostNetInfo.getPortgroup();
+		if(portGroups != null) {
+			for(HostPortGroup portGroup : portGroups) {
+				HostPortGroupSpec spec = portGroup.getSpec();
+				if(spec.getName().equals(portGroupName))
+					return spec.getVswitchName();
+			}
+		}
+		
+		return null;
+	}
+	
+	public HostPortGroupSpec getPortGroupSpec(String portGroupName) throws Exception {
+		HostNetworkInfo hostNetInfo = getHostNetworkInfo();
+		HostPortGroup[] portGroups = hostNetInfo.getPortgroup();
+		if(portGroups != null) {
+			for(HostPortGroup portGroup : portGroups) {
+				HostPortGroupSpec spec = portGroup.getSpec();
+				if(spec.getName().equals(portGroupName))
+					return spec;
+			}
+		}
+		
+		return null;
+	}
+	
+	public String getPortGroupNameByNicType(HostVirtualNicType nicType) throws Exception {
+		assert(nicType != null);
+		
+		VirtualNicManagerNetConfig[] netConfigs = (VirtualNicManagerNetConfig[])_context.getServiceUtil().getDynamicProperty(_mor, 
+			"config.virtualNicManagerInfo.netConfig");
+		
+		if(netConfigs != null) {
+			for(VirtualNicManagerNetConfig netConfig : netConfigs) {
+				if(netConfig.getNicType().equals(nicType.toString())) {
+					HostVirtualNic[] nics = netConfig.getCandidateVnic();
+					if(nics != null) {
+						for(HostVirtualNic nic : nics) {
+							return nic.getPortgroup();
+						}
+					}
+				}
+			}
+		}
+		
+		if(nicType == HostVirtualNicType.management) {
+			// ESX management network is configured in service console
+			HostNetworkInfo netInfo = getHostNetworkInfo();
+			assert(netInfo != null);
+			HostVirtualNic[] nics = netInfo.getConsoleVnic();
+			if(nics != null) {
+				for(HostVirtualNic nic : nics) {
+					return nic.getPortgroup();
+				}
+			}
+		}
+		
+		return null;
+	}
+	
+	public boolean hasPortGroup(HostVirtualSwitch vSwitch, String portGroupName) throws Exception {
+		ManagedObjectReference morNetwork = getNetworkMor(portGroupName);
+		if(morNetwork != null)
+			return true;
+		return false;
+	}
+	
+	public void createPortGroup(HostVirtualSwitch vSwitch, String portGroupName, Integer vlanId, HostNetworkTrafficShapingPolicy shapingPolicy) throws Exception {
+		assert(portGroupName != null);
+		HostNetworkSystemMO hostNetMo = getHostNetworkSystemMO();
+		assert(hostNetMo != null);
+		
+		HostPortGroupSpec spec = new HostPortGroupSpec();
+		
+		spec.setName(portGroupName);
+		if(vlanId != null)
+			spec.setVlanId(vlanId.intValue());
+		HostNetworkPolicy policy = new HostNetworkPolicy();
+		policy.setShapingPolicy(shapingPolicy);
+		spec.setPolicy(policy);
+		spec.setVswitchName(vSwitch.getName());
+		hostNetMo.addPortGroup(spec);
+	}
+	
+	public void updatePortGroup(HostVirtualSwitch vSwitch, String portGroupName, Integer vlanId, HostNetworkTrafficShapingPolicy shapingPolicy) throws Exception {
+		assert(portGroupName != null);
+		HostNetworkSystemMO hostNetMo = getHostNetworkSystemMO();
+		assert(hostNetMo != null);
+		
+		HostPortGroupSpec spec = new HostPortGroupSpec();
+		
+		spec.setName(portGroupName);
+		if(vlanId != null)
+			spec.setVlanId(vlanId.intValue());
+		HostNetworkPolicy policy = new HostNetworkPolicy();
+		policy.setShapingPolicy(shapingPolicy);
+		spec.setPolicy(policy);
+		spec.setVswitchName(vSwitch.getName());
+		hostNetMo.updatePortGroup(portGroupName, spec);
+	}
+	
+	public void deletePortGroup(String portGroupName) throws Exception {
+		assert(portGroupName != null);
+		HostNetworkSystemMO hostNetMo = getHostNetworkSystemMO();
+		assert(hostNetMo != null);
+		hostNetMo.removePortGroup(portGroupName); 
+	}
+	
+	public ManagedObjectReference getNetworkMor(String portGroupName) throws Exception {
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("Network");
+		pSpec.setPathSet(new String[] {"summary.name"});
+		
+	    TraversalSpec host2NetworkTraversal = new TraversalSpec();
+	    host2NetworkTraversal.setType("HostSystem");
+	    host2NetworkTraversal.setPath("network");
+	    host2NetworkTraversal.setName("host2NetworkTraversal");
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(_mor);
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { host2NetworkTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    ObjectContent[] ocs = _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec });
+	    
+	    if(ocs != null) {
+	    	for(ObjectContent oc : ocs) {
+	    		DynamicProperty[] props = oc.getPropSet();
+	    		if(props != null) {
+	    			for(DynamicProperty prop : props) {
+	    				if(prop.getVal().equals(portGroupName))
+	    					return oc.getObj();
+	    			}
+	    		}
+	    	}
+	    }
+	    return null;
+	}
+	
+	public ManagedObjectReference[] getVmMorsOnNetwork(String portGroupName) throws Exception {
+		ManagedObjectReference morNetwork = getNetworkMor(portGroupName);
+		if(morNetwork != null)
+			return (ManagedObjectReference[])_context.getServiceUtil().getDynamicProperty(morNetwork, "vm");
+		return null;
+	}
+	
+	public String getHostName() throws Exception {
+		return (String)_context.getServiceUtil().getDynamicProperty(_mor, "name");
+	}
+
+    @Override
+    public synchronized VirtualMachineMO findVmOnHyperHost(String name) throws Exception {
+    	if(s_logger.isDebugEnabled())
+    		s_logger.debug("find VM " + name + " on host");
+    	
+        VirtualMachineMO vmMo = _vmCache.get(name);
+        if(vmMo != null) {
+        	if(s_logger.isDebugEnabled())
+        		s_logger.debug("VM " + name + " found in host cache");
+            return vmMo;
+        }
+        
+        loadVmCache();
+        return _vmCache.get(name);
+    }
+    
+    private void loadVmCache() throws Exception {
+    	if(s_logger.isDebugEnabled())
+    		s_logger.debug("load VM cache on host");
+    	
+        _vmCache.clear();
+        
+        ObjectContent[] ocs = getVmPropertiesOnHyperHost(new String[] { "name" });
+        if(ocs != null && ocs.length > 0) {
+            for(ObjectContent oc : ocs) {
+                String vmName = oc.getPropSet()[0].getVal().toString();
+                
+                if(s_logger.isDebugEnabled())
+                	s_logger.debug("put " + vmName + " into host cache");
+                
+                _vmCache.put(vmName, new VirtualMachineMO(_context, oc.getObj()));
+            }
+        }
+    }
+	
+	@Override
+	public VirtualMachineMO findVmOnPeerHyperHost(String name) throws Exception {
+		ManagedObjectReference morParent = getParentMor();
+		
+		if(morParent.getType().equals("ClusterComputeResource")) {
+			ClusterMO clusterMo = new ClusterMO(_context, morParent);
+			return clusterMo.findVmOnHyperHost(name);
+		} else {
+			// we don't support standalone host, all hosts have to be managed by 
+			// a cluster within vCenter
+			assert(false);
+			return null;
+		}
+	}
+
+	@Override
+	public boolean createVm(VirtualMachineConfigSpec vmSpec) throws Exception {
+		assert(vmSpec != null);
+		DatacenterMO dcMo = new DatacenterMO(_context, getHyperHostDatacenter());
+        ManagedObjectReference morPool = getHyperHostOwnerResourcePool();
+		
+	    ManagedObjectReference morTask = _context.getService().createVM_Task(
+	    	dcMo.getVmFolder(), vmSpec, morPool, _mor);
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware createVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		
+		return false;
+	}
+	
+	public HashMap<String, Integer> getVmVncPortsOnHost() throws Exception {
+    	ObjectContent[] ocs = getVmPropertiesOnHyperHost(
+        		new String[] { "name", "config.extraConfig[\"RemoteDisplay.vnc.port\"]" }
+        	);
+		
+        HashMap<String, Integer> portInfo = new HashMap<String, Integer>();
+    	if(ocs != null && ocs.length > 0) {
+    		for(ObjectContent oc : ocs) {
+		        DynamicProperty[] objProps = oc.getPropSet();
+		        if(objProps != null) {
+		        	String name = null;
+		        	String value = null;
+		        	for(DynamicProperty objProp : objProps) {
+		        		if(objProp.getName().equals("name")) {
+		        			name = (String)objProp.getVal();
+		        		} else {
+		        			OptionValue optValue = (OptionValue)objProp.getVal();
+		        			value = (String)optValue.getValue();
+		        		} 
+		        	}
+		        	
+		        	if(name != null && value != null) {
+		        		portInfo.put(name, Integer.parseInt(value));
+		        	}
+		        }
+    		}
+    	}
+    	
+    	return portInfo;
+	}
+	
+	public ObjectContent[] getVmPropertiesOnHyperHost(String[] propertyPaths) throws Exception {
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - retrieveProperties() for VM properties. target MOR: " + _mor.get_value() + ", properties: " + new Gson().toJson(propertyPaths));
+		
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("VirtualMachine");
+		pSpec.setPathSet(propertyPaths);
+		
+	    TraversalSpec host2VmTraversal = new TraversalSpec();
+	    host2VmTraversal.setType("HostSystem");
+	    host2VmTraversal.setPath("vm");
+	    host2VmTraversal.setName("host2VmTraversal");
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(_mor);
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { host2VmTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    ObjectContent[] properties = _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec });
+
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - retrieveProperties() done");
+	    return properties;
+	}
+
+	@Override
+	public ObjectContent[] getDatastorePropertiesOnHyperHost(String[] propertyPaths) throws Exception {
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - retrieveProperties() on Datastore properties. target MOR: " + _mor.get_value() + ", properties: " + new Gson().toJson(propertyPaths));
+
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("Datastore");
+		pSpec.setPathSet(propertyPaths);
+		
+	    TraversalSpec host2DatastoreTraversal = new TraversalSpec();
+	    host2DatastoreTraversal.setType("HostSystem");
+	    host2DatastoreTraversal.setPath("datastore");
+	    host2DatastoreTraversal.setName("host2DatastoreTraversal");
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(_mor);
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { host2DatastoreTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    ObjectContent[] properties = _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec });
+	    
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - retrieveProperties() done");
+	    return properties;
+	}
+	
+	public List<Pair<ManagedObjectReference, String>> getDatastoreMountsOnHost() throws Exception {
+		List<Pair<ManagedObjectReference, String>> mounts = new ArrayList<Pair<ManagedObjectReference, String>>();
+		
+		ObjectContent[] ocs = getDatastorePropertiesOnHyperHost(new String[] {
+			String.format("host[\"%s\"].mountInfo.path", _mor.get_value()) });
+		if(ocs != null) {
+			for(ObjectContent oc : ocs) {
+				Pair<ManagedObjectReference, String> mount = new Pair<ManagedObjectReference, String>(
+					oc.getObj(), oc.getPropSet(0).getVal().toString());
+				mounts.add(mount);
+			}
+		}
+		return mounts;
+	}
+	
+	public List<Pair<ManagedObjectReference, String>> getLocalDatastoreOnHost() throws Exception {
+		List<Pair<ManagedObjectReference, String>> dsList = new ArrayList<Pair<ManagedObjectReference, String>>();
+		
+		ObjectContent[] ocs = getDatastorePropertiesOnHyperHost(new String[] { "name", "summary" });
+		if(ocs != null) {
+			for(ObjectContent oc : ocs) {
+				DatastoreSummary dsSummary = (DatastoreSummary)VmwareHelper.getPropValue(oc, "summary");
+				if(dsSummary.getMultipleHostAccess() == false) {
+					ManagedObjectReference morDs = oc.getObj();
+					String name = (String)VmwareHelper.getPropValue(oc, "name");
+					
+					dsList.add(new Pair<ManagedObjectReference, String>(morDs, name));
+				}
+			}
+		}
+		return dsList;
+	}
+	
+	public void importVmFromOVF(String ovfFilePath, String vmName, String datastoreName, String diskOption) throws Exception {
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - importVmFromOVF(). target MOR: " + _mor.get_value() + ", ovfFilePath: " + ovfFilePath + ", vmName: " + vmName 
+				+ ",datastoreName: " + datastoreName + ", diskOption: " + diskOption);
+	
+		DatastoreMO dsMo = getHostDatastoreMO(datastoreName);
+		if(dsMo == null)
+			throw new Exception("Invalid datastore name: " + datastoreName);
+		
+		importVmFromOVF(ovfFilePath, vmName, dsMo, diskOption);
+		
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - importVmFromOVF() done");
+	}
+	
+	@Override
+	public void importVmFromOVF(String ovfFilePath, String vmName, DatastoreMO dsMo, String diskOption) throws Exception {
+
+		ManagedObjectReference morRp = getHyperHostOwnerResourcePool();
+		assert(morRp != null);
+		
+		HypervisorHostHelper.importVmFromOVF(this, ovfFilePath, vmName, dsMo, diskOption, morRp, _mor);
+	}
+	
+	@Override
+	public boolean createBlankVm(String vmName, int cpuCount, int cpuSpeedMHz, int cpuReservedMHz, boolean limitCpuUse, int memoryMB, 
+		String guestOsIdentifier, ManagedObjectReference morDs, boolean snapshotDirToParent) throws Exception {
+
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - createBlankVm(). target MOR: " + _mor.get_value() + ", vmName: " + vmName + ", cpuCount: " + cpuCount
+				+ ", cpuSpeedMhz: " + cpuSpeedMHz + ", cpuReservedMHz: " + cpuReservedMHz + ", limitCpu: " + limitCpuUse + ", memoryMB: " + memoryMB 
+				+ ", guestOS: " + guestOsIdentifier + ", datastore: " + morDs.get_value() + ", snapshotDirToParent: " + snapshotDirToParent);
+		
+		boolean result = HypervisorHostHelper.createBlankVm(this, vmName, cpuCount, cpuSpeedMHz, cpuReservedMHz, limitCpuUse,
+			memoryMB, guestOsIdentifier, morDs, snapshotDirToParent);
+
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - createBlankVm() done");
+		return result;
+	}
+
+	@Override
+	public ManagedObjectReference mountDatastore(boolean vmfsDatastore, String poolHostAddress, 
+		int poolHostPort, String poolPath, String poolUuid) throws Exception {
+		
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - mountDatastore(). target MOR: " + _mor.get_value() + ", vmfs: " + vmfsDatastore + ", poolHost: " + poolHostAddress
+				+ ", poolHostPort: " + poolHostPort + ", poolPath: " + poolPath + ", poolUuid: " + poolUuid);
+		
+    	HostDatastoreSystemMO hostDatastoreSystemMo = getHostDatastoreSystemMO();
+        ManagedObjectReference morDatastore = hostDatastoreSystemMo.findDatastore(poolUuid);
+        if(morDatastore == null) {
+        	if(!vmfsDatastore) {
+	        	morDatastore = hostDatastoreSystemMo.createNfsDatastore(
+	        		poolHostAddress,
+	        		poolHostPort, 
+	        		poolPath, 
+	        		poolUuid);
+	        	if(morDatastore == null) {
+	        		String msg = "Unable to create NFS datastore. host: " + poolHostAddress + ", port: " 
+	    			+ poolHostPort + ", path: " + poolPath + ", uuid: " + poolUuid;
+		    		s_logger.error(msg);
+		    		
+					if(s_logger.isTraceEnabled())
+						s_logger.trace("vCenter API trace - mountDatastore() done(failed)");
+		    		throw new Exception(msg);
+	        	}
+        	} else {
+        		morDatastore = _context.getDatastoreMorByPath(poolPath);
+	        	if(morDatastore == null) {
+	        		String msg = "Unable to create VMFS datastore. host: " + poolHostAddress + ", port: " 
+	    			+ poolHostPort + ", path: " + poolPath + ", uuid: " + poolUuid;
+		    		s_logger.error(msg);
+		    		
+					if(s_logger.isTraceEnabled())
+						s_logger.trace("vCenter API trace - mountDatastore() done(failed)");
+		    		throw new Exception(msg);
+	        	}
+	        	
+        		DatastoreMO dsMo = new DatastoreMO(_context, morDatastore);
+        		dsMo.setCustomFieldValue(CustomFieldConstants.CLOUD_UUID, poolUuid);
+        	}
+        }
+        
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - mountDatastore() done(successfully)");
+        
+    	return morDatastore;
+	}
+	
+	@Override
+	public void unmountDatastore(String poolUuid) throws Exception {
+		
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - unmountDatastore(). target MOR: " + _mor.get_value() + ", poolUuid: " + poolUuid);
+		
+    	HostDatastoreSystemMO hostDatastoreSystemMo = getHostDatastoreSystemMO();
+    	if(!hostDatastoreSystemMo.deleteDatastore(poolUuid)) {
+    		String msg = "Unable to unmount datastore. uuid: " + poolUuid;
+    		s_logger.error(msg);
+
+    		if(s_logger.isTraceEnabled())
+    			s_logger.trace("vCenter API trace - unmountDatastore() done(failed)");
+    		throw new Exception(msg);
+    	}
+    	
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - unmountDatastore() done");
+	}
+	
+	@Override
+	public ManagedObjectReference findDatastore(String poolUuid) throws Exception {
+    	HostDatastoreSystemMO hostDsMo = getHostDatastoreSystemMO();
+		return hostDsMo.findDatastore(poolUuid);
+	}
+	
+	@Override
+	public ManagedObjectReference findDatastoreByExportPath(String exportPath) throws Exception {
+		HostDatastoreSystemMO datastoreSystemMo = getHostDatastoreSystemMO();
+		return datastoreSystemMo.findDatastoreByExportPath(exportPath);
+	}
+	
+	@Override
+	public ManagedObjectReference findMigrationTarget(VirtualMachineMO vmMo) throws Exception {
+		return _mor;
+	}
+	
+	@Override
+	public VmwareHypervisorHostResourceSummary getHyperHostResourceSummary() throws Exception {
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - getHyperHostResourceSummary(). target MOR: " + _mor.get_value());
+		
+		VmwareHypervisorHostResourceSummary summary = new VmwareHypervisorHostResourceSummary();
+		
+		HostConnectInfo hostInfo = _context.getService().queryHostConnectionInfo(_mor);
+		HostHardwareSummary hardwareSummary = hostInfo.getHost().getHardware();
+		
+		// TODO: not sure how hyper-thread is counted in VMware resource pool
+		summary.setCpuCount(hardwareSummary.getNumCpuCores()*hardwareSummary.getNumCpuPkgs());
+		summary.setMemoryBytes(hardwareSummary.getMemorySize());
+		summary.setCpuSpeed(hardwareSummary.getCpuMhz());
+
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - getHyperHostResourceSummary() done");
+		return summary;
+	}
+	
+	@Override
+	public VmwareHypervisorHostNetworkSummary getHyperHostNetworkSummary(String managementPortGroup) throws Exception {
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - getHyperHostNetworkSummary(). target MOR: " + _mor.get_value() + ", mgmtPortgroup: " + managementPortGroup);
+		
+		VmwareHypervisorHostNetworkSummary summary = new VmwareHypervisorHostNetworkSummary();
+		
+		if(this.getHostType() == VmwareHostType.ESXi) {
+			VirtualNicManagerNetConfig[] netConfigs = (VirtualNicManagerNetConfig[])_context.getServiceUtil().getDynamicProperty(_mor, 
+				"config.virtualNicManagerInfo.netConfig");
+			assert(netConfigs != null);
+	
+			for(int i = 0; i < netConfigs.length; i++) {
+				if(netConfigs[i].getNicType().equals("management")) {
+					for(HostVirtualNic nic : netConfigs[i].getCandidateVnic()) {
+						if(nic.getPortgroup().equals(managementPortGroup)) {
+							summary.setHostIp(nic.getSpec().getIp().getIpAddress());
+							summary.setHostNetmask(nic.getSpec().getIp().getSubnetMask());
+							summary.setHostMacAddress(nic.getSpec().getMac());
+							
+						    if(s_logger.isTraceEnabled())
+								s_logger.trace("vCenter API trace - getHyperHostNetworkSummary() done(successfully)");
+							return summary;
+						}
+					}
+				}
+			}
+		} else {
+			// try with ESX path
+			HostVirtualNic[] hostVNics = (HostVirtualNic[])_context.getServiceUtil().getDynamicProperty(_mor, 
+				"config.network.consoleVnic");
+			
+			if(hostVNics != null) {
+				for(HostVirtualNic vnic : hostVNics) {
+					if(vnic.getPortgroup().equals(managementPortGroup)) {
+						summary.setHostIp(vnic.getSpec().getIp().getIpAddress());
+						summary.setHostNetmask(vnic.getSpec().getIp().getSubnetMask());
+						summary.setHostMacAddress(vnic.getSpec().getMac());
+						
+					    if(s_logger.isTraceEnabled())
+							s_logger.trace("vCenter API trace - getHyperHostNetworkSummary() done(successfully)");
+						return summary;
+					}
+				}
+			}
+		}
+
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - getHyperHostNetworkSummary() done(failed)");
+		throw new Exception("Uanble to find management port group " + managementPortGroup);
+	}
+	
+	@Override
+	public ComputeResourceSummary getHyperHostHardwareSummary() throws Exception {
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - getHyperHostHardwareSummary(). target MOR: " + _mor.get_value());
+
+		//
+		// This is to adopt the model when using Cluster as a big host while ComputeResourceSummary is used
+		// directly from VMware resource pool
+		//
+		// When we break cluster hosts into individual hosts used in our resource allocator, 
+		// we will have to populate ComputeResourceSummary by ourselves here
+		//
+		HostHardwareSummary hardwareSummary = getHostHardwareSummary();
+		
+		ComputeResourceSummary resourceSummary = new ComputeResourceSummary();
+		
+		// TODO: not sure how hyper-threading is counted in VMware
+		short totalCores = (short)(hardwareSummary.getNumCpuCores()*hardwareSummary.getNumCpuPkgs());
+		resourceSummary.setNumCpuCores(totalCores);
+		
+		// Note: memory here is in Byte unit
+		resourceSummary.setTotalMemory(hardwareSummary.getMemorySize());
+		
+		// Total CPU is based on socket x core x Mhz
+		int totalCpu = hardwareSummary.getCpuMhz() * totalCores;
+		resourceSummary.setTotalCpu(totalCpu);
+
+		HostListSummaryQuickStats stats = getHostQuickStats();
+		if(stats.getOverallCpuUsage() == null || stats.getOverallMemoryUsage() == null)
+			throw new Exception("Unable to get valid overal CPU/Memory usage data, host may be disconnected");
+		
+		resourceSummary.setEffectiveCpu(totalCpu - stats.getOverallCpuUsage());
+		
+		// Note effective memory is in MB unit
+		resourceSummary.setEffectiveMemory(hardwareSummary.getMemorySize()/(1024*1024) - stats.getOverallMemoryUsage());
+		
+	    if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - getHyperHostHardwareSummary() done");
+		return resourceSummary;
+	}
+	
+	@Override
+	public boolean isHyperHostConnected() throws Exception {
+    	HostRuntimeInfo runtimeInfo = (HostRuntimeInfo)_context.getServiceUtil().getDynamicProperty(_mor, "runtime");
+    	return runtimeInfo.getConnectionState() == HostSystemConnectionState.connected;
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostNetworkSystemMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostNetworkSystemMO.java
new file mode 100755
index 00000000000..dda09e3431e
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostNetworkSystemMO.java
@@ -0,0 +1,53 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.vmware.vim25.HostPortGroupSpec;
+import com.vmware.vim25.HostVirtualSwitchSpec;
+import com.vmware.vim25.ManagedObjectReference;
+
+public class HostNetworkSystemMO extends BaseMO {
+    private static final Logger s_logger = Logger.getLogger(HostNetworkSystemMO.class);
+    
+	public HostNetworkSystemMO(VmwareContext context, ManagedObjectReference morNetworkSystem) {
+		super(context, morNetworkSystem);
+	}
+	
+	public HostNetworkSystemMO(VmwareContext context, String morType, String morValue) {
+		super(context, morType, morValue);
+	}
+	
+	public void addPortGroup(HostPortGroupSpec spec) throws Exception {
+		_context.getService().addPortGroup(_mor, spec);
+	}
+	
+	public void updatePortGroup(String portGroupName, HostPortGroupSpec spec) throws Exception {
+		_context.getService().updatePortGroup(_mor, portGroupName, spec);
+	}
+	
+	public void removePortGroup(String portGroupName) throws Exception {
+		_context.getService().removePortGroup(_mor, portGroupName);
+	}
+	
+	public void addVirtualSwitch(String vSwitchName, HostVirtualSwitchSpec spec) throws Exception {
+		_context.getService().addVirtualSwitch(_mor, vSwitchName, spec);
+	}
+	
+	public void updateVirtualSwitch(String vSwitchName, HostVirtualSwitchSpec spec) throws Exception {
+		_context.getService().updateVirtualSwitch(_mor, vSwitchName, spec);
+	}
+	
+	public void removeVirtualSwitch(String vSwitchName) throws Exception {
+		_context.getService().removeVirtualSwitch(_mor, vSwitchName);
+	}
+	
+	public void refresh() throws Exception {
+		_context.getService().refreshNetworkSystem(_mor);
+	}
+}
+
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostVirtualNicType.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostVirtualNicType.java
new file mode 100644
index 00000000000..0fcfe54763f
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HostVirtualNicType.java
@@ -0,0 +1,8 @@
+package com.cloud.hypervisor.vmware.mo;
+
+public enum HostVirtualNicType {
+	management,
+	vmotion,
+	faultToleranceLogging
+}
+
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/HttpNfcLeaseMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HttpNfcLeaseMO.java
new file mode 100755
index 00000000000..b6a2afbd14f
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HttpNfcLeaseMO.java
@@ -0,0 +1,145 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.vmware.vim25.HttpNfcLeaseInfo;
+import com.vmware.vim25.HttpNfcLeaseManifestEntry;
+import com.vmware.vim25.HttpNfcLeaseState;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.OvfCreateImportSpecResult;
+import com.vmware.vim25.OvfFileItem;
+
+public class HttpNfcLeaseMO extends BaseMO {
+    private static final Logger s_logger = Logger.getLogger(HttpNfcLeaseMO.class);
+	
+	public HttpNfcLeaseMO(VmwareContext context, ManagedObjectReference morHttpNfcLease) {
+		super(context, morHttpNfcLease);
+	}
+	
+	public HttpNfcLeaseMO(VmwareContext context, String morType, String morValue) {
+		super(context, morType, morValue);
+	}
+
+	public HttpNfcLeaseState getState() throws Exception {
+		return (HttpNfcLeaseState)_context.getServiceUtil().getDynamicProperty(_mor, "state");
+	}
+	
+	public HttpNfcLeaseState waitState(HttpNfcLeaseState[] states) throws Exception {
+		assert(states != null);
+		assert(states.length > 0);
+		
+		HttpNfcLeaseState state;
+		while(true) {
+			state = getState();
+			if(state == HttpNfcLeaseState.ready || state == HttpNfcLeaseState.error)
+				return state;
+		}
+	}
+	
+	public HttpNfcLeaseInfo getLeaseInfo() throws Exception {
+		return (HttpNfcLeaseInfo)_context.getServiceUtil().getDynamicProperty(_mor, "info");
+	}
+	
+	public HttpNfcLeaseManifestEntry[] getLeaseManifest() throws Exception {
+		return _context.getService().httpNfcLeaseGetManifest(_mor);
+	}
+	
+	public void completeLease() throws Exception {
+		_context.getService().httpNfcLeaseComplete(_mor);
+	}
+	
+	public void abortLease() throws Exception {
+		_context.getService().httpNfcLeaseAbort(_mor, null);
+	}
+	
+	public void updateLeaseProgress(int percent) throws Exception {
+		// make sure percentage is in right range
+		if(percent < 0)
+			percent = 0;
+		else if(percent > 100)
+			percent = 100;
+		
+		_context.getService().httpNfcLeaseProgress(_mor, percent);
+	}
+	
+	public ProgressReporter createProgressReporter() {
+		return new ProgressReporter();
+	}
+	
+	public static long calcTotalBytes(OvfCreateImportSpecResult ovfImportResult) {  
+		OvfFileItem[] fileItemArr = ovfImportResult.getFileItem();  
+		long totalBytes = 0;  
+		if (fileItemArr != null) {  
+			for (OvfFileItem fi : fileItemArr) {  
+				totalBytes += fi.getSize();  
+			}  
+		}  
+		return totalBytes;  
+	}
+	
+	public static String readOvfContent(String ovfFilePath) throws IOException {  
+		StringBuffer strContent = new StringBuffer();  
+		BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(ovfFilePath)));  
+		String lineStr;  
+		while ((lineStr = in.readLine()) != null) {  
+			strContent.append(lineStr);  
+		}  
+
+		in.close();  
+		return strContent.toString();  
+	}
+	
+	public class ProgressReporter extends Thread {
+		volatile int _percent;
+		volatile boolean _done;
+		
+		public ProgressReporter() {
+			_percent = 0;
+			_done = false;
+			
+			setDaemon(true);
+			start();
+		}
+		
+		public void reportProgress(int percent) {
+			_percent = percent;
+		}
+		
+		public void close() {
+			if(s_logger.isInfoEnabled())
+				s_logger.info("close ProgressReporter, interrupt reporter runner to let it quit");
+			
+			_done = true;
+			interrupt();
+		}
+		
+		@Override
+		public void run() {
+			while(!_done) {
+				try {
+					Thread.sleep(1000);			// update progess every 1 second
+					updateLeaseProgress(_percent);
+				} catch(InterruptedException e) {
+					if(s_logger.isInfoEnabled())
+						s_logger.info("ProgressReporter is interrupted, quiting");
+					break;
+				} catch(Exception e) {
+					s_logger.warn("Unexpected exception ", e);
+				}
+			}
+			
+			if(s_logger.isInfoEnabled())
+				s_logger.info("ProgressReporter stopped");
+		}
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/HypervisorHostHelper.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HypervisorHostHelper.java
new file mode 100755
index 00000000000..2edbcf5f87f
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/HypervisorHostHelper.java
@@ -0,0 +1,538 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import java.io.File;
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.cloud.hypervisor.vmware.util.VmwareHelper;
+import com.cloud.utils.ActionDelegate;
+import com.cloud.utils.Pair;
+import com.cloud.utils.db.GlobalLock;
+import com.cloud.utils.net.NetUtils;
+import com.vmware.vim25.DynamicProperty;
+import com.vmware.vim25.HostNetworkTrafficShapingPolicy;
+import com.vmware.vim25.HostVirtualSwitch;
+import com.vmware.vim25.HttpNfcLeaseDeviceUrl;
+import com.vmware.vim25.HttpNfcLeaseInfo;
+import com.vmware.vim25.HttpNfcLeaseState;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.ObjectContent;
+import com.vmware.vim25.OvfCreateImportSpecParams;
+import com.vmware.vim25.OvfCreateImportSpecResult;
+import com.vmware.vim25.OvfFileItem;
+import com.vmware.vim25.VirtualDeviceConfigSpec;
+import com.vmware.vim25.VirtualDeviceConfigSpecOperation;
+import com.vmware.vim25.VirtualLsiLogicController;
+import com.vmware.vim25.VirtualMachineConfigSpec;
+import com.vmware.vim25.VirtualMachineFileInfo;
+import com.vmware.vim25.VirtualMachineVideoCard;
+import com.vmware.vim25.VirtualSCSISharing;
+
+public class HypervisorHostHelper {
+    private static final Logger s_logger = Logger.getLogger(HypervisorHostHelper.class);
+    private static final int DEFAULT_LOCK_TIMEOUT_SECONDS = 600;
+    
+    // make vmware-base loosely coupled with cloud-specific stuff, duplicate VLAN.UNTAGGED constant here
+    private static final String UNTAGGED_VLAN_NAME = "untagged";
+	
+	public static VirtualMachineMO findVmFromObjectContent(VmwareContext context, 
+		ObjectContent[] ocs, String name) {
+		
+		if(ocs != null && ocs.length > 0) {
+			for(ObjectContent oc : ocs) {
+				DynamicProperty prop = oc.getPropSet(0);
+				assert(prop != null);
+				if(prop.getVal().toString().equals(name))
+					return new VirtualMachineMO(context, oc.getObj());
+			}
+		}
+		return null;
+	}
+	
+	public static DatastoreMO getHyperHostDatastoreMO(VmwareHypervisorHost hyperHost, String datastoreName) throws Exception {
+		ObjectContent[] ocs = hyperHost.getDatastorePropertiesOnHyperHost(new String[] { "name"} );
+		if(ocs != null && ocs.length > 0) {
+    		for(ObjectContent oc : ocs) {
+		        DynamicProperty[] objProps = oc.getPropSet();
+		        if(objProps != null) {
+		        	for(DynamicProperty objProp : objProps) {
+		        		if(objProp.getVal().toString().equals(datastoreName))
+		        			return new DatastoreMO(hyperHost.getContext(), oc.getObj());
+		        	}
+		        }
+    		}
+		}
+		return null;
+	}
+	
+	public static String getPublicNetworkNamePrefix(String vlanId) {
+		if (UNTAGGED_VLAN_NAME.equalsIgnoreCase(vlanId)) {
+			return "cloud.public.untagged";
+		} else {
+			return "cloud.public." + vlanId;
+		}
+	}
+	
+	public static synchronized Pair<ManagedObjectReference, String> preparePublicNetwork(String vSwitchName,
+			HostMO hostMo, String vlanId, Integer networkRateMbps, Integer networkRateMulticastMbps, long timeOutMs, boolean syncPeerHosts) throws Exception {
+		
+		HostVirtualSwitch vSwitch = hostMo.getHostVirtualSwitchByName(vSwitchName);
+		if (vSwitch == null) {
+			String msg = "Unable to find vSwitch configured for public network";
+			s_logger.error(msg);
+			throw new Exception(msg);
+		}
+
+		boolean createGCTag = false;
+		String networkName;
+		Integer vid = null;
+		if(vlanId != null && !UNTAGGED_VLAN_NAME.equalsIgnoreCase(vlanId)) {
+			createGCTag = true;
+			vid = Integer.parseInt(vlanId);
+		}
+		
+		networkName = composeCloudNetworkName("cloud.public", vlanId, networkRateMbps, vSwitchName);
+		
+		HostNetworkTrafficShapingPolicy shapingPolicy = null;
+		if(networkRateMbps != null && networkRateMbps.intValue() > 0) {
+			shapingPolicy = new HostNetworkTrafficShapingPolicy();
+			shapingPolicy.setEnabled(true);
+			shapingPolicy.setAverageBandwidth((long)networkRateMbps.intValue()*1024L*1024L);
+		
+			// 
+			// TODO : people may have different opinion on how to set the following
+			//
+			
+			// give 50% premium to peek
+			shapingPolicy.setPeakBandwidth((long)(shapingPolicy.getAverageBandwidth()*1.5));
+
+			// allow 5 seconds of burst transfer
+			shapingPolicy.setBurstSize(5*shapingPolicy.getAverageBandwidth()/8);
+		}
+		
+		if (!hostMo.hasPortGroup(vSwitch, networkName)) {
+			hostMo.createPortGroup(vSwitch, networkName, vid, shapingPolicy);
+		} else {
+			hostMo.updatePortGroup(vSwitch, networkName, vid, shapingPolicy);
+		}
+
+		ManagedObjectReference morNetwork = waitForNetworkReady(hostMo, networkName, timeOutMs);
+		if (morNetwork == null) {
+			String msg = "Failed to create public network on vSwitch " + vSwitchName;
+			s_logger.error(msg);
+			throw new Exception(msg);
+		}
+		
+		if(createGCTag) {
+			NetworkMO networkMo = new NetworkMO(hostMo.getContext(), morNetwork);
+			networkMo.setCustomFieldValue(CustomFieldConstants.CLOUD_GC, "true");
+		}
+		
+		if(syncPeerHosts) {
+			ManagedObjectReference morParent = hostMo.getParentMor();
+			if(morParent != null && morParent.getType().equals("ClusterComputeResource")) {
+
+				// to be conservative, lock cluster
+				GlobalLock lock = GlobalLock.getInternLock("ClusterLock." + morParent.get_value());
+				try {
+					if(lock.lock(DEFAULT_LOCK_TIMEOUT_SECONDS)) {
+						try {
+							ManagedObjectReference[] hosts = (ManagedObjectReference[])hostMo.getContext().getServiceUtil().getDynamicProperty(morParent, "host");
+							if(hosts != null) {
+								for(ManagedObjectReference otherHost: hosts) {
+									if(!otherHost.get_value().equals(hostMo.getMor().get_value())) {
+										HostMO otherHostMo = new HostMO(hostMo.getContext(), otherHost);
+										try {
+											if(s_logger.isDebugEnabled())
+												s_logger.debug("prepare public network on other host, vlan: " + vlanId + ", host: " + otherHostMo.getHostName());
+											preparePublicNetwork(vSwitchName, otherHostMo, vlanId, networkRateMbps, networkRateMulticastMbps, timeOutMs, false);
+										} catch(Exception e) {
+											s_logger.warn("Unable to prepare public network on other host, vlan: " + vlanId + ", host: " + otherHostMo.getHostName());
+										}
+									}
+								}
+							}
+						} finally {
+							lock.unlock();
+						}
+					} else {
+						s_logger.warn("Unable to lock cluster to prepare public network, vlan: " + vlanId);
+					}
+				} finally {
+					lock.releaseRef();
+				}
+			}
+		}
+
+		s_logger.info("Network " + networkName + " is ready on vSwitch " + vSwitchName);
+		return new Pair<ManagedObjectReference, String>(morNetwork, networkName);
+	}
+	
+	public static Pair<ManagedObjectReference, String> preparePrivateNetwork(String vSwitchName, 
+		HostMO hostMo, Integer vlanId, long timeOutMs) throws Exception {
+		
+		HostVirtualSwitch vSwitch = hostMo.getHostVirtualSwitchByName(vSwitchName);
+		if (vSwitch == null) {
+			String msg = "Unable to find vSwitch configured for private network";
+			s_logger.error(msg);
+			throw new Exception(msg);
+		}
+		
+		String networkName;
+		networkName = composeCloudNetworkName("cloud.private", vlanId == null ? null : String.valueOf(vlanId), null, vSwitchName);
+				
+		if (!hostMo.hasPortGroup(vSwitch, networkName)) {
+			hostMo.createPortGroup(vSwitch, networkName, vlanId, null);
+		}
+
+		ManagedObjectReference morNetwork = waitForNetworkReady(hostMo, networkName, timeOutMs);
+		if (morNetwork == null) {
+			String msg = "Failed to create private network";
+			s_logger.error(msg);
+			throw new Exception(msg);
+		}
+
+		s_logger.info("Network " + networkName + " is ready on vSwitch " + vSwitchName);
+		return new Pair<ManagedObjectReference, String>(morNetwork, networkName);
+	}
+	
+	public static String composeCloudNetworkName(String prefix, String vlanId, Integer networkRateMbps, String vSwitchName) {
+		StringBuffer sb = new StringBuffer(prefix);
+		if(vlanId == null || UNTAGGED_VLAN_NAME.equalsIgnoreCase(vlanId))
+			sb.append(".untagged");
+		else
+			sb.append(".").append(vlanId);
+		
+		if(networkRateMbps != null && networkRateMbps.intValue() > 0)
+			sb.append(".").append(String.valueOf(networkRateMbps));
+		else
+			sb.append(".0");
+		sb.append(".").append(VersioningContants.PORTGROUP_NAMING_VERSION);
+		sb.append("-").append(vSwitchName);
+		
+		return sb.toString();
+	}
+	
+	public static Pair<ManagedObjectReference, String> prepareGuestNetwork(String vSwitchName,
+			HostMO hostMo, String vlanId, Integer networkRateMbps, Integer networkRateMulticastMbps, 
+			long timeOutMs, boolean syncPeerHosts) throws Exception {
+
+		HostVirtualSwitch vSwitch;
+		vSwitch = hostMo.getHostVirtualSwitchByName(vSwitchName);
+
+		if (vSwitch == null) {
+			String msg = "Unable to find the default virtual switch";
+			s_logger.error(msg);
+			throw new Exception(msg);
+		}
+
+		boolean createGCTag = false;
+		String networkName;
+		Integer vid = null;
+		
+		if(vlanId != null && !UNTAGGED_VLAN_NAME.equalsIgnoreCase(vlanId)) {
+			createGCTag = true;
+			vid = Integer.parseInt(vlanId);
+		}
+		
+		networkName = composeCloudNetworkName("cloud.guest", vlanId, networkRateMbps, vSwitchName);
+
+		HostNetworkTrafficShapingPolicy shapingPolicy = null;
+		if(networkRateMbps != null && networkRateMbps.intValue() > 0) {
+			shapingPolicy = new HostNetworkTrafficShapingPolicy();
+			shapingPolicy.setEnabled(true);
+			shapingPolicy.setAverageBandwidth((long)networkRateMbps.intValue()*1024L*1024L);
+		
+			// 
+			// TODO : people may have different opinion on how to set the following
+			//
+			
+			// give 50% premium to peek
+			shapingPolicy.setPeakBandwidth((long)(shapingPolicy.getAverageBandwidth()*1.5));
+
+			// allow 5 seconds of burst transfer
+			shapingPolicy.setBurstSize(5*shapingPolicy.getAverageBandwidth()/8);
+		}
+
+		if (!hostMo.hasPortGroup(vSwitch, networkName)) {
+			hostMo.createPortGroup(vSwitch, networkName, vid, shapingPolicy);
+		} else {
+			hostMo.updatePortGroup(vSwitch, networkName, vid, shapingPolicy);
+		}
+
+		ManagedObjectReference morNetwork = waitForNetworkReady(hostMo, networkName, timeOutMs);
+		if (morNetwork == null) {
+			String msg = "Failed to create guest network " + networkName;
+			s_logger.error(msg);
+			throw new Exception(msg);
+		}
+		
+		if(createGCTag) {
+			NetworkMO networkMo = new NetworkMO(hostMo.getContext(), morNetwork);
+			networkMo.setCustomFieldValue(CustomFieldConstants.CLOUD_GC, "true");
+		}
+		
+		if(syncPeerHosts) {
+			ManagedObjectReference morParent = hostMo.getParentMor();
+			if(morParent != null && morParent.getType().equals("ClusterComputeResource")) {
+				// to be conservative, lock cluster
+				GlobalLock lock = GlobalLock.getInternLock("ClusterLock." + morParent.get_value());
+				try {
+					if(lock.lock(DEFAULT_LOCK_TIMEOUT_SECONDS)) {
+						try {
+							ManagedObjectReference[] hosts = (ManagedObjectReference[])hostMo.getContext().getServiceUtil().getDynamicProperty(morParent, "host");
+							if(hosts != null) {
+								for(ManagedObjectReference otherHost: hosts) {
+									if(!otherHost.get_value().equals(hostMo.getMor().get_value())) {
+										HostMO otherHostMo = new HostMO(hostMo.getContext(), otherHost);
+										try {
+											if(s_logger.isDebugEnabled())
+												s_logger.debug("Prepare guest network on other host, vlan: " + vlanId + ", host: " + otherHostMo.getHostName());
+											prepareGuestNetwork(vSwitchName, otherHostMo, vlanId, networkRateMbps, networkRateMulticastMbps, timeOutMs, false);
+										} catch(Exception e) {
+											s_logger.warn("Unable to prepare guest network on other host, vlan: " + vlanId + ", host: " + otherHostMo.getHostName());
+										}
+									}
+								}
+							}
+						} finally {
+							lock.unlock();
+						}
+					} else {
+						s_logger.warn("Unable to lock cluster to prepare guest network, vlan: " + vlanId);
+					}
+				} finally {
+					lock.releaseRef();
+				}
+			}
+		}
+
+		s_logger.info("Network " + networkName + " is ready on vSwitch " + vSwitchName);
+		return new Pair<ManagedObjectReference, String>(morNetwork, networkName);
+	}
+	
+	public static ManagedObjectReference waitForNetworkReady(HostMO hostMo,
+			String networkName, long timeOutMs) throws Exception {
+
+		ManagedObjectReference morNetwork = null;
+
+		// if portGroup is just created, getNetwork may fail to retrieve it, we
+		// need to retry
+		long startTick = System.currentTimeMillis();
+		while (System.currentTimeMillis() - startTick <= timeOutMs) {
+			morNetwork = hostMo.getNetworkMor(networkName);
+			if (morNetwork != null) {
+				break;
+			}
+
+			s_logger.info("Waiting for network " + networkName + " to be ready");
+			Thread.sleep(1000);
+		}
+
+		return morNetwork;
+	}
+	
+	public static boolean createBlankVm(VmwareHypervisorHost host, String vmName, 
+		int cpuCount, int cpuSpeedMHz, int cpuReservedMHz, boolean limitCpuUse, int memoryMB, String guestOsIdentifier, 
+		ManagedObjectReference morDs, boolean snapshotDirToParent) throws Exception {
+		
+		if(s_logger.isInfoEnabled())
+			s_logger.info("Create blank VM. cpuCount: " + cpuCount + ", cpuSpeed(MHz): " + cpuSpeedMHz + ", mem(Mb): " + memoryMB);
+		
+		// VM config basics
+		VirtualMachineConfigSpec vmConfig = new VirtualMachineConfigSpec();
+		vmConfig.setName(vmName);
+		VmwareHelper.setBasicVmConfig(vmConfig, cpuCount, cpuSpeedMHz, cpuReservedMHz, memoryMB, guestOsIdentifier, limitCpuUse);
+
+		// Scsi controller
+		VirtualLsiLogicController scsiController = new VirtualLsiLogicController();
+		scsiController.setSharedBus(VirtualSCSISharing.noSharing);
+		scsiController.setBusNumber(0);
+		scsiController.setKey(1);
+		VirtualDeviceConfigSpec scsiControllerSpec = new VirtualDeviceConfigSpec();
+		scsiControllerSpec.setDevice(scsiController);
+		scsiControllerSpec.setOperation(VirtualDeviceConfigSpecOperation.add);
+
+		VirtualMachineFileInfo fileInfo = new VirtualMachineFileInfo();
+		DatastoreMO dsMo = new DatastoreMO(host.getContext(), morDs);
+		fileInfo.setVmPathName(String.format("[%s]", dsMo.getName()));
+		vmConfig.setFiles(fileInfo);
+		
+		VirtualMachineVideoCard videoCard = new VirtualMachineVideoCard();
+		videoCard.setControllerKey(100);
+		videoCard.setUseAutoDetect(true);
+		
+		VirtualDeviceConfigSpec videoDeviceSpec = new VirtualDeviceConfigSpec();
+		videoDeviceSpec.setDevice(videoCard);
+		videoDeviceSpec.setOperation(VirtualDeviceConfigSpecOperation.add);
+		
+		vmConfig.setDeviceChange(new VirtualDeviceConfigSpec[] { scsiControllerSpec, videoDeviceSpec });
+		if(host.createVm(vmConfig)) {
+			VirtualMachineMO vmMo = host.findVmOnHyperHost(vmName);
+			assert(vmMo != null);
+			
+			int ideControllerKey = -1;
+			while(ideControllerKey < 0) {
+				ideControllerKey = vmMo.tryGetIDEDeviceControllerKey();
+				if(ideControllerKey >= 0)
+					break;
+				
+				s_logger.info("Waiting for IDE controller be ready in VM: " + vmName);
+				Thread.sleep(1000);
+			}
+			
+			if(snapshotDirToParent) {
+				String snapshotDir = String.format("/vmfs/volumes/%s/", dsMo.getName());
+				
+				s_logger.info("Switch snapshot working directory to " + snapshotDir + " for " + vmName);
+				vmMo.setSnapshotDirectory(snapshotDir);
+				
+				// Don't have a good way to test if the VM is really ready for use through normal API after configuration file manipulation,
+				// delay 3 seconds
+				Thread.sleep(3000);
+			}
+			
+			s_logger.info("Blank VM: " + vmName + " is ready for use");
+			return true;
+		}
+		return false;
+	}
+	
+	public static String resolveHostNameInUrl(DatacenterMO dcMo, String url) {
+		
+		s_logger.info("Resolving host name in url through vCenter, url: " + url);
+		
+		URI uri;
+		try {
+			uri = new URI(url);
+		} catch (URISyntaxException e) {
+			s_logger.warn("URISyntaxException on url " + url);
+			return url;
+		}
+		
+		String host = uri.getHost();
+		if(NetUtils.isValidIp(host)) {
+			s_logger.info("host name in url is already in IP address, url: " + url);
+			return url;
+		}
+		
+		try {
+			ManagedObjectReference morHost = dcMo.findHost(host);
+			if(morHost != null) {
+				HostMO hostMo = new HostMO(dcMo.getContext(), morHost);
+				String managementPortGroupName;
+				if(hostMo.getHostType() == VmwareHostType.ESXi)
+					managementPortGroupName = (String)dcMo.getContext().getStockObject("manageportgroup");
+				else
+					managementPortGroupName = (String)dcMo.getContext().getStockObject("serviceconsole");
+				
+				VmwareHypervisorHostNetworkSummary summary = hostMo.getHyperHostNetworkSummary(managementPortGroupName);
+				if(summary == null) {
+					s_logger.warn("Unable to resolve host name in url through vSphere, url: " + url);
+					return url;
+				}
+				
+				String hostIp = summary.getHostIp();
+				
+				try {
+					URI resolvedUri = new URI(uri.getScheme(), uri.getUserInfo(), hostIp, uri.getPort(), uri.getPath(), uri.getQuery(), uri.getFragment());
+					
+					s_logger.info("url " + url + " is resolved to " + resolvedUri.toString() + " through vCenter");
+					return resolvedUri.toString();
+				} catch (URISyntaxException e) {
+					assert(false);
+					return url;
+				}
+			}
+		} catch(Exception e) {
+			s_logger.warn("Unexpected exception ", e);
+		}
+		
+		return url;
+	}
+	
+	public static void importVmFromOVF(VmwareHypervisorHost host, String ovfFilePath, String vmName, DatastoreMO dsMo, String diskOption, 
+		ManagedObjectReference morRp, ManagedObjectReference morHost) throws Exception {
+		
+		assert(morRp != null);
+		
+		OvfCreateImportSpecParams importSpecParams = new OvfCreateImportSpecParams();  
+		importSpecParams.setHostSystem(morHost);  
+		importSpecParams.setLocale("US");  
+		importSpecParams.setEntityName(vmName);  
+		importSpecParams.setDeploymentOption("");
+		importSpecParams.setDiskProvisioning(diskOption); // diskOption: thin, thick, etc
+		importSpecParams.setPropertyMapping(null);
+		
+		String ovfDescriptor = HttpNfcLeaseMO.readOvfContent(ovfFilePath);
+		VmwareContext context = host.getContext();
+		OvfCreateImportSpecResult ovfImportResult = context.getService().createImportSpec(
+			context.getServiceContent().getOvfManager(), ovfDescriptor, morRp, 
+			dsMo.getMor(), importSpecParams);
+		
+		if(ovfImportResult == null) {
+			String msg = "createImportSpec() failed. ovfFilePath: " + ovfFilePath + ", vmName: " 
+				+ vmName + ", diskOption: " + diskOption;
+			s_logger.error(msg);
+			throw new Exception(msg);
+		}
+		
+		DatacenterMO dcMo = new DatacenterMO(context, host.getHyperHostDatacenter());
+		ManagedObjectReference morLease = context.getService().importVApp(morRp, 
+			ovfImportResult.getImportSpec(), dcMo.getVmFolder(), morHost);
+		if(morLease == null) {
+			String msg = "importVApp() failed. ovfFilePath: " + ovfFilePath + ", vmName: " 
+				+ vmName + ", diskOption: " + diskOption;
+			s_logger.error(msg);
+			throw new Exception(msg);
+		}
+		final HttpNfcLeaseMO leaseMo = new HttpNfcLeaseMO(context, morLease);
+		HttpNfcLeaseState state = leaseMo.waitState(
+			new HttpNfcLeaseState[] { HttpNfcLeaseState.ready, HttpNfcLeaseState.error });
+		try {
+			if(state == HttpNfcLeaseState.ready) {
+				final long totalBytes = HttpNfcLeaseMO.calcTotalBytes(ovfImportResult);
+				File ovfFile = new File(ovfFilePath); 
+				
+				HttpNfcLeaseInfo httpNfcLeaseInfo = leaseMo.getLeaseInfo();
+		        HttpNfcLeaseDeviceUrl[] deviceUrls = httpNfcLeaseInfo.getDeviceUrl();  
+		        long bytesAlreadyWritten = 0;
+		        
+		        final HttpNfcLeaseMO.ProgressReporter progressReporter = leaseMo.createProgressReporter();
+		        try {
+			        for (HttpNfcLeaseDeviceUrl deviceUrl : deviceUrls) {
+			        	String deviceKey = deviceUrl.getImportKey();  
+			        	for (OvfFileItem ovfFileItem : ovfImportResult.getFileItem()) {
+			        		if (deviceKey.equals(ovfFileItem.getDeviceId())) {  
+			        			String absoluteFile = ovfFile.getParent() + File.separator + ovfFileItem.getPath();
+			        			String urlToPost = deviceUrl.getUrl();
+			        			urlToPost = resolveHostNameInUrl(dcMo, urlToPost);
+			        			
+		        			  	context.uploadVmdkFile(ovfFileItem.isCreate() ? "PUT" : "POST", urlToPost, absoluteFile, 
+		    			  			bytesAlreadyWritten, new ActionDelegate<Long> () {
+									public void action(Long param) {
+										progressReporter.reportProgress((int)(param * 100 / totalBytes));
+									}
+		    			  		});  
+		        			  	
+		        			  	bytesAlreadyWritten += ovfFileItem.getSize();
+		        			 }  
+			        	 }  
+			        }
+		        } finally {
+		        	progressReporter.close();
+		        }
+		        leaseMo.updateLeaseProgress(100);
+			}
+		} finally {
+			leaseMo.completeLease();
+		}
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/NetworkDetails.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/NetworkDetails.java
new file mode 100644
index 00000000000..451d1dc8fa7
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/NetworkDetails.java
@@ -0,0 +1,38 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import com.vmware.vim25.ManagedObjectReference;
+
+public class NetworkDetails {
+
+	private String _name;
+	private ManagedObjectReference _morNetwork;
+	private ManagedObjectReference[] _morVMsOnNetwork;
+	private String _gcTag;
+	
+	public NetworkDetails(String name, ManagedObjectReference morNetwork, ManagedObjectReference[] morVMsOnNetwork, String gcTag) {
+		_name = name;
+		_morNetwork = morNetwork;
+		_morVMsOnNetwork = morVMsOnNetwork;
+		_gcTag = gcTag;
+	}
+	
+	public String getName() {
+		return _name;
+	}
+	
+	public ManagedObjectReference getNetworkMor() {
+		return _morNetwork;
+	}
+	
+	public ManagedObjectReference[] getVMMorsOnNetwork() {
+		return _morVMsOnNetwork;
+	}
+	
+	public String getGCTag() {
+		return _gcTag;
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/NetworkMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/NetworkMO.java
new file mode 100644
index 00000000000..34257620beb
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/NetworkMO.java
@@ -0,0 +1,27 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.vmware.vim25.ManagedObjectReference;
+
+public class NetworkMO extends BaseMO {
+    public NetworkMO(VmwareContext context, ManagedObjectReference morCluster) {
+        super(context, morCluster);
+    }
+    
+    public NetworkMO(VmwareContext context, String morType, String morValue) {
+        super(context, morType, morValue);
+    }
+    
+    public void destroyNetwork() throws Exception {
+        _context.getService().destroyNetwork(_mor); 
+    }
+    
+    public ManagedObjectReference[] getVMsOnNetwork() throws Exception {
+        ManagedObjectReference[] vms = (ManagedObjectReference[])_context.getServiceUtil().getDynamicProperty(_mor, "vm");
+        return vms;
+    }
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/PerfCounterInfoMapper.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/PerfCounterInfoMapper.java
new file mode 100644
index 00000000000..4ecd99c908d
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/PerfCounterInfoMapper.java
@@ -0,0 +1,82 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.vmware.vim25.PerfCounterInfo;
+import com.vmware.vim25.PerfSummaryType;
+
+public class PerfCounterInfoMapper {
+    // map <group name, counter name, list of PerfCounterInfo based on rollupType>
+    Map<String, Map<String, List<PerfCounterInfo>>> _mapCounterInfos = 
+        new HashMap<String, Map<String, List<PerfCounterInfo>>>();
+    
+    public PerfCounterInfoMapper(PerfCounterInfo[] counterInfos) {
+        if(counterInfos != null) {
+            for(PerfCounterInfo counterInfo : counterInfos) {
+                List<PerfCounterInfo> counterInfoList = getSafeCounterInfoList(
+                    counterInfo.getGroupInfo().getKey(), counterInfo.getNameInfo().getKey());
+                counterInfoList.add(counterInfo);
+            }
+        }
+    }
+    
+    public PerfCounterInfo[] lookup(String groupName, String counterName, PerfSummaryType rollupType) {
+        assert(groupName != null);
+        assert(counterName != null);
+        
+        Map<String, List<PerfCounterInfo>> groupMap = _mapCounterInfos.get(groupName);
+        if(groupMap == null)
+            return null;
+        
+        List<PerfCounterInfo> counterInfoList = groupMap.get(counterName);
+        if(counterInfoList == null)
+            return null;
+        
+        if(rollupType == null) {
+            return counterInfoList.toArray(new PerfCounterInfo[0]);
+        }
+        
+        for(PerfCounterInfo info : counterInfoList) {
+            if(info.getRollupType() == rollupType)
+                return new PerfCounterInfo[] { info };
+        }
+        
+        return null; 
+    }
+    
+    public PerfCounterInfo lookupOne(String groupName, String counterName, PerfSummaryType rollupType) {
+        PerfCounterInfo[] infos = lookup(groupName, counterName, rollupType);
+        if(infos != null && infos.length > 0)
+            return infos[0];
+        
+        return null;
+    }
+    
+    private Map<String, List<PerfCounterInfo>> getSafeGroupMap(String groupName) {
+        Map<String, List<PerfCounterInfo>> groupMap = _mapCounterInfos.get(groupName);
+        if(groupMap == null) {
+            groupMap = new HashMap<String, List<PerfCounterInfo>>();
+            _mapCounterInfos.put(groupName, groupMap);
+        }
+        return groupMap;
+    }
+    
+    private List<PerfCounterInfo> getSafeCounterInfoList(String groupName, String counterName) {
+        Map<String, List<PerfCounterInfo>> groupMap = getSafeGroupMap(groupName);
+        assert(groupMap != null);
+        
+        List<PerfCounterInfo> counterInfoList = groupMap.get(counterName);
+        if(counterInfoList == null) {
+            counterInfoList = new ArrayList<PerfCounterInfo>();
+            groupMap.put(counterName, counterInfoList);
+        }
+        return counterInfoList;
+    }
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/PerfManagerMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/PerfManagerMO.java
new file mode 100644
index 00000000000..fb19b798b65
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/PerfManagerMO.java
@@ -0,0 +1,73 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import java.util.Calendar;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.PerfCompositeMetric;
+import com.vmware.vim25.PerfCounterInfo;
+import com.vmware.vim25.PerfEntityMetricBase;
+import com.vmware.vim25.PerfInterval;
+import com.vmware.vim25.PerfMetricId;
+import com.vmware.vim25.PerfProviderSummary;
+import com.vmware.vim25.PerfQuerySpec;
+
+public class PerfManagerMO extends BaseMO {
+    public PerfManagerMO(VmwareContext context, ManagedObjectReference mor) {
+        super(context, mor);
+    }
+    
+    public PerfManagerMO(VmwareContext context, String morType, String morValue) {
+        super(context, morType, morValue);
+    }
+    
+    public void createPerfInterval(PerfInterval interval) throws Exception {
+        _context.getService().createPerfInterval(_mor, interval);
+    }
+    
+    public PerfMetricId[] queryAvailablePerfMetric(ManagedObjectReference morEntity, Calendar beginTime, 
+        Calendar endTime, Integer intervalId) throws Exception {
+        
+        return _context.getService().queryAvailablePerfMetric(_mor, morEntity, beginTime, endTime, intervalId);
+    }
+
+    public PerfCompositeMetric queryPerfComposite(PerfQuerySpec spec) throws Exception {
+        return _context.getService().queryPerfComposite(_mor, spec);
+    }
+    
+    public PerfCounterInfo[] queryPerfCounter(int[] counterId) throws Exception {
+        return _context.getService().queryPerfCounter(_mor, counterId);
+    }
+    
+    public PerfCounterInfo[] queryPerfCounterByLevel(int level) throws Exception {
+        return _context.getService().queryPerfCounterByLevel(_mor, level);
+    }
+    
+    public PerfProviderSummary queryPerfProviderSummary(ManagedObjectReference morEntity) throws Exception {
+        return _context.getService().queryPerfProviderSummary(_mor, morEntity); 
+    }
+
+    public PerfEntityMetricBase[] queryPerf(PerfQuerySpec[] specs) throws Exception {
+        return _context.getService().queryPerf(_mor, specs);
+    }
+    
+    public void removePerfInterval(int samplePeriod) throws Exception {
+        _context.getService().removePerfInterval(_mor, samplePeriod);
+    }
+    
+    public void updatePerfInterval(PerfInterval interval) throws Exception {
+        _context.getService().updatePerfInterval(_mor, interval);
+    }
+    
+    public PerfCounterInfo[] getCounterInfo() throws Exception {
+        return (PerfCounterInfo[])_context.getServiceUtil().getDynamicProperty(_mor, "perfCounter");
+    }
+    
+    public PerfInterval[] getIntervalInfo() throws Exception {
+        return (PerfInterval[])_context.getServiceUtil().getDynamicProperty(_mor, "historicalInterval");
+    }
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/SnapshotDescriptor.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/SnapshotDescriptor.java
new file mode 100755
index 00000000000..45428cd29ec
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/SnapshotDescriptor.java
@@ -0,0 +1,260 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.ArrayList;
+import java.util.Properties;
+
+import org.apache.log4j.Logger;
+
+public class SnapshotDescriptor {
+	private static final Logger s_logger = Logger.getLogger(SnapshotDescriptor.class);
+
+	private Properties _properties = new Properties();
+	
+	public SnapshotDescriptor() {
+	}
+	
+	public void parse(byte[] vmsdFileContent) throws IOException {
+		BufferedReader in = null;
+		try {
+			in = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(vmsdFileContent)));
+			String line;
+			while((line = in.readLine()) != null) {
+				// TODO, remember to remove this log, temporarily added for debugging purpose
+				s_logger.info("Parse snapshot file content: " + line);
+				
+				String[] tokens = line.split("=");
+				if(tokens.length == 2) {
+					String name = tokens[0].trim();
+					String value = tokens[1].trim();
+					if(value.charAt(0) == '\"')
+						value = value.substring(1, value.length() -1); 
+					
+					_properties.put(name, value);
+				}
+			}
+		} finally {
+			if(in != null)
+				in.close();
+		}
+	}
+	
+	public void removeDiskReferenceFromSnapshot(String diskFileName) {
+		String  numSnapshotsStr = _properties.getProperty("snapshot.numSnapshots");
+		if(numSnapshotsStr != null) {
+			int numSnaphosts = Integer.parseInt(numSnapshotsStr);
+			for(int i = 0; i < numSnaphosts; i++) {
+				String numDisksStr = _properties.getProperty(String.format("snapshot%d.numDisks", i));
+				int numDisks = Integer.parseInt(numDisksStr);
+
+				boolean diskFound = false;
+				for(int j = 0; j < numDisks; j++) {
+					String keyName = String.format("snapshot%d.disk%d.fileName", i, j);
+					String fileName = _properties.getProperty(keyName);
+					if(!diskFound) {
+						if(fileName.equalsIgnoreCase(diskFileName)) {
+							diskFound = true;
+							_properties.remove(keyName);
+						}
+					} else {
+						_properties.setProperty(String.format("snapshot%d.disk%d.fileName", i, j - 1), fileName);
+					}
+				}
+				
+				if(diskFound)
+					_properties.setProperty(String.format("snapshot%d.numDisks", i), String.valueOf(numDisks-1));
+			}
+		}
+	}
+	
+	public byte[] getVmsdContent() {
+		BufferedWriter out = null;
+		ByteArrayOutputStream bos = new ByteArrayOutputStream();
+
+		try {
+			out = new BufferedWriter(new OutputStreamWriter(bos, "UTF-8")); 
+			
+			out.write(".encoding = \"UTF-8\""); out.newLine();
+			out.write(String.format("snapshot.lastUID = \"%s\"", _properties.getProperty("snapshot.lastUID"))); out.newLine();
+			String numSnapshotsStr = _properties.getProperty("snapshot.numSnapshots");
+			if(numSnapshotsStr == null || numSnapshotsStr.isEmpty())
+				numSnapshotsStr = "0";
+			out.write(String.format("snapshot.numSnapshots = \"%s\"", numSnapshotsStr)); out.newLine();
+			
+			String value = _properties.getProperty("snapshot.current");
+			if(value != null) {
+				out.write(String.format("snapshot.current = \"%s\"", value)); 
+				out.newLine();
+			}
+				
+			String key;
+			for(int i = 0; i < Integer.parseInt(numSnapshotsStr); i++) {
+				key = String.format("snapshot%d.uid", i);
+				value = _properties.getProperty(key);
+				out.write(String.format("%s = \"%s\"", key, value)); out.newLine();
+				
+				key = String.format("snapshot%d.filename", i);
+				value = _properties.getProperty(key);
+				out.write(String.format("%s = \"%s\"", key, value)); out.newLine();
+
+				key = String.format("snapshot%d.displayName", i);
+				value = _properties.getProperty(key);
+				out.write(String.format("%s = \"%s\"", key, value)); out.newLine();
+
+				key = String.format("snapshot%d.description", i);
+				value = _properties.getProperty(key);
+				out.write(String.format("%s = \"%s\"", key, value)); out.newLine();
+
+				key = String.format("snapshot%d.createTimeHigh", i);
+				value = _properties.getProperty(key);
+				out.write(String.format("%s = \"%s\"", key, value)); out.newLine();
+
+				key = String.format("snapshot%d.createTimeLow", i);
+				value = _properties.getProperty(key);
+				out.write(String.format("%s = \"%s\"", key, value)); out.newLine();
+
+				key = String.format("snapshot%d.numDisks", i);
+				value = _properties.getProperty(key);
+				out.write(String.format("%s = \"%s\"", key, value)); out.newLine();
+				
+				int numDisks = Integer.parseInt(value);
+				for(int j = 0; j < numDisks; j++) {
+					key = String.format("snapshot%d.disk%d.fileName", i, j);
+					value = _properties.getProperty(key);
+					out.write(String.format("%s = \"%s\"", key, value)); out.newLine();
+
+					key = String.format("snapshot%d.disk%d.node", i, j);
+					value = _properties.getProperty(key);
+					out.write(String.format("%s = \"%s\"", key, value)); out.newLine();
+				}
+			}
+		} catch(IOException e) {
+			assert(false);
+			s_logger.error("Unexpected exception ", e);
+		} finally {
+			if(out != null) {
+				try {
+					out.close();
+				} catch (IOException e) {
+				}
+			}
+		}
+		
+		return bos.toByteArray();
+	}
+	
+	private int getSnapshotId(String seqStr) {
+		if(seqStr != null) {
+			int seq = Integer.parseInt(seqStr);
+			String numSnapshotStr = _properties.getProperty("snapshot.numSnapshots");
+			assert(numSnapshotStr != null);
+			for(int i = 0; i < Integer.parseInt(numSnapshotStr); i++) {
+				String value = _properties.getProperty(String.format("snapshot%d.uid", i));
+				if(value != null && Integer.parseInt(value) == seq)
+					return i;
+			}
+		}
+		
+		return 0;
+	}
+	
+	public SnapshotInfo[] getCurrentDiskChain() {
+		ArrayList<SnapshotInfo> l = new ArrayList<SnapshotInfo>();
+		String current = _properties.getProperty("snapshot.current");
+		int id;
+		while(current != null) {
+			id = getSnapshotId(current);
+			String numDisksStr = _properties.getProperty(String.format("snapshot%d.numDisks", id));
+			assert(numDisksStr != null);
+			int numDisks = Integer.parseInt(numDisksStr);
+			DiskInfo[] disks = new DiskInfo[numDisks];
+			for(int i = 0; i < numDisks; i++) {
+				disks[i] = new DiskInfo(
+					_properties.getProperty(String.format("snapshot%d.disk%d.fileName", id, i)),
+					_properties.getProperty(String.format("snapshot%d.disk%d.node", id, i))
+				);			
+			}
+			
+			SnapshotInfo info = new SnapshotInfo();
+			info.setId(id);
+			info.setNumOfDisks(numDisks);
+			info.setDisks(disks);
+			info.setDisplayName(_properties.getProperty(String.format("snapshot%d.displayName", id)));
+			l.add(info);
+			
+			current = _properties.getProperty(String.format("snapshot%d.parent", id));
+		}
+		
+		return l.toArray(new SnapshotInfo[0]);
+	}
+
+	public static class SnapshotInfo {
+		private int _id;
+		private String _displayName;
+		private int _numOfDisks;  
+		private DiskInfo[] _disks;
+		
+		public SnapshotInfo() {
+		}
+		
+		public void setId(int id) {
+			_id = id;
+		}
+		
+		public int getId() {
+			return _id;
+		}
+		
+		public void setDisplayName(String name) {
+			_displayName = name;
+		}
+		
+		public String getDisplayName() {
+			return _displayName;
+		}
+		
+		public void setNumOfDisks(int numOfDisks) {
+			_numOfDisks = numOfDisks;
+		}
+		
+		public int getNumOfDisks() {
+			return _numOfDisks;
+		}
+		
+		public void setDisks(DiskInfo[] disks) {
+			_disks = disks;
+		}
+		
+		public DiskInfo[] getDisks() {
+			return _disks;
+		}
+	}
+	
+	public static class DiskInfo {
+		private String _diskFileName;
+		private String _deviceName;
+		
+		public DiskInfo(String diskFileName, String deviceName) {
+			_diskFileName = diskFileName;
+			_deviceName = deviceName;
+		}
+		
+		public String getDiskFileName() {
+			return _diskFileName; 
+		}
+		
+		public String getDeviceName() {
+			return _deviceName;
+		}
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/TaskMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/TaskMO.java
new file mode 100644
index 00000000000..83b020ebb5c
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/TaskMO.java
@@ -0,0 +1,62 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.vmware.vim25.LocalizableMessage;
+import com.vmware.vim25.LocalizedMethodFault;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.TaskInfo;
+import com.vmware.vim25.TaskInfoState;
+
+public class TaskMO extends BaseMO {
+    public TaskMO(VmwareContext context, ManagedObjectReference morTask) {
+        super(context, morTask);
+    }
+    
+    public TaskMO(VmwareContext context, String morType, String morValue) {
+        super(context, morType, morValue);
+    }
+    
+    public TaskInfo getTaskInfo() throws Exception {
+		return (TaskInfo)getContext().getServiceUtil().getDynamicProperty(_mor, "info");
+    }
+    
+    public void setTaskDescription(LocalizableMessage description) throws Exception {
+    	_context.getService().setTaskDescription(_mor, description);
+    }
+    
+    public void setTaskState(TaskInfoState state, Object result, LocalizedMethodFault fault) throws Exception {
+    	_context.getService().setTaskState(_mor, state, result, fault);
+    }
+    
+    public void updateProgress(int percentDone) throws Exception {
+    	_context.getService().updateProgress(_mor, percentDone);
+    }
+    
+    public void cancelTask() throws Exception {
+    	_context.getService().cancelTask(_mor);
+    }
+    
+    public static String getTaskFailureInfo(VmwareContext context, ManagedObjectReference morTask) {
+    	StringBuffer sb = new StringBuffer();
+    	
+    	try {
+    		TaskInfo info = (TaskInfo)context.getServiceUtil().getDynamicProperty(morTask, "info");
+    		if(info != null) {
+    			LocalizedMethodFault fault = info.getError();
+    			if(fault != null) {
+    				sb.append(fault.getLocalizedMessage()).append(" ");
+    				
+    				if(fault.getFault() != null)
+    					sb.append(fault.getFault().getClass().getName());
+    			}
+    		}
+    	} catch(Exception e) {
+    	}
+    	
+    	return sb.toString();
+    }
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/VersioningContants.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VersioningContants.java
new file mode 100644
index 00000000000..49fa4a3fd75
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VersioningContants.java
@@ -0,0 +1,8 @@
+package com.cloud.hypervisor.vmware.mo;
+
+public interface VersioningContants {
+	
+	// portgroups created on vSwitch will carry a version number now, so that when CloudStack has a major naming convention upgrade
+	// we know how to cleanup at vCenter side
+	public final static int PORTGROUP_NAMING_VERSION = 1;
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/VirtualDiskManagerMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VirtualDiskManagerMO.java
new file mode 100755
index 00000000000..7f5df7e4567
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VirtualDiskManagerMO.java
@@ -0,0 +1,145 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.vmware.vim25.HostDiskDimensionsChs;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.VirtualDiskSpec;
+
+public class VirtualDiskManagerMO extends BaseMO {
+    private static final Logger s_logger = Logger.getLogger(VirtualDiskManagerMO.class);
+    
+	public VirtualDiskManagerMO(VmwareContext context, ManagedObjectReference morDiskMgr) {
+		super(context, morDiskMgr);
+	}
+	
+	public VirtualDiskManagerMO(VmwareContext context, String morType, String morValue) {
+		super(context, morType, morValue);
+	}
+	
+    public void copyVirtualDisk(String srcName, ManagedObjectReference morSrcDc,
+    	String destName, ManagedObjectReference morDestDc, VirtualDiskSpec diskSpec, 
+    	boolean force) throws Exception {
+    	
+    	ManagedObjectReference morTask = _context.getService().copyVirtualDisk_Task(_mor, srcName, morSrcDc, destName, morDestDc, diskSpec, force);
+    	
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(!result.equals("sucess"))
+			throw new Exception("Unable to copy virtual disk " + srcName + " to " + destName 
+				+ " due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		
+		_context.waitForTaskProgressDone(morTask);
+    }
+    
+    public void createVirtualDisk(String name, ManagedObjectReference morDc, VirtualDiskSpec diskSpec) throws Exception {
+    	ManagedObjectReference morTask = _context.getService().createVirtualDisk_Task(_mor, name, morDc, diskSpec);
+    	
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(!result.equals("sucess"))
+			throw new Exception("Unable to create virtual disk " + name 
+				+ " due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+
+		_context.waitForTaskProgressDone(morTask);
+    }
+    
+    public void defragmentVirtualDisk(String name, ManagedObjectReference morDc) throws Exception {
+    	ManagedObjectReference morTask = _context.getService().defragmentVirtualDisk_Task(_mor, name, morDc);
+    	
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(!result.equals("sucess"))
+			throw new Exception("Unable to defragment virtual disk " + name + " due to " + result);
+
+		_context.waitForTaskProgressDone(morTask);
+    }
+    
+    public void deleteVirtualDisk(String name, ManagedObjectReference morDc) throws Exception {
+    	ManagedObjectReference morTask = _context.getService().deleteVirtualDisk_Task(_mor, name, morDc);
+    	
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(!result.equals("sucess"))
+			throw new Exception("Unable to delete virtual disk " + name + " due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+
+		_context.waitForTaskProgressDone(morTask);
+    }
+    
+    public void eagerZeroVirtualDisk(String name, ManagedObjectReference morDc) throws Exception {
+    	ManagedObjectReference morTask = _context.getService().eagerZeroVirtualDisk_Task(_mor, name, morDc);
+    	
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(!result.equals("sucess"))
+			throw new Exception("Unable to eager zero virtual disk " + name + " due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+
+		_context.waitForTaskProgressDone(morTask);
+    }
+    
+    public void extendVirtualDisk(String name, ManagedObjectReference morDc, long newCapacityKb, boolean eagerZero) throws Exception {
+    	ManagedObjectReference morTask = _context.getService().extendVirtualDisk_Task(_mor, name, morDc, newCapacityKb, eagerZero);
+    	
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(!result.equals("sucess"))
+			throw new Exception("Unable to extend virtual disk " + name + " due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+
+		_context.waitForTaskProgressDone(morTask);
+    }
+    
+    public void inflateVirtualDisk(String name, ManagedObjectReference morDc) throws Exception {
+    	ManagedObjectReference morTask = _context.getService().inflateVirtualDisk_Task(_mor, name, morDc);
+    	
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(!result.equals("sucess"))
+			throw new Exception("Unable to inflate virtual disk " + name + " due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		_context.waitForTaskProgressDone(morTask);
+    }
+    
+    public void shrinkVirtualDisk(String name, ManagedObjectReference morDc, boolean copy) throws Exception {
+    	ManagedObjectReference morTask = _context.getService().shrinkVirtualDisk_Task(_mor, name, morDc, copy);
+    	
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(!result.equals("sucess"))
+			throw new Exception("Unable to shrink virtual disk " + name + " due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		_context.waitForTaskProgressDone(morTask);
+    }
+    
+    public void zeroFillVirtualDisk(String name, ManagedObjectReference morDc) throws Exception {
+    	ManagedObjectReference morTask = _context.getService().zeroFillVirtualDisk_Task(_mor, name, morDc);
+    	
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(!result.equals("sucess"))
+			throw new Exception("Unable to zero fill virtual disk " + name + " due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		_context.waitForTaskProgressDone(morTask);
+    }
+    
+    public void moveVirtualDisk(String srcName, ManagedObjectReference morSrcDc,
+    	String destName, ManagedObjectReference morDestDc, boolean force) throws Exception {
+    	
+    	ManagedObjectReference morTask = _context.getService().moveVirtualDisk_Task(_mor, srcName, morSrcDc,
+    		destName, morDestDc, force);
+    	
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(!result.equals("sucess"))
+			throw new Exception("Unable to move virtual disk " + srcName + " to " + destName 
+				+ " due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		_context.waitForTaskProgressDone(morTask);
+    }
+    
+    public int queryVirtualDiskFragmentation(String name, ManagedObjectReference morDc) throws Exception {
+    	return _context.getService().queryVirtualDiskFragmentation(_mor, name, morDc);
+    }
+    
+    public HostDiskDimensionsChs queryVirtualDiskGeometry(String name, ManagedObjectReference morDc) throws Exception {
+    	return _context.getService().queryVirtualDiskGeometry(_mor, name, morDc);
+    }
+    
+    public String queryVirtualDiskUuid(String name, ManagedObjectReference morDc) throws Exception {
+    	return _context.getService().queryVirtualDiskUuid(_mor, name, morDc);
+    }
+    
+    public void setVirtualDiskUuid(String name, ManagedObjectReference morDc, String uuid) throws Exception {
+    	_context.getService().setVirtualDiskUuid(_mor, name, morDc, uuid);
+    }
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/VirtualEthernetCardType.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VirtualEthernetCardType.java
new file mode 100644
index 00000000000..7cd3adf45ca
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VirtualEthernetCardType.java
@@ -0,0 +1,5 @@
+package com.cloud.hypervisor.vmware.mo;
+
+public enum VirtualEthernetCardType {
+	E1000, PCNet32, Vmxnet2, Vmxnet3
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/VirtualMachineMO.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VirtualMachineMO.java
new file mode 100755
index 00000000000..4784825267a
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VirtualMachineMO.java
@@ -0,0 +1,1912 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.mo.SnapshotDescriptor.SnapshotInfo;
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.cloud.hypervisor.vmware.util.VmwareHelper;
+import com.cloud.utils.ActionDelegate;
+import com.cloud.utils.Pair;
+import com.cloud.utils.Ternary;
+import com.cloud.utils.script.Script;
+import com.google.gson.Gson;
+import com.vmware.vim25.ArrayOfManagedObjectReference;
+import com.vmware.vim25.CustomFieldStringValue;
+import com.vmware.vim25.DynamicProperty;
+import com.vmware.vim25.GuestInfo;
+import com.vmware.vim25.HttpNfcLeaseDeviceUrl;
+import com.vmware.vim25.HttpNfcLeaseInfo;
+import com.vmware.vim25.HttpNfcLeaseState;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.ObjectContent;
+import com.vmware.vim25.ObjectSpec;
+import com.vmware.vim25.OptionValue;
+import com.vmware.vim25.OvfCreateDescriptorParams;
+import com.vmware.vim25.OvfCreateDescriptorResult;
+import com.vmware.vim25.OvfFile;
+import com.vmware.vim25.PropertyFilterSpec;
+import com.vmware.vim25.PropertySpec;
+import com.vmware.vim25.SelectionSpec;
+import com.vmware.vim25.TraversalSpec;
+import com.vmware.vim25.VirtualCdrom;
+import com.vmware.vim25.VirtualCdromIsoBackingInfo;
+import com.vmware.vim25.VirtualCdromRemotePassthroughBackingInfo;
+import com.vmware.vim25.VirtualDevice;
+import com.vmware.vim25.VirtualDeviceBackingInfo;
+import com.vmware.vim25.VirtualDeviceConfigSpec;
+import com.vmware.vim25.VirtualDeviceConfigSpecFileOperation;
+import com.vmware.vim25.VirtualDeviceConfigSpecOperation;
+import com.vmware.vim25.VirtualDeviceConnectInfo;
+import com.vmware.vim25.VirtualDisk;
+import com.vmware.vim25.VirtualDiskFlatVer1BackingInfo;
+import com.vmware.vim25.VirtualDiskFlatVer2BackingInfo;
+import com.vmware.vim25.VirtualDiskMode;
+import com.vmware.vim25.VirtualDiskRawDiskMappingVer1BackingInfo;
+import com.vmware.vim25.VirtualDiskSparseVer1BackingInfo;
+import com.vmware.vim25.VirtualDiskSparseVer2BackingInfo;
+import com.vmware.vim25.VirtualDiskType;
+import com.vmware.vim25.VirtualEthernetCard;
+import com.vmware.vim25.VirtualIDEController;
+import com.vmware.vim25.VirtualLsiLogicController;
+import com.vmware.vim25.VirtualMachineCloneSpec;
+import com.vmware.vim25.VirtualMachineConfigInfo;
+import com.vmware.vim25.VirtualMachineConfigSpec;
+import com.vmware.vim25.VirtualMachineConfigSummary;
+import com.vmware.vim25.VirtualMachineFileInfo;
+import com.vmware.vim25.VirtualMachineMovePriority;
+import com.vmware.vim25.VirtualMachinePowerState;
+import com.vmware.vim25.VirtualMachineRelocateDiskMoveOptions;
+import com.vmware.vim25.VirtualMachineRelocateSpec;
+import com.vmware.vim25.VirtualMachineRelocateSpecDiskLocator;
+import com.vmware.vim25.VirtualMachineRuntimeInfo;
+import com.vmware.vim25.VirtualMachineSnapshotInfo;
+import com.vmware.vim25.VirtualMachineSnapshotTree;
+import com.vmware.vim25.VirtualPCIController;
+import com.vmware.vim25.VirtualSCSIController;
+
+public class VirtualMachineMO extends BaseMO {
+    private static final Logger s_logger = Logger.getLogger(VirtualMachineMO.class);
+
+	public VirtualMachineMO(VmwareContext context, ManagedObjectReference morVm) {
+		super(context, morVm);
+	}
+	
+	public VirtualMachineMO(VmwareContext context, String morType, String morValue) {
+		super(context, morType, morValue);
+	}
+		
+	public Pair<DatacenterMO, String> getOwnerDatacenter() throws Exception {
+		return DatacenterMO.getOwnerDatacenter(getContext(), getMor());
+	}
+	
+	public Pair<DatastoreMO, String> getOwnerDatastore(String dsFullPath) throws Exception {
+		String dsName = DatastoreFile.getDatastoreNameFromPath(dsFullPath);
+		
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("Datastore");
+		pSpec.setPathSet(new String[] { "name" });
+		
+	    TraversalSpec vmDatastoreTraversal = new TraversalSpec();
+	    vmDatastoreTraversal.setType("VirtualMachine");
+	    vmDatastoreTraversal.setPath("datastore");
+	    vmDatastoreTraversal.setName("vmDatastoreTraversal");
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(_mor);
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { vmDatastoreTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    ObjectContent[] ocs = _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec });
+	    
+	    if(ocs != null) {
+	    	for(ObjectContent oc : ocs) {
+	    		DynamicProperty prop = oc.getPropSet(0);
+	    		if(prop.getVal().toString().equals(dsName)) {
+	    			return new Pair<DatastoreMO, String>(new DatastoreMO(_context, oc.getObj()), dsName);
+	    		}
+	    	}
+	    }
+		
+		return null;
+	}
+	
+	public HostMO getRunningHost() throws Exception {
+		VirtualMachineRuntimeInfo runtimeInfo = getRuntimeInfo();
+		return new HostMO(_context, runtimeInfo.getHost());
+	}
+	
+	public String getVmName() throws Exception {
+		return (String)getContext().getServiceUtil().getDynamicProperty(_mor, "name");
+	}
+	
+	public GuestInfo getVmGuestInfo() throws Exception {
+		return (GuestInfo)getContext().getServiceUtil().getDynamicProperty(_mor, "guest");
+	}
+	
+	public boolean isVMwareToolsRunning() throws Exception {
+		GuestInfo guestInfo = getVmGuestInfo();
+		if(guestInfo != null) {
+			if("guestToolsRunning".equalsIgnoreCase(guestInfo.getToolsRunningStatus()))
+				return true;
+		}
+		return false;
+	}
+	
+	public boolean powerOn() throws Exception {
+		if(getPowerState() == VirtualMachinePowerState.poweredOn)
+			return true;
+		
+		ManagedObjectReference morTask = _context.getService().powerOnVM_Task(_mor, null);
+		
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware powerOnVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		
+		return false;
+	}
+	
+	public boolean powerOff() throws Exception {
+		if(getPowerState() == VirtualMachinePowerState.poweredOff)
+			return true;
+		
+		return powerOffNoCheck();
+	}
+	
+	public boolean safePowerOff(int shutdownWaitMs) throws Exception {
+		
+		if(getPowerState() == VirtualMachinePowerState.poweredOff)
+			return true;
+		
+		if(isVMwareToolsRunning()) {
+			try {
+				String vmName = this.getName();
+				
+				s_logger.info("Try gracefully shut down VM " + vmName);
+				shutdown();
+				
+				long startTick = System.currentTimeMillis();
+				while(getPowerState() != VirtualMachinePowerState.poweredOff && System.currentTimeMillis() - startTick < shutdownWaitMs) {
+					try { 
+						Thread.sleep(1000);
+					} catch(InterruptedException e) {
+					}
+				}
+				
+				if(getPowerState() != VirtualMachinePowerState.poweredOff) {
+					s_logger.info("can not gracefully shutdown VM within " + (shutdownWaitMs/1000) + " seconds, we will perform force power off on VM " + vmName);
+					return powerOffNoCheck();
+				}
+				
+				return true;
+			} catch(Exception e) {
+				s_logger.warn("Failed to do guest-os graceful shutdown due to " + VmwareHelper.getExceptionMessage(e));				
+			}
+		}
+		
+		return powerOffNoCheck();
+	}
+	
+	private boolean powerOffNoCheck() throws Exception {
+		ManagedObjectReference morTask = _context.getService().powerOffVM_Task(_mor);
+		
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware powerOffVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		
+		return false;
+	}
+	
+	public VirtualMachinePowerState getPowerState() throws Exception {
+		return (VirtualMachinePowerState)getContext().getServiceUtil().getDynamicProperty(_mor, "runtime.powerState");
+	}
+	
+	public boolean reset() throws Exception {
+		ManagedObjectReference morTask = _context.getService().resetVM_Task(_mor);
+		
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware resetVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		return false;
+	}
+	
+	public void shutdown() throws Exception {
+		_context.getService().shutdownGuest(_mor);
+	}
+	
+	public void rebootGuest() throws Exception {
+		_context.getService().rebootGuest(_mor);
+	}
+	
+	public void markAsTemplate() throws Exception {
+		_context.getService().markAsTemplate(_mor);
+	}
+	
+	public boolean isTemplate() throws Exception {
+		VirtualMachineConfigInfo configInfo = this.getConfigInfo();
+		return configInfo.isTemplate();
+	}
+	
+	public boolean migrate(ManagedObjectReference morRp, ManagedObjectReference morTargetHost) throws Exception {
+		ManagedObjectReference morTask = _context.getService().migrateVM_Task(_mor,
+			morRp, morTargetHost, VirtualMachineMovePriority.defaultPriority, null);
+		
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware migrateVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		
+		return false;
+	}
+	
+	public boolean relocate(ManagedObjectReference morTargetHost) throws Exception {
+	    VirtualMachineRelocateSpec relocateSpec = new VirtualMachineRelocateSpec();
+	    relocateSpec.setHost(morTargetHost);
+	    
+        ManagedObjectReference morTask = _context.getService().relocateVM_Task(_mor, 
+            relocateSpec, null);
+	    
+        String result = _context.getServiceUtil().waitForTask(morTask);
+        if(result.equals("sucess")) {
+            _context.waitForTaskProgressDone(morTask);
+            return true;
+        } else {
+        	s_logger.error("VMware relocateVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+        }
+        
+        return false;
+	}
+	
+	public VirtualMachineSnapshotInfo getSnapshotInfo() throws Exception {
+		return (VirtualMachineSnapshotInfo)_context.getServiceUtil().getDynamicProperty(_mor, "snapshot");
+	}
+	
+	public boolean createSnapshot(String snapshotName, String snapshotDescription, 
+		boolean dumpMemory, boolean quiesce) throws Exception {
+		
+		ManagedObjectReference morTask = _context.getService().createSnapshot_Task(_mor, snapshotName, 
+			snapshotDescription, dumpMemory, quiesce);
+		
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware createSnapshot_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		
+		return false;
+	}
+	
+	public boolean removeSnapshot(String snapshotName, boolean removeChildren) throws Exception {
+		ManagedObjectReference morSnapshot = getSnapshotMor(snapshotName);
+		if(morSnapshot == null) {
+			s_logger.warn("Unable to find snapshot: " + snapshotName);
+			return false;
+		}
+		
+		ManagedObjectReference morTask = _context.getService().removeSnapshot_Task(morSnapshot, removeChildren);
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware removeSnapshot_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		
+		return false;
+	}
+	
+	public boolean removeAllSnapshots() throws Exception {
+		VirtualMachineSnapshotInfo snapshotInfo = getSnapshotInfo();
+		
+		if(snapshotInfo != null && snapshotInfo.getRootSnapshotList() != null) {
+			VirtualMachineSnapshotTree[] tree = snapshotInfo.getRootSnapshotList();
+			for(VirtualMachineSnapshotTree treeNode : tree) {
+				ManagedObjectReference morTask = _context.getService().removeSnapshot_Task(treeNode.getSnapshot(), true);
+				String result = _context.getServiceUtil().waitForTask(morTask);
+				if(result.equals("sucess")) {
+					_context.waitForTaskProgressDone(morTask);
+				} else {
+		        	s_logger.error("VMware removeSnapshot_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		        	return false;
+				}
+			}
+		}
+		
+		return true;
+	}
+	
+	public String getSnapshotDiskFileDatastorePath(VirtualMachineFileInfo vmFileInfo, 
+		List<Pair<ManagedObjectReference, String>> datastoreMounts,
+		String snapshotDiskFile) throws Exception {
+		
+		// if file path start with "/", need to search all datastore mounts on the host in order
+		// to form fully qualified datastore path 
+		if(snapshotDiskFile.startsWith("/")) {
+			for(Pair<ManagedObjectReference, String> mount: datastoreMounts) {
+				if(snapshotDiskFile.startsWith(mount.second())) {
+					DatastoreMO dsMo = new DatastoreMO(_context, mount.first());
+					
+					String dsFullPath = String.format("[%s] %s", dsMo.getName(), snapshotDiskFile.substring(mount.second().length() + 1));
+					s_logger.info("Convert snapshot disk file name to datastore path. " + snapshotDiskFile + "->" + dsFullPath);
+					return dsFullPath;
+				}
+			}
+			
+			s_logger.info("Convert snapshot disk file name to datastore path. " + snapshotDiskFile + "->" + snapshotDiskFile);
+			return snapshotDiskFile;
+		} else {
+			
+			// snapshot directory string from VirtualMachineFileInfo ends with / 
+			String dsFullPath = vmFileInfo.getSnapshotDirectory() + snapshotDiskFile;
+			s_logger.info("Convert snapshot disk file name to datastore path. " + snapshotDiskFile + "->" + dsFullPath);
+			return dsFullPath;
+		}
+	}
+	
+	public SnapshotDescriptor getSnapshotDescriptor() throws Exception {
+
+		Pair<DatacenterMO, String> dcPair = getOwnerDatacenter();
+		
+		String dsPath = getSnapshotDescriptorDatastorePath();
+		assert(dsPath != null);
+		String url = getContext().composeDatastoreBrowseUrl(dcPair.second(), dsPath);
+		byte[] content = getContext().getResourceContent(url);
+		
+		if(content == null || content.length < 1) {
+			s_logger.warn("Snapshot descriptor file (vsd) does not exist anymore?");
+		}
+		
+		SnapshotDescriptor descriptor = new SnapshotDescriptor();
+		descriptor.parse(content);
+		return descriptor;
+	}
+	
+	public String getSnapshotDescriptorDatastorePath() throws Exception {
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("VirtualMachine");
+		pSpec.setPathSet(new String[] { "name", "config.files" });
+		
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(_mor);
+	    oSpec.setSkip(Boolean.FALSE);
+	    
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    ObjectContent[] ocs = _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec });
+	    assert(ocs != null);
+
+    	String vmName = null;
+    	VirtualMachineFileInfo fileInfo = null;
+    	
+    	assert(ocs.length == 1);
+    	for(ObjectContent oc : ocs) {
+    		DynamicProperty[] props = oc.getPropSet();
+    		if(props != null) {
+    			assert(props.length == 2);
+    			
+    			for(DynamicProperty prop : props) {
+    				if(prop.getName().equals("name")) {
+    					vmName = prop.getVal().toString();
+    				} else {
+    					fileInfo = (VirtualMachineFileInfo)prop.getVal();	
+    				}
+    			}
+    		}
+    	}
+    	assert(vmName != null);
+    	assert(fileInfo != null);
+
+    	// .vmsd file exists at the same directory of .vmx file
+    	DatastoreFile vmxFile = new DatastoreFile(fileInfo.getVmPathName());
+    	return vmxFile.getCompanionPath(vmName + ".vmsd");
+	}
+	
+	public ManagedObjectReference getSnapshotMor(String snapshotName) throws Exception {
+		VirtualMachineSnapshotInfo info = getSnapshotInfo();
+		if(info != null) {
+	         VirtualMachineSnapshotTree[] snapTree = info.getRootSnapshotList();
+	         return VmwareHelper.findSnapshotInTree(snapTree, snapshotName); 
+		}
+		return null;
+	}
+	
+	public boolean createFullClone(String cloneName, ManagedObjectReference morFolder, ManagedObjectReference morResourcePool, 
+		ManagedObjectReference morDs) throws Exception {
+		
+     	VirtualMachineCloneSpec cloneSpec = new VirtualMachineCloneSpec();
+     	VirtualMachineRelocateSpec relocSpec = new VirtualMachineRelocateSpec();
+     	cloneSpec.setLocation(relocSpec);
+     	cloneSpec.setPowerOn(false);
+     	cloneSpec.setTemplate(false);
+     
+     	relocSpec.setDatastore(morDs);
+     	relocSpec.setPool(morResourcePool);
+        ManagedObjectReference morTask = _context.getService().cloneVM_Task(_mor, morFolder, cloneName, cloneSpec); 
+    		
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware cloneVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		
+		return false;
+	}
+	
+	public boolean createLinkedClone(String cloneName, ManagedObjectReference morBaseSnapshot, 
+		ManagedObjectReference morFolder, ManagedObjectReference morResourcePool, 
+		ManagedObjectReference morDs) throws Exception {
+		
+		assert(morBaseSnapshot != null);
+		assert(morFolder != null);
+		assert(morResourcePool != null);
+		assert(morDs != null);
+		
+		VirtualDisk[] independentDisks = getAllIndependentDiskDevice();
+        VirtualMachineRelocateSpec rSpec = new VirtualMachineRelocateSpec();
+        if(independentDisks.length > 0) {
+            VirtualMachineRelocateSpecDiskLocator[] diskLocator = new VirtualMachineRelocateSpecDiskLocator[independentDisks.length];
+            for(int i = 0; i < diskLocator.length; i++) {
+            	diskLocator[i] = new VirtualMachineRelocateSpecDiskLocator();
+            	diskLocator[i].setDatastore(morDs);
+            	diskLocator[i].setDiskId(independentDisks[i].getKey());
+            	diskLocator[i].setDiskMoveType(VirtualMachineRelocateDiskMoveOptions._moveAllDiskBackingsAndDisallowSharing);
+            }
+            
+            rSpec.setDiskMoveType(VirtualMachineRelocateDiskMoveOptions._createNewChildDiskBacking);
+            rSpec.setDisk(diskLocator);
+        } else {
+        	rSpec.setDiskMoveType(VirtualMachineRelocateDiskMoveOptions._createNewChildDiskBacking);
+        }
+        rSpec.setPool(morResourcePool);
+        
+        VirtualMachineCloneSpec cloneSpec = new VirtualMachineCloneSpec();
+        cloneSpec.setPowerOn(false);
+        cloneSpec.setTemplate(false);
+        cloneSpec.setLocation(rSpec);
+        cloneSpec.setSnapshot(morBaseSnapshot);
+        
+        ManagedObjectReference morTask = _context.getService().cloneVM_Task(_mor, morFolder, cloneName, cloneSpec); 
+    		
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware cloneVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		
+		return false;
+	}
+	
+	public VirtualMachineRuntimeInfo getRuntimeInfo() throws Exception {
+		return (VirtualMachineRuntimeInfo)_context.getServiceUtil().getDynamicProperty(
+			_mor, "runtime");
+	}
+	
+	public VirtualMachineConfigInfo getConfigInfo() throws Exception {
+		return (VirtualMachineConfigInfo)_context.getServiceUtil().getDynamicProperty(
+			_mor, "config");
+	}
+	
+	public VirtualMachineConfigSummary getConfigSummary() throws Exception {
+		return (VirtualMachineConfigSummary)_context.getServiceUtil().getDynamicProperty(
+			_mor, "summary.config");
+	}
+	
+	public VirtualMachineFileInfo getFileInfo() throws Exception {
+		return (VirtualMachineFileInfo)_context.getServiceUtil().getDynamicProperty(
+			_mor, "config.files");
+	}
+	
+	public ManagedObjectReference getParentMor() throws Exception {
+		return (ManagedObjectReference)_context.getServiceUtil().getDynamicProperty(
+			_mor, "parent");
+	}
+
+	public String[] getNetworks() throws Exception {
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("Network");
+		pSpec.setPathSet(new String[] {"name"});
+		
+	    TraversalSpec vm2NetworkTraversal = new TraversalSpec();
+	    vm2NetworkTraversal.setType("VirtualMachine");
+	    vm2NetworkTraversal.setPath("network");
+	    vm2NetworkTraversal.setName("vm2NetworkTraversal");
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(_mor);
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { vm2NetworkTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    ObjectContent[] ocs = _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec });
+	    
+	    List<String> networks = new ArrayList<String>();
+	    if(ocs != null && ocs.length > 0) {
+	    	for(ObjectContent oc : ocs) {
+	    		networks.add(oc.getPropSet(0).getVal().toString());
+	    	}
+	    }
+	    return networks.toArray(new String[0]);
+	}
+
+	public List<NetworkDetails> getNetworksWithDetails() throws Exception {
+		List<NetworkDetails> networks = new ArrayList<NetworkDetails>();
+
+		int gcTagKey = getCustomFieldKey("Network", CustomFieldConstants.CLOUD_GC);
+		
+		PropertySpec pSpec = new PropertySpec();
+		pSpec.setType("Network");
+		pSpec.setPathSet(new String[] {"name", "vm", String.format("value[%d]", gcTagKey)});
+		
+	    TraversalSpec vm2NetworkTraversal = new TraversalSpec();
+	    vm2NetworkTraversal.setType("VirtualMachine");
+	    vm2NetworkTraversal.setPath("network");
+	    vm2NetworkTraversal.setName("vm2NetworkTraversal");
+
+	    ObjectSpec oSpec = new ObjectSpec();
+	    oSpec.setObj(_mor);
+	    oSpec.setSkip(Boolean.TRUE);
+	    oSpec.setSelectSet(new SelectionSpec[] { vm2NetworkTraversal });
+
+	    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+	    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+	    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+	    
+	    ObjectContent[] ocs = _context.getService().retrieveProperties(
+	    	_context.getServiceContent().getPropertyCollector(), 
+	    	new PropertyFilterSpec[] { pfSpec });
+	    
+	    if(ocs != null && ocs.length > 0) {
+	    	for(ObjectContent oc : ocs) {
+	    		ArrayOfManagedObjectReference morVms = null;
+	    		String gcTagValue = null;
+	    		String name = null;
+
+	    		for(DynamicProperty prop : oc.getPropSet()) {
+	    			if(prop.getName().equals("name"))
+	    				name = prop.getVal().toString();
+	    			else if(prop.getName().equals("vm"))
+	    	    		morVms = (ArrayOfManagedObjectReference)prop.getVal();
+	    			else if(prop.getName().startsWith("value[")) {
+		    			CustomFieldStringValue val = (CustomFieldStringValue)prop.getVal();
+		    			if(val != null)
+		    				gcTagValue = val.getValue();
+	    			}
+	    		}
+	    		
+	    		NetworkDetails details = new NetworkDetails(name, oc.getObj(), 
+	    			(morVms != null ? morVms.getManagedObjectReference() : null), 
+	    			gcTagValue);
+	    		
+	    		networks.add(details);
+	    	}
+	    }
+		
+		return networks;
+	}
+	
+	/**
+	 * Retrieve path info to access VM files via vSphere web interface 
+	 * @return [0] vm-name, [1] data-center-name, [2] datastore-name 
+	 * @throws Exception
+	 */
+	public String[] getHttpAccessPathInfo() throws Exception {
+		String[] pathInfo = new String[3];
+		
+		Pair<DatacenterMO, String> dcInfo = getOwnerDatacenter();
+		
+		VirtualMachineFileInfo fileInfo = getFileInfo();
+		String vmxFilePath = fileInfo.getVmPathName();
+		String vmxPathTokens[] = vmxFilePath.split("\\[|\\]|/");
+		assert(vmxPathTokens.length == 4);
+		pathInfo[1] = vmxPathTokens[1].trim();							// vSphere vm name
+		pathInfo[2] = dcInfo.second();									// vSphere datacenter name
+		pathInfo[3] = vmxPathTokens[0].trim();							// vSphere datastore name
+		return pathInfo;
+	}
+	
+	public String getVmxHttpAccessUrl() throws Exception {
+		Pair<DatacenterMO, String> dcInfo = getOwnerDatacenter();
+		
+		VirtualMachineFileInfo fileInfo = getFileInfo();
+		String vmxFilePath = fileInfo.getVmPathName();
+		String vmxPathTokens[] = vmxFilePath.split("\\[|\\]|/");
+		
+		StringBuffer sb = new StringBuffer("https://" + _context.getServerAddress() + "/folder/");
+		sb.append(URLEncoder.encode(vmxPathTokens[2].trim()));
+		sb.append("/");
+		sb.append(URLEncoder.encode(vmxPathTokens[3].trim()));
+		sb.append("?dcPath=");
+		sb.append(URLEncoder.encode(dcInfo.second()));
+		sb.append("&dsName=");
+		sb.append(URLEncoder.encode(vmxPathTokens[1].trim()));
+		
+		return sb.toString();
+	}
+	
+	public boolean setVncConfigInfo(boolean enableVnc, String vncPassword, int vncPort, String keyboard) throws Exception {
+		VirtualMachineConfigSpec vmConfigSpec = new VirtualMachineConfigSpec();
+		OptionValue[] vncOptions = VmwareHelper.composeVncOptions(null, enableVnc, vncPassword, vncPort, keyboard);
+		vmConfigSpec.setExtraConfig(vncOptions);
+    	ManagedObjectReference morTask = _context.getService().reconfigVM_Task(_mor, vmConfigSpec);
+    	  
+  		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware reconfigVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		return false;
+	}
+	
+	public boolean configureVm(VirtualMachineConfigSpec vmConfigSpec) throws Exception {
+    	ManagedObjectReference morTask = _context.getService().reconfigVM_Task(_mor, vmConfigSpec);
+  	  
+  		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware reconfigVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		return false;
+	}
+	
+	public boolean configureVm(Ternary<VirtualDevice, VirtualDeviceConfigSpecOperation, 
+		VirtualDeviceConfigSpecFileOperation>[] devices) throws Exception {
+		
+		assert(devices != null);
+		
+		VirtualMachineConfigSpec configSpec = new VirtualMachineConfigSpec();
+	    VirtualDeviceConfigSpec[] deviceConfigSpecArray = new VirtualDeviceConfigSpec[devices.length];
+	    int i = 0;
+	    for(Ternary<VirtualDevice, VirtualDeviceConfigSpecOperation, VirtualDeviceConfigSpecFileOperation> deviceTernary: devices) {
+	    	VirtualDeviceConfigSpec deviceConfigSpec = new VirtualDeviceConfigSpec();
+	    	deviceConfigSpec.setDevice(deviceTernary.first());
+	    	deviceConfigSpec.setOperation(deviceTernary.second());
+	    	deviceConfigSpec.setFileOperation(deviceTernary.third());
+	    	deviceConfigSpecArray[i++] = deviceConfigSpec;
+	    }
+	    configSpec.setDeviceChange(deviceConfigSpecArray);
+
+    	ManagedObjectReference morTask = _context.getService().reconfigVM_Task(_mor, configSpec);
+    	  
+  		String result = _context.getServiceUtil().waitForTask(morTask);
+		if(result.equals("sucess")) {
+			_context.waitForTaskProgressDone(morTask);
+			return true;
+		} else {
+        	s_logger.error("VMware reconfigVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		}
+		return false;
+	}
+	
+	public Pair<String, Integer> getVncPort(String hostNetworkName) throws Exception {
+		HostMO hostMo = getRunningHost();
+		VmwareHypervisorHostNetworkSummary summary = hostMo.getHyperHostNetworkSummary(hostNetworkName);
+
+		VirtualMachineConfigInfo configInfo = getConfigInfo();
+		OptionValue[] values = configInfo.getExtraConfig();
+		
+		if(values != null) {
+			for(OptionValue option : values) {
+				if(option.getKey().equals("RemoteDisplay.vnc.port")) {
+					String value = (String)option.getValue();
+					if(value != null) {
+                        return new Pair<String, Integer>(summary.getHostIp(), Integer.parseInt(value));
+                    }
+				}
+			}
+		}
+		return new Pair<String, Integer>(summary.getHostIp(), 0);
+	}
+	
+	// vmdkDatastorePath: [datastore name] vmdkFilePath
+	public void createDisk(String vmdkDatastorePath, int sizeInMb, ManagedObjectReference morDs, int controllerKey) throws Exception {
+		createDisk(vmdkDatastorePath, VirtualDiskType.thin, VirtualDiskMode.persistent, null, sizeInMb, morDs, controllerKey);
+	}
+	
+	// vmdkDatastorePath: [datastore name] vmdkFilePath
+	public void createDisk(String vmdkDatastorePath, VirtualDiskType diskType, VirtualDiskMode diskMode,
+		String rdmDeviceName, int sizeInMb, ManagedObjectReference morDs, int controllerKey) throws Exception {
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - createDisk(). target MOR: " + _mor.get_value() + ", vmdkDatastorePath: " + vmdkDatastorePath
+				+ ", sizeInMb: " + sizeInMb + ", diskType: " + diskType + ", diskMode: " + diskMode + ", rdmDeviceName: " + rdmDeviceName 
+				+ ", datastore: " + morDs.get_value() + ", controllerKey: " + controllerKey);
+		
+		assert(vmdkDatastorePath != null);
+		assert(morDs != null);
+		
+		if(controllerKey < 0) {
+            controllerKey = getIDEDeviceControllerKey();
+        }
+		
+		VirtualDisk newDisk = new VirtualDisk();
+		if(diskType == VirtualDiskType.thin || diskType == VirtualDiskType.preallocated
+			|| diskType == VirtualDiskType.eagerZeroedThick) {
+			
+			VirtualDiskFlatVer2BackingInfo backingInfo = new VirtualDiskFlatVer2BackingInfo();
+	        backingInfo.setDiskMode(diskMode.persistent.toString());
+	        if(diskType == VirtualDiskType.thin) {
+                backingInfo.setThinProvisioned(true);
+            } else {
+                backingInfo.setThinProvisioned(false);
+            }
+			
+	        if(diskType == VirtualDiskType.eagerZeroedThick) {
+                backingInfo.setEagerlyScrub(true);
+            } else {
+                backingInfo.setEagerlyScrub(false);
+            }
+	        
+	        backingInfo.setDatastore(morDs);
+	        backingInfo.setFileName(vmdkDatastorePath);
+	        newDisk.setBacking(backingInfo);
+		} else if(diskType == VirtualDiskType.rdm || diskType == VirtualDiskType.rdmp) {
+			VirtualDiskRawDiskMappingVer1BackingInfo backingInfo = 
+				new VirtualDiskRawDiskMappingVer1BackingInfo();   
+			if(diskType == VirtualDiskType.rdm) {
+				backingInfo.setCompatibilityMode("virtualMode");
+	        } else {
+	        	backingInfo.setCompatibilityMode("physicalMode");
+	        }
+	        backingInfo.setDeviceName(rdmDeviceName);
+	        if(diskType == VirtualDiskType.rdm) {
+	        	backingInfo.setDiskMode(diskMode.persistent.toString());
+	        }
+	          
+	        backingInfo.setDatastore(morDs);
+	        backingInfo.setFileName(vmdkDatastorePath);
+	        newDisk.setBacking(backingInfo);
+		}
+		
+		int deviceNumber = getNextDeviceNumber(controllerKey);
+		
+		newDisk.setControllerKey(controllerKey);
+	    newDisk.setKey(-deviceNumber);
+	    newDisk.setUnitNumber(deviceNumber);
+	    newDisk.setCapacityInKB(sizeInMb*1024);
+
+	    VirtualMachineConfigSpec reConfigSpec = new VirtualMachineConfigSpec();      
+	    VirtualDeviceConfigSpec[] deviceConfigSpecArray = new VirtualDeviceConfigSpec[1];
+	    VirtualDeviceConfigSpec deviceConfigSpec = new VirtualDeviceConfigSpec();
+	    
+	    deviceConfigSpec.setDevice(newDisk);
+	    deviceConfigSpec.setFileOperation(VirtualDeviceConfigSpecFileOperation.create);
+	    deviceConfigSpec.setOperation(VirtualDeviceConfigSpecOperation.add);
+	      
+	    deviceConfigSpecArray[0] = deviceConfigSpec;
+	    reConfigSpec.setDeviceChange(deviceConfigSpecArray);
+		
+	    ManagedObjectReference morTask = _context.getService().reconfigVM_Task(_mor, reConfigSpec);
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		
+		if(!result.equals("sucess")) {
+			if(s_logger.isTraceEnabled())
+				s_logger.trace("vCenter API trace - createDisk() done(failed)");
+			throw new Exception("Unable to create disk " + vmdkDatastorePath + " due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+        }
+	
+		_context.waitForTaskProgressDone(morTask);
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - createDisk() done(successfully)");
+	}
+	
+	public void attachDisk(String[] vmdkDatastorePathChain, ManagedObjectReference morDs) throws Exception {
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - attachDisk(). target MOR: " + _mor.get_value() + ", vmdkDatastorePath: " 
+				+ new Gson().toJson(vmdkDatastorePathChain) + ", datastore: " + morDs.get_value());
+		
+		VirtualDevice newDisk = VmwareHelper.prepareDiskDevice(this, getScsiDeviceControllerKey(), 
+			vmdkDatastorePathChain, morDs, -1, 1);
+	    VirtualMachineConfigSpec reConfigSpec = new VirtualMachineConfigSpec();      
+	    VirtualDeviceConfigSpec[] deviceConfigSpecArray = new VirtualDeviceConfigSpec[1];
+	    VirtualDeviceConfigSpec deviceConfigSpec = new VirtualDeviceConfigSpec();
+	    
+	    deviceConfigSpec.setDevice(newDisk);
+	    deviceConfigSpec.setOperation(VirtualDeviceConfigSpecOperation.add);
+	      
+	    deviceConfigSpecArray[0] = deviceConfigSpec;
+	    reConfigSpec.setDeviceChange(deviceConfigSpecArray);
+		
+	    ManagedObjectReference morTask = _context.getService().reconfigVM_Task(_mor, reConfigSpec);
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		
+		if(!result.equals("sucess")) {
+			if(s_logger.isTraceEnabled())
+				s_logger.trace("vCenter API trace - attachDisk() done(failed)"); 
+            throw new Exception("Failed to attach disk due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+        }
+	
+		_context.waitForTaskProgressDone(morTask);
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - attachDisk() done(successfully)"); 
+	}
+	
+	// vmdkDatastorePath: [datastore name] vmdkFilePath
+	public List<Pair<String, ManagedObjectReference>> detachDisk(String vmdkDatastorePath, boolean deleteBackingFile) throws Exception {
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - detachDisk(). target MOR: " + _mor.get_value() + ", vmdkDatastorePath: " 
+				+ vmdkDatastorePath + ", deleteBacking: " + deleteBackingFile);
+		
+		// Note: if VM has been taken snapshot, original backing file will be renamed, therefore, when we try to find the matching
+		// VirtualDisk, we only perform prefix matching
+		Pair<VirtualDisk, String> deviceInfo = getDiskDevice(vmdkDatastorePath, false);
+		if(deviceInfo == null) {
+			if(s_logger.isTraceEnabled())
+				s_logger.trace("vCenter API trace - detachDisk() done (failed)");
+			throw new Exception("No such disk device: " + vmdkDatastorePath);
+		}
+		
+		List<Pair<String, ManagedObjectReference>> chain = getDiskDatastorePathChain(deviceInfo.first(), true);
+		
+	    VirtualMachineConfigSpec reConfigSpec = new VirtualMachineConfigSpec();      
+	    VirtualDeviceConfigSpec[] deviceConfigSpecArray = new VirtualDeviceConfigSpec[1];
+	    VirtualDeviceConfigSpec deviceConfigSpec = new VirtualDeviceConfigSpec();
+	    
+	    deviceConfigSpec.setDevice(deviceInfo.first());
+	    if(deleteBackingFile) {
+            deviceConfigSpec.setFileOperation(VirtualDeviceConfigSpecFileOperation.destroy);
+        }
+	    deviceConfigSpec.setOperation(VirtualDeviceConfigSpecOperation.remove);
+	      
+	    deviceConfigSpecArray[0] = deviceConfigSpec;
+	    reConfigSpec.setDeviceChange(deviceConfigSpecArray);
+		
+	    ManagedObjectReference morTask = _context.getService().reconfigVM_Task(_mor, reConfigSpec);
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		
+		if(!result.equals("sucess")) {
+			if(s_logger.isTraceEnabled())
+				s_logger.trace("vCenter API trace - detachDisk() done (failed)");
+			
+            throw new Exception("Failed to detach disk due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+        }
+		_context.waitForTaskProgressDone(morTask);
+
+		// VMware does not update snapshot references to the detached disk, we have to work around it
+		SnapshotDescriptor snapshotDescriptor = null;
+		try {
+			snapshotDescriptor = getSnapshotDescriptor();
+		} catch(Exception e) {
+			s_logger.info("Unable to retrieve snapshot descriptor, will skip updating snapshot reference");
+		}
+		
+		if(snapshotDescriptor != null) {
+			for(Pair<String, ManagedObjectReference> pair: chain) {
+				DatastoreFile dsFile = new DatastoreFile(pair.first());
+				snapshotDescriptor.removeDiskReferenceFromSnapshot(dsFile.getFileName());
+			}
+			
+			Pair<DatacenterMO, String> dcPair = getOwnerDatacenter();
+			String dsPath = getSnapshotDescriptorDatastorePath();
+			assert(dsPath != null);
+			String url = getContext().composeDatastoreBrowseUrl(dcPair.second(), dsPath);
+			getContext().uploadResourceContent(url, snapshotDescriptor.getVmsdContent());
+		}
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - detachDisk() done (successfully)");
+		return chain;
+	}
+	
+	public void detachAllDisks() throws Exception {
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - detachAllDisk(). target MOR: " + _mor.get_value());
+		
+		VirtualDisk[] disks = getAllDiskDevice();
+		if(disks.length > 0) {
+		    VirtualMachineConfigSpec reConfigSpec = new VirtualMachineConfigSpec();      
+		    VirtualDeviceConfigSpec[] deviceConfigSpecArray = new VirtualDeviceConfigSpec[disks.length];
+		    
+			for(int i = 0; i < disks.length; i++) {
+				deviceConfigSpecArray[i] = new VirtualDeviceConfigSpec();
+				deviceConfigSpecArray[i].setDevice(disks[i]);
+				deviceConfigSpecArray[i].setOperation(VirtualDeviceConfigSpecOperation.remove);
+			}
+		    reConfigSpec.setDeviceChange(deviceConfigSpecArray);
+			
+		    ManagedObjectReference morTask = _context.getService().reconfigVM_Task(_mor, reConfigSpec);
+			String result = _context.getServiceUtil().waitForTask(morTask);
+			
+			if(!result.equals("sucess")) {
+				if(s_logger.isTraceEnabled())
+					s_logger.trace("vCenter API trace - detachAllDisk() done(failed)");
+				throw new Exception("Failed to detach disk due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+            }
+		
+			_context.waitForTaskProgressDone(morTask);
+		}
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - detachAllDisk() done(successfully)");
+	}
+	
+	// isoDatastorePath: [datastore name] isoFilePath
+	public void attachIso(String isoDatastorePath, ManagedObjectReference morDs,
+		boolean connect, boolean connectAtBoot) throws Exception {
+
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - detachIso(). target MOR: " + _mor.get_value() + ", isoDatastorePath: " 
+				+ isoDatastorePath + ", datastore: " + morDs.get_value() + ", connect: " + connect + ", connectAtBoot: " + connectAtBoot);
+		
+		assert(isoDatastorePath != null);
+		assert(morDs != null);
+
+		boolean newCdRom = false;
+		VirtualCdrom cdRom = (VirtualCdrom )getIsoDevice();
+		if(cdRom == null) {
+			newCdRom = true;
+			cdRom = new VirtualCdrom();
+			cdRom.setControllerKey(getIDEDeviceControllerKey());
+			
+			int deviceNumber = getNextIDEDeviceNumber();
+			cdRom.setUnitNumber(deviceNumber);            
+			cdRom.setKey(-deviceNumber);
+		}
+		
+	    VirtualDeviceConnectInfo cInfo = new VirtualDeviceConnectInfo();
+	    cInfo.setConnected(connect);
+	    cInfo.setStartConnected(connectAtBoot);
+	    cdRom.setConnectable(cInfo);
+	    
+        VirtualCdromIsoBackingInfo backingInfo = new VirtualCdromIsoBackingInfo();
+        backingInfo.setFileName(isoDatastorePath);
+        backingInfo.setDatastore(morDs);
+        cdRom.setBacking(backingInfo);
+
+	    VirtualMachineConfigSpec reConfigSpec = new VirtualMachineConfigSpec();      
+	    VirtualDeviceConfigSpec[] deviceConfigSpecArray = new VirtualDeviceConfigSpec[1];
+	    VirtualDeviceConfigSpec deviceConfigSpec = new VirtualDeviceConfigSpec();
+        
+        deviceConfigSpec.setDevice(cdRom);
+        if(newCdRom) {
+            deviceConfigSpec.setOperation(VirtualDeviceConfigSpecOperation.add);
+        } else {
+            deviceConfigSpec.setOperation(VirtualDeviceConfigSpecOperation.edit);
+        }
+           
+	    deviceConfigSpecArray[0] = deviceConfigSpec;
+	    reConfigSpec.setDeviceChange(deviceConfigSpecArray);
+		
+	    ManagedObjectReference morTask = _context.getService().reconfigVM_Task(_mor, reConfigSpec);
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		
+		if(!result.equals("sucess")) {
+			if(s_logger.isTraceEnabled())
+				s_logger.trace("vCenter API trace - detachIso() done(failed)");
+			throw new Exception("Failed to attach ISO due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+        }
+	
+		_context.waitForTaskProgressDone(morTask);
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - detachIso() done(successfully)");
+	}
+	
+	public void detachIso(String isoDatastorePath) throws Exception {
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - detachIso(). target MOR: " + _mor.get_value() + ", isoDatastorePath: " 
+				+ isoDatastorePath);
+
+		VirtualDevice device = getIsoDevice();
+		if(device == null) {
+			if(s_logger.isTraceEnabled())
+				s_logger.trace("vCenter API trace - detachIso() done(failed)");
+			throw new Exception("Unable to find a CDROM device");
+		}
+		
+		VirtualCdromRemotePassthroughBackingInfo backingInfo = new VirtualCdromRemotePassthroughBackingInfo();
+		backingInfo.setDeviceName("");
+		device.setBacking(backingInfo);
+		
+	    VirtualMachineConfigSpec reConfigSpec = new VirtualMachineConfigSpec();      
+	    VirtualDeviceConfigSpec[] deviceConfigSpecArray = new VirtualDeviceConfigSpec[1];
+	    VirtualDeviceConfigSpec deviceConfigSpec = new VirtualDeviceConfigSpec();
+	    
+	    deviceConfigSpec.setDevice(device);
+	    deviceConfigSpec.setOperation(VirtualDeviceConfigSpecOperation.edit);
+	      
+	    deviceConfigSpecArray[0] = deviceConfigSpec;
+	    reConfigSpec.setDeviceChange(deviceConfigSpecArray);
+		
+	    ManagedObjectReference morTask = _context.getService().reconfigVM_Task(_mor, reConfigSpec);
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		
+		if(!result.equals("sucess")) {
+			if(s_logger.isTraceEnabled())
+				s_logger.trace("vCenter API trace - detachIso() done(failed)");
+            throw new Exception("Failed to detachIso due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+        }
+		_context.waitForTaskProgressDone(morTask);
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - detachIso() done(successfully)");
+	}
+	
+	public Pair<VmdkFileDescriptor, byte[]> getVmdkFileInfo(String vmdkDatastorePath) throws Exception {
+		
+		if(s_logger.isTraceEnabled())
+			s_logger.trace("vCenter API trace - getVmdkFileInfo(). target MOR: " + _mor.get_value() + ", vmdkDatastorePath: " 
+				+ vmdkDatastorePath);
+		
+		Pair<DatacenterMO, String> dcPair = getOwnerDatacenter();
+		
+		String url = getContext().composeDatastoreBrowseUrl(dcPair.second(), vmdkDatastorePath);
+		byte[] content = getContext().getResourceContent(url);
+		VmdkFileDescriptor descriptor = new VmdkFileDescriptor();
+		descriptor.parse(content);
+		
+		Pair<VmdkFileDescriptor, byte[]> result = new Pair<VmdkFileDescriptor, byte[]>(descriptor, content);
+		if(s_logger.isTraceEnabled()) {
+			s_logger.trace("vCenter API trace - getVmdkFileInfo() done");
+			s_logger.trace("VMDK file descriptor: " + new Gson().toJson(result.first()));
+		}
+		return result;
+	}
+	
+	public void exportVm(String exportDir, String exportName, boolean packToOva, boolean leaveOvaFileOnly) throws Exception {
+		ManagedObjectReference morOvf = _context.getServiceContent().getOvfManager();
+		
+		VirtualMachineRuntimeInfo runtimeInfo = getRuntimeInfo();
+		HostMO hostMo = new HostMO(_context, runtimeInfo.getHost());
+		String hostName = hostMo.getHostName();
+		String vmName = getVmName();
+		
+		DatacenterMO dcMo = new DatacenterMO(_context, hostMo.getHyperHostDatacenter());
+		
+		if(runtimeInfo.getPowerState() != VirtualMachinePowerState.poweredOff) {
+			String msg = "Unable to export VM because it is not at powerdOff state. vmName: " + vmName + ", host: " + hostName;
+			s_logger.error(msg);
+			throw new Exception(msg);
+		}
+		
+		ManagedObjectReference morLease = _context.getService().exportVm(getMor());
+		if(morLease == null) {
+			s_logger.error("exportVm() failed");
+			throw new Exception("exportVm() failed");
+		}
+		
+		HttpNfcLeaseMO leaseMo = new HttpNfcLeaseMO(_context, morLease);
+		HttpNfcLeaseState state = leaseMo.waitState(new HttpNfcLeaseState[] { HttpNfcLeaseState.ready, HttpNfcLeaseState.error });
+		
+		try {
+			if(state == HttpNfcLeaseState.ready) {
+				final HttpNfcLeaseMO.ProgressReporter progressReporter = leaseMo.createProgressReporter();
+				try {
+					HttpNfcLeaseInfo leaseInfo = leaseMo.getLeaseInfo();
+					final long totalBytes = leaseInfo.getTotalDiskCapacityInKB() * 1024;
+					long totalBytesDownloaded = 0;
+					
+					HttpNfcLeaseDeviceUrl[] deviceUrls = leaseInfo.getDeviceUrl();
+					if(deviceUrls != null) {
+						List<String> fileNames = new ArrayList<String>();
+						
+						OvfFile[] ovfFiles = new OvfFile[deviceUrls.length];  
+						for (int i = 0; i < deviceUrls.length; i++) {  
+							String deviceId = deviceUrls[i].getKey();  
+						 	String deviceUrlStr = deviceUrls[i].getUrl();  
+						 	String orgDiskFileName = deviceUrlStr.substring(deviceUrlStr.lastIndexOf("/") + 1);
+						 	String diskFileName = String.format("%s-disk%d%s", exportName, i, VmwareHelper.getFileExtension(orgDiskFileName, ".vmdk"));
+						 	String diskUrlStr = deviceUrlStr.replace("*", hostName);
+						 	diskUrlStr = HypervisorHostHelper.resolveHostNameInUrl(dcMo, diskUrlStr);
+						 	String diskLocalPath = exportDir + File.separator + diskFileName;
+						 	fileNames.add(diskLocalPath);
+						 	
+						 	if(s_logger.isInfoEnabled()) {
+                                s_logger.info("Download VMDK file for export. url: " + deviceUrlStr);
+                            }
+						 	long lengthOfDiskFile = _context.downloadVmdkFile(diskUrlStr, diskLocalPath, totalBytesDownloaded, 
+						 		new ActionDelegate<Long> () {
+						 			@Override
+                                    public void action(Long param) {
+						 				if(s_logger.isTraceEnabled()) {
+                                            s_logger.trace("Download progress " + param + "/" + totalBytes);
+                                        }
+						 				progressReporter.reportProgress((int)(param * 100 / totalBytes));
+						 			}
+					  			});
+						 	totalBytesDownloaded += lengthOfDiskFile;
+						 	
+						 	OvfFile ovfFile = new OvfFile();
+						 	ovfFile.setPath(diskFileName);  
+						 	ovfFile.setDeviceId(deviceId);  
+						 	ovfFile.setSize(lengthOfDiskFile);  
+						 	ovfFiles[i] = ovfFile;  
+						}
+						
+						// write OVF descriptor file
+						OvfCreateDescriptorParams ovfDescParams = new OvfCreateDescriptorParams();  
+						ovfDescParams.setOvfFiles(ovfFiles);  
+						OvfCreateDescriptorResult ovfCreateDescriptorResult = _context.getService().createDescriptor(morOvf, getMor(), ovfDescParams);  
+						String ovfPath = exportDir + File.separator + exportName + ".ovf";
+						fileNames.add(ovfPath);
+		
+						FileWriter out = new FileWriter(ovfPath);
+						out.write(ovfCreateDescriptorResult.getOvfDescriptor());  
+						out.close();
+						
+						// tar files into OVA
+						if(packToOva) {
+					        Script command = new Script(false, "tar", 0, s_logger);
+					        command.setWorkDir(exportDir);
+					        command.add("-cf", exportName + ".ova");
+					        command.add(exportName + ".ovf");		// OVF file should be the first file in OVA archive
+					        for(String name: fileNames) {
+                                command.add((new File(name).getName()));
+                            }
+					        
+					        String result = command.execute();
+					        if(result == null) {
+					        	if(leaveOvaFileOnly) {
+							        for(String name: fileNames) {
+                                        new File(name).delete();
+                                    }
+					        	}
+					        }
+						}
+					}
+				} catch(Throwable e) {
+					s_logger.error("Unexpected exception ", e);
+				} finally {
+					progressReporter.close();
+				}
+			}
+		} finally {
+			leaseMo.updateLeaseProgress(100);
+			leaseMo.completeLease();
+		}
+	}
+	
+	// snapshot directory in format of: /vmfs/volumes/<datastore name>/<path>
+	@Deprecated
+	public void setSnapshotDirectory(String snapshotDir) throws Exception {
+		VirtualMachineFileInfo fileInfo = getFileInfo();
+		Pair<DatacenterMO, String> dcInfo = getOwnerDatacenter();
+		String vmxUrl = _context.composeDatastoreBrowseUrl(dcInfo.second(), fileInfo.getVmPathName());
+		byte[] vmxContent = _context.getResourceContent(vmxUrl);
+		
+		BufferedReader in = null;
+		BufferedWriter out = null;
+		ByteArrayOutputStream bos = new ByteArrayOutputStream();
+		
+		boolean replaced = false;
+		try {
+			in = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(vmxContent)));
+			out = new BufferedWriter(new OutputStreamWriter(bos)); 
+			String line;
+			while((line = in.readLine()) != null) {
+				if(line.startsWith("workingDir")) {
+					replaced = true;
+					out.write(String.format("workingDir=\"%s\"", snapshotDir));
+					out.newLine();
+				} else {
+					out.write(line);
+					out.newLine();
+				}
+			}
+			
+			if(!replaced) {
+				out.newLine();
+				out.write(String.format("workingDir=\"%s\"", snapshotDir));
+				out.newLine();
+			}
+		} finally {
+			if(in != null) {
+                in.close();
+            }
+			if(out != null) {
+                out.close();
+            }
+		}
+		_context.uploadResourceContent(vmxUrl, bos.toByteArray());
+
+		// It seems that I don't need to do re-registration. VMware has bug in writing the correct snapshot's VMDK path to
+		// its disk backing info anyway.
+		// redoRegistration();
+	}
+	
+	// destName does not contain extension name
+	public void backupCurrentSnapshot(String deviceName, ManagedObjectReference morDestDs, 
+		String destDsDirectory, String destName, boolean includeBase) throws Exception {
+		
+		SnapshotDescriptor descriptor = getSnapshotDescriptor();
+		SnapshotInfo[] snapshotInfo = descriptor.getCurrentDiskChain();
+		if(snapshotInfo.length == 0) {
+			String msg = "No snapshot found in this VM";
+			throw new Exception(msg);
+		}
+		
+		HostMO hostMo = getRunningHost();
+		DatacenterMO dcMo = getOwnerDatacenter().first();
+		List<Pair<ManagedObjectReference, String>> mounts = hostMo.getDatastoreMountsOnHost();
+		VirtualMachineFileInfo vmFileInfo = getFileInfo();
+		
+		List<Ternary<String, String, String>> backupInfo = new ArrayList<Ternary<String, String, String>>(); 
+		
+		for(int i = 0; i < snapshotInfo.length; i++) {
+			if(!includeBase && i == snapshotInfo.length - 1) {
+                break;
+            }
+			
+			SnapshotDescriptor.DiskInfo[] disks = snapshotInfo[i].getDisks();
+			if(disks != null) {
+				String destBaseFileName;
+				String destFileName;
+				String destParentFileName;
+				for(SnapshotDescriptor.DiskInfo disk : disks) {
+					if(deviceName == null || deviceName.equals(disk.getDeviceName())) {
+						String srcVmdkFullDsPath = getSnapshotDiskFileDatastorePath(vmFileInfo, 
+							mounts, disk.getDiskFileName());
+						Pair<DatastoreMO, String> srcDsInfo = getOwnerDatastore(srcVmdkFullDsPath);
+						
+						Pair<VmdkFileDescriptor, byte[]> vmdkInfo = getVmdkFileInfo(srcVmdkFullDsPath);
+						String srcVmdkBaseFilePath = DatastoreFile.getCompanionDatastorePath(
+							srcVmdkFullDsPath, vmdkInfo.first().getBaseFileName());
+
+						destFileName = destName + (snapshotInfo.length - i - 1)+ ".vmdk";
+						if(vmdkInfo.first().getParentFileName() != null) {
+							destBaseFileName = destName + (snapshotInfo.length - i - 1)+ "-delta.vmdk";
+							destParentFileName = destName + (snapshotInfo.length - i - 2)+ ".vmdk";
+						} else {
+							destBaseFileName = destName + (snapshotInfo.length - i - 1) + "-flat.vmdk";
+							destParentFileName = null;
+						}
+						
+						s_logger.info("Copy VMDK base file " + srcVmdkBaseFilePath + " to " + destDsDirectory + "/" + destBaseFileName);
+						srcDsInfo.first().copyDatastoreFile(srcVmdkBaseFilePath, dcMo.getMor(), 
+							morDestDs, destDsDirectory + "/" + destBaseFileName, dcMo.getMor(), true);
+						
+						byte[] newVmdkContent = VmdkFileDescriptor.changeVmdkContentBaseInfo(
+							vmdkInfo.second(), destBaseFileName, destParentFileName);
+						String vmdkUploadUrl = getContext().composeDatastoreBrowseUrl(dcMo.getName(), 
+							destDsDirectory + "/" + destFileName);
+						
+						s_logger.info("Upload VMDK content file to " + destDsDirectory + "/" + destFileName);
+						getContext().uploadResourceContent(vmdkUploadUrl, newVmdkContent);
+						
+						backupInfo.add(new Ternary<String, String, String>(
+							destFileName, destBaseFileName, destParentFileName)
+						);
+					}
+				}
+			}
+		}
+		
+		byte[] vdiskInfo = VmwareHelper.composeDiskInfo(backupInfo, snapshotInfo.length, includeBase);
+		String vdiskUploadUrl = getContext().composeDatastoreBrowseUrl(dcMo.getName(), 
+				destDsDirectory + "/" + destName + ".vdisk");
+		getContext().uploadResourceContent(vdiskUploadUrl, vdiskInfo);
+	}
+	
+	public String[] getCurrentSnapshotDiskChainDatastorePaths(String diskDevice) throws Exception {
+		HostMO hostMo = getRunningHost();
+		List<Pair<ManagedObjectReference, String>> mounts = hostMo.getDatastoreMountsOnHost();
+		VirtualMachineFileInfo vmFileInfo = getFileInfo();
+		
+		SnapshotDescriptor descriptor = getSnapshotDescriptor();
+		SnapshotInfo[] snapshotInfo = descriptor.getCurrentDiskChain();
+		
+		List<String> diskDsFullPaths = new ArrayList<String>();
+		for(int i = 0; i < snapshotInfo.length; i++) {
+			SnapshotDescriptor.DiskInfo[] disks = snapshotInfo[i].getDisks();
+			if(disks != null) {
+				for(SnapshotDescriptor.DiskInfo disk: disks) {
+					String deviceNameInDisk = disk.getDeviceName();
+					if(diskDevice == null || diskDevice.equalsIgnoreCase(deviceNameInDisk)) {
+						String vmdkFullDsPath = getSnapshotDiskFileDatastorePath(vmFileInfo, 
+								mounts, disk.getDiskFileName());
+						diskDsFullPaths.add(vmdkFullDsPath);
+					}
+				}
+			}
+		}
+		return diskDsFullPaths.toArray(new String[0]);
+	}
+	
+	public void cloneFromCurrentSnapshot(String clonedVmName, int cpuSpeedMHz, int memoryMb, String diskDevice, 
+		ManagedObjectReference morDs) throws Exception {
+		assert(morDs != null);
+		String[] disks = getCurrentSnapshotDiskChainDatastorePaths(diskDevice);
+		cloneFromDiskChain(clonedVmName, cpuSpeedMHz, memoryMb, disks, morDs);
+	}
+	
+	public void cloneFromDiskChain(String clonedVmName, int cpuSpeedMHz, int memoryMb, 
+		String[] disks, ManagedObjectReference morDs) throws Exception {
+		assert(disks != null);
+	    assert(disks.length >= 1);
+		
+		HostMO hostMo = getRunningHost();
+		VirtualMachineConfigInfo vmConfigInfo = getConfigInfo();
+		
+		hostMo.createBlankVm(clonedVmName, 1, cpuSpeedMHz, 0, false, memoryMb, vmConfigInfo.getGuestId(), morDs, false);
+		VirtualMachineMO clonedVmMo = hostMo.findVmOnHyperHost(clonedVmName);
+		
+		VirtualMachineConfigSpec vmConfigSpec = new VirtualMachineConfigSpec();
+	    VirtualDeviceConfigSpec[] deviceConfigSpecArray = new VirtualDeviceConfigSpec[1];
+	    deviceConfigSpecArray[0] = new VirtualDeviceConfigSpec();
+	    
+	    VirtualDevice device = VmwareHelper.prepareDiskDevice(clonedVmMo, -1, disks, morDs, -1, 1);
+	    
+	    deviceConfigSpecArray[0].setDevice(device);
+		deviceConfigSpecArray[0].setOperation(VirtualDeviceConfigSpecOperation.add);
+	    vmConfigSpec.setDeviceChange(deviceConfigSpecArray);
+	    clonedVmMo.configureVm(vmConfigSpec);
+	}
+	
+	public void plugDevice(VirtualDevice device) throws Exception {
+        VirtualMachineConfigSpec vmConfigSpec = new VirtualMachineConfigSpec();
+        VirtualDeviceConfigSpec[] deviceConfigSpecArray = new VirtualDeviceConfigSpec[1];
+        deviceConfigSpecArray[0] = new VirtualDeviceConfigSpec();
+        deviceConfigSpecArray[0].setDevice(device);
+        deviceConfigSpecArray[0].setOperation(VirtualDeviceConfigSpecOperation.add);
+        
+        vmConfigSpec.setDeviceChange(deviceConfigSpecArray);
+        if(!configureVm(vmConfigSpec)) {
+            throw new Exception("Failed to add devices");
+        }
+	}
+	
+	public void tearDownDevice(VirtualDevice device) throws Exception {
+        VirtualMachineConfigSpec vmConfigSpec = new VirtualMachineConfigSpec();
+        VirtualDeviceConfigSpec[] deviceConfigSpecArray = new VirtualDeviceConfigSpec[1];
+        deviceConfigSpecArray[0] = new VirtualDeviceConfigSpec();
+        deviceConfigSpecArray[0].setDevice(device);
+        deviceConfigSpecArray[0].setOperation(VirtualDeviceConfigSpecOperation.remove);
+        
+        vmConfigSpec.setDeviceChange(deviceConfigSpecArray);
+        if(!configureVm(vmConfigSpec)) {
+            throw new Exception("Failed to detach devices");
+        }
+	}
+	
+	public void tearDownDevices(Class<?>[] deviceClasses) throws Exception {
+		VirtualDevice[] devices = getMatchedDevices(deviceClasses);
+		if(devices.length > 0) {
+    		VirtualMachineConfigSpec vmConfigSpec = new VirtualMachineConfigSpec();
+    	    VirtualDeviceConfigSpec[] deviceConfigSpecArray = new VirtualDeviceConfigSpec[devices.length];
+    	    
+    	    for(int i = 0; i < devices.length; i++) {
+    	    	deviceConfigSpecArray[i] = new VirtualDeviceConfigSpec();
+    	    	deviceConfigSpecArray[i].setDevice(devices[i]);
+    	    	deviceConfigSpecArray[i].setOperation(VirtualDeviceConfigSpecOperation.remove);
+    	    }
+    	    
+    	    vmConfigSpec.setDeviceChange(deviceConfigSpecArray);
+    		if(!configureVm(vmConfigSpec)) {
+                throw new Exception("Failed to detach devices");
+            }
+		}
+	}
+	
+	public void copyAllVmDiskFiles(DatastoreMO destDsMo, String destDsDir, boolean followDiskChain) throws Exception {
+		VirtualDevice[] disks = getAllDiskDevice();
+		DatacenterMO dcMo = getOwnerDatacenter().first();
+		if(disks != null) {
+			for(VirtualDevice disk : disks) {
+				List<Pair<String, ManagedObjectReference>> vmdkFiles = this.getDiskDatastorePathChain((VirtualDisk)disk, followDiskChain);
+				for(Pair<String, ManagedObjectReference> fileItem : vmdkFiles) {
+					DatastoreMO srcDsMo = new DatastoreMO(_context, fileItem.second());
+					
+					DatastoreFile srcFile = new DatastoreFile(fileItem.first());
+					DatastoreFile destFile = new DatastoreFile(destDsMo.getName(), destDsDir, srcFile.getFileName());
+					
+					Pair<VmdkFileDescriptor, byte[]> vmdkDescriptor = null;
+					
+					vmdkDescriptor = getVmdkFileInfo(fileItem.first());
+					
+					s_logger.info("Copy VM disk file " + srcFile.getPath() + " to " + destFile.getPath());
+					srcDsMo.copyDatastoreFile(fileItem.first(), dcMo.getMor(), destDsMo.getMor(), 
+						destFile.getPath(), dcMo.getMor(), true);
+					
+					if(vmdkDescriptor != null) {
+						String vmdkBaseFileName = vmdkDescriptor.first().getBaseFileName();
+						String baseFilePath = srcFile.getCompanionPath(vmdkBaseFileName);
+						destFile = new DatastoreFile(destDsMo.getName(), destDsDir, vmdkBaseFileName);
+						
+						s_logger.info("Copy VM disk file " + baseFilePath + " to " + destFile.getPath());
+						srcDsMo.copyDatastoreFile(baseFilePath, dcMo.getMor(), destDsMo.getMor(), 
+							destFile.getPath(), dcMo.getMor(), true);
+					}
+				}
+			}
+		}
+	}
+
+	// this method relies on un-offical VMware API
+	@Deprecated
+	public void moveAllVmDiskFiles(DatastoreMO destDsMo, String destDsDir, boolean followDiskChain) throws Exception {
+		VirtualDevice[] disks = getAllDiskDevice();
+		DatacenterMO dcMo = getOwnerDatacenter().first();
+		if(disks != null) {
+			for(VirtualDevice disk : disks) {
+				List<Pair<String, ManagedObjectReference>> vmdkFiles = this.getDiskDatastorePathChain((VirtualDisk)disk, followDiskChain);
+				for(Pair<String, ManagedObjectReference> fileItem : vmdkFiles) {
+					DatastoreMO srcDsMo = new DatastoreMO(_context, fileItem.second());
+					
+					DatastoreFile srcFile = new DatastoreFile(fileItem.first());
+					DatastoreFile destFile = new DatastoreFile(destDsMo.getName(), destDsDir, srcFile.getFileName());
+					
+					Pair<VmdkFileDescriptor, byte[]> vmdkDescriptor = null;
+					vmdkDescriptor = getVmdkFileInfo(fileItem.first());
+					
+					s_logger.info("Move VM disk file " + srcFile.getPath() + " to " + destFile.getPath());
+					srcDsMo.moveDatastoreFile(fileItem.first(), dcMo.getMor(), destDsMo.getMor(), 
+						destFile.getPath(), dcMo.getMor(), true);
+					
+					if(vmdkDescriptor != null) {
+						String vmdkBaseFileName = vmdkDescriptor.first().getBaseFileName();
+						String baseFilePath = srcFile.getCompanionPath(vmdkBaseFileName);
+						destFile = new DatastoreFile(destDsMo.getName(), destDsDir, vmdkBaseFileName);
+						
+						s_logger.info("Move VM disk file " + baseFilePath + " to " + destFile.getPath());
+						srcDsMo.moveDatastoreFile(baseFilePath, dcMo.getMor(), destDsMo.getMor(), 
+							destFile.getPath(), dcMo.getMor(), true);
+					}
+				}
+			}
+		}
+	}
+	
+	public int getNextScsiDiskDeviceNumber() throws Exception {
+		int scsiControllerKey = getScsiDeviceControllerKey();
+		return getNextDeviceNumber(scsiControllerKey);
+	}
+	
+	public int getScsiDeviceControllerKey() throws Exception {
+	    VirtualDevice[] devices = (VirtualDevice [])_context.getServiceUtil().
+	    	getDynamicProperty(_mor, "config.hardware.device");
+		
+	    if(devices != null && devices.length > 0) {
+	    	for(VirtualDevice device : devices) {
+                if(device instanceof VirtualLsiLogicController) {
+                    return device.getKey();
+                }
+            }
+	    }
+	
+	    assert(false);
+	    throw new Exception("SCSI Controller Not Found");
+	}
+
+	// return pair of VirtualDisk and disk device bus name(ide0:0, etc)
+	public Pair<VirtualDisk, String> getDiskDevice(String vmdkDatastorePath, boolean matchExactly) throws Exception {
+		VirtualDevice[] devices = (VirtualDevice[])_context.getServiceUtil().getDynamicProperty(_mor, "config.hardware.device");
+		
+		s_logger.info("Look for disk device info from volume : " + vmdkDatastorePath);
+		DatastoreFile dsSrcFile = new DatastoreFile(vmdkDatastorePath);
+		String srcBaseName = dsSrcFile.getFileBaseName();
+		
+		if(devices != null && devices.length > 0) {
+			for(VirtualDevice device : devices) {
+				if(device instanceof VirtualDisk) {
+					s_logger.info("Test against disk device, controller key: " + device.getControllerKey() + ", unit number: " + device.getUnitNumber());
+					
+					VirtualDeviceBackingInfo backingInfo = ((VirtualDisk)device).getBacking();
+					if(backingInfo instanceof VirtualDiskFlatVer2BackingInfo) {
+						VirtualDiskFlatVer2BackingInfo diskBackingInfo = (VirtualDiskFlatVer2BackingInfo)backingInfo;
+						do {
+							s_logger.info("Test against disk backing : " + diskBackingInfo.getFileName());
+							
+							DatastoreFile dsBackingFile = new DatastoreFile(diskBackingInfo.getFileName());
+							String backingBaseName = dsBackingFile.getFileBaseName();
+							if(matchExactly) {
+								if(backingBaseName .equalsIgnoreCase(srcBaseName)) {
+									String deviceNumbering = getDeviceBusName(devices, device);
+									
+									s_logger.info("Disk backing : " + diskBackingInfo.getFileName() + " matches ==> " + deviceNumbering);
+									return new Pair<VirtualDisk, String>((VirtualDisk)device, deviceNumbering);
+								} 
+							} else {
+								if(backingBaseName.contains(srcBaseName)) {
+									String deviceNumbering = getDeviceBusName(devices, device);
+
+									s_logger.info("Disk backing : " + diskBackingInfo.getFileName() + " matches ==> " + deviceNumbering);
+									return new Pair<VirtualDisk, String>((VirtualDisk)device, deviceNumbering);
+								} 
+							}
+							
+							diskBackingInfo = diskBackingInfo.getParent();
+						} while(diskBackingInfo != null);
+					} 
+				}
+			}
+		}
+			
+		return null;
+	}
+	
+	@Deprecated
+	public List<Pair<String, ManagedObjectReference>> getDiskDatastorePathChain(VirtualDisk disk, boolean followChain) throws Exception {
+		VirtualDeviceBackingInfo backingInfo = disk.getBacking();
+		if(!(backingInfo instanceof VirtualDiskFlatVer2BackingInfo)) {
+            throw new Exception("Unsupported VirtualDeviceBackingInfo");
+        }
+
+		List<Pair<String, ManagedObjectReference>> pathList = new ArrayList<Pair<String, ManagedObjectReference>>();
+		VirtualDiskFlatVer2BackingInfo diskBackingInfo = (VirtualDiskFlatVer2BackingInfo)backingInfo;
+
+		if(!followChain) {
+			pathList.add(new Pair<String, ManagedObjectReference>(diskBackingInfo.getFileName(), diskBackingInfo.getDatastore()));
+			return pathList;
+		}
+		
+		Pair<DatacenterMO, String> dcPair = getOwnerDatacenter();
+		VirtualMachineFileInfo vmFilesInfo = getFileInfo();
+		DatastoreFile snapshotDirFile = new DatastoreFile(vmFilesInfo.getSnapshotDirectory());
+		DatastoreFile vmxDirFile = new DatastoreFile(vmFilesInfo.getVmPathName());
+		
+		do {
+			if(diskBackingInfo.getParent() != null) {
+				pathList.add(new Pair<String, ManagedObjectReference>(diskBackingInfo.getFileName(), diskBackingInfo.getDatastore()));
+				diskBackingInfo = diskBackingInfo.getParent();
+			} else {
+				// try getting parent info from VMDK file itself 
+				byte[] content = null;
+				try {
+					String url = getContext().composeDatastoreBrowseUrl(dcPair.second(), diskBackingInfo.getFileName());
+					content = getContext().getResourceContent(url);
+					if(content == null || content.length == 0) {
+                        break;
+                    }
+					
+					pathList.add(new Pair<String, ManagedObjectReference>(diskBackingInfo.getFileName(), diskBackingInfo.getDatastore()));
+				} catch(Exception e) {
+					// if snapshot directory has been changed to place other than default. VMware has a bug
+					// that its corresponding disk backing info is not updated correctly. therefore, we will try search
+					// in snapshot directory one more time
+					DatastoreFile currentFile = new DatastoreFile(diskBackingInfo.getFileName());
+					String vmdkFullDsPath = snapshotDirFile.getCompanionPath(currentFile.getFileName());
+					
+					String url = getContext().composeDatastoreBrowseUrl(dcPair.second(), vmdkFullDsPath);
+					content = getContext().getResourceContent(url);
+					if(content == null || content.length == 0) {
+                        break;
+                    }
+					
+					pathList.add(new Pair<String, ManagedObjectReference>(vmdkFullDsPath, diskBackingInfo.getDatastore()));
+				}
+					
+				VmdkFileDescriptor descriptor = new VmdkFileDescriptor();
+				descriptor.parse(content);
+				if(descriptor.getParentFileName() != null && !descriptor.getParentFileName().isEmpty()) {
+					// create a fake one
+					VirtualDiskFlatVer2BackingInfo parentDiskBackingInfo = new VirtualDiskFlatVer2BackingInfo();
+					parentDiskBackingInfo.setDatastore(diskBackingInfo.getDatastore());
+					
+					String parentFileName = descriptor.getParentFileName();
+					if(parentFileName.startsWith("/")) {
+						int fileNameStartPos = parentFileName.lastIndexOf("/");
+						parentFileName = parentFileName.substring(fileNameStartPos + 1);
+						parentDiskBackingInfo.setFileName(vmxDirFile.getCompanionPath(parentFileName));
+					} else {
+						parentDiskBackingInfo.setFileName(snapshotDirFile.getCompanionPath(parentFileName));
+					}
+					diskBackingInfo = parentDiskBackingInfo;  
+				} else {
+					break;
+				}
+			}
+		} while(diskBackingInfo != null);
+		
+		return pathList;
+	}
+	
+	private String getDeviceBusName(VirtualDevice[] allDevices, VirtualDevice theDevice) throws Exception {
+		for(VirtualDevice device : allDevices) {
+			if(device.getKey() == theDevice.getControllerKey().intValue()) {
+				if(device instanceof VirtualIDEController) {
+					return String.format("ide%d:%d", ((VirtualIDEController)device).getBusNumber(), theDevice.getUnitNumber());
+				} else if(device instanceof VirtualSCSIController) {
+					return String.format("scsi%d:%d", ((VirtualSCSIController)device).getBusNumber(), theDevice.getUnitNumber());
+				} else {
+					throw new Exception("Device controller is not supported yet");
+				}
+			}
+		}
+		throw new Exception("Unable to find device controller");
+	}
+	
+	public VirtualDisk[] getAllDiskDevice() throws Exception {
+		List<VirtualDisk> deviceList = new ArrayList<VirtualDisk>();
+		VirtualDevice[] devices = (VirtualDevice[])_context.getServiceUtil().getDynamicProperty(_mor, "config.hardware.device");
+		if(devices != null && devices.length > 0) {
+			for(VirtualDevice device : devices) {
+				if(device instanceof VirtualDisk) {
+					deviceList.add((VirtualDisk)device);
+				}
+			}
+		}
+		
+		return deviceList.toArray(new VirtualDisk[0]);
+	}
+
+	public VirtualDisk[] getAllIndependentDiskDevice() throws Exception {
+		List<VirtualDisk> independentDisks = new ArrayList<VirtualDisk>();
+		VirtualDisk[] allDisks = getAllDiskDevice();
+		if(allDisks.length > 0) {
+			for(VirtualDisk disk : allDisks) {
+	            String diskMode = "";
+	            if(disk.getBacking() instanceof VirtualDiskFlatVer1BackingInfo) {
+	            	diskMode = ((VirtualDiskFlatVer1BackingInfo)disk.getBacking()).getDiskMode();
+				} else if(disk.getBacking() instanceof VirtualDiskFlatVer2BackingInfo) {
+					diskMode = ((VirtualDiskFlatVer2BackingInfo)disk.getBacking()).getDiskMode();
+				} else if(disk.getBacking() instanceof VirtualDiskRawDiskMappingVer1BackingInfo) {
+					diskMode = ((VirtualDiskRawDiskMappingVer1BackingInfo)disk.getBacking()).getDiskMode();
+				} else if(disk.getBacking() instanceof VirtualDiskSparseVer1BackingInfo) {
+					diskMode = ((VirtualDiskSparseVer1BackingInfo)disk.getBacking()).getDiskMode();
+				} else if(disk.getBacking() instanceof VirtualDiskSparseVer2BackingInfo) {
+					diskMode = ((VirtualDiskSparseVer2BackingInfo)disk.getBacking()).getDiskMode();
+				}
+	            
+				if(diskMode.indexOf("independent") != -1) {
+					independentDisks.add(disk);
+				}
+			}
+		}
+		
+		return independentDisks.toArray(new VirtualDisk[0]);
+	}
+	
+	public int tryGetIDEDeviceControllerKey() throws Exception {
+	    VirtualDevice[] devices = (VirtualDevice [])_context.getServiceUtil().
+    		getDynamicProperty(_mor, "config.hardware.device");
+	
+	    if(devices != null && devices.length > 0) {
+	    	for(VirtualDevice device : devices) {
+	    		if(device instanceof VirtualIDEController) {
+	    			return ((VirtualIDEController)device).getKey();
+	    		}
+	    	}
+	    }
+	    
+		return -1;
+	}
+	
+	public int getIDEDeviceControllerKey() throws Exception {
+	    VirtualDevice[] devices = (VirtualDevice [])_context.getServiceUtil().
+	    	getDynamicProperty(_mor, "config.hardware.device");
+		
+	    if(devices != null && devices.length > 0) {
+	    	for(VirtualDevice device : devices) {
+	    		if(device instanceof VirtualIDEController) {
+	    			return ((VirtualIDEController)device).getKey();
+	    		}
+	    	}
+	    }
+	
+	    assert(false);
+	    throw new Exception("IDE Controller Not Found");
+	}
+	
+	public int getNextIDEDeviceNumber() throws Exception {
+		int controllerKey = getIDEDeviceControllerKey();
+		return getNextDeviceNumber(controllerKey);
+	}
+	
+	public VirtualDevice getIsoDevice() throws Exception {
+		VirtualDevice[] devices = (VirtualDevice[])_context.getServiceUtil().
+			getDynamicProperty(_mor, "config.hardware.device");
+		if(devices != null && devices.length > 0) {
+			for(VirtualDevice device : devices) {
+				if(device instanceof VirtualCdrom) {
+					return device;
+				}
+			}
+		}
+		return null;
+	}
+	
+	public int getPCIDeviceControllerKey() throws Exception {
+	    VirtualDevice[] devices = (VirtualDevice [])_context.getServiceUtil().
+	        getDynamicProperty(_mor, "config.hardware.device");
+	
+	    if(devices != null && devices.length > 0) {
+	    	for(VirtualDevice device : devices) {
+	    		if(device instanceof VirtualPCIController) {
+	    			return ((VirtualPCIController)device).getKey();
+	    		}
+	    	}
+	    }
+	    
+	    assert(false);
+	    throw new Exception("PCI Controller Not Found");
+	}
+	
+	public int getNextPCIDeviceNumber() throws Exception {
+		int controllerKey = getPCIDeviceControllerKey();
+		return getNextDeviceNumber(controllerKey);
+	}
+	
+	public int getNextDeviceNumber(int controllerKey) throws Exception {
+		VirtualDevice[] devices = (VirtualDevice[])_context.getServiceUtil().
+			getDynamicProperty(_mor, "config.hardware.device");
+		
+		int deviceNumber = -1;
+		if(devices != null && devices.length > 0) {
+			for(VirtualDevice device : devices) {
+				if(device.getControllerKey() != null && device.getControllerKey().intValue() == controllerKey) {
+					if(device.getUnitNumber() != null && device.getUnitNumber().intValue() > deviceNumber) {
+                        deviceNumber = device.getUnitNumber().intValue();
+                    }
+				}
+			}
+		}
+		return ++deviceNumber;
+	}
+	
+	public VirtualDevice[] getNicDevices() throws Exception {
+		VirtualDevice[] devices = (VirtualDevice[])_context.getServiceUtil().
+			getDynamicProperty(_mor, "config.hardware.device");
+		
+		List<VirtualDevice> nics = new ArrayList<VirtualDevice>();
+		if(devices != null) {
+			for(VirtualDevice device : devices) {
+				if(device instanceof VirtualEthernetCard) {
+                    nics.add(device);
+                }
+			}
+		}
+		
+		return nics.toArray(new VirtualDevice[0]);
+	}
+	
+	public Pair<Integer, VirtualDevice> getNicDeviceIndex(String networkNamePrefix) throws Exception {
+        VirtualDevice[] devices = (VirtualDevice[])_context.getServiceUtil().
+        getDynamicProperty(_mor, "config.hardware.device");
+        
+        List<VirtualDevice> nics = new ArrayList<VirtualDevice>();
+        if(devices != null) {
+            for(VirtualDevice device : devices) {
+                if(device instanceof VirtualEthernetCard) {
+                    nics.add(device);
+                }
+            }
+        }
+        
+        Collections.sort(nics, new Comparator<VirtualDevice>() {
+            @Override
+            public int compare(VirtualDevice arg0, VirtualDevice arg1) {
+                int unitNumber0 = arg0.getUnitNumber() != null ? arg0.getUnitNumber().intValue() : -1;
+                int unitNumber1 = arg1.getUnitNumber() != null ? arg1.getUnitNumber().intValue() : -1;
+                if(unitNumber0 < unitNumber1)
+                    return -1;
+                else if(unitNumber0 > unitNumber1)
+                    return 1;
+                return 0;
+            }
+        });
+	    
+        int index = 0; 
+        for(VirtualDevice nic : nics) {
+            if(((VirtualEthernetCard)nic).getDeviceInfo().getSummary().startsWith(networkNamePrefix))
+                return new Pair<Integer, VirtualDevice>(new Integer(index), nic);
+            index++;
+        }
+        return new Pair<Integer, VirtualDevice>(new Integer(-1), null);
+	}
+	
+	public VirtualDevice[] getMatchedDevices(Class<?>[] deviceClasses) throws Exception {
+		assert(deviceClasses != null);
+		
+		List<VirtualDevice> returnList = new ArrayList<VirtualDevice>();
+		
+		VirtualDevice[] devices = (VirtualDevice[])_context.getServiceUtil().
+			getDynamicProperty(_mor, "config.hardware.device");
+		
+		if(devices != null) {
+			for(VirtualDevice device : devices) {
+				for(Class<?> clz : deviceClasses) {
+					if(clz.isInstance(device)) {
+						returnList.add(device);
+						break;
+					}
+				}
+			}
+		}
+	
+		return returnList.toArray(new VirtualDevice[0]);
+	}
+	
+	public void mountToolsInstaller() throws Exception {
+		_context.getService().mountToolsInstaller(_mor);
+	}
+	
+	public void unmountToolsInstaller() throws Exception {
+		_context.getService().unmountToolsInstaller(_mor);
+	}
+	
+	public void redoRegistration(ManagedObjectReference morHost) throws Exception {
+		String vmName = getVmName();
+		VirtualMachineFileInfo vmFileInfo = getFileInfo();
+		boolean isTemplate = isTemplate();
+		
+		HostMO hostMo;
+		if(morHost != null)
+			hostMo = new HostMO(getContext(), morHost);
+		else
+			hostMo = getRunningHost();
+		
+		ManagedObjectReference morFolder = getParentMor();
+		ManagedObjectReference morPool = hostMo.getHyperHostOwnerResourcePool();
+		
+		_context.getService().unregisterVM(_mor);
+		
+		ManagedObjectReference morTask = _context.getService().registerVM_Task(
+    		 morFolder, 
+    		 vmFileInfo.getVmPathName(),
+    		 vmName, false, 
+    		 morPool, hostMo.getMor());
+			
+		String result = _context.getServiceUtil().waitForTask(morTask);
+		if (!result.equalsIgnoreCase("Sucess")) {
+			throw new Exception("Unable to register template due to " + TaskMO.getTaskFailureInfo(_context, morTask));
+		} else {
+			_context.waitForTaskProgressDone(morTask);
+			if(isTemplate) {
+				VirtualMachineMO vmNewRegistration = hostMo.findVmOnHyperHost(vmName);
+				assert(vmNewRegistration != null); 
+				vmNewRegistration.markAsTemplate();
+			}
+		}
+	}
+}
+
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmdkFileDescriptor.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmdkFileDescriptor.java
new file mode 100755
index 00000000000..f0109cba293
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmdkFileDescriptor.java
@@ -0,0 +1,146 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.Properties;
+
+import org.apache.log4j.Logger;
+
+public class VmdkFileDescriptor {
+    private static final Logger s_logger = Logger.getLogger(VmdkFileDescriptor.class);
+	
+	private Properties _properties = new Properties();
+	private String _baseFileName;
+	
+	public VmdkFileDescriptor() {
+	}
+	
+	public void parse(byte[] vmdkFileContent) throws IOException {
+		BufferedReader in = null;
+		try {
+			in = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(vmdkFileContent)));
+			String line;
+			while((line = in.readLine()) != null) {
+				// ignore empty and comment lines
+				line = line.trim();
+				if(line.isEmpty())
+					continue;
+				if(line.charAt(0) == '#')
+					continue;
+				
+				String[] tokens = line.split("=");
+				if(tokens.length == 2) {
+					String name = tokens[0].trim();
+					String value = tokens[1].trim();
+					if(value.charAt(0) == '\"')
+						value = value.substring(1, value.length() -1); 
+					
+					_properties.put(name, value);
+				} else {
+					if(line.startsWith("RW")) {
+						int startPos = line.indexOf('\"');
+						int endPos = line.lastIndexOf('\"');
+						assert(startPos > 0);
+						assert(endPos > 0);
+						
+						_baseFileName = line.substring(startPos + 1, endPos);
+					} else {
+						s_logger.warn("Unrecognized vmdk line content: " + line);
+					}
+				}
+			}
+		} finally {
+			if(in != null)
+				in.close();
+		}
+	}
+	
+	public String getBaseFileName() {
+		return _baseFileName;
+	}
+	
+	public String getParentFileName() {
+		return _properties.getProperty("parentFileNameHint");
+	}
+	
+	public static byte[] changeVmdkContentBaseInfo(byte[] vmdkContent, 
+		String baseFileName, String parentFileName) throws IOException {
+		
+		assert(vmdkContent != null);
+		
+		BufferedReader in = null;
+		BufferedWriter out = null;
+		ByteArrayOutputStream bos = new ByteArrayOutputStream();
+		
+		try {
+			in = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(vmdkContent)));
+			out = new BufferedWriter(new OutputStreamWriter(bos)); 
+			String line;
+			while((line = in.readLine()) != null) {
+				// ignore empty and comment lines
+				line = line.trim();
+				if(line.isEmpty()) {
+					out.newLine();
+					continue;
+				}
+				if(line.charAt(0) == '#') {
+					out.write(line);
+					out.newLine();
+					continue;
+				}
+			
+				String[] tokens = line.split("=");
+				if(tokens.length == 2) {
+					String name = tokens[0].trim();
+					String value = tokens[1].trim();
+					if(value.charAt(0) == '\"')
+						value = value.substring(1, value.length() - 1);
+					
+					if(parentFileName != null && name.equals("parentFileNameHint")) {
+						out.write(name + "=\"" + parentFileName + "\"");
+						out.newLine();
+					} else {
+						out.write(line);
+						out.newLine();
+					}
+				} else {
+					if(line.startsWith("RW")) {
+						if(baseFileName != null) {
+							int startPos = line.indexOf('\"');
+							int endPos = line.lastIndexOf('\"');
+							assert(startPos > 0);
+							assert(endPos > 0);
+							
+							// replace it with base file name
+							out.write(line.substring(0, startPos + 1));
+							out.write(baseFileName);
+							out.write(line.substring(endPos));
+							out.newLine();
+						} else {
+							out.write(line);
+							out.newLine();
+						}
+					} else {
+						s_logger.warn("Unrecognized vmdk line content: " + line);
+					}
+				}
+			}
+		} finally {
+			if(in != null)
+				in.close();
+			if(out != null)
+				out.close();
+		}
+		
+		return bos.toByteArray();
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmwareHostType.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmwareHostType.java
new file mode 100644
index 00000000000..4f6a4daddcb
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmwareHostType.java
@@ -0,0 +1,8 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+package com.cloud.hypervisor.vmware.mo;
+
+public enum VmwareHostType {
+	ESXi, ESX
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmwareHypervisorHost.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmwareHypervisorHost.java
new file mode 100755
index 00000000000..3796bc0c1d1
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmwareHypervisorHost.java
@@ -0,0 +1,57 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+import com.cloud.hypervisor.vmware.util.VmwareContext;
+import com.vmware.vim25.ClusterDasConfigInfo;
+import com.vmware.vim25.ComputeResourceSummary;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.ObjectContent;
+import com.vmware.vim25.VirtualMachineConfigSpec;
+
+/**
+ * Interface to consolidate ESX(i) hosts and HA/FT clusters into a common interface used by Cloud.com Hypervisor resources  
+ */
+public interface VmwareHypervisorHost {
+	VmwareContext getContext();
+	ManagedObjectReference getMor();
+	
+	String getHyperHostName() throws Exception;
+	
+	ClusterDasConfigInfo getDasConfig() throws Exception;
+	
+	ManagedObjectReference getHyperHostDatacenter() throws Exception;
+	ManagedObjectReference getHyperHostOwnerResourcePool() throws Exception;
+	ManagedObjectReference getHyperHostCluster() throws Exception;
+	
+	boolean isHyperHostConnected() throws Exception;
+	String getHyperHostDefaultGateway() throws Exception;
+	
+	VirtualMachineMO findVmOnHyperHost(String name) throws Exception;
+	VirtualMachineMO findVmOnPeerHyperHost(String name) throws Exception;
+	
+	boolean createVm(VirtualMachineConfigSpec vmSpec) throws Exception;
+	boolean createBlankVm(String vmName, int cpuCount, int cpuSpeedMHz, int cpuReservedMHz, boolean limitCpuUse, int memoryMB, 
+		String guestOsIdentifier, ManagedObjectReference morDs, boolean snapshotDirToParent) throws Exception;
+	void importVmFromOVF(String ovfFilePath, String vmName, DatastoreMO dsMo, String diskOption) throws Exception;
+
+	ObjectContent[] getVmPropertiesOnHyperHost(String[] propertyPaths) throws Exception;
+	ObjectContent[] getDatastorePropertiesOnHyperHost(String[] propertyPaths) throws Exception;
+	
+	ManagedObjectReference mountDatastore(boolean vmfsDatastore, String poolHostAddress, 
+		int poolHostPort, String poolPath, String poolUuid) throws Exception;
+	void unmountDatastore(String poolUuid) throws Exception;
+	
+	ManagedObjectReference findDatastore(String poolUuid) throws Exception;
+	
+	@Deprecated
+	ManagedObjectReference findDatastoreByExportPath(String exportPath) throws Exception;
+	
+	ManagedObjectReference findMigrationTarget(VirtualMachineMO vmMo) throws Exception;
+	
+	VmwareHypervisorHostResourceSummary getHyperHostResourceSummary() throws Exception;
+	VmwareHypervisorHostNetworkSummary getHyperHostNetworkSummary(String esxServiceConsolePort) throws Exception;
+	ComputeResourceSummary getHyperHostHardwareSummary() throws Exception;
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmwareHypervisorHostNetworkSummary.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmwareHypervisorHostNetworkSummary.java
new file mode 100755
index 00000000000..5f065368b1f
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmwareHypervisorHostNetworkSummary.java
@@ -0,0 +1,38 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+public class VmwareHypervisorHostNetworkSummary {
+	private String hostIp;
+	private String hostNetmask;
+	private String hostMacAddress;
+
+	public VmwareHypervisorHostNetworkSummary() {
+	}
+	
+	public String getHostIp() {
+		return hostIp;
+	}
+	
+	public void setHostIp(String hostIp) {
+		this.hostIp = hostIp;
+	}
+	
+	public String getHostNetmask() {
+		return hostNetmask;
+	}
+	
+	public void setHostNetmask(String hostNetmask) {
+		this.hostNetmask = hostNetmask;
+	}
+	
+	public String getHostMacAddress() {
+		return hostMacAddress;
+	}
+	
+	public void setHostMacAddress(String hostMacAddress) {
+		this.hostMacAddress = hostMacAddress;
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmwareHypervisorHostResourceSummary.java b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmwareHypervisorHostResourceSummary.java
new file mode 100755
index 00000000000..02485c7b060
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/mo/VmwareHypervisorHostResourceSummary.java
@@ -0,0 +1,38 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.mo;
+
+public class VmwareHypervisorHostResourceSummary {
+	private long memoryBytes;
+	private long cpuCount;
+	private long cpuSpeed;
+
+	public VmwareHypervisorHostResourceSummary() {
+	}
+	
+	public long getMemoryBytes() {
+		return memoryBytes;
+	}
+	
+	public void setMemoryBytes(long memoryBytes) {
+		this.memoryBytes = memoryBytes;
+	}
+	
+	public long getCpuCount() {
+		return cpuCount;
+	}
+	
+	public void setCpuCount(long cpuCount) {
+		this.cpuCount = cpuCount;
+	}
+	
+	public long getCpuSpeed() {
+		return cpuSpeed;
+	}
+	
+	public void setCpuSpeed(long cpuSpeed) {
+		this.cpuSpeed = cpuSpeed;
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/util/VmwareContext.java b/vmware-base/src/com/cloud/hypervisor/vmware/util/VmwareContext.java
new file mode 100755
index 00000000000..6fc068d57cf
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/util/VmwareContext.java
@@ -0,0 +1,593 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.util;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.SSLSession;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.mo.DatacenterMO;
+import com.cloud.hypervisor.vmware.mo.DatastoreFile;
+import com.cloud.utils.ActionDelegate;
+import com.vmware.apputils.version.ExtendedAppUtil;
+import com.vmware.apputils.vim25.ServiceConnection;
+import com.vmware.apputils.vim25.ServiceUtil;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.ObjectContent;
+import com.vmware.vim25.ObjectSpec;
+import com.vmware.vim25.PropertyFilterSpec;
+import com.vmware.vim25.PropertySpec;
+import com.vmware.vim25.SelectionSpec;
+import com.vmware.vim25.ServiceContent;
+import com.vmware.vim25.TaskInfo;
+import com.vmware.vim25.TraversalSpec;
+import com.vmware.vim25.VimPortType;
+
+public class VmwareContext {
+    private static final Logger s_logger = Logger.getLogger(VmwareContext.class);
+	
+	private ExtendedAppUtil _appUtil;
+	private String _serverAddress;
+	
+	private Map<String, Object> _stockMap = new HashMap<String, Object>();
+	
+	static {
+		try {
+			javax.net.ssl.TrustManager[] trustAllCerts = new javax.net.ssl.TrustManager[1]; 
+			javax.net.ssl.TrustManager tm = new TrustAllManager(); 
+			trustAllCerts[0] = tm; 
+			javax.net.ssl.SSLContext sc = javax.net.ssl.SSLContext.getInstance("SSL"); 
+			sc.init(null, trustAllCerts, null); 
+			javax.net.ssl.HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
+		} catch (Exception e) {
+			s_logger.error("Unexpected exception ", e);
+		}
+	}
+	
+	public VmwareContext(ExtendedAppUtil appUtil, String address) {
+		assert(appUtil != null) : "Invalid parameter in constructing VmwareContext object";
+		
+		_appUtil = appUtil;
+		_serverAddress = address;
+	}
+
+	public void registerStockObject(String name, Object obj) {
+		synchronized(_stockMap) {
+			_stockMap.put(name, obj);
+		}
+	}
+	
+	public void uregisterStockObject(String name) {
+		synchronized(_stockMap) {
+			_stockMap.remove(name);
+		}
+	}
+	
+	@SuppressWarnings("unchecked")
+	public <T> T getStockObject(String name) {
+		synchronized(_stockMap) {
+			return (T)_stockMap.get(name);
+		}
+	}
+	
+	public String getServerAddress() {
+		return _serverAddress;
+	}
+	
+	public ServiceConnection getServiceConnection() {
+		return _appUtil.getServiceConnection3();
+	}
+	
+	public VimPortType getService() {
+		return getServiceConnection().getService();
+	}
+	
+	public ServiceContent getServiceContent() {
+		return getServiceConnection().getServiceContent();
+	}
+	
+	public ServiceUtil getServiceUtil() {
+		return _appUtil.getServiceUtil3(); 
+	}
+	
+	public ManagedObjectReference getRootFolder() {
+		return getServiceContent().getRootFolder();
+	}
+	
+	public ManagedObjectReference getHostMorByPath(String inventoryPath) throws Exception {
+		assert(inventoryPath != null);
+		
+		String[] tokens;
+		if(inventoryPath.startsWith("/"))
+			tokens = inventoryPath.substring(1).split("/");
+		else
+			tokens = inventoryPath.split("/");
+		
+		ManagedObjectReference mor = getRootFolder();
+		for(int i=0; i < tokens.length;i++) {
+			String token = tokens[i];
+			ObjectContent[] ocs;
+			if(mor.getType().equalsIgnoreCase("Datacenter")) {
+				PropertySpec pSpec = new PropertySpec();
+				pSpec.setType("ManagedEntity");
+				pSpec.setPathSet(new String[] { "name" });
+				
+			    TraversalSpec dcHostFolderTraversal = new TraversalSpec();
+			    dcHostFolderTraversal.setType("Datacenter");
+			    dcHostFolderTraversal.setPath("hostFolder");
+			    dcHostFolderTraversal.setName("dcHostFolderTraversal");
+
+			    ObjectSpec oSpec = new ObjectSpec();
+			    oSpec.setObj(mor);
+			    oSpec.setSkip(Boolean.TRUE);
+			    oSpec.setSelectSet(new SelectionSpec[] { dcHostFolderTraversal });
+
+			    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+			    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+			    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+			    ocs = getService().retrieveProperties(
+			    	getServiceContent().getPropertyCollector(), 
+			    	new PropertyFilterSpec[] { pfSpec });
+				
+			} else if(mor.getType().equalsIgnoreCase("Folder")) {
+				PropertySpec pSpec = new PropertySpec();
+				pSpec.setType("ManagedEntity");
+				pSpec.setPathSet(new String[] { "name" });
+				
+			    TraversalSpec folderChildrenTraversal = new TraversalSpec();
+			    folderChildrenTraversal.setType("Folder");
+			    folderChildrenTraversal.setPath("childEntity");
+			    folderChildrenTraversal.setName("folderChildrenTraversal");
+
+			    ObjectSpec oSpec = new ObjectSpec();
+			    oSpec.setObj(mor);
+			    oSpec.setSkip(Boolean.TRUE);
+			    oSpec.setSelectSet(new SelectionSpec[] { folderChildrenTraversal });
+
+			    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+			    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+			    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+			    
+			    ocs = getService().retrieveProperties(
+			    	getServiceContent().getPropertyCollector(), 
+			    	new PropertyFilterSpec[] { pfSpec });
+			} else if(mor.getType().equalsIgnoreCase("ClusterComputeResource")) {
+				PropertySpec pSpec = new PropertySpec();
+				pSpec.setType("ManagedEntity");
+				pSpec.setPathSet(new String[] { "name" });
+				
+			    TraversalSpec clusterHostTraversal = new TraversalSpec();
+			    clusterHostTraversal.setType("ClusterComputeResource");
+			    clusterHostTraversal.setPath("host");
+			    clusterHostTraversal.setName("folderChildrenTraversal");
+
+			    ObjectSpec oSpec = new ObjectSpec();
+			    oSpec.setObj(mor);
+			    oSpec.setSkip(Boolean.TRUE);
+			    oSpec.setSelectSet(new SelectionSpec[] { clusterHostTraversal });
+
+			    PropertyFilterSpec pfSpec = new PropertyFilterSpec();
+			    pfSpec.setPropSet(new PropertySpec[] { pSpec });
+			    pfSpec.setObjectSet(new ObjectSpec[] { oSpec });
+			    
+			    ocs = getService().retrieveProperties(
+			    	getServiceContent().getPropertyCollector(), 
+			    	new PropertyFilterSpec[] { pfSpec });
+			} else {
+				s_logger.error("Invalid inventory path, path element can only be datacenter and folder");
+				return null;
+			}
+			
+		    if(ocs != null && ocs.length > 0) {
+		    	boolean found = false;
+		    	for(ObjectContent oc : ocs) {
+		    		String name = oc.getPropSet()[0].getVal().toString();		    		
+		    		if(name.equalsIgnoreCase(token) || name.equalsIgnoreCase("host")) {
+		    			mor = oc.getObj();
+		    			found  = true;
+		    			if (name.equalsIgnoreCase("host"))
+		    				i--;
+		    			break;
+		    		}
+		    	}
+		    	if(!found) {
+					s_logger.error("Path element points to an un-existing inventory entity");
+			    	return null;
+		    	}
+		    } else {
+				s_logger.error("Path element points to an un-existing inventory entity");
+		    	return null;
+		    }
+		}
+		return mor;
+	}
+
+	// path in format of <datacenter name>/<datastore name>
+	public ManagedObjectReference getDatastoreMorByPath(String inventoryPath) throws Exception {
+		assert(inventoryPath != null);
+		
+		String[] tokens;
+		if(inventoryPath.startsWith("/"))
+			tokens = inventoryPath.substring(1).split("/");
+		else
+			tokens = inventoryPath.split("/");
+		
+		if(tokens == null || tokens.length != 2) {
+			s_logger.error("Invalid datastore inventory path. path: " + inventoryPath);
+			return null;
+		}
+			
+		DatacenterMO dcMo = new DatacenterMO(this, tokens[0]);
+		if(dcMo.getMor() == null) {
+			s_logger.error("Unable to locate the datacenter specified in path: " + inventoryPath);
+			return null;
+		}
+		
+		return dcMo.findDatastore(tokens[1]);
+	}
+	
+	public void waitForTaskProgressDone(ManagedObjectReference morTask) throws Exception {
+		while(true) {
+			TaskInfo tinfo = (TaskInfo)getServiceUtil().getDynamicProperty(morTask, "info");
+			Integer progress = tinfo.getProgress();
+			if(progress == null)
+				break;
+			
+			if(progress.intValue() >= 100)
+				break;
+			
+			Thread.sleep(1000);
+		}
+	}
+	
+	public void getFile(String urlString, String localFileFullName) throws Exception {
+		HttpURLConnection conn = getHTTPConnection(urlString);
+		
+	    InputStream in = conn.getInputStream();
+	    OutputStream out = new FileOutputStream(new File(localFileFullName));
+	    byte[] buf = new byte[102400];
+	    int len = 0;
+	    while ((len = in.read(buf)) > 0) {
+	    	out.write(buf, 0, len);
+	    }
+	    in.close();
+	    out.close();              
+	}
+	
+	public void uploadFile(String urlString, String localFileFullName) throws Exception {
+		uploadFile(urlString, new File(localFileFullName));
+	}
+	
+	public void uploadFile(String urlString, File localFile) throws Exception {
+		HttpURLConnection conn = getHTTPConnection(urlString, "PUT");
+		OutputStream out = null;
+		InputStream in = null;
+		BufferedReader br = null;
+		
+		try {
+		    out = conn.getOutputStream();
+		    in = new FileInputStream(localFile);
+		    byte[] buf = new byte[102400];
+		    int len = 0;
+		    while ((len = in.read(buf)) > 0) {
+		    	out.write(buf, 0, len);
+		    }
+		    out.flush();
+		    
+			br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
+		    String line;
+		    while ((line = br.readLine()) != null) {
+		    	if(s_logger.isTraceEnabled())
+		    		s_logger.trace("Upload " + urlString + " response: " + line);
+		    }
+		} finally {
+			if(in != null)
+				in.close();
+			
+			if(out != null)
+				out.close();
+			
+			if(br != null)
+				br.close();
+		}
+	}
+	
+	public void uploadVmdkFile(String httpMethod, String urlString, String localFileName, 
+		long totalBytesUpdated, ActionDelegate progressUpdater) throws Exception {
+		
+		HttpURLConnection conn = getRawHTTPConnection(urlString);
+		
+		conn.setDoOutput(true);
+		conn.setUseCaches(false);
+		
+		int CHUCK_LEN = 64*1024;
+		conn.setChunkedStreamingMode(CHUCK_LEN);  
+		conn.setRequestMethod(httpMethod);  
+		conn.setRequestProperty("Connection", "Keep-Alive");  
+		conn.setRequestProperty("Content-Type", "application/x-vnd.vmware-streamVmdk");  
+		conn.setRequestProperty("Content-Length", Long.toString(new File(localFileName).length()));
+		conn.connect();
+		
+		BufferedOutputStream bos = null;
+		BufferedInputStream is = null;
+		try {
+			bos = new BufferedOutputStream(conn.getOutputStream());  
+			is = new BufferedInputStream(new FileInputStream(localFileName));  
+			int bytesAvailable = is.available();  
+			int bufferSize = Math.min(bytesAvailable, CHUCK_LEN);  
+			byte[] buffer = new byte[bufferSize];  
+			while (true) {  
+				int bytesRead = is.read(buffer, 0, bufferSize);  
+				if (bytesRead == -1) {  
+					break;  
+				}  
+				bos.write(buffer, 0, bufferSize);
+				totalBytesUpdated += bytesRead;
+				bos.flush();
+				if(progressUpdater != null)
+					progressUpdater.action(new Long(totalBytesUpdated));
+			}
+		 	bos.flush();
+		} finally {
+			if(is != null)
+				is.close();
+			if(bos != null)
+				bos.close();
+			
+		 	conn.disconnect();
+		}
+	}
+	
+	public long downloadVmdkFile(String urlString, String localFileName, 
+			long totalBytesDownloaded, ActionDelegate progressUpdater) throws Exception {
+		HttpURLConnection conn = getRawHTTPConnection(urlString);
+		
+		String cookieString = getServiceCookie();
+	    conn.setRequestProperty(org.apache.axis.transport.http.HTTPConstants.HEADER_COOKIE, cookieString);
+	    conn.setDoInput(true);
+	    conn.setDoOutput(true);  
+	    conn.setAllowUserInteraction(true);
+	    conn.connect();
+
+    	long bytesWritten = 0;  
+	    InputStream in = null;  
+	    OutputStream out = null;  
+	    try {
+	    	in = conn.getInputStream();  
+	    	out = new FileOutputStream(new File(localFileName));  
+	    
+	    	byte[] buf = new byte[64*1024];  
+	    	int len = 0;  
+	    	while ((len = in.read(buf)) > 0) {  
+	    		out.write(buf, 0, len);  
+	    		bytesWritten += len;
+	    		totalBytesDownloaded += len;
+	    	
+	    		if(progressUpdater != null)
+	    			progressUpdater.action(new Long(totalBytesDownloaded));
+	    	}  
+	    } catch(Throwable e) {
+	    	s_logger.error("Unexpected exception ", e);
+	    } finally {
+	    	if(in != null)
+	    		in.close();
+	    	if(out != null)
+	    		out.close();
+	    	
+	    	conn.disconnect();
+	    }
+	    return bytesWritten; 
+	}
+	
+	public byte[] getResourceContent(String urlString) throws Exception {
+		HttpURLConnection conn = getHTTPConnection(urlString);
+	    InputStream in = conn.getInputStream();
+	    
+	    ByteArrayOutputStream out = new ByteArrayOutputStream();
+	    byte[] buf = new byte[102400];
+	    int len = 0;
+	    while ((len = in.read(buf)) > 0) {
+	    	out.write(buf, 0, len);
+	    }
+	    in.close();
+	    out.close();              
+	    return out.toByteArray();
+	}
+	
+	public void uploadResourceContent(String urlString, byte[] content) throws Exception {
+		// vSphere does not support POST
+		HttpURLConnection conn = getHTTPConnection(urlString, "PUT");
+
+		OutputStream out = conn.getOutputStream();
+		out.write(content);
+		out.flush();
+		
+		BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
+	    String line;
+	    while ((line = in.readLine()) != null) {
+	    	if(s_logger.isTraceEnabled())
+	    		s_logger.trace("Upload " + urlString + " response: " + line);
+	    }
+	    out.close();
+	    in.close();
+	}
+	
+	/*
+	 * Sample content returned by query a datastore directory
+	 * 
+	 * Url for the query
+	 * 	https://vsphere-1.lab.vmops.com/folder/Fedora-clone-test?dcPath=cupertino&dsName=NFS+datastore
+	 *
+	 * Returned conent from vSphere
+	 * 
+	    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+	    <html>
+	      <head>
+	        <meta http-equiv="content-type" content="text/html; charset=utf-8">
+	        <title>Index of Fedora-clone-test on datastore NFS datastore in datacenter cupertino</title></head>
+	      <body>
+	    <h1>Index of Fedora-clone-test on datastore NFS datastore in datacenter cupertino</h1>
+	    <table>
+		    <tr><th>Name</th><th>Last modified</th><th>Size</th></tr><tr><th colspan="3"><hr></th></tr>
+		    <tr><td><a href="/folder?dcPath=cupertino&amp;dsName=NFS%20datastore">Parent Directory</a></td><td>&nbsp;</td><td align="right">  - </td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/Fedora%2dclone%2dtest%2da2013465%2ehlog?dcPath=cupertino&amp;dsName=NFS%20datastore">Fedora-clone-test-a2013465.hlog</a></td><td align="right">15-Aug-2010 00:13</td><td align="right">1</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/Fedora%2dclone%2dtest%2da2013465%2evswp?dcPath=cupertino&amp;dsName=NFS%20datastore">Fedora-clone-test-a2013465.vswp</a></td><td align="right">14-Aug-2010 23:01</td><td align="right">402653184</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/Fedora%2dclone%2dtest%2dflat%2evmdk?dcPath=cupertino&amp;dsName=NFS%20datastore">Fedora-clone-test-flat.vmdk</a></td><td align="right">26-Aug-2010 18:43</td><td align="right">17179869184</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/Fedora%2dclone%2dtest%2envram?dcPath=cupertino&amp;dsName=NFS%20datastore">Fedora-clone-test.nvram</a></td><td align="right">15-Aug-2010 00:13</td><td align="right">8684</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/Fedora%2dclone%2dtest%2evmdk?dcPath=cupertino&amp;dsName=NFS%20datastore">Fedora-clone-test.vmdk</a></td><td align="right">15-Aug-2010 00:13</td><td align="right">479</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/Fedora%2dclone%2dtest%2evmsd?dcPath=cupertino&amp;dsName=NFS%20datastore">Fedora-clone-test.vmsd</a></td><td align="right">14-Aug-2010 16:59</td><td align="right">0</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/Fedora%2dclone%2dtest%2evmx?dcPath=cupertino&amp;dsName=NFS%20datastore">Fedora-clone-test.vmx</a></td><td align="right">15-Aug-2010 00:13</td><td align="right">3500</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/Fedora%2dclone%2dtest%2evmxf?dcPath=cupertino&amp;dsName=NFS%20datastore">Fedora-clone-test.vmxf</a></td><td align="right">15-Aug-2010 00:13</td><td align="right">272</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/test%2etxt?dcPath=cupertino&amp;dsName=NFS%20datastore">test.txt</a></td><td align="right">24-Aug-2010 01:03</td><td align="right">12</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/vmware%2d2%2elog?dcPath=cupertino&amp;dsName=NFS%20datastore">vmware-2.log</a></td><td align="right">14-Aug-2010 16:51</td><td align="right">80782</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/vmware%2d3%2elog?dcPath=cupertino&amp;dsName=NFS%20datastore">vmware-3.log</a></td><td align="right">14-Aug-2010 19:07</td><td align="right">58573</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/vmware%2d4%2elog?dcPath=cupertino&amp;dsName=NFS%20datastore">vmware-4.log</a></td><td align="right">14-Aug-2010 23:00</td><td align="right">49751</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/vmware%2d5%2elog?dcPath=cupertino&amp;dsName=NFS%20datastore">vmware-5.log</a></td><td align="right">15-Aug-2010 00:04</td><td align="right">64024</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/vmware%2d6%2elog?dcPath=cupertino&amp;dsName=NFS%20datastore">vmware-6.log</a></td><td align="right">15-Aug-2010 00:11</td><td align="right">59742</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/vmware%2d7%2elog?dcPath=cupertino&amp;dsName=NFS%20datastore">vmware-7.log</a></td><td align="right">15-Aug-2010 00:13</td><td align="right">59859</td></tr>
+		    <tr><td><a href="/folder/Fedora%2dclone%2dtest/vmware%2elog?dcPath=cupertino&amp;dsName=NFS%20datastore">vmware.log</a></td><td align="right">15-Aug-2010 00:23</td><td align="right">47157</td></tr>
+		    <tr><th colspan="5"><hr></th></tr>
+	    </table>
+	      </body>
+	    </html>
+	*/    
+	public String[] listDatastoreDirContent(String urlString) throws Exception {
+		List<String> fileList = new ArrayList<String>();
+		String content = new String(getResourceContent(urlString));
+    	String marker = "</a></td><td ";
+    	int parsePos = -1;
+    	do {
+    		parsePos = content.indexOf(marker, parsePos < 0 ? 0 : parsePos);
+    		if(parsePos > 0) {
+    			int beginPos = content.lastIndexOf('>', parsePos -1);
+    			if(beginPos < 0)
+    				beginPos = 0;
+    			
+    			fileList.add((content.substring(beginPos + 1, parsePos)));
+    			parsePos += marker.length();
+    		} else {
+    			break;
+    		}
+    	} while(parsePos > 0);
+		return fileList.toArray(new String[0]);
+	}
+
+	public String composeDatastoreBrowseUrl(String dcName, String fullPath) {
+		DatastoreFile dsFile = new DatastoreFile(fullPath);
+		return composeDatastoreBrowseUrl(dcName, dsFile.getDatastoreName(), dsFile.getRelativePath());
+	}
+	
+	public String composeDatastoreBrowseUrl(String dcName, String datastoreName, String relativePath) {
+		assert(relativePath != null);
+		assert(datastoreName != null);
+		
+		StringBuffer sb = new StringBuffer();
+		sb.append("https://");
+		sb.append(_serverAddress);
+		sb.append("/folder/");
+		sb.append(relativePath);
+		sb.append("?dcPath=").append(URLEncoder.encode(dcName)).append("&dsName=");
+		sb.append(URLEncoder.encode(datastoreName));
+		return sb.toString();
+	}
+	
+	public HttpURLConnection getHTTPConnection(String urlString) throws Exception {
+		return getHTTPConnection(urlString, "GET");
+	}
+	
+	public HttpURLConnection getHTTPConnection(String urlString, String httpMethod) throws Exception {
+		String cookieString = getServiceCookie();
+	    HostnameVerifier hv = new HostnameVerifier() {
+	    	public boolean verify(String urlHostName, SSLSession session) {
+	    		return true;
+	        }
+	    };
+	      
+	    HttpsURLConnection.setDefaultHostnameVerifier(hv);           
+	    URL url = new URL(urlString);      
+	    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
+	      
+	    conn.setDoInput(true);
+	    conn.setDoOutput(true);
+	    conn.setAllowUserInteraction(true);
+	    conn.setRequestProperty(org.apache.axis.transport.http.HTTPConstants.HEADER_COOKIE, cookieString);
+	    conn.setRequestMethod(httpMethod);
+	    conn.connect();
+	    return conn;
+	}
+	
+	public HttpURLConnection getRawHTTPConnection(String urlString) throws Exception {
+	    HostnameVerifier hv = new HostnameVerifier() {
+	    	public boolean verify(String urlHostName, SSLSession session) {
+	    		return true;
+	        }
+	    };
+	      
+	    HttpsURLConnection.setDefaultHostnameVerifier(hv);           
+	    URL url = new URL(urlString);      
+	    return (HttpURLConnection)url.openConnection();
+	}
+
+	private String getServiceCookie() throws Exception {
+		com.vmware.vim25.VimPortType service = getService();
+		org.apache.axis.client.Stub st = (org.apache.axis.client.Stub)service;
+		org.apache.axis.client.Call callObj = st._getCall();
+		org.apache.axis.MessageContext msgContext = callObj.getMessageContext();
+		String cookieString = (String)msgContext.getProperty(org.apache.axis.transport.http.HTTPConstants.HEADER_COOKIE);
+		return cookieString;
+	}
+	
+	public void close() {
+		try {
+			_appUtil.disConnect();
+		} catch(Exception e) {
+			s_logger.warn("Unexpected exception: ", e);
+		}
+	}
+
+	public static class TrustAllManager implements javax.net.ssl.TrustManager, javax.net.ssl.X509TrustManager {
+		public java.security.cert.X509Certificate[] getAcceptedIssuers() {
+			return null;
+		}
+		
+		public boolean isServerTrusted(java.security.cert.X509Certificate[] certs) {
+			return true;
+		}
+		
+		public boolean isClientTrusted(java.security.cert.X509Certificate[] certs) {
+			return true;
+		}
+		
+		public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType)
+          	throws java.security.cert.CertificateException {
+			return;
+		}
+		
+		public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType)
+          	throws java.security.cert.CertificateException {
+			return;
+		}
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/util/VmwareGuestOsMapper.java b/vmware-base/src/com/cloud/hypervisor/vmware/util/VmwareGuestOsMapper.java
new file mode 100755
index 00000000000..c7a1890c626
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/util/VmwareGuestOsMapper.java
@@ -0,0 +1,97 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.util;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.vmware.vim25.VirtualMachineGuestOsIdentifier;
+
+public class VmwareGuestOsMapper {
+	private static Map<String, VirtualMachineGuestOsIdentifier> s_mapper = new HashMap<String, VirtualMachineGuestOsIdentifier>();
+	static {
+		s_mapper.put("Windows 7 (32-bit)", VirtualMachineGuestOsIdentifier.windows7Guest);
+		s_mapper.put("Windows 7 (64-bit)", VirtualMachineGuestOsIdentifier.windows7_64Guest);
+		s_mapper.put("Windows Server 2003 Enterprise Edition(32-bit)", VirtualMachineGuestOsIdentifier.winNetEnterpriseGuest);
+		s_mapper.put("Windows Server 2003 Enterprise Edition(64-bit)", VirtualMachineGuestOsIdentifier.winNetEnterprise64Guest);
+		s_mapper.put("Windows Server 2008 (32-bit)", VirtualMachineGuestOsIdentifier.winLonghornGuest);
+		s_mapper.put("Windows Server 2008 (64-bit)", VirtualMachineGuestOsIdentifier.winLonghorn64Guest);
+		s_mapper.put("Windows Server 2008 R2 (64-bit)", VirtualMachineGuestOsIdentifier.winLonghorn64Guest);
+		s_mapper.put("Windows 2000 Server SP4 (32-bit)", VirtualMachineGuestOsIdentifier.win2000ServGuest);
+		s_mapper.put("Windows Vista (32-bit)", VirtualMachineGuestOsIdentifier.winVistaGuest);
+		s_mapper.put("Windows XP SP2 (32-bit)", VirtualMachineGuestOsIdentifier.winXPProGuest);
+		s_mapper.put("Windows XP SP3 (32-bit)", VirtualMachineGuestOsIdentifier.winXPProGuest);
+		s_mapper.put("Other Ubuntu (32-bit)", VirtualMachineGuestOsIdentifier.ubuntuGuest);
+		s_mapper.put("Other (32-bit)", VirtualMachineGuestOsIdentifier.otherGuest);
+		s_mapper.put("Windows 2000 Server", VirtualMachineGuestOsIdentifier.win2000ServGuest);
+		s_mapper.put("Windows 98", VirtualMachineGuestOsIdentifier.win98Guest);
+		s_mapper.put("Windows 95", VirtualMachineGuestOsIdentifier.win95Guest);
+		s_mapper.put("Windows NT 4", VirtualMachineGuestOsIdentifier.winNTGuest);
+		s_mapper.put("Windows 3.1", VirtualMachineGuestOsIdentifier.win31Guest);
+		s_mapper.put("Red Hat Enterprise Linux 3(32-bit)", VirtualMachineGuestOsIdentifier.rhel3Guest);
+		s_mapper.put("Red Hat Enterprise Linux 3(64-bit)", VirtualMachineGuestOsIdentifier.rhel3_64Guest);
+		s_mapper.put("Open Enterprise Server", VirtualMachineGuestOsIdentifier.oesGuest);
+		s_mapper.put("Asianux 3(32-bit)", VirtualMachineGuestOsIdentifier.asianux3Guest);
+		s_mapper.put("Asianux 3(64-bit)", VirtualMachineGuestOsIdentifier.asianux3_64Guest);
+		s_mapper.put("Debian GNU/Linux 5(64-bit)", VirtualMachineGuestOsIdentifier.debian5_64Guest);
+		s_mapper.put("Debian GNU/Linux 4(32-bit)", VirtualMachineGuestOsIdentifier.debian4Guest);
+		s_mapper.put("Debian GNU/Linux 4(64-bit)", VirtualMachineGuestOsIdentifier.debian4_64Guest);
+		s_mapper.put("Other 2.6x Linux (32-bit)", VirtualMachineGuestOsIdentifier.other26xLinuxGuest);
+		s_mapper.put("Other 2.6x Linux (64-bit)", VirtualMachineGuestOsIdentifier.other26xLinux64Guest);
+		s_mapper.put("Novell Netware 6.x", VirtualMachineGuestOsIdentifier.netware6Guest);
+		s_mapper.put("Novell Netware 5.1", VirtualMachineGuestOsIdentifier.netware5Guest);
+		s_mapper.put("Sun Solaris 10(32-bit)", VirtualMachineGuestOsIdentifier.solaris10Guest);
+		s_mapper.put("Sun Solaris 10(64-bit)", VirtualMachineGuestOsIdentifier.solaris10_64Guest);
+		s_mapper.put("Sun Solaris 9(Experimental)", VirtualMachineGuestOsIdentifier.solaris9Guest);
+		s_mapper.put("Sun Solaris 8(Experimental)", VirtualMachineGuestOsIdentifier.solaris8Guest);
+		s_mapper.put("FreeBSD (32-bit)", VirtualMachineGuestOsIdentifier.freebsdGuest);
+		s_mapper.put("FreeBSD (64-bit)", VirtualMachineGuestOsIdentifier.freebsd64Guest);
+		s_mapper.put("SCO OpenServer 5", VirtualMachineGuestOsIdentifier.otherGuest);
+		s_mapper.put("SCO UnixWare 7", VirtualMachineGuestOsIdentifier.unixWare7Guest);
+		s_mapper.put("Windows Server 2003 DataCenter Edition(32-bit)", VirtualMachineGuestOsIdentifier.winNetDatacenterGuest);
+		s_mapper.put("Windows Server 2003 DataCenter Edition(64-bit)", VirtualMachineGuestOsIdentifier.winNetDatacenter64Guest);
+		s_mapper.put("Windows Server 2003 Standard Edition(32-bit)", VirtualMachineGuestOsIdentifier.winNetStandardGuest);
+		s_mapper.put("Windows Server 2003 Standard Edition(64-bit)", VirtualMachineGuestOsIdentifier.winNetStandard64Guest);
+		s_mapper.put("Windows Server 2003 Web Edition", VirtualMachineGuestOsIdentifier.winNetWebGuest);
+		s_mapper.put("Microsoft Small Bussiness Server 2003", VirtualMachineGuestOsIdentifier.winNetBusinessGuest);
+		s_mapper.put("Windows XP (32-bit)", VirtualMachineGuestOsIdentifier.winXPProGuest);
+		s_mapper.put("Windows XP (64-bit)", VirtualMachineGuestOsIdentifier.winXPPro64Guest);
+		s_mapper.put("Windows 2000 Advanced Server", VirtualMachineGuestOsIdentifier.win2000AdvServGuest);
+		s_mapper.put("SUSE Linux Enterprise 8(32-bit)", VirtualMachineGuestOsIdentifier.suseGuest);
+		s_mapper.put("SUSE Linux Enterprise 8(64-bit)", VirtualMachineGuestOsIdentifier.suse64Guest);
+		s_mapper.put("Other Linux (32-bit)", VirtualMachineGuestOsIdentifier.otherLinuxGuest);
+		s_mapper.put("Other Linux (64-bit)", VirtualMachineGuestOsIdentifier.otherLinux64Guest);
+		s_mapper.put("Other Ubuntu (64-bit)", VirtualMachineGuestOsIdentifier.ubuntu64Guest);
+		s_mapper.put("Windows Vista (64-bit)", VirtualMachineGuestOsIdentifier.winVista64Guest);
+		s_mapper.put("DOS", VirtualMachineGuestOsIdentifier.dosGuest);
+		s_mapper.put("Other (64-bit)", VirtualMachineGuestOsIdentifier.otherGuest64);
+		s_mapper.put("OS/2", VirtualMachineGuestOsIdentifier.os2Guest);
+		s_mapper.put("Windows 2000 Professional", VirtualMachineGuestOsIdentifier.win2000ProGuest);
+		s_mapper.put("Red Hat Enterprise Linux 4(64-bit)", VirtualMachineGuestOsIdentifier.rhel4_64Guest);
+		s_mapper.put("SUSE Linux Enterprise 9(32-bit)", VirtualMachineGuestOsIdentifier.suseGuest);
+		s_mapper.put("SUSE Linux Enterprise 9(64-bit)", VirtualMachineGuestOsIdentifier.suse64Guest);
+		s_mapper.put("SUSE Linux Enterprise 10(32-bit)", VirtualMachineGuestOsIdentifier.suseGuest);
+		s_mapper.put("SUSE Linux Enterprise 10(64-bit)", VirtualMachineGuestOsIdentifier.suse64Guest);
+		s_mapper.put("CentOS 5.5 (32-bit)", VirtualMachineGuestOsIdentifier.centosGuest);
+		s_mapper.put("CentOS 5.5 (64-bit)", VirtualMachineGuestOsIdentifier.centos64Guest);
+		s_mapper.put("Red Hat Enterprise Linux 5.5 (32-bit)", VirtualMachineGuestOsIdentifier.rhel5Guest);
+		s_mapper.put("Red Hat Enterprise Linux 5.5 (64-bit)", VirtualMachineGuestOsIdentifier.rhel5_64Guest);
+		s_mapper.put("Red Hat Enterprise Linux 2", VirtualMachineGuestOsIdentifier.rhel2Guest);
+		s_mapper.put("Ubuntu 10.04 (32-bit)", VirtualMachineGuestOsIdentifier.ubuntuGuest);
+		s_mapper.put("Ubuntu 9.10 (32-bit)", VirtualMachineGuestOsIdentifier.ubuntuGuest);
+		s_mapper.put("Ubuntu 9.04 (32-bit)", VirtualMachineGuestOsIdentifier.ubuntuGuest);
+		s_mapper.put("Ubuntu 8.10 (32-bit)", VirtualMachineGuestOsIdentifier.ubuntuGuest);
+		s_mapper.put("Ubuntu 8.04 (32-bit)", VirtualMachineGuestOsIdentifier.ubuntuGuest);
+		s_mapper.put("Ubuntu 10.04 (64-bit)", VirtualMachineGuestOsIdentifier.ubuntu64Guest);
+		s_mapper.put("Ubuntu 9.10 (64-bit)", VirtualMachineGuestOsIdentifier.ubuntu64Guest);
+		s_mapper.put("Ubuntu 9.04 (64-bit)", VirtualMachineGuestOsIdentifier.ubuntu64Guest);
+		s_mapper.put("Ubuntu 8.10 (64-bit)", VirtualMachineGuestOsIdentifier.ubuntu64Guest);
+		s_mapper.put("Ubuntu 8.04 (64-bit)", VirtualMachineGuestOsIdentifier.ubuntu64Guest);
+	}
+	
+	public static VirtualMachineGuestOsIdentifier getGuestOsIdentifier(String guestOsName) {
+		return s_mapper.get(guestOsName);
+	}
+}
diff --git a/vmware-base/src/com/cloud/hypervisor/vmware/util/VmwareHelper.java b/vmware-base/src/com/cloud/hypervisor/vmware/util/VmwareHelper.java
new file mode 100755
index 00000000000..178ee337ddd
--- /dev/null
+++ b/vmware-base/src/com/cloud/hypervisor/vmware/util/VmwareHelper.java
@@ -0,0 +1,513 @@
+/**
+ *  Copyright (C) 2011 Cloud.com, Inc.  All rights reserved.
+ */
+
+package com.cloud.hypervisor.vmware.util;
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.hypervisor.vmware.mo.DatacenterMO;
+import com.cloud.hypervisor.vmware.mo.DatastoreMO;
+import com.cloud.hypervisor.vmware.mo.HostMO;
+import com.cloud.hypervisor.vmware.mo.VirtualEthernetCardType;
+import com.cloud.hypervisor.vmware.mo.VirtualMachineMO;
+import com.cloud.utils.Pair;
+import com.cloud.utils.Ternary;
+import com.cloud.utils.exception.ExceptionUtil;
+import com.vmware.vim25.DynamicProperty;
+import com.vmware.vim25.ManagedObjectReference;
+import com.vmware.vim25.MethodFault;
+import com.vmware.vim25.ObjectContent;
+import com.vmware.vim25.OptionValue;
+import com.vmware.vim25.ResourceAllocationInfo;
+import com.vmware.vim25.VirtualCdrom;
+import com.vmware.vim25.VirtualCdromIsoBackingInfo;
+import com.vmware.vim25.VirtualCdromRemotePassthroughBackingInfo;
+import com.vmware.vim25.VirtualDevice;
+import com.vmware.vim25.VirtualDeviceBackingInfo;
+import com.vmware.vim25.VirtualDeviceConnectInfo;
+import com.vmware.vim25.VirtualDisk;
+import com.vmware.vim25.VirtualDiskFlatVer1BackingInfo;
+import com.vmware.vim25.VirtualDiskFlatVer2BackingInfo;
+import com.vmware.vim25.VirtualDiskMode;
+import com.vmware.vim25.VirtualDiskRawDiskMappingVer1BackingInfo;
+import com.vmware.vim25.VirtualDiskSparseVer1BackingInfo;
+import com.vmware.vim25.VirtualDiskSparseVer2BackingInfo;
+import com.vmware.vim25.VirtualE1000;
+import com.vmware.vim25.VirtualEthernetCard;
+import com.vmware.vim25.VirtualEthernetCardNetworkBackingInfo;
+import com.vmware.vim25.VirtualMachineConfigSpec;
+import com.vmware.vim25.VirtualMachineSnapshotTree;
+import com.vmware.vim25.VirtualPCNet32;
+import com.vmware.vim25.VirtualVmxnet2;
+import com.vmware.vim25.VirtualVmxnet3;
+
+public class VmwareHelper {
+    private static final Logger s_logger = Logger.getLogger(VmwareHelper.class);
+	
+	public static VirtualDevice prepareNicDevice(VirtualMachineMO vmMo, ManagedObjectReference morNetwork, VirtualEthernetCardType deviceType,
+		String portGroupName, String macAddress, int deviceNumber, int contextNumber, boolean conntected, boolean connectOnStart) throws Exception {
+		
+		VirtualEthernetCard nic;
+		switch(deviceType) {
+		case E1000 :
+			nic = new VirtualE1000();
+			break;
+			
+		case PCNet32 :
+			nic = new VirtualPCNet32();
+			break;
+			
+		case Vmxnet2 :
+			nic = new VirtualVmxnet2();
+			break;
+			
+		case Vmxnet3 :
+			nic = new VirtualVmxnet3();
+			break;
+			
+		default :
+			assert(false);
+			nic = new VirtualE1000();
+		}
+		
+		VirtualEthernetCardNetworkBackingInfo nicBacking = new VirtualEthernetCardNetworkBackingInfo();
+		nicBacking.setDeviceName(portGroupName);
+		nicBacking.setNetwork(morNetwork);
+		nic.setBacking(nicBacking);
+		
+		VirtualDeviceConnectInfo connectInfo = new VirtualDeviceConnectInfo();
+		connectInfo.setAllowGuestControl(true);
+		connectInfo.setConnected(conntected);
+		connectInfo.setStartConnected(connectOnStart);
+		nic.setAddressType("Manual");
+		nic.setConnectable(connectInfo);
+		nic.setMacAddress(macAddress);
+		nic.setControllerKey(vmMo.getPCIDeviceControllerKey());
+		
+		if(deviceNumber < 0)
+			deviceNumber = vmMo.getNextPCIDeviceNumber();
+		nic.setUnitNumber(deviceNumber);
+		nic.setKey(-contextNumber);
+		return nic;
+	}
+	
+	// vmdkDatastorePath: [datastore name] vmdkFilePath
+	public static VirtualDevice prepareDiskDevice(VirtualMachineMO vmMo, int controllerKey, String vmdkDatastorePath, 
+		int sizeInMb, ManagedObjectReference morDs, int deviceNumber, int contextNumber) throws Exception {
+		
+		if(controllerKey < 0)
+			controllerKey = vmMo.getIDEDeviceControllerKey();
+		
+		VirtualDisk disk = new VirtualDisk();
+
+		VirtualDiskFlatVer2BackingInfo backingInfo = new VirtualDiskFlatVer2BackingInfo();
+        backingInfo.setDiskMode(VirtualDiskMode.persistent.toString());
+    	backingInfo.setThinProvisioned(true);
+    	backingInfo.setEagerlyScrub(false);
+        backingInfo.setDatastore(morDs);
+        backingInfo.setFileName(vmdkDatastorePath);
+        disk.setBacking(backingInfo);
+
+        if(deviceNumber < 0)
+        	deviceNumber = vmMo.getNextDeviceNumber(controllerKey);
+		disk.setControllerKey(controllerKey);
+	    disk.setKey(-contextNumber);
+	    disk.setUnitNumber(deviceNumber);
+	    disk.setCapacityInKB(sizeInMb*1024);
+
+	    VirtualDeviceConnectInfo connectInfo = new VirtualDeviceConnectInfo();
+	    connectInfo.setConnected(true);
+	    connectInfo.setStartConnected(true);
+	    disk.setConnectable(connectInfo);
+	    
+	    return disk;
+	}
+
+	// vmdkDatastorePath: [datastore name] vmdkFilePath, create delta disk based on disk from template
+	public static VirtualDevice prepareDiskDevice(VirtualMachineMO vmMo, int controllerKey, String vmdkDatastorePath, 
+		int sizeInMb, ManagedObjectReference morDs, VirtualDisk templateDisk, int deviceNumber, int contextNumber) throws Exception {
+		
+		assert(templateDisk != null);
+		VirtualDeviceBackingInfo parentBacking = templateDisk.getBacking();
+		assert(parentBacking != null);
+		
+		// TODO Not sure if we need to check if the disk in template and the new disk needs to share the 
+		// same datastore
+		VirtualDisk disk = new VirtualDisk();
+		if(parentBacking instanceof VirtualDiskFlatVer1BackingInfo) {
+			VirtualDiskFlatVer1BackingInfo backingInfo = new VirtualDiskFlatVer1BackingInfo();
+	        backingInfo.setDiskMode(((VirtualDiskFlatVer1BackingInfo)parentBacking).getDiskMode());
+	        backingInfo.setDatastore(morDs);
+	        backingInfo.setFileName(vmdkDatastorePath);
+	        backingInfo.setParent((VirtualDiskFlatVer1BackingInfo)parentBacking);
+	        disk.setBacking(backingInfo);
+		} else if(parentBacking instanceof VirtualDiskFlatVer2BackingInfo) {
+			VirtualDiskFlatVer2BackingInfo backingInfo = new VirtualDiskFlatVer2BackingInfo();
+	        backingInfo.setDiskMode(((VirtualDiskFlatVer2BackingInfo)parentBacking).getDiskMode());
+	        backingInfo.setDatastore(morDs);
+	        backingInfo.setFileName(vmdkDatastorePath);
+	        backingInfo.setParent((VirtualDiskFlatVer2BackingInfo)parentBacking);
+	        disk.setBacking(backingInfo);
+		} else if(parentBacking instanceof VirtualDiskRawDiskMappingVer1BackingInfo) {
+			VirtualDiskRawDiskMappingVer1BackingInfo backingInfo = new VirtualDiskRawDiskMappingVer1BackingInfo();
+	        backingInfo.setDiskMode(((VirtualDiskRawDiskMappingVer1BackingInfo)parentBacking).getDiskMode());
+	        backingInfo.setDatastore(morDs);
+	        backingInfo.setFileName(vmdkDatastorePath);
+	        backingInfo.setParent((VirtualDiskRawDiskMappingVer1BackingInfo)parentBacking);
+	        disk.setBacking(backingInfo);
+		} else if(parentBacking instanceof VirtualDiskSparseVer1BackingInfo) {
+			VirtualDiskSparseVer1BackingInfo backingInfo = new VirtualDiskSparseVer1BackingInfo();
+	        backingInfo.setDiskMode(((VirtualDiskSparseVer1BackingInfo)parentBacking).getDiskMode());
+	        backingInfo.setDatastore(morDs);
+	        backingInfo.setFileName(vmdkDatastorePath);
+	        backingInfo.setParent((VirtualDiskSparseVer1BackingInfo)parentBacking);
+	        disk.setBacking(backingInfo);
+		} else if(parentBacking instanceof VirtualDiskSparseVer2BackingInfo) {
+			VirtualDiskSparseVer2BackingInfo backingInfo = new VirtualDiskSparseVer2BackingInfo();
+	        backingInfo.setDiskMode(((VirtualDiskSparseVer2BackingInfo)parentBacking).getDiskMode());
+	        backingInfo.setDatastore(morDs);
+	        backingInfo.setFileName(vmdkDatastorePath);
+	        backingInfo.setParent((VirtualDiskSparseVer2BackingInfo)parentBacking);
+	        disk.setBacking(backingInfo);
+		} else {
+			throw new Exception("Unsupported disk backing: " + parentBacking.getClass().getCanonicalName());
+		}
+		
+		if(controllerKey < 0)
+			controllerKey = vmMo.getIDEDeviceControllerKey();
+		disk.setControllerKey(controllerKey);
+		
+		if(deviceNumber < 0)
+			deviceNumber = vmMo.getNextDeviceNumber(controllerKey);
+	    disk.setKey(-contextNumber);
+	    disk.setUnitNumber(deviceNumber);
+	    disk.setCapacityInKB(sizeInMb*1024);
+
+	    VirtualDeviceConnectInfo connectInfo = new VirtualDeviceConnectInfo();
+	    connectInfo.setConnected(true);
+	    connectInfo.setStartConnected(true);
+	    disk.setConnectable(connectInfo);
+	    return disk;
+	}
+	
+	// vmdkDatastorePath: [datastore name] vmdkFilePath
+	public static VirtualDevice prepareDiskDevice(VirtualMachineMO vmMo, int controllerKey, String vmdkDatastorePathChain[], 
+		ManagedObjectReference morDs, int deviceNumber, int contextNumber) throws Exception {
+		
+		assert(vmdkDatastorePathChain != null);
+		assert(vmdkDatastorePathChain.length >= 1);
+	
+		if(controllerKey < 0)
+			controllerKey = vmMo.getIDEDeviceControllerKey();
+		
+		VirtualDisk disk = new VirtualDisk();
+		
+		VirtualDiskFlatVer2BackingInfo backingInfo = new VirtualDiskFlatVer2BackingInfo();
+        backingInfo.setDatastore(morDs);
+        backingInfo.setFileName(vmdkDatastorePathChain[0]);
+        backingInfo.setDiskMode(VirtualDiskMode.persistent.toString());
+        if(vmdkDatastorePathChain.length > 1) {
+        	String[] parentDisks = new String[vmdkDatastorePathChain.length - 1];
+        	for(int i = 0; i < vmdkDatastorePathChain.length - 1; i++)
+        		parentDisks[i] = vmdkDatastorePathChain[i + 1];
+        	
+        	setParentBackingInfo(backingInfo, morDs, parentDisks);
+        }
+        
+        disk.setBacking(backingInfo);
+
+        if(deviceNumber < 0)
+        	deviceNumber = vmMo.getNextDeviceNumber(controllerKey);
+		
+		disk.setControllerKey(controllerKey);
+	    disk.setKey(-contextNumber);
+	    disk.setUnitNumber(deviceNumber);
+	    
+	    VirtualDeviceConnectInfo connectInfo = new VirtualDeviceConnectInfo();
+	    connectInfo.setConnected(true);
+	    connectInfo.setStartConnected(true);
+	    disk.setConnectable(connectInfo);
+	    
+	    return disk;
+	}
+
+	private static void setParentBackingInfo(VirtualDiskFlatVer2BackingInfo backingInfo, 
+		ManagedObjectReference morDs, String[] parentDatastorePathList) {
+		
+		VirtualDiskFlatVer2BackingInfo parentBacking = new VirtualDiskFlatVer2BackingInfo();
+		parentBacking.setDatastore(morDs);
+		parentBacking.setDiskMode(VirtualDiskMode.persistent.toString());
+		
+		if(parentDatastorePathList.length > 1) {
+			String[] nextDatastorePathList = new String[parentDatastorePathList.length -1];
+			for(int i = 0; i < parentDatastorePathList.length -1; i++)
+				nextDatastorePathList[i] = parentDatastorePathList[i + 1];
+			setParentBackingInfo(parentBacking, morDs, nextDatastorePathList);
+		}
+		parentBacking.setFileName(parentDatastorePathList[0]);
+		
+		backingInfo.setParent(parentBacking);
+	}
+	
+	public static Pair<VirtualDevice, Boolean> prepareIsoDevice(VirtualMachineMO vmMo, String isoDatastorePath, ManagedObjectReference morDs,
+		boolean connect, boolean connectAtBoot, int deviceNumber, int contextNumber) throws Exception {
+		
+		boolean newCdRom = false;
+		VirtualCdrom cdRom = (VirtualCdrom )vmMo.getIsoDevice();
+		if(cdRom == null) {
+			newCdRom = true;
+			cdRom = new VirtualCdrom();
+			assert(vmMo.getIDEDeviceControllerKey() >= 0);
+			cdRom.setControllerKey(vmMo.getIDEDeviceControllerKey());
+			
+			if(deviceNumber < 0)
+				deviceNumber = vmMo.getNextIDEDeviceNumber();
+			cdRom.setUnitNumber(deviceNumber);            
+			cdRom.setKey(-contextNumber);
+		}
+		
+	    VirtualDeviceConnectInfo cInfo = new VirtualDeviceConnectInfo();
+	    cInfo.setConnected(connect);
+	    cInfo.setStartConnected(connectAtBoot);
+	    cdRom.setConnectable(cInfo);
+	    
+        if(isoDatastorePath != null) {
+            VirtualCdromIsoBackingInfo backingInfo = new VirtualCdromIsoBackingInfo();
+	        backingInfo.setFileName(isoDatastorePath);
+	        backingInfo.setDatastore(morDs);
+	        cdRom.setBacking(backingInfo);
+        } else {
+    		VirtualCdromRemotePassthroughBackingInfo backingInfo = new VirtualCdromRemotePassthroughBackingInfo();
+    		backingInfo.setDeviceName("");
+    		cdRom.setBacking(backingInfo);
+        }
+		
+		return new Pair<VirtualDevice, Boolean>(cdRom, newCdRom);
+	}
+	
+	public static VirtualDisk getRootDisk(VirtualDisk[] disks) {
+		if(disks.length == 1)
+			return disks[0];
+		
+		// TODO : for now, always return the first disk as root disk
+		return disks[0];
+	}
+	
+	public static ManagedObjectReference findSnapshotInTree(VirtualMachineSnapshotTree[] snapTree, String findName) {
+		assert(findName != null);
+		
+		ManagedObjectReference snapMor = null;
+		if (snapTree == null) 
+			return snapMor;
+		
+		for (int i = 0; i < snapTree.length && snapMor == null; i++) {
+			VirtualMachineSnapshotTree node = snapTree[i];
+
+			if (node.getName().equals(findName)) {
+				snapMor = node.getSnapshot();
+			} else {
+				VirtualMachineSnapshotTree[] childTree = node.getChildSnapshotList();
+				snapMor = findSnapshotInTree(childTree, findName);
+			}
+		}
+		return snapMor;
+	}
+
+	public static byte[] composeDiskInfo(List<Ternary<String, String, String>> diskInfo, int disksInChain, boolean includeBase) throws IOException {
+		
+		BufferedWriter out = null;
+		ByteArrayOutputStream bos = new ByteArrayOutputStream();
+		
+		try {
+			out = new BufferedWriter(new OutputStreamWriter(bos)); 
+
+			out.write("disksInChain=" + disksInChain);
+			out.newLine();
+			
+			out.write("disksInBackup=" + diskInfo.size());
+			out.newLine();
+			
+			out.write("baseDiskIncluded=" + includeBase);
+			out.newLine();
+			
+			int seq = disksInChain - 1;
+			for(Ternary<String, String, String> item : diskInfo) {
+				out.write(String.format("disk%d.fileName=%s", seq, item.first()));
+				out.newLine();
+				
+				out.write(String.format("disk%d.baseFileName=%s", seq, item.second()));
+				out.newLine();
+				
+				if(item.third() != null) {
+					out.write(String.format("disk%d.parentFileName=%s", seq, item.third()));
+					out.newLine();
+				}
+				seq--;
+			}
+			
+			out.newLine();
+		} finally {
+			if(out != null)
+				out.close();
+		}
+		
+		return bos.toByteArray();
+	}
+	
+	public static OptionValue[] composeVncOptions(OptionValue[] optionsToMerge, 
+		boolean enableVnc, String vncPassword, int vncPort, String keyboardLayout) {
+		
+		int numOptions = 3;
+		boolean needKeyboardSetup = false;
+		if(keyboardLayout != null && !keyboardLayout.isEmpty()) {
+			numOptions++;
+			needKeyboardSetup = true;
+		}
+		
+		if(optionsToMerge != null)
+			numOptions += optionsToMerge.length;
+		
+		OptionValue[] options = new OptionValue[numOptions];
+		int i = 0;
+		if(optionsToMerge != null) {
+			for(int j = 0; j < optionsToMerge.length; j++)
+				options[i++] = optionsToMerge[j];
+		}
+			
+		options[i] = new OptionValue();
+		options[i].setKey("RemoteDisplay.vnc.enabled");
+		options[i++].setValue(enableVnc ? "true" : "false");
+  
+		options[i] = new OptionValue();
+		options[i].setKey("RemoteDisplay.vnc.password");
+		options[i++].setValue(vncPassword);
+  
+		options[i] = new OptionValue();
+		options[i].setKey("RemoteDisplay.vnc.port");
+		options[i++].setValue("" + vncPort);
+		
+		if(needKeyboardSetup) {
+			options[i] = new OptionValue();
+			options[i].setKey("RemoteDisplay.vnc.keymap");
+			options[i++].setValue(keyboardLayout);
+		}
+		
+		return options;
+	}
+	
+	public static void setBasicVmConfig(VirtualMachineConfigSpec vmConfig, int cpuCount, int cpuSpeedMHz, int cpuReservedMhz,
+		int memoryMB, String guestOsIdentifier, boolean limitCpuUse) {
+		
+		// VM config basics
+		vmConfig.setMemoryMB((long)memoryMB);
+		vmConfig.setNumCPUs(cpuCount);
+		
+		ResourceAllocationInfo cpuInfo = new ResourceAllocationInfo();
+		if (limitCpuUse) {
+			cpuInfo.setLimit((long)cpuSpeedMHz);
+		} else {
+			cpuInfo.setLimit(-1L);
+		}
+
+		cpuInfo.setReservation((long)cpuReservedMhz);
+		vmConfig.setCpuAllocation(cpuInfo);
+		
+		ResourceAllocationInfo memInfo = new ResourceAllocationInfo();
+		memInfo.setLimit((long)memoryMB);
+		memInfo.setReservation((long)memoryMB);
+		vmConfig.setMemoryAllocation(memInfo);
+		
+		vmConfig.setGuestId(guestOsIdentifier);
+	}
+	
+	public static ManagedObjectReference getDiskDeviceDatastore(VirtualDisk diskDevice) throws Exception {
+		VirtualDeviceBackingInfo backingInfo = diskDevice.getBacking();
+		assert(backingInfo instanceof VirtualDiskFlatVer2BackingInfo);
+		return ((VirtualDiskFlatVer2BackingInfo)backingInfo).getDatastore();
+	}
+	
+	public static Object getPropValue(ObjectContent oc, String name) {
+		DynamicProperty[] props = oc.getPropSet();
+		
+		for(DynamicProperty prop : props) {
+			if(prop.getName().equalsIgnoreCase(name))
+				return prop.getVal();
+		}
+		
+		return null;
+	}
+	
+	public static String getFileExtension(String fileName, String defaultExtension) {
+		int pos = fileName.lastIndexOf('.');
+		if(pos < 0)
+			return defaultExtension;
+		
+		return fileName.substring(pos); 
+	}
+	
+	public static boolean isSameHost(String ipAddress, String destName) {
+		// TODO : may need to do DNS lookup to compare IP address exactly
+		return ipAddress.equals(destName);
+	}
+	
+	public static void deleteVolumeVmdkFiles(DatastoreMO dsMo, String volumeName, DatacenterMO dcMo) throws Exception {
+        String volumeDatastorePath = String.format("[%s] %s.vmdk", dsMo.getName(), volumeName);
+        dsMo.deleteFile(volumeDatastorePath, dcMo.getMor(), true);
+        
+        volumeDatastorePath = String.format("[%s] %s-flat.vmdk", dsMo.getName(), volumeName);
+        dsMo.deleteFile(volumeDatastorePath, dcMo.getMor(), true);
+	    
+        volumeDatastorePath = String.format("[%s] %s-delta.vmdk", dsMo.getName(), volumeName);
+        dsMo.deleteFile(volumeDatastorePath, dcMo.getMor(), true);
+	}
+
+	public static String getExceptionMessage(Throwable e) {
+		return getExceptionMessage(e, false);
+	}
+	
+	public static String getExceptionMessage(Throwable e, boolean printStack) {
+		if(e instanceof MethodFault) {
+			final StringWriter writer = new StringWriter();
+			writer.append("Exception: " + e.getClass().getName() + "\n");
+			writer.append("message: " + ((MethodFault)e).getFaultString() + "\n");
+			
+			if(printStack) {
+				writer.append("stack: ");
+				e.printStackTrace(new PrintWriter(writer));
+			}
+			return writer.toString();
+		}
+		
+		return ExceptionUtil.toString(e, printStack);
+	}
+	
+	public static VirtualMachineMO pickOneVmOnRunningHost(List<VirtualMachineMO> vmList, boolean bFirstFit) throws Exception {
+		List<VirtualMachineMO> candidates = new ArrayList<VirtualMachineMO>();
+		
+    	for(VirtualMachineMO vmMo : vmList) {
+    		HostMO hostMo = vmMo.getRunningHost();
+    		if(hostMo.isHyperHostConnected())
+    			candidates.add(vmMo);
+    	}
+    	
+    	if(candidates.size() == 0)
+    		return null;
+    	
+    	if(bFirstFit)
+    		return candidates.get(0);
+    	
+    	Random random = new Random();
+    	return candidates.get(random.nextInt(candidates.size()));
+	}
+}