incubator-cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bfede...@apache.org
Subject [4/54] [abbrv] Simulator: moving hypervisor simulator into plugin
Date Tue, 08 Jan 2013 00:41:19 GMT
http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/d6083ce5/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockAgentManagerImpl.java
----------------------------------------------------------------------
diff --git a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockAgentManagerImpl.java b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockAgentManagerImpl.java
new file mode 100755
index 0000000..cb99297
--- /dev/null
+++ b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockAgentManagerImpl.java
@@ -0,0 +1,468 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+package com.cloud.agent.manager;
+
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.PatternSyntaxException;
+
+import javax.ejb.Local;
+import javax.naming.ConfigurationException;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.agent.AgentManager;
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.CheckHealthCommand;
+import com.cloud.agent.api.CheckNetworkAnswer;
+import com.cloud.agent.api.CheckNetworkCommand;
+import com.cloud.agent.api.GetHostStatsAnswer;
+import com.cloud.agent.api.GetHostStatsCommand;
+import com.cloud.agent.api.HostStatsEntry;
+import com.cloud.agent.api.MaintainAnswer;
+import com.cloud.agent.api.PingTestCommand;
+import com.cloud.agent.api.PrepareForMigrationAnswer;
+import com.cloud.agent.api.PrepareForMigrationCommand;
+import com.cloud.agent.api.to.VirtualMachineTO;
+import com.cloud.dc.dao.HostPodDao;
+import com.cloud.host.Host;
+import com.cloud.resource.AgentResourceBase;
+import com.cloud.resource.AgentRoutingResource;
+import com.cloud.resource.AgentStorageResource;
+import com.cloud.resource.ResourceManager;
+import com.cloud.simulator.MockHost;
+import com.cloud.simulator.MockHostVO;
+import com.cloud.simulator.MockVMVO;
+import com.cloud.simulator.dao.MockHostDao;
+import com.cloud.simulator.dao.MockVMDao;
+import com.cloud.utils.Pair;
+import com.cloud.utils.component.Inject;
+import com.cloud.utils.concurrency.NamedThreadFactory;
+import com.cloud.utils.db.DB;
+import com.cloud.utils.db.Transaction;
+import com.cloud.utils.exception.CloudRuntimeException;
+import com.cloud.utils.net.NetUtils;
+
+@Local(value = { MockAgentManager.class })
+public class MockAgentManagerImpl implements MockAgentManager {
+	private static final Logger s_logger = Logger.getLogger(MockAgentManagerImpl.class);
+	@Inject
+	HostPodDao _podDao = null;
+	@Inject
+	MockHostDao _mockHostDao = null;
+	@Inject
+	MockVMDao _mockVmDao = null;
+	@Inject
+	SimulatorManager _simulatorMgr = null;
+	@Inject
+	AgentManager _agentMgr = null;
+	@Inject
+	MockStorageManager _storageMgr = null;
+	@Inject
+	ResourceManager _resourceMgr;
+	private SecureRandom random;
+	private Map<String, AgentResourceBase> _resources = new ConcurrentHashMap<String, AgentResourceBase>();
+	private ThreadPoolExecutor _executor;
+
+	private Pair<String, Long> getPodCidr(long podId, long dcId) {
+		try {
+
+			HashMap<Long, List<Object>> podMap = _podDao.getCurrentPodCidrSubnets(dcId, 0);
+			List<Object> cidrPair = podMap.get(podId);
+			String cidrAddress = (String) cidrPair.get(0);
+			Long cidrSize = (Long) cidrPair.get(1);
+			return new Pair<String, Long>(cidrAddress, cidrSize);
+		} catch (PatternSyntaxException e) {
+			s_logger.error("Exception while splitting pod cidr");
+			return null;
+		} catch (IndexOutOfBoundsException e) {
+			s_logger.error("Invalid pod cidr. Please check");
+			return null;
+		}
+	}
+
+	private String getIpAddress(long instanceId, long dcId, long podId) {
+		Pair<String, Long> cidr = this.getPodCidr(podId, dcId);
+		return NetUtils.long2Ip(NetUtils.ip2Long(cidr.first()) + instanceId);
+	}
+
+	private String getMacAddress(long dcId, long podId, long clusterId, int instanceId) {
+		return NetUtils.long2Mac((dcId << 40 + podId << 32 + clusterId << 24 + instanceId));
+	}
+
+	public synchronized int getNextAgentId(long cidrSize) {
+		return random.nextInt((int) cidrSize);
+	}
+
+	@Override
+	@DB
+	public Map<AgentResourceBase, Map<String, String>> createServerResources(Map<String, Object> params) {
+
+		Map<String, String> args = new HashMap<String, String>();
+		Map<AgentResourceBase, Map<String, String>> newResources = new HashMap<AgentResourceBase, Map<String, String>>();
+		AgentResourceBase agentResource;
+		long cpuCore = Long.parseLong((String) params.get("cpucore"));
+		long cpuSpeed = Long.parseLong((String) params.get("cpuspeed"));
+		long memory = Long.parseLong((String) params.get("memory"));
+		long localStorageSize = Long.parseLong((String) params.get("localstorage"));
+		synchronized (this) {
+			long dataCenterId = Long.parseLong((String) params.get("zone"));
+			long podId = Long.parseLong((String) params.get("pod"));
+			long clusterId = Long.parseLong((String) params.get("cluster"));
+			long cidrSize = getPodCidr(podId, dataCenterId).second();
+
+			int agentId = getNextAgentId(cidrSize);
+			String ipAddress = getIpAddress(agentId, dataCenterId, podId);
+			String macAddress = getMacAddress(dataCenterId, podId, clusterId, agentId);
+			MockHostVO mockHost = new MockHostVO();
+			mockHost.setDataCenterId(dataCenterId);
+			mockHost.setPodId(podId);
+			mockHost.setClusterId(clusterId);
+			mockHost.setCapabilities("hvm");
+			mockHost.setCpuCount(cpuCore);
+			mockHost.setCpuSpeed(cpuSpeed);
+			mockHost.setMemorySize(memory);
+			String guid = UUID.randomUUID().toString();
+			mockHost.setGuid(guid);
+			mockHost.setName("SimulatedAgent." + guid);
+			mockHost.setPrivateIpAddress(ipAddress);
+			mockHost.setPublicIpAddress(ipAddress);
+			mockHost.setStorageIpAddress(ipAddress);
+			mockHost.setPrivateMacAddress(macAddress);
+			mockHost.setPublicMacAddress(macAddress);
+			mockHost.setStorageMacAddress(macAddress);
+			mockHost.setVersion(this.getClass().getPackage().getImplementationVersion());
+			mockHost.setResource("com.cloud.agent.AgentRoutingResource");
+
+			Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+			try {
+				txn.start();
+				mockHost = _mockHostDao.persist(mockHost);
+				txn.commit();
+			} catch (Exception ex) {
+				txn.rollback();
+				s_logger.error("Error while configuring mock agent " + ex.getMessage());
+				throw new CloudRuntimeException("Error configuring agent", ex);
+			} finally {
+				txn.close();
+                txn = Transaction.open(Transaction.CLOUD_DB);
+                txn.close();
+			}
+
+			_storageMgr.getLocalStorage(guid, localStorageSize);
+
+			agentResource = new AgentRoutingResource();
+			if (agentResource != null) {
+				try {
+					params.put("guid", mockHost.getGuid());
+					agentResource.start();
+					agentResource.configure(mockHost.getName(), params);
+
+					newResources.put(agentResource, args);
+				} catch (ConfigurationException e) {
+					s_logger.error("error while configuring server resource" + e.getMessage());
+				}
+			}
+		}
+		return newResources;
+	}
+
+	@Override
+	public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
+		try {
+			random = SecureRandom.getInstance("SHA1PRNG");
+			_executor = new ThreadPoolExecutor(1, 5, 1, TimeUnit.DAYS, new LinkedBlockingQueue<Runnable>(),
+					new NamedThreadFactory("Simulator-Agent-Mgr"));
+			// ComponentLocator locator = ComponentLocator.getCurrentLocator();
+			// _simulatorMgr = (SimulatorManager)
+			// locator.getComponent(SimulatorManager.Name);
+		} catch (NoSuchAlgorithmException e) {
+			s_logger.debug("Failed to initialize random:" + e.toString());
+			return false;
+		}
+		return true;
+	}
+
+	@Override
+	public boolean handleSystemVMStart(long vmId, String privateIpAddress, String privateMacAddress,
+			String privateNetMask, long dcId, long podId, String name, String vmType, String url) {
+		_executor.execute(new SystemVMHandler(vmId, privateIpAddress, privateMacAddress, privateNetMask, dcId, podId,
+				name, vmType, _simulatorMgr, url));
+		return true;
+	}
+
+	@Override
+	public boolean handleSystemVMStop(long vmId) {
+		_executor.execute(new SystemVMHandler(vmId));
+		return true;
+	}
+
+	private class SystemVMHandler implements Runnable {
+		private long vmId;
+		private String privateIpAddress;
+		private String privateMacAddress;
+		private String privateNetMask;
+		private long dcId;
+		private long podId;
+		private String guid;
+		private String name;
+		private String vmType;
+		private SimulatorManager mgr;
+		private String mode;
+		private String url;
+
+		public SystemVMHandler(long vmId, String privateIpAddress, String privateMacAddress, String privateNetMask,
+				long dcId, long podId, String name, String vmType, SimulatorManager mgr, String url) {
+			this.vmId = vmId;
+			this.privateIpAddress = privateIpAddress;
+			this.privateMacAddress = privateMacAddress;
+			this.privateNetMask = privateNetMask;
+			this.dcId = dcId;
+			this.guid = "SystemVM-" + UUID.randomUUID().toString();
+			this.name = name;
+			this.vmType = vmType;
+			this.mgr = mgr;
+			this.mode = "Start";
+			this.url = url;
+			this.podId = podId;
+		}
+
+		public SystemVMHandler(long vmId) {
+			this.vmId = vmId;
+			this.mode = "Stop";
+		}
+
+		@Override
+		@DB
+		public void run() {
+
+			Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+			try {
+				if (this.mode.equalsIgnoreCase("Stop")) {
+					txn.start();
+					MockHost host = _mockHostDao.findByVmId(this.vmId);
+					if (host != null) {
+						String guid = host.getGuid();
+						if (guid != null) {
+							AgentResourceBase res = _resources.get(guid);
+							if (res != null) {
+								res.stop();
+								_resources.remove(guid);
+							}
+						}
+					}
+					txn.commit();
+					return;
+				}
+			} catch (Exception ex) {
+				txn.rollback();
+				throw new CloudRuntimeException("Unable to get host " + guid + " due to " + ex.getMessage(), ex);
+			} finally {
+				txn.close();
+                txn = Transaction.open(Transaction.CLOUD_DB);
+                txn.close();
+			}
+
+			String resource = null;
+			if (vmType.equalsIgnoreCase("secstorage")) {
+				resource = "com.cloud.agent.AgentStorageResource";
+			}
+			MockHostVO mockHost = new MockHostVO();
+			mockHost.setDataCenterId(this.dcId);
+			mockHost.setPodId(this.podId);
+			mockHost.setCpuCount(DEFAULT_HOST_CPU_CORES);
+			mockHost.setCpuSpeed(DEFAULT_HOST_SPEED_MHZ);
+			mockHost.setMemorySize(DEFAULT_HOST_MEM_SIZE);
+			mockHost.setGuid(this.guid);
+			mockHost.setName(name);
+			mockHost.setPrivateIpAddress(this.privateIpAddress);
+			mockHost.setPublicIpAddress(this.privateIpAddress);
+			mockHost.setStorageIpAddress(this.privateIpAddress);
+			mockHost.setPrivateMacAddress(this.privateMacAddress);
+			mockHost.setPublicMacAddress(this.privateMacAddress);
+			mockHost.setStorageMacAddress(this.privateMacAddress);
+			mockHost.setVersion(this.getClass().getPackage().getImplementationVersion());
+			mockHost.setResource(resource);
+			mockHost.setVmId(vmId);
+			Transaction simtxn = Transaction.open(Transaction.SIMULATOR_DB);
+			try {
+				simtxn.start();
+				mockHost = _mockHostDao.persist(mockHost);
+				simtxn.commit();
+			} catch (Exception ex) {
+				simtxn.rollback();
+				throw new CloudRuntimeException("Unable to persist host " + mockHost.getGuid() + " due to "
+						+ ex.getMessage(), ex);
+			} finally {
+				simtxn.close();
+                simtxn = Transaction.open(Transaction.CLOUD_DB);
+                simtxn.close();
+			}
+
+			if (vmType.equalsIgnoreCase("secstorage")) {
+				AgentStorageResource storageResource = new AgentStorageResource();
+				try {
+					Map<String, Object> params = new HashMap<String, Object>();
+					Map<String, String> details = new HashMap<String, String>();
+					params.put("guid", this.guid);
+					details.put("guid", this.guid);
+					storageResource.configure("secondaryStorage", params);
+					storageResource.start();
+					// on the simulator the ssvm is as good as a direct
+					// agent
+					_resourceMgr.addHost(mockHost.getDataCenterId(), storageResource, Host.Type.SecondaryStorageVM,
+							details);
+					_resources.put(this.guid, storageResource);
+				} catch (ConfigurationException e) {
+					s_logger.debug("Failed to load secondary storage resource: " + e.toString());
+					return;
+				}
+			}
+		}
+	}
+
+	@Override
+	public MockHost getHost(String guid) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			MockHost _host = _mockHostDao.findByGuid(guid);
+			txn.commit();
+			if (_host != null) {
+				return _host;
+			} else {
+				s_logger.error("Host with guid " + guid + " was not found");
+				return null;
+			}
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Unable to get host " + guid + " due to " + ex.getMessage(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+	}
+
+	@Override
+	public GetHostStatsAnswer getHostStatistic(GetHostStatsCommand cmd) {
+		String hostGuid = cmd.getHostGuid();
+		MockHost host = null;
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			host = _mockHostDao.findByGuid(hostGuid);
+			txn.commit();
+			if (host == null) {
+				return null;
+			}
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Unable to get host " + hostGuid + " due to " + ex.getMessage(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		Transaction vmtxn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			vmtxn.start();
+			List<MockVMVO> vms = _mockVmDao.findByHostId(host.getId());
+			vmtxn.commit();
+			double usedMem = 0.0;
+			double usedCpu = 0.0;
+			for (MockVMVO vm : vms) {
+				usedMem += vm.getMemory();
+				usedCpu += vm.getCpu();
+			}
+
+			HostStatsEntry hostStats = new HostStatsEntry();
+			hostStats.setTotalMemoryKBs(host.getMemorySize());
+			hostStats.setFreeMemoryKBs(host.getMemorySize() - usedMem);
+			hostStats.setNetworkReadKBs(32768);
+			hostStats.setNetworkWriteKBs(16384);
+			hostStats.setCpuUtilization(usedCpu / (host.getCpuCount() * host.getCpuSpeed()));
+			hostStats.setEntityType("simulator-host");
+			hostStats.setHostId(cmd.getHostId());
+			return new GetHostStatsAnswer(cmd, hostStats);
+		} catch (Exception ex) {
+			vmtxn.rollback();
+			throw new CloudRuntimeException("Unable to get Vms on host " + host.getGuid() + " due to "
+					+ ex.getMessage(), ex);
+		} finally {
+			vmtxn.close();
+            vmtxn = Transaction.open(Transaction.CLOUD_DB);
+            vmtxn.close();
+		}
+	}
+
+	@Override
+	public Answer checkHealth(CheckHealthCommand cmd) {
+		return new Answer(cmd);
+	}
+
+	@Override
+	public Answer pingTest(PingTestCommand cmd) {
+		return new Answer(cmd);
+	}
+
+	@Override
+	public PrepareForMigrationAnswer prepareForMigrate(PrepareForMigrationCommand cmd) {
+		VirtualMachineTO vm = cmd.getVirtualMachine();
+		if (s_logger.isDebugEnabled()) {
+			s_logger.debug("Preparing host for migrating " + vm);
+		}
+		return new PrepareForMigrationAnswer(cmd);
+	}
+
+	@Override
+	public boolean start() {
+		return true;
+	}
+
+	@Override
+	public boolean stop() {
+		return true;
+	}
+
+	@Override
+	public String getName() {
+		return this.getClass().getSimpleName();
+	}
+
+	@Override
+	public MaintainAnswer maintain(com.cloud.agent.api.MaintainCommand cmd) {
+		return new MaintainAnswer(cmd);
+	}
+
+	@Override
+	public Answer checkNetworkCommand(CheckNetworkCommand cmd) {
+		if (s_logger.isDebugEnabled()) {
+			s_logger.debug("Checking if network name setup is done on the resource");
+		}
+		return new CheckNetworkAnswer(cmd, true, "Network Setup check by names is done");
+	}
+}

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/d6083ce5/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManager.java
----------------------------------------------------------------------
diff --git a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManager.java b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManager.java
new file mode 100644
index 0000000..fc8aacc
--- /dev/null
+++ b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManager.java
@@ -0,0 +1,91 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+package com.cloud.agent.manager;
+
+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.BackupSnapshotCommand;
+import com.cloud.agent.api.ComputeChecksumCommand;
+import com.cloud.agent.api.CreatePrivateTemplateFromSnapshotCommand;
+import com.cloud.agent.api.CreatePrivateTemplateFromVolumeCommand;
+import com.cloud.agent.api.CreateStoragePoolCommand;
+import com.cloud.agent.api.CreateVolumeFromSnapshotCommand;
+import com.cloud.agent.api.DeleteSnapshotBackupCommand;
+import com.cloud.agent.api.DeleteStoragePoolCommand;
+import com.cloud.agent.api.GetStorageStatsAnswer;
+import com.cloud.agent.api.GetStorageStatsCommand;
+import com.cloud.agent.api.ManageSnapshotCommand;
+import com.cloud.agent.api.ModifyStoragePoolCommand;
+import com.cloud.agent.api.SecStorageSetupCommand;
+import com.cloud.agent.api.SecStorageVMSetupCommand;
+import com.cloud.agent.api.StoragePoolInfo;
+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.DeleteTemplateCommand;
+import com.cloud.agent.api.storage.DestroyCommand;
+import com.cloud.agent.api.storage.DownloadCommand;
+import com.cloud.agent.api.storage.DownloadProgressCommand;
+import com.cloud.agent.api.storage.ListTemplateCommand;
+import com.cloud.agent.api.storage.PrimaryStorageDownloadAnswer;
+import com.cloud.agent.api.storage.PrimaryStorageDownloadCommand;
+import com.cloud.utils.component.Manager;
+
+public interface MockStorageManager extends Manager {
+    public static final long DEFAULT_HOST_STORAGE_SIZE = 1 * 1024 * 1024 * 1024 * 1024L; //1T
+    public static final long DEFAULT_TEMPLATE_SIZE = 1 * 1000 * 1000 * 1000L; //1G
+
+	public PrimaryStorageDownloadAnswer primaryStorageDownload(PrimaryStorageDownloadCommand cmd);
+
+	public CreateAnswer createVolume(CreateCommand cmd);
+	public AttachVolumeAnswer AttachVolume(AttachVolumeCommand cmd);
+	public Answer AttachIso(AttachIsoCommand cmd);
+
+	public Answer DeleteStoragePool(DeleteStoragePoolCommand cmd);
+	public Answer ModifyStoragePool(ModifyStoragePoolCommand cmd);
+	public Answer CreateStoragePool(CreateStoragePoolCommand cmd);
+
+	public Answer SecStorageSetup(SecStorageSetupCommand cmd);
+	public Answer ListTemplates(ListTemplateCommand cmd);
+	public Answer Destroy(DestroyCommand cmd);
+	public Answer Download(DownloadCommand cmd);
+	public Answer DownloadProcess(DownloadProgressCommand cmd);
+	public GetStorageStatsAnswer GetStorageStats(GetStorageStatsCommand cmd);
+	public Answer ManageSnapshot(ManageSnapshotCommand cmd);
+	public Answer BackupSnapshot(BackupSnapshotCommand cmd, SimulatorInfo info);
+	public Answer DeleteSnapshotBackup(DeleteSnapshotBackupCommand cmd);
+	public Answer CreateVolumeFromSnapshot(CreateVolumeFromSnapshotCommand cmd);
+	public Answer DeleteTemplate(DeleteTemplateCommand cmd);
+	public Answer SecStorageVMSetup(SecStorageVMSetupCommand cmd);
+
+	public void preinstallTemplates(String url, long zoneId);
+
+    StoragePoolInfo getLocalStorage(String hostGuid);
+
+    public Answer CreatePrivateTemplateFromSnapshot(CreatePrivateTemplateFromSnapshotCommand cmd);
+
+    public Answer ComputeChecksum(ComputeChecksumCommand cmd);
+
+    public Answer CreatePrivateTemplateFromVolume(CreatePrivateTemplateFromVolumeCommand cmd);
+
+    StoragePoolInfo getLocalStorage(String hostGuid, Long storageSize);
+
+	CopyVolumeAnswer CopyVolume(CopyVolumeCommand cmd);
+}

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/d6083ce5/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManagerImpl.java
----------------------------------------------------------------------
diff --git a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManagerImpl.java b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManagerImpl.java
new file mode 100644
index 0000000..9bf4192
--- /dev/null
+++ b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManagerImpl.java
@@ -0,0 +1,1298 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+package com.cloud.agent.manager;
+
+import java.io.File;
+import java.math.BigInteger;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+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.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.ComputeChecksumCommand;
+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.DeleteSnapshotBackupCommand;
+import com.cloud.agent.api.DeleteStoragePoolCommand;
+import com.cloud.agent.api.GetStorageStatsAnswer;
+import com.cloud.agent.api.GetStorageStatsCommand;
+import com.cloud.agent.api.ManageSnapshotAnswer;
+import com.cloud.agent.api.ManageSnapshotCommand;
+import com.cloud.agent.api.ModifyStoragePoolAnswer;
+import com.cloud.agent.api.ModifyStoragePoolCommand;
+import com.cloud.agent.api.SecStorageSetupAnswer;
+import com.cloud.agent.api.SecStorageSetupCommand;
+import com.cloud.agent.api.SecStorageVMSetupCommand;
+import com.cloud.agent.api.StoragePoolInfo;
+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.DeleteTemplateCommand;
+import com.cloud.agent.api.storage.DestroyCommand;
+import com.cloud.agent.api.storage.DownloadAnswer;
+import com.cloud.agent.api.storage.DownloadCommand;
+import com.cloud.agent.api.storage.DownloadProgressCommand;
+import com.cloud.agent.api.storage.ListTemplateAnswer;
+import com.cloud.agent.api.storage.ListTemplateCommand;
+import com.cloud.agent.api.storage.PrimaryStorageDownloadAnswer;
+import com.cloud.agent.api.storage.PrimaryStorageDownloadCommand;
+import com.cloud.agent.api.to.StorageFilerTO;
+import com.cloud.agent.api.to.VolumeTO;
+import com.cloud.simulator.MockHost;
+import com.cloud.simulator.MockSecStorageVO;
+import com.cloud.simulator.MockStoragePoolVO;
+import com.cloud.simulator.MockVMVO;
+import com.cloud.simulator.MockVm;
+import com.cloud.simulator.MockVolumeVO;
+import com.cloud.simulator.MockVolumeVO.MockVolumeType;
+import com.cloud.simulator.dao.MockHostDao;
+import com.cloud.simulator.dao.MockSecStorageDao;
+import com.cloud.simulator.dao.MockStoragePoolDao;
+import com.cloud.simulator.dao.MockVMDao;
+import com.cloud.simulator.dao.MockVolumeDao;
+import com.cloud.storage.Storage;
+import com.cloud.storage.VMTemplateStorageResourceAssoc;
+import com.cloud.storage.Storage.ImageFormat;
+import com.cloud.storage.Storage.StoragePoolType;
+import com.cloud.storage.VMTemplateStorageResourceAssoc.Status;
+import com.cloud.storage.template.TemplateInfo;
+import com.cloud.utils.component.Inject;
+import com.cloud.utils.db.Transaction;
+import com.cloud.utils.exception.CloudRuntimeException;
+import com.cloud.vm.DiskProfile;
+import com.cloud.vm.VirtualMachine.State;
+
+@Local(value = { MockStorageManager.class })
+public class MockStorageManagerImpl implements MockStorageManager {
+	private static final Logger s_logger = Logger.getLogger(MockStorageManagerImpl.class);
+	@Inject
+	MockStoragePoolDao _mockStoragePoolDao = null;
+	@Inject
+	MockSecStorageDao _mockSecStorageDao = null;
+	@Inject
+	MockVolumeDao _mockVolumeDao = null;
+	@Inject
+	MockVMDao _mockVMDao = null;
+	@Inject
+	MockHostDao _mockHostDao = null;
+
+	private MockVolumeVO findVolumeFromSecondary(String path, String ssUrl, MockVolumeType type) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			String volumePath = path.replaceAll(ssUrl, "");
+			MockSecStorageVO secStorage = _mockSecStorageDao.findByUrl(ssUrl);
+			if (secStorage == null) {
+				return null;
+			}
+			volumePath = secStorage.getMountPoint() + volumePath;
+			volumePath = volumePath.replaceAll("//", "/");
+			MockVolumeVO volume = _mockVolumeDao.findByStoragePathAndType(volumePath);
+			txn.commit();
+			if (volume == null) {
+				return null;
+			}
+			return volume;
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Unable to find volume " + path + " on secondary " + ssUrl, ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+	}
+
+	@Override
+	public PrimaryStorageDownloadAnswer primaryStorageDownload(PrimaryStorageDownloadCommand cmd) {
+		MockVolumeVO template = findVolumeFromSecondary(cmd.getUrl(), cmd.getSecondaryStorageUrl(),
+				MockVolumeType.TEMPLATE);
+		if (template == null) {
+			return new PrimaryStorageDownloadAnswer("Can't find primary storage");
+		}
+
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		MockStoragePoolVO primaryStorage = null;
+		try {
+			txn.start();
+			primaryStorage = _mockStoragePoolDao.findByUuid(cmd.getPoolUuid());
+			txn.commit();
+			if (primaryStorage == null) {
+				return new PrimaryStorageDownloadAnswer("Can't find primary storage");
+			}
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when finding primary storagee " + cmd.getPoolUuid(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		String volumeName = UUID.randomUUID().toString();
+		MockVolumeVO newVolume = new MockVolumeVO();
+		newVolume.setName(volumeName);
+		newVolume.setPath(primaryStorage.getMountPoint() + volumeName);
+		newVolume.setPoolId(primaryStorage.getId());
+		newVolume.setSize(template.getSize());
+		newVolume.setType(MockVolumeType.VOLUME);
+		txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			_mockVolumeDao.persist(newVolume);
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when saving volume " + newVolume, ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+		return new PrimaryStorageDownloadAnswer(newVolume.getPath(), newVolume.getSize());
+	}
+
+	@Override
+	public CreateAnswer createVolume(CreateCommand cmd) {
+		StorageFilerTO sf = cmd.getPool();
+		DiskProfile dskch = cmd.getDiskCharacteristics();
+		MockStoragePoolVO storagePool = null;
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			storagePool = _mockStoragePoolDao.findByUuid(sf.getUuid());
+			txn.commit();
+			if (storagePool == null) {
+				return new CreateAnswer(cmd, "Failed to find storage pool: " + sf.getUuid());
+			}
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when finding storage " + sf.getUuid(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		String volumeName = UUID.randomUUID().toString();
+		MockVolumeVO volume = new MockVolumeVO();
+		volume.setPoolId(storagePool.getId());
+		volume.setName(volumeName);
+		volume.setPath(storagePool.getMountPoint() + volumeName);
+		volume.setSize(dskch.getSize());
+		volume.setType(MockVolumeType.VOLUME);
+		txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			volume = _mockVolumeDao.persist(volume);
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when saving volume " + volume, ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		VolumeTO volumeTo = new VolumeTO(cmd.getVolumeId(), dskch.getType(), sf.getType(), sf.getUuid(),
+				volume.getName(), storagePool.getMountPoint(), volume.getPath(), volume.getSize(), null);
+
+		return new CreateAnswer(cmd, volumeTo);
+	}
+
+	@Override
+	public AttachVolumeAnswer AttachVolume(AttachVolumeCommand cmd) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			String poolid = cmd.getPoolUuid();
+			String volumeName = cmd.getVolumeName();
+			MockVolumeVO volume = _mockVolumeDao.findByStoragePathAndType(cmd.getVolumePath());
+			if (volume == null) {
+				return new AttachVolumeAnswer(cmd, "Can't find volume:" + volumeName + "on pool:" + poolid);
+			}
+
+			String vmName = cmd.getVmName();
+			MockVMVO vm = _mockVMDao.findByVmName(vmName);
+			if (vm == null) {
+				return new AttachVolumeAnswer(cmd, "can't vm :" + vmName);
+			}
+			txn.commit();
+
+			return new AttachVolumeAnswer(cmd, cmd.getDeviceId());
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when attaching volume " + cmd.getVolumeName() + " to VM "
+					+ cmd.getVmName(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+	}
+
+	@Override
+	public Answer AttachIso(AttachIsoCommand cmd) {
+		MockVolumeVO iso = findVolumeFromSecondary(cmd.getIsoPath(), cmd.getStoreUrl(), MockVolumeType.ISO);
+		if (iso == null) {
+			return new Answer(cmd, false, "Failed to find the iso: " + cmd.getIsoPath() + "on secondary storage "
+					+ cmd.getStoreUrl());
+		}
+
+		String vmName = cmd.getVmName();
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		MockVMVO vm = null;
+		try {
+			txn.start();
+			vm = _mockVMDao.findByVmName(vmName);
+			txn.commit();
+			if (vm == null) {
+				return new Answer(cmd, false, "can't vm :" + vmName);
+			}
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when attaching iso to vm " + vm.getName(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+		return new Answer(cmd);
+	}
+
+	@Override
+	public Answer DeleteStoragePool(DeleteStoragePoolCommand cmd) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			MockStoragePoolVO storage = _mockStoragePoolDao.findByUuid(cmd.getPool().getUuid());
+			if (storage == null) {
+				return new Answer(cmd, false, "can't find storage pool:" + cmd.getPool().getUuid());
+			}
+			_mockStoragePoolDao.remove(storage.getId());
+			txn.commit();
+			return new Answer(cmd);
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when deleting storage pool " + cmd.getPool().getPath(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+	}
+
+	@Override
+	public ModifyStoragePoolAnswer ModifyStoragePool(ModifyStoragePoolCommand cmd) {
+		StorageFilerTO sf = cmd.getPool();
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		MockStoragePoolVO storagePool = null;
+		try {
+			txn.start();
+			storagePool = _mockStoragePoolDao.findByUuid(sf.getUuid());
+			if (storagePool == null) {
+				storagePool = new MockStoragePoolVO();
+				storagePool.setUuid(sf.getUuid());
+				storagePool.setMountPoint("/mnt/" + sf.getUuid() + File.separator);
+
+				Long size = DEFAULT_HOST_STORAGE_SIZE;
+				String path = sf.getPath();
+				int index = path.lastIndexOf("/");
+				if (index != -1) {
+					path = path.substring(index + 1);
+					if (path != null) {
+						String values[] = path.split("=");
+						if (values.length > 1 && values[0].equalsIgnoreCase("size")) {
+							size = Long.parseLong(values[1]);
+						}
+					}
+				}
+				storagePool.setCapacity(size);
+				storagePool.setStorageType(sf.getType());
+				storagePool = _mockStoragePoolDao.persist(storagePool);
+			}
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when modifying storage pool " + cmd.getPool().getPath(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+		return new ModifyStoragePoolAnswer(cmd, storagePool.getCapacity(), 0, new HashMap<String, TemplateInfo>());
+	}
+
+	@Override
+	public Answer CreateStoragePool(CreateStoragePoolCommand cmd) {
+		StorageFilerTO sf = cmd.getPool();
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		MockStoragePoolVO storagePool = null;
+		try {
+			txn.start();
+			storagePool = _mockStoragePoolDao.findByUuid(sf.getUuid());
+			if (storagePool == null) {
+				storagePool = new MockStoragePoolVO();
+				storagePool.setUuid(sf.getUuid());
+				storagePool.setMountPoint("/mnt/" + sf.getUuid() + File.separator);
+
+				Long size = DEFAULT_HOST_STORAGE_SIZE;
+				String path = sf.getPath();
+				int index = path.lastIndexOf("/");
+				if (index != -1) {
+					path = path.substring(index + 1);
+					if (path != null) {
+						String values[] = path.split("=");
+						if (values.length > 1 && values[0].equalsIgnoreCase("size")) {
+							size = Long.parseLong(values[1]);
+						}
+					}
+				}
+				storagePool.setCapacity(size);
+				storagePool.setStorageType(sf.getType());
+				storagePool = _mockStoragePoolDao.persist(storagePool);
+			}
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when creating storage pool " + cmd.getPool().getPath(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+		return new ModifyStoragePoolAnswer(cmd, storagePool.getCapacity(), 0, new HashMap<String, TemplateInfo>());
+	}
+
+	@Override
+	public Answer SecStorageSetup(SecStorageSetupCommand cmd) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		MockSecStorageVO storage = null;
+		try {
+			txn.start();
+			storage = _mockSecStorageDao.findByUrl(cmd.getSecUrl());
+			if (storage == null) {
+				return new Answer(cmd, false, "can't find the storage");
+			}
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when setting up sec storage" + cmd.getSecUrl(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+		return new SecStorageSetupAnswer(storage.getMountPoint());
+	}
+
+	@Override
+	public Answer ListTemplates(ListTemplateCommand cmd) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		MockSecStorageVO storage = null;
+		try {
+			txn.start();
+			storage = _mockSecStorageDao.findByUrl(cmd.getSecUrl());
+			if (storage == null) {
+				return new Answer(cmd, false, "Failed to get secondary storage");
+			}
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when finding sec storage " + cmd.getSecUrl(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			List<MockVolumeVO> templates = _mockVolumeDao.findByStorageIdAndType(storage.getId(),
+					MockVolumeType.TEMPLATE);
+
+			Map<String, TemplateInfo> templateInfos = new HashMap<String, TemplateInfo>();
+			for (MockVolumeVO template : templates) {
+				templateInfos.put(template.getName(), new TemplateInfo(template.getName(), template.getPath()
+						.replaceAll(storage.getMountPoint(), ""), template.getSize(), template.getSize(), true, false));
+			}
+			txn.commit();
+			return new ListTemplateAnswer(cmd.getSecUrl(), templateInfos);
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when finding template on sec storage " + storage.getId(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+	}
+
+	@Override
+	public Answer Destroy(DestroyCommand cmd) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			MockVolumeVO volume = _mockVolumeDao.findByStoragePathAndType(cmd.getVolume().getPath());
+			if (volume != null) {
+				_mockVolumeDao.remove(volume.getId());
+			}
+
+			if (cmd.getVmName() != null) {
+				MockVm vm = _mockVMDao.findByVmName(cmd.getVmName());
+				vm.setState(State.Expunging);
+				if (vm != null) {
+					MockVMVO vmVo = _mockVMDao.createForUpdate(vm.getId());
+					_mockVMDao.update(vm.getId(), vmVo);
+				}
+			}
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when destroying volume " + cmd.getVolume().getPath(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+		return new Answer(cmd);
+	}
+
+	@Override
+	public DownloadAnswer Download(DownloadCommand cmd) {
+		MockSecStorageVO ssvo = null;
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			ssvo = _mockSecStorageDao.findByUrl(cmd.getSecUrl());
+			if (ssvo == null) {
+				return new DownloadAnswer("can't find secondary storage",
+						VMTemplateStorageResourceAssoc.Status.DOWNLOAD_ERROR);
+			}
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error accessing secondary storage " + cmd.getSecUrl(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		MockVolumeVO volume = new MockVolumeVO();
+		volume.setPoolId(ssvo.getId());
+		volume.setName(cmd.getName());
+		volume.setPath(ssvo.getMountPoint() + cmd.getName());
+		volume.setSize(0);
+		volume.setType(MockVolumeType.TEMPLATE);
+		volume.setStatus(Status.DOWNLOAD_IN_PROGRESS);
+		txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			volume = _mockVolumeDao.persist(volume);
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when saving volume " + volume, ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+		return new DownloadAnswer(String.valueOf(volume.getId()), 0, "Downloading", Status.DOWNLOAD_IN_PROGRESS,
+				cmd.getName(), cmd.getName(), volume.getSize(), volume.getSize(), null);
+	}
+
+	@Override
+	public DownloadAnswer DownloadProcess(DownloadProgressCommand cmd) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			String volumeId = cmd.getJobId();
+			MockVolumeVO volume = _mockVolumeDao.findById(Long.parseLong(volumeId));
+			if (volume == null) {
+				return new DownloadAnswer("Can't find the downloading volume", Status.ABANDONED);
+			}
+
+			long size = Math.min(volume.getSize() + DEFAULT_TEMPLATE_SIZE / 5, DEFAULT_TEMPLATE_SIZE);
+			volume.setSize(size);
+
+			double volumeSize = volume.getSize();
+			double pct = volumeSize / DEFAULT_TEMPLATE_SIZE;
+			if (pct >= 1.0) {
+				volume.setStatus(Status.DOWNLOADED);
+				_mockVolumeDao.update(volume.getId(), volume);
+				txn.commit();
+				return new DownloadAnswer(cmd.getJobId(), 100, cmd,
+						com.cloud.storage.VMTemplateStorageResourceAssoc.Status.DOWNLOADED, volume.getPath(),
+						volume.getName());
+			} else {
+				_mockVolumeDao.update(volume.getId(), volume);
+				txn.commit();
+				return new DownloadAnswer(cmd.getJobId(), (int) (pct * 100.0), cmd,
+						com.cloud.storage.VMTemplateStorageResourceAssoc.Status.DOWNLOAD_IN_PROGRESS, volume.getPath(),
+						volume.getName());
+			}
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error during download job " + cmd.getJobId(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+	}
+
+	@Override
+	public GetStorageStatsAnswer GetStorageStats(GetStorageStatsCommand cmd) {
+		String uuid = cmd.getStorageId();
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			if (uuid == null) {
+				String secUrl = cmd.getSecUrl();
+				MockSecStorageVO secondary = _mockSecStorageDao.findByUrl(secUrl);
+				if (secondary == null) {
+					return new GetStorageStatsAnswer(cmd, "Can't find the secondary storage:" + secUrl);
+				}
+				Long totalUsed = _mockVolumeDao.findTotalStorageId(secondary.getId());
+				txn.commit();
+				return new GetStorageStatsAnswer(cmd, secondary.getCapacity(), totalUsed);
+			} else {
+				MockStoragePoolVO pool = _mockStoragePoolDao.findByUuid(uuid);
+				if (pool == null) {
+					return new GetStorageStatsAnswer(cmd, "Can't find the pool");
+				}
+				Long totalUsed = _mockVolumeDao.findTotalStorageId(pool.getId());
+				if (totalUsed == null) {
+					totalUsed = 0L;
+				}
+				txn.commit();
+				return new GetStorageStatsAnswer(cmd, pool.getCapacity(), totalUsed);
+			}
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("DBException during storage stats collection for pool " + uuid, ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+	}
+
+	@Override
+	public ManageSnapshotAnswer ManageSnapshot(ManageSnapshotCommand cmd) {
+		String volPath = cmd.getVolumePath();
+		MockVolumeVO volume = null;
+		MockStoragePoolVO storagePool = null;
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			volume = _mockVolumeDao.findByStoragePathAndType(volPath);
+			if (volume == null) {
+				return new ManageSnapshotAnswer(cmd, false, "Can't find the volume");
+			}
+			storagePool = _mockStoragePoolDao.findById(volume.getPoolId());
+			if (storagePool == null) {
+				return new ManageSnapshotAnswer(cmd, false, "Can't find the storage pooll");
+			}
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Unable to perform snapshot", ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		String mountPoint = storagePool.getMountPoint();
+		MockVolumeVO snapshot = new MockVolumeVO();
+
+		snapshot.setName(cmd.getSnapshotName());
+		snapshot.setPath(mountPoint + cmd.getSnapshotName());
+		snapshot.setSize(volume.getSize());
+		snapshot.setPoolId(storagePool.getId());
+		snapshot.setType(MockVolumeType.SNAPSHOT);
+		snapshot.setStatus(Status.DOWNLOADED);
+		txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			snapshot = _mockVolumeDao.persist(snapshot);
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when saving snapshot " + snapshot, ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		return new ManageSnapshotAnswer(cmd, snapshot.getId(), snapshot.getPath(), true, "");
+	}
+
+	@Override
+	public BackupSnapshotAnswer BackupSnapshot(BackupSnapshotCommand cmd, SimulatorInfo info) {
+		// emulate xenserver backupsnapshot, if the base volume is deleted, then
+		// backupsnapshot failed
+		MockVolumeVO volume = null;
+		MockVolumeVO snapshot = null;
+		MockSecStorageVO secStorage = null;
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			volume = _mockVolumeDao.findByStoragePathAndType(cmd.getVolumePath());
+			if (volume == null) {
+				return new BackupSnapshotAnswer(cmd, false, "Can't find base volume: " + cmd.getVolumePath(), null,
+						true);
+			}
+			String snapshotPath = cmd.getSnapshotUuid();
+			snapshot = _mockVolumeDao.findByStoragePathAndType(snapshotPath);
+			if (snapshot == null) {
+				return new BackupSnapshotAnswer(cmd, false, "can't find snapshot" + snapshotPath, null, true);
+			}
+
+			String secStorageUrl = cmd.getSecondaryStorageUrl();
+			secStorage = _mockSecStorageDao.findByUrl(secStorageUrl);
+			if (secStorage == null) {
+				return new BackupSnapshotAnswer(cmd, false, "can't find sec storage" + snapshotPath, null, true);
+			}
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when backing up snapshot");
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		MockVolumeVO newsnapshot = new MockVolumeVO();
+		String name = UUID.randomUUID().toString();
+		newsnapshot.setName(name);
+		newsnapshot.setPath(secStorage.getMountPoint() + name);
+		newsnapshot.setPoolId(secStorage.getId());
+		newsnapshot.setSize(snapshot.getSize());
+		newsnapshot.setStatus(Status.DOWNLOADED);
+		newsnapshot.setType(MockVolumeType.SNAPSHOT);
+		txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			snapshot = _mockVolumeDao.persist(snapshot);
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when backing up snapshot " + newsnapshot, ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		return new BackupSnapshotAnswer(cmd, true, null, newsnapshot.getName(), true);
+	}
+
+	@Override
+	public Answer DeleteSnapshotBackup(DeleteSnapshotBackupCommand cmd) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			MockVolumeVO backSnapshot = _mockVolumeDao.findByName(cmd.getSnapshotUuid());
+			if (backSnapshot == null) {
+				return new Answer(cmd, false, "can't find the backupsnapshot: " + cmd.getSnapshotUuid());
+			}
+			_mockVolumeDao.remove(backSnapshot.getId());
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when deleting snapshot");
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+		return new Answer(cmd);
+	}
+
+	@Override
+	public CreateVolumeFromSnapshotAnswer CreateVolumeFromSnapshot(CreateVolumeFromSnapshotCommand cmd) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		MockVolumeVO backSnapshot = null;
+		MockStoragePoolVO primary = null;
+		try {
+			txn.start();
+			backSnapshot = _mockVolumeDao.findByName(cmd.getSnapshotUuid());
+			if (backSnapshot == null) {
+				return new CreateVolumeFromSnapshotAnswer(cmd, false, "can't find the backupsnapshot: "
+						+ cmd.getSnapshotUuid(), null);
+			}
+
+			primary = _mockStoragePoolDao.findByUuid(cmd.getPrimaryStoragePoolNameLabel());
+			if (primary == null) {
+				return new CreateVolumeFromSnapshotAnswer(cmd, false, "can't find the primary storage: "
+						+ cmd.getPrimaryStoragePoolNameLabel(), null);
+			}
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when creating volume from snapshot", ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		String uuid = UUID.randomUUID().toString();
+		MockVolumeVO volume = new MockVolumeVO();
+
+		volume.setName(uuid);
+		volume.setPath(primary.getMountPoint() + uuid);
+		volume.setPoolId(primary.getId());
+		volume.setSize(backSnapshot.getSize());
+		volume.setStatus(Status.DOWNLOADED);
+		volume.setType(MockVolumeType.VOLUME);
+		txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			_mockVolumeDao.persist(volume);
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when creating volume from snapshot " + volume, ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		return new CreateVolumeFromSnapshotAnswer(cmd, true, null, volume.getPath());
+	}
+
+	@Override
+	public Answer DeleteTemplate(DeleteTemplateCommand cmd) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			MockVolumeVO template = _mockVolumeDao.findByStoragePathAndType(cmd.getTemplatePath());
+			if (template == null) {
+				return new Answer(cmd, false, "can't find template:" + cmd.getTemplatePath());
+			}
+			_mockVolumeDao.remove(template.getId());
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when deleting template");
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+		return new Answer(cmd);
+	}
+
+	@Override
+	public Answer SecStorageVMSetup(SecStorageVMSetupCommand cmd) {
+		return new Answer(cmd);
+	}
+
+	@Override
+	public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
+		// TODO Auto-generated method stub
+		return true;
+	}
+
+	@Override
+	public boolean start() {
+		// TODO Auto-generated method stub
+		return true;
+	}
+
+	@Override
+	public boolean stop() {
+		// TODO Auto-generated method stub
+		return true;
+	}
+
+	@Override
+	public String getName() {
+		return this.getClass().getSimpleName();
+	}
+
+	@Override
+	public void preinstallTemplates(String url, long zoneId) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		MockSecStorageVO storage = null;
+		try {
+			txn.start();
+			storage = _mockSecStorageDao.findByUrl(url);
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Unable to find sec storage at " + url, ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+		if (storage == null) {
+			storage = new MockSecStorageVO();
+			URI uri;
+			try {
+				uri = new URI(url);
+			} catch (URISyntaxException e) {
+				return;
+			}
+
+			String nfsHost = uri.getHost();
+			String nfsPath = uri.getPath();
+			String path = nfsHost + ":" + nfsPath;
+			String dir = "/mnt/" + UUID.nameUUIDFromBytes(path.getBytes()).toString() + File.separator;
+
+			storage.setUrl(url);
+			storage.setCapacity(DEFAULT_HOST_STORAGE_SIZE);
+
+			storage.setMountPoint(dir);
+			txn = Transaction.open(Transaction.SIMULATOR_DB);
+			try {
+				txn.start();
+				storage = _mockSecStorageDao.persist(storage);
+				txn.commit();
+			} catch (Exception ex) {
+				txn.rollback();
+				throw new CloudRuntimeException("Error when saving storage " + storage, ex);
+			} finally {
+				txn.close();
+                txn = Transaction.open(Transaction.CLOUD_DB);
+                txn.close();
+			}
+
+			// preinstall default templates into secondary storage
+			long defaultTemplateSize = 2 * 1024 * 1024 * 1024L;
+			MockVolumeVO template = new MockVolumeVO();
+			template.setName("simulator-domR");
+			template.setPath(storage.getMountPoint() + "template/tmpl/1/9/" + UUID.randomUUID().toString());
+			template.setPoolId(storage.getId());
+			template.setSize(defaultTemplateSize);
+			template.setType(MockVolumeType.TEMPLATE);
+			template.setStatus(Status.DOWNLOADED);
+			txn = Transaction.open(Transaction.SIMULATOR_DB);
+			try {
+				txn.start();
+				template = _mockVolumeDao.persist(template);
+				txn.commit();
+			} catch (Exception ex) {
+				txn.rollback();
+				throw new CloudRuntimeException("Error when saving template " + template, ex);
+			} finally {
+				txn.close();
+                txn = Transaction.open(Transaction.CLOUD_DB);
+                txn.close();
+			}
+
+			template = new MockVolumeVO();
+			template.setName("simulator-Centos");
+			template.setPath(storage.getMountPoint() + "template/tmpl/1/10/" + UUID.randomUUID().toString());
+			template.setPoolId(storage.getId());
+			template.setSize(defaultTemplateSize);
+			template.setType(MockVolumeType.TEMPLATE);
+			template.setStatus(Status.DOWNLOADED);
+			txn = Transaction.open(Transaction.SIMULATOR_DB);
+			try {
+				txn.start();
+				template = _mockVolumeDao.persist(template);
+				txn.commit();
+			} catch (Exception ex) {
+				txn.rollback();
+				throw new CloudRuntimeException("Error when saving template " + template, ex);
+			} finally {
+				txn.close();
+                txn = Transaction.open(Transaction.CLOUD_DB);
+                txn.close();
+			}
+		}
+
+	}
+
+	@Override
+	public StoragePoolInfo getLocalStorage(String hostGuid) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		MockHost host = null;
+		MockStoragePoolVO storagePool = null;
+		try {
+			txn.start();
+			host = _mockHostDao.findByGuid(hostGuid);
+			storagePool = _mockStoragePoolDao.findByHost(hostGuid);
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Unable to find host " + hostGuid, ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		if (storagePool == null) {
+			String uuid = UUID.randomUUID().toString();
+			storagePool = new MockStoragePoolVO();
+			storagePool.setUuid(uuid);
+			storagePool.setMountPoint("/mnt/" + uuid + File.separator);
+			storagePool.setCapacity(DEFAULT_HOST_STORAGE_SIZE);
+			storagePool.setHostGuid(hostGuid);
+			storagePool.setStorageType(StoragePoolType.Filesystem);
+			txn = Transaction.open(Transaction.SIMULATOR_DB);
+			try {
+				txn.start();
+				storagePool = _mockStoragePoolDao.persist(storagePool);
+				txn.commit();
+			} catch (Exception ex) {
+				txn.rollback();
+				throw new CloudRuntimeException("Error when saving storagePool " + storagePool, ex);
+			} finally {
+				txn.close();
+                txn = Transaction.open(Transaction.CLOUD_DB);
+                txn.close();
+			}
+		}
+		return new StoragePoolInfo(storagePool.getUuid(), host.getPrivateIpAddress(), storagePool.getMountPoint(),
+				storagePool.getMountPoint(), storagePool.getPoolType(), storagePool.getCapacity(), 0);
+	}
+
+	@Override
+	public StoragePoolInfo getLocalStorage(String hostGuid, Long storageSize) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		MockHost host = null;
+		try {
+			txn.start();
+			host = _mockHostDao.findByGuid(hostGuid);
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Unable to find host " + hostGuid, ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+		if (storageSize == null) {
+			storageSize = DEFAULT_HOST_STORAGE_SIZE;
+		}
+		txn = Transaction.open(Transaction.SIMULATOR_DB);
+		MockStoragePoolVO storagePool = null;
+		try {
+			txn.start();
+			storagePool = _mockStoragePoolDao.findByHost(hostGuid);
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when finding storagePool " + storagePool, ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+		if (storagePool == null) {
+			String uuid = UUID.randomUUID().toString();
+			storagePool = new MockStoragePoolVO();
+			storagePool.setUuid(uuid);
+			storagePool.setMountPoint("/mnt/" + uuid + File.separator);
+			storagePool.setCapacity(storageSize);
+			storagePool.setHostGuid(hostGuid);
+			storagePool.setStorageType(StoragePoolType.Filesystem);
+			txn = Transaction.open(Transaction.SIMULATOR_DB);
+			try {
+				txn.start();
+				storagePool = _mockStoragePoolDao.persist(storagePool);
+				txn.commit();
+			} catch (Exception ex) {
+				txn.rollback();
+				throw new CloudRuntimeException("Error when saving storagePool " + storagePool, ex);
+			} finally {
+				txn.close();
+                txn = Transaction.open(Transaction.CLOUD_DB);
+                txn.close();
+			}
+		}
+		return new StoragePoolInfo(storagePool.getUuid(), host.getPrivateIpAddress(), storagePool.getMountPoint(),
+				storagePool.getMountPoint(), storagePool.getPoolType(), storagePool.getCapacity(), 0);
+	}
+
+	@Override
+	public CreatePrivateTemplateAnswer CreatePrivateTemplateFromSnapshot(CreatePrivateTemplateFromSnapshotCommand cmd) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		MockVolumeVO snapshot = null;
+		MockSecStorageVO sec = null;
+		try {
+			txn.start();
+			String snapshotUUId = cmd.getSnapshotUuid();
+			snapshot = _mockVolumeDao.findByName(snapshotUUId);
+			if (snapshot == null) {
+				snapshotUUId = cmd.getSnapshotName();
+				snapshot = _mockVolumeDao.findByName(snapshotUUId);
+				if (snapshot == null) {
+					return new CreatePrivateTemplateAnswer(cmd, false, "can't find snapshot:" + snapshotUUId);
+				}
+			}
+
+			sec = _mockSecStorageDao.findByUrl(cmd.getSecondaryStorageUrl());
+			if (sec == null) {
+				return new CreatePrivateTemplateAnswer(cmd, false, "can't find secondary storage");
+			}
+			txn.commit();
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		MockVolumeVO template = new MockVolumeVO();
+		String uuid = UUID.randomUUID().toString();
+		template.setName(uuid);
+		template.setPath(sec.getMountPoint() + uuid);
+		template.setPoolId(sec.getId());
+		template.setSize(snapshot.getSize());
+		template.setStatus(Status.DOWNLOADED);
+		template.setType(MockVolumeType.TEMPLATE);
+		txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			template = _mockVolumeDao.persist(template);
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when saving template " + template, ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		return new CreatePrivateTemplateAnswer(cmd, true, "", template.getName(), template.getSize(),
+				template.getSize(), template.getName(), ImageFormat.QCOW2);
+	}
+
+	@Override
+	public Answer ComputeChecksum(ComputeChecksumCommand cmd) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			MockVolumeVO volume = _mockVolumeDao.findByName(cmd.getTemplatePath());
+			if (volume == null) {
+				return new Answer(cmd, false, "cant' find volume:" + cmd.getTemplatePath());
+			}
+			String md5 = null;
+			try {
+				MessageDigest md = MessageDigest.getInstance("md5");
+				md5 = String.format("%032x", new BigInteger(1, md.digest(cmd.getTemplatePath().getBytes())));
+			} catch (NoSuchAlgorithmException e) {
+				s_logger.debug("failed to gernerate md5:" + e.toString());
+			}
+			txn.commit();
+			return new Answer(cmd, true, md5);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+	}
+
+	@Override
+	public CreatePrivateTemplateAnswer CreatePrivateTemplateFromVolume(CreatePrivateTemplateFromVolumeCommand cmd) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		MockVolumeVO volume = null;
+		MockSecStorageVO sec = null;
+		try {
+			txn.start();
+			volume = _mockVolumeDao.findByStoragePathAndType(cmd.getVolumePath());
+			if (volume == null) {
+				return new CreatePrivateTemplateAnswer(cmd, false, "cant' find volume" + cmd.getVolumePath());
+			}
+
+			sec = _mockSecStorageDao.findByUrl(cmd.getSecondaryStorageUrl());
+			if (sec == null) {
+				return new CreatePrivateTemplateAnswer(cmd, false, "can't find secondary storage");
+			}
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Error when creating private template from volume");
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		MockVolumeVO template = new MockVolumeVO();
+		String uuid = UUID.randomUUID().toString();
+		template.setName(uuid);
+		template.setPath(sec.getMountPoint() + uuid);
+		template.setPoolId(sec.getId());
+		template.setSize(volume.getSize());
+		template.setStatus(Status.DOWNLOADED);
+		template.setType(MockVolumeType.TEMPLATE);
+		txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			template = _mockVolumeDao.persist(template);
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Encountered " + ex.getMessage() + " when persisting template "
+					+ template.getName(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		return new CreatePrivateTemplateAnswer(cmd, true, "", template.getName(), template.getSize(),
+				template.getSize(), template.getName(), ImageFormat.QCOW2);
+	}
+
+	@Override
+	public CopyVolumeAnswer CopyVolume(CopyVolumeCommand cmd) {
+		Transaction txn = Transaction.open(Transaction.SIMULATOR_DB);
+		boolean toSecondaryStorage = cmd.toSecondaryStorage();
+		MockSecStorageVO sec = null;
+		MockStoragePoolVO primaryStorage = null;
+		try {
+			txn.start();
+			sec = _mockSecStorageDao.findByUrl(cmd.getSecondaryStorageURL());
+			if (sec == null) {
+				return new CopyVolumeAnswer(cmd, false, "can't find secondary storage", null, null);
+			}
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Encountered " + ex.getMessage() + " when accessing secondary at "
+					+ cmd.getSecondaryStorageURL(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			primaryStorage = _mockStoragePoolDao.findByUuid(cmd.getPool().getUuid());
+			if (primaryStorage == null) {
+				return new CopyVolumeAnswer(cmd, false, "Can't find primary storage", null, null);
+			}
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Encountered " + ex.getMessage() + " when accessing primary at "
+					+ cmd.getPool(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		MockVolumeVO volume = null;
+		txn = Transaction.open(Transaction.SIMULATOR_DB);
+		try {
+			txn.start();
+			volume = _mockVolumeDao.findByStoragePathAndType(cmd.getVolumePath());
+			if (volume == null) {
+				return new CopyVolumeAnswer(cmd, false, "cant' find volume" + cmd.getVolumePath(), null, null);
+			}
+			txn.commit();
+		} catch (Exception ex) {
+			txn.rollback();
+			throw new CloudRuntimeException("Encountered " + ex.getMessage() + " when accessing volume at "
+					+ cmd.getVolumePath(), ex);
+		} finally {
+			txn.close();
+            txn = Transaction.open(Transaction.CLOUD_DB);
+            txn.close();
+		}
+
+		String name = UUID.randomUUID().toString();
+		if (toSecondaryStorage) {
+			MockVolumeVO vol = new MockVolumeVO();
+			vol.setName(name);
+			vol.setPath(sec.getMountPoint() + name);
+			vol.setPoolId(sec.getId());
+			vol.setSize(volume.getSize());
+			vol.setStatus(Status.DOWNLOADED);
+			vol.setType(MockVolumeType.VOLUME);
+			txn = Transaction.open(Transaction.SIMULATOR_DB);
+			try {
+				txn.start();
+				vol = _mockVolumeDao.persist(vol);
+				txn.commit();
+			} catch (Exception ex) {
+				txn.rollback();
+				throw new CloudRuntimeException("Encountered " + ex.getMessage() + " when persisting volume "
+						+ vol.getName(), ex);
+			} finally {
+				txn.close();
+                txn = Transaction.open(Transaction.CLOUD_DB);
+                txn.close();
+			}
+			return new CopyVolumeAnswer(cmd, true, null, sec.getMountPoint(), vol.getPath());
+		} else {
+			MockVolumeVO vol = new MockVolumeVO();
+			vol.setName(name);
+			vol.setPath(primaryStorage.getMountPoint() + name);
+			vol.setPoolId(primaryStorage.getId());
+			vol.setSize(volume.getSize());
+			vol.setStatus(Status.DOWNLOADED);
+			vol.setType(MockVolumeType.VOLUME);
+			txn = Transaction.open(Transaction.SIMULATOR_DB);
+			try {
+				txn.start();
+				vol = _mockVolumeDao.persist(vol);
+				txn.commit();
+			} catch (Exception ex) {
+				txn.rollback();
+				throw new CloudRuntimeException("Encountered " + ex.getMessage() + " when persisting volume "
+						+ vol.getName(), ex);
+			} finally {
+				txn.close();
+                txn = Transaction.open(Transaction.CLOUD_DB);
+                txn.close();
+			}
+			return new CopyVolumeAnswer(cmd, true, null, primaryStorage.getMountPoint(), vol.getPath());
+		}
+	}
+}

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/d6083ce5/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockVmManager.java
----------------------------------------------------------------------
diff --git a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockVmManager.java b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockVmManager.java
new file mode 100644
index 0000000..82f600d
--- /dev/null
+++ b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockVmManager.java
@@ -0,0 +1,83 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+package com.cloud.agent.manager;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.cloud.agent.api.*;
+import com.cloud.agent.api.check.CheckSshAnswer;
+import com.cloud.agent.api.check.CheckSshCommand;
+import com.cloud.agent.api.proxy.CheckConsoleProxyLoadCommand;
+import com.cloud.agent.api.proxy.WatchConsoleProxyLoadCommand;
+import com.cloud.agent.api.routing.DhcpEntryCommand;
+import com.cloud.agent.api.routing.IpAssocCommand;
+import com.cloud.agent.api.routing.LoadBalancerConfigCommand;
+import com.cloud.agent.api.routing.SavePasswordCommand;
+import com.cloud.agent.api.routing.SetFirewallRulesCommand;
+import com.cloud.agent.api.routing.SetPortForwardingRulesCommand;
+import com.cloud.agent.api.routing.SetStaticNatRulesCommand;
+import com.cloud.agent.api.routing.VmDataCommand;
+import com.cloud.simulator.MockVMVO;
+import com.cloud.utils.Pair;
+import com.cloud.utils.component.Manager;
+import com.cloud.vm.VirtualMachine.State;
+
+public interface MockVmManager extends Manager {
+    public Answer stopVM(StopCommand cmd);
+	public Answer rebootVM(RebootCommand cmd);
+
+    public Answer checkVmState(CheckVirtualMachineCommand cmd);
+    public Map<String, State> getVmStates(String hostGuid);
+    public Answer getVncPort(GetVncPortCommand cmd);
+
+	Answer startVM(StartCommand cmd, SimulatorInfo info);
+
+	Answer getVmStats(GetVmStatsCommand cmd);
+    public CheckSshAnswer checkSshCommand(CheckSshCommand cmd);
+
+    Answer SetStaticNatRules(SetStaticNatRulesCommand cmd);
+
+    Answer SetPortForwardingRules(SetPortForwardingRulesCommand cmd);
+
+    Answer SetFirewallRules(SetFirewallRulesCommand cmd);
+
+    Answer getNetworkUsage(NetworkUsageCommand cmd);
+
+    Answer IpAssoc(IpAssocCommand cmd);
+
+    Answer LoadBalancerConfig(LoadBalancerConfigCommand cmd);
+
+    Answer AddDhcpEntry(DhcpEntryCommand cmd);
+
+    Answer setVmData(VmDataCommand cmd);
+    Answer CleanupNetworkRules(CleanupNetworkRulesCmd cmd, SimulatorInfo info);
+
+    Answer CheckConsoleProxyLoad(CheckConsoleProxyLoadCommand cmd);
+    Answer WatchConsoleProxyLoad(WatchConsoleProxyLoadCommand cmd);
+
+    Answer SavePassword(SavePasswordCommand cmd);
+    HashMap<String, Pair<Long, Long>> syncNetworkGroups(SimulatorInfo info);
+    SecurityGroupRuleAnswer AddSecurityGroupRules(SecurityGroupRulesCmd cmd, SimulatorInfo info);
+	MigrateAnswer Migrate(MigrateCommand cmd, SimulatorInfo info);
+	GetDomRVersionAnswer getDomRVersion(GetDomRVersionCmd cmd);
+	Map<String, MockVMVO> getVms(String hostGuid);
+
+    CheckRouterAnswer checkRouter(CheckRouterCommand cmd);
+
+    Answer bumpPriority(BumpUpPriorityCommand cmd);
+}


Mime
View raw message