// 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.mockvm;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Random;

import java.util.Set;

import org.apache.log4j.Logger;

import com.cloud.agent.api.to.VirtualMachineTO;

import com.cloud.utils.exception.CloudRuntimeException;

import com.cloud.vm.VirtualMachine.State;

public class MockVmMgr implements VmMgr {

private static final Logger s_logger = Logger.getLogger(MockVmMgr.class);

private static final int DEFAULT_DOM0_MEM_MB = 128;

private static final Random randSeed = new Random();

private final Map<String, MockVm> vms = new HashMap<String, MockVm>();

private long vncPortMap = 0;

private Map<String, Object> _params = null;

public MockVmMgr() {

}

@Override

public Set<String> getCurrentVMs() {

HashSet<String> vmNameSet = new HashSet<String>();

synchronized (this) {

for (String vmName : vms.keySet())

vmNameSet.add(vmName);

}

return vmNameSet;

}

@Override

public String startVM(String vmName, String vnetId, String gateway,

String dns, String privateIP, String privateMac,

String privateMask, String publicIP, String publicMac,

String publicMask, int cpuCount, int cpuUtilization, long ramSize,

String localPath, String vncPassword) {

if (s_logger.isInfoEnabled()) {

StringBuffer sb = new StringBuffer();

sb.append("Start VM. name: " + vmName + ", vnet: " + vnetId

+ ", dns: " + dns);

sb.append(", privateIP: " + privateIP + ", privateMac: "

+ privateMac + ", privateMask: " + privateMask);

sb.append(", publicIP: " + publicIP + ", publicMac: " + publicMac

+ ", publicMask: " + publicMask);

sb.append(", cpu count: " + cpuCount + ", cpuUtilization: "

+ cpuUtilization + ", ram : " + ramSize);

sb.append(", localPath: " + localPath);

s_logger.info(sb.toString());

}

synchronized (this) {

MockVm vm = vms.get(vmName);

if (vm == null) {

if (ramSize > getHostFreeMemory())

return "Out of memory";

int vncPort = allocVncPort();

if (vncPort < 0)

return "Unable to allocate VNC port";

vm = new MockVm(vmName, State.Running, ramSize, cpuCount,

cpuUtilization, vncPort);

vms.put(vmName, vm);

}

}

return null;

}

@Override

public String stopVM(String vmName, boolean force) {

if (s_logger.isInfoEnabled())

s_logger.info("Stop VM. name: " + vmName);

synchronized (this) {

MockVm vm = vms.get(vmName);

if (vm != null) {

vm.setState(State.Stopped);

freeVncPort(vm.getVncPort());

}

}

return null;

}

@Override

public String rebootVM(String vmName) {

if (s_logger.isInfoEnabled())

s_logger.info("Reboot VM. name: " + vmName);

synchronized (this) {

MockVm vm = vms.get(vmName);

if (vm != null)

vm.setState(State.Running);

}

return null;

}

@Override

public boolean migrate(String vmName, String params) {

if (s_logger.isInfoEnabled())

s_logger.info("Migrate VM. name: " + vmName);

synchronized (this) {

MockVm vm = vms.get(vmName);

if (vm != null) {

vm.setState(State.Stopped);

freeVncPort(vm.getVncPort());

vms.remove(vmName);

return true;

}

}

return false;

}

public MockVm getVm(String vmName) {

synchronized (this) {

MockVm vm = vms.get(vmName);

return vm;

}

}

@Override

public State checkVmState(String vmName) {

synchronized (this) {

MockVm vm = vms.get(vmName);

if (vm != null)

return vm.getState();

}

return State.Unknown;

}

@Override

public Map<String, State> getVmStates() {

Map<String, State> states = new HashMap<String, State>();

synchronized (this) {

for (MockVm vm : vms.values()) {

states.put(vm.getName(), vm.getState());

}

}

return states;

}

@Override

public void cleanupVM(String vmName, String local, String vnet) {

synchronized (this) {

MockVm vm = vms.get(vmName);

if (vm != null) {

freeVncPort(vm.getVncPort());

}

vms.remove(vmName);

}

}

@Override

public double getHostCpuUtilization() {

return 0.0d;

}

@Override

public int getHostCpuCount() {

return getConfiguredProperty("cpus", 4);

}

@Override

public long getHostCpuSpeed() {

return getConfiguredProperty("cpuspeed", 4000L);

}

@Override

public long getHostTotalMemory() { // total memory in bytes

return getConfiguredProperty("memory", 16000L);

}

@Override

public long getHostFreeMemory() { // free memory in bytes

long memSize = getHostTotalMemory();

memSize -= getHostDom0Memory();

synchronized (this) {

for (MockVm vm : vms.values()) {

if (vm.getState() != State.Stopped)

memSize -= vm.getRamSize();

}

}

return memSize;

}

@Override

public long getHostDom0Memory() { // memory size in bytes

return DEFAULT_DOM0_MEM_MB * 1024 * 1024L;

}

@Override

public String cleanupVnet(String vnetId) {

return null;

}

@Override

public Integer getVncPort(String name) {

synchronized (this) {

MockVm vm = vms.get(name);

if (vm != null)

return vm.getVncPort();

}

return new Integer(-1);

}

public int allocVncPort() {

for (int i = 0; i < 64; i++) {

if (((1L << i) & vncPortMap) == 0) {

vncPortMap |= (1L << i);

return i;

}

}

return -1;

}

public void freeVncPort(int port) {

vncPortMap &= ~(1L << port);

}

@Override

public MockVm createVmFromSpec(VirtualMachineTO vmSpec) {

String vmName = vmSpec.getName();

long ramSize = vmSpec.getMinRam();

int utilizationPercent = randSeed.nextInt() % 100;

MockVm vm = null;

synchronized (this) {

vm = vms.get(vmName);

if (vm == null) {

if (ramSize > getHostFreeMemory()) {

s_logger.debug("host is out of memory");

throw new CloudRuntimeException("Host is out of Memory");

}

int vncPort = allocVncPort();

if (vncPort < 0) {

s_logger.debug("Unable to allocate VNC port");

throw new CloudRuntimeException(

"Unable to allocate vnc port");

}

vm = new MockVm(vmName, State.Running, ramSize,

vmSpec.getCpus(), utilizationPercent, vncPort);

vms.put(vmName, vm);

}

}

return vm;

}

@Override

public void createVbd(VirtualMachineTO vmSpec, String vmName, MockVm vm) {

// TODO Auto-generated method stub

}

@Override

public void createVif(VirtualMachineTO vmSpec, String vmName, MockVm vm) {

// TODO Auto-generated method stub

}

@Override

public void configure(Map<String, Object> params) {

_params = params;

}

protected Long getConfiguredProperty(String key, Long defaultValue) {

String val = (String) _params.get(key);

if (val != null) {

Long result = Long.parseLong(val);

return result;

}

return defaultValue;

}

protected Integer getConfiguredProperty(String key, Integer defaultValue) {

String val = (String) _params.get(key);

if (val != null) {

Integer result = Integer.parseInt(val);

return result;

}

return defaultValue;

}

}