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

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Executors;

import javax.ejb.Local;
import javax.naming.ConfigurationException;

import org.apache.cloudstack.api.command.user.template.CreateTemplateCmd;
import org.apache.cloudstack.api.command.user.vm.DeployVMCmd;
import org.apache.cloudstack.api.command.user.vm.UpgradeVMCmd;
import org.apache.cloudstack.api.command.user.volume.AttachVolumeCmd;
import org.apache.cloudstack.api.command.user.volume.DetachVolumeCmd;
import org.apache.log4j.Logger;

import com.cloud.agent.api.Answer;
import com.cloud.agent.api.StopAnswer;
import com.cloud.agent.api.baremetal.IpmISetBootDevCommand;
import com.cloud.agent.api.baremetal.IpmiBootorResetCommand;
import com.cloud.agent.manager.Commands;
import org.apache.cloudstack.api.command.user.vm.StartVMCmd;
import com.cloud.baremetal.PxeServerManager.PxeServerType;
import com.cloud.configuration.Resource.ResourceType;
import com.cloud.configuration.dao.ConfigurationDao;
import com.cloud.dc.DataCenter.NetworkType;
import com.cloud.dc.DataCenterVO;
import com.cloud.deploy.DataCenterDeployment;
import com.cloud.deploy.DeployDestination;
import com.cloud.domain.DomainVO;
import com.cloud.event.EventTypes;
import com.cloud.event.UsageEventVO;
import com.cloud.exception.ConcurrentOperationException;
import com.cloud.exception.InsufficientCapacityException;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.PermissionDeniedException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.exception.StorageUnavailableException;
import com.cloud.host.Host;
import com.cloud.host.HostVO;
import com.cloud.hypervisor.Hypervisor.HypervisorType;
import com.cloud.network.Network;
import com.cloud.network.NetworkVO;
import com.cloud.network.Networks.TrafficType;
import com.cloud.org.Grouping;
import com.cloud.resource.ResourceManager;
import com.cloud.service.ServiceOfferingVO;
import com.cloud.storage.Storage;
import com.cloud.storage.Storage.TemplateType;
import com.cloud.storage.VMTemplateVO;
import com.cloud.storage.Volume;
import com.cloud.template.TemplateAdapter;
import com.cloud.template.TemplateAdapter.TemplateAdapterType;
import com.cloud.template.TemplateProfile;
import com.cloud.user.Account;
import com.cloud.user.AccountVO;
import com.cloud.user.SSHKeyPair;
import com.cloud.user.User;
import com.cloud.user.UserContext;
import com.cloud.uservm.UserVm;
import com.cloud.utils.NumbersUtil;
import com.cloud.utils.Pair;
import com.cloud.utils.component.Adapters;
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.exception.CloudRuntimeException;
import com.cloud.utils.fsm.StateListener;
import com.cloud.utils.net.NetUtils;
import com.cloud.vm.BareMetalVmService;
import com.cloud.vm.NicProfile;
import com.cloud.vm.NicVO;
import com.cloud.vm.ReservationContext;
import com.cloud.vm.UserVmManagerImpl;
import com.cloud.vm.UserVmVO;
import com.cloud.vm.VirtualMachine;
import com.cloud.vm.VirtualMachine.Event;
import com.cloud.vm.VirtualMachine.State;
import com.cloud.vm.VirtualMachine.Type;
import com.cloud.vm.VirtualMachineName;
import com.cloud.vm.VirtualMachineProfile;
import com.cloud.vm.VirtualMachineProfile.Param;

@Local(value={BareMetalVmManager.class, BareMetalVmService.class})
public class BareMetalVmManagerImpl extends UserVmManagerImpl implements BareMetalVmManager, BareMetalVmService, Manager,
		StateListener<State, VirtualMachine.Event, VirtualMachine> {
	private static final Logger s_logger = Logger.getLogger(BareMetalVmManagerImpl.class); 
	private ConfigurationDao _configDao;
	@Inject PxeServerManager _pxeMgr;
	@Inject ResourceManager _resourceMgr;
	
    @Inject (adapter=TemplateAdapter.class)
    protected Adapters<TemplateAdapter> _adapters;

	@Override
	public boolean attachISOToVM(long vmId, long isoId, boolean attach) {
		s_logger.warn("attachISOToVM is not supported by Bare Metal, just fake a true");
		return true;
	}
	
	@Override
	public Volume attachVolumeToVM(AttachVolumeCmd command) {
		s_logger.warn("attachVolumeToVM is not supported by Bare Metal, return null");
		return null;
	}
	
	@Override
	public Volume detachVolumeFromVM(DetachVolumeCmd cmd) {
		s_logger.warn("detachVolumeFromVM is not supported by Bare Metal, return null");
		return null;
	}
	
	@Override
	public UserVm upgradeVirtualMachine(UpgradeVMCmd cmd) {
		s_logger.warn("upgradeVirtualMachine is not supported by Bare Metal, return null");
		return null;
	}
	
	@Override
    public VMTemplateVO createPrivateTemplateRecord(CreateTemplateCmd cmd, Account templateOwner) throws ResourceAllocationException {
		/*Baremetal creates record after host rebooting for imaging, in createPrivateTemplate*/
		return null;
	}
	
	@Override @DB
    public VMTemplateVO createPrivateTemplate(CreateTemplateCmd cmd) throws CloudRuntimeException {
	    Long vmId = cmd.getVmId();
	    if (vmId == null) {
	        throw new InvalidParameterValueException("VM ID is null");
	    }
	    
	    UserVmVO vm = _vmDao.findById(vmId);
	    if (vm == null) {
	        throw new InvalidParameterValueException("Cannot find VM for ID " + vmId);
	    }
	    
	    Long hostId = (vm.getHostId() == null ? vm.getLastHostId() : vm.getHostId());
        HostVO host = _hostDao.findById(hostId);
        if (host == null) {
            throw new InvalidParameterValueException("Cannot find host with id " + hostId);
        }

        List<HostVO> pxes = _resourceMgr.listAllUpAndEnabledHosts(Host.Type.PxeServer, null, host.getPodId(), host.getDataCenterId());
        if (pxes.size() == 0) {
            throw new CloudRuntimeException("Please add PXE server in Pod before taking image");
        }

        if (pxes.size() > 1) {
        	CloudRuntimeException ex = new CloudRuntimeException("Multiple PXE servers found in Pod " + host.getPodId() + " in Zone with specified id");
            ex.addProxyObject("data_center", host.getDataCenterId(), "zoneId");
            throw ex;
        }

        HostVO pxe = pxes.get(0);
        /*
         * prepare() will check if current account has right for creating
         * template
         */
        TemplateAdapter adapter = _adapters.get(TemplateAdapterType.BareMetal.getName());
        Long userId = UserContext.current().getCallerUserId();
        userId = (userId == null ? User.UID_SYSTEM : userId);
        AccountVO account = _accountDao.findById(vm.getAccountId());
      
        try {
            TemplateProfile tmplProfile;
            tmplProfile = adapter.prepare(false, userId, cmd.getTemplateName(), cmd.getDisplayText(), cmd.getBits(), false, false, cmd.getUrl(), cmd.isPublic(), cmd.isFeatured(), false,
                    "BareMetal", cmd.getOsTypeId(), pxe.getDataCenterId(), HypervisorType.BareMetal, account.getAccountName(), account.getDomainId(), "0", true, cmd.getDetails());
 
            if (!_pxeMgr.prepareCreateTemplate(_pxeMgr.getPxeServerType(pxe), pxe.getId(), vm, cmd.getUrl())) {
                throw new Exception("Prepare PXE boot file for host  " + hostId + " failed");
            }

            IpmISetBootDevCommand setBootDev = new IpmISetBootDevCommand(IpmISetBootDevCommand.BootDev.pxe);
            Answer ans = _agentMgr.send(hostId, setBootDev);
            if (!ans.getResult()) {
                throw new Exception("Set host " + hostId + " to PXE boot failed");
            }

            IpmiBootorResetCommand boot = new IpmiBootorResetCommand();
            ans = _agentMgr.send(hostId, boot);
            if (!ans.getResult()) {
                throw new Exception("Boot/Reboot host " + hostId + " failed");
            }

            VMTemplateVO tmpl = adapter.create(tmplProfile);
            s_logger.debug("Create baremetal template for host " + hostId + " successfully, template id:" + tmpl.getId());
            return tmpl;
        } catch (Exception e) {
            s_logger.debug("Create baremetal tempalte for host " + hostId + " failed", e);
            throw new CloudRuntimeException(e.getMessage());
        }
	}

	@Override
	public UserVm createVirtualMachine(DeployVMCmd cmd) throws InsufficientCapacityException, ResourceUnavailableException, ConcurrentOperationException,
			StorageUnavailableException, ResourceAllocationException {
		Account caller = UserContext.current().getCaller();

		String accountName = cmd.getAccountName();
		Long domainId = cmd.getDomainId();
		List<Long> networkList = cmd.getNetworkIds();
		String group = cmd.getGroup();

		Account owner = _accountDao.findActiveAccount(accountName, domainId);
		if (owner == null) {
			throw new InvalidParameterValueException("Unable to find account " + accountName + " in domain " + domainId);
		}

		_accountMgr.checkAccess(caller, null, true, owner);
		long accountId = owner.getId();

		DataCenterVO dc = _dcDao.findById(cmd.getZoneId());
		if (dc == null) {
			throw new InvalidParameterValueException("Unable to find zone: " + cmd.getZoneId());
		}
		
		if(Grouping.AllocationState.Disabled == dc.getAllocationState() && !_accountMgr.isRootAdmin(caller.getType())){
			throw new PermissionDeniedException("Cannot perform this operation, Zone is currently disabled: "+ cmd.getZoneId() );
		}

		if (dc.getDomainId() != null) {
			DomainVO domain = _domainDao.findById(dc.getDomainId());
			if (domain == null) {
				throw new CloudRuntimeException("Unable to find the domain " + dc.getDomainId() + " for the zone: " + dc);
			}
			_configMgr.checkZoneAccess(caller, dc);
			_configMgr.checkZoneAccess(owner, dc);
		}

		// check if account/domain is with in resource limits to create a new vm
		_resourceLimitMgr.checkResourceLimit(owner, ResourceType.user_vm);
		
		ServiceOfferingVO offering = _serviceOfferingDao.findById(cmd.getServiceOfferingId());
        if (offering == null || offering.getRemoved() != null) {
            throw new InvalidParameterValueException("Unable to find service offering: " + cmd.getServiceOfferingId());
        }
		
		VMTemplateVO template = _templateDao.findById(cmd.getTemplateId());
        // Make sure a valid template ID was specified
        if (template == null || template.getRemoved() != null) {
            throw new InvalidParameterValueException("Unable to use template " + cmd.getTemplateId());
        }
        
        if (template.getTemplateType().equals(TemplateType.SYSTEM)) {
        	throw new InvalidParameterValueException("Unable to use system template " + cmd.getTemplateId()+" to deploy a user vm");
        }

        if (template.getFormat() != Storage.ImageFormat.BAREMETAL) {
        	throw new InvalidParameterValueException("Unable to use non Bare Metal template" + cmd.getTemplateId() +" to deploy a bare metal vm");
        }
        
        String userData = cmd.getUserData();
        byte [] decodedUserData = null;
        if (userData != null) {
            if (userData.length() >= 2 * MAX_USER_DATA_LENGTH_BYTES) {
                throw new InvalidParameterValueException("User data is too long");
            }
            decodedUserData = org.apache.commons.codec.binary.Base64.decodeBase64(userData.getBytes());
            if (decodedUserData.length > MAX_USER_DATA_LENGTH_BYTES){
                throw new InvalidParameterValueException("User data is too long");
            }
            if (decodedUserData.length < 1) {
                throw new InvalidParameterValueException("User data is too short");
            }
        }
        
        // Find an SSH public key corresponding to the key pair name, if one is given
        String sshPublicKey = null;
        if (cmd.getSSHKeyPairName() != null && !cmd.getSSHKeyPairName().equals("")) {
            Account account = UserContext.current().getCaller();
        	SSHKeyPair pair = _sshKeyPairDao.findByName(account.getAccountId(), account.getDomainId(), cmd.getSSHKeyPairName());
    		if (pair == null) {
                throw new InvalidParameterValueException("A key pair with name '" + cmd.getSSHKeyPairName() + "' was not found.");
            }

			sshPublicKey = pair.getPublicKey();
		}

		_accountMgr.checkAccess(caller, null, true, template);

		DataCenterDeployment plan = new DataCenterDeployment(dc.getId());

		s_logger.debug("Allocating in the DB for bare metal vm");
		
		if (dc.getNetworkType() != NetworkType.Basic || networkList != null) {
			s_logger.warn("Bare Metal only supports basical network mode now, switch to baisc network automatically");
		}
		
		Network defaultNetwork = _networkModel.getExclusiveGuestNetwork(dc.getId());
		if (defaultNetwork == null) {
			throw new InvalidParameterValueException("Unable to find a default network to start a vm");
		}
		
		
		networkList = new ArrayList<Long>();
		networkList.add(defaultNetwork.getId());
		
		List<Pair<NetworkVO, NicProfile>> networks = new ArrayList<Pair<NetworkVO, NicProfile>>();
        for (Long networkId : networkList) {
            NetworkVO network = _networkDao.findById(networkId);
            if (network == null) {
                throw new InvalidParameterValueException("Unable to find network by id " + networkId);
            } else {
                if (network.getGuestType() != Network.GuestType.Shared) {
                    //Check account permissions
                    List<NetworkVO> networkMap = _networkDao.listBy(accountId, networkId);
                    if (networkMap == null || networkMap.isEmpty()) {
                        throw new PermissionDeniedException("Unable to create a vm using network with id " + networkId + ", permission denied");
                    }
                } 
                networks.add(new Pair<NetworkVO, NicProfile>(network, null));
            }
        }
        
        long id = _vmDao.getNextInSequence(Long.class, "id");
        
        String hostName = cmd.getName();
        String instanceName = VirtualMachineName.getVmName(id, owner.getId(), _instance);
        if (hostName == null) {
            hostName = instanceName;
        } else {
            //verify hostName (hostname doesn't have to be unique)
            if (!NetUtils.verifyDomainNameLabel(hostName, true)) {
                throw new InvalidParameterValueException("Invalid name. Vm name can contain ASCII letters 'a' through 'z', the digits '0' through '9', " +
                		                                "and the hyphen ('-'), must be between 1 and 63 characters long, and can't start or end with \"-\" and can't start with digit");
            }
        }
        
        UserVmVO vm = new UserVmVO(id, instanceName, cmd.getDisplayName(), template.getId(), HypervisorType.BareMetal,
                template.getGuestOSId(), offering.getOfferHA(), false, domainId, owner.getId(), offering.getId(), userData, hostName);
        
        if (sshPublicKey != null) {
            vm.setDetail("SSH.PublicKey", sshPublicKey);
        }

		if (_itMgr.allocate(vm, template, offering, null, null, networks, null, plan, cmd.getHypervisor(), owner) == null) {
			return null;
		}
		

		if (s_logger.isDebugEnabled()) {
			s_logger.debug("Successfully allocated DB entry for " + vm);
		}

		if (s_logger.isDebugEnabled()) {
			s_logger.debug("Successfully allocated DB entry for " + vm);
		}
		UserContext.current().setEventDetails("Vm Id: " + vm.getId());
		 UsageEventVO usageEvent = new UsageEventVO(EventTypes.EVENT_VM_CREATE, accountId, cmd.getZoneId(), vm.getId(), vm.getHostName(), offering.getId(), template.getId(), HypervisorType.BareMetal.toString());
		_usageEventDao.persist(usageEvent);

		_resourceLimitMgr.incrementResourceCount(accountId, ResourceType.user_vm);

		// Assign instance to the group
		try {
			if (group != null) {
				boolean addToGroup = addInstanceToGroup(Long.valueOf(id), group);
				if (!addToGroup) {
					throw new CloudRuntimeException("Unable to assign Vm to the group " + group);
				}
			}
		} catch (Exception ex) {
			throw new CloudRuntimeException("Unable to assign Vm to the group " + group);
		}

		return vm;
	}
	
	public UserVm startVirtualMachine(DeployVMCmd cmd) throws ResourceUnavailableException, InsufficientCapacityException, ConcurrentOperationException {
	    UserVmVO vm = _vmDao.findById(cmd.getInstanceId());
	    
		List<HostVO> servers = _resourceMgr.listAllUpAndEnabledHostsInOneZoneByType(Host.Type.PxeServer, vm.getDataCenterIdToDeployIn()); 
	    if (servers.size() == 0) {
	    	throw new CloudRuntimeException("Cannot find PXE server, please make sure there is one PXE server per zone");
	    }
	    HostVO pxeServer = servers.get(0);
	    
	    VMTemplateVO template = _templateDao.findById(vm.getTemplateId());
	    if (template == null || template.getFormat() != Storage.ImageFormat.BAREMETAL) {
	    	throw new InvalidParameterValueException("Invalid template with id = " + vm.getTemplateId());
	    }
	    
		Map<VirtualMachineProfile.Param, Object> params = new HashMap<VirtualMachineProfile.Param, Object>();
		params.put(Param.PxeSeverType, _pxeMgr.getPxeServerType(pxeServer));

		return startVirtualMachine(cmd, params);
	}
	
	
	public UserVm startVirtualMachine(StartVMCmd cmd) throws ResourceUnavailableException, InsufficientCapacityException, ConcurrentOperationException {
        UserVmVO vm = _vmDao.findById(cmd.getInstanceId());

        VMTemplateVO template = _templateDao.findById(vm.getTemplateId());
        if (template == null || template.getFormat() != Storage.ImageFormat.BAREMETAL) {
            throw new InvalidParameterValueException("Invalid template with id = " + vm.getTemplateId());
        }
        
        Map<VirtualMachineProfile.Param, Object> params = null;
        if (vm.isUpdateParameters()) {
            List<HostVO> servers = _resourceMgr.listAllUpAndEnabledHostsInOneZoneByType(Host.Type.PxeServer, vm.getDataCenterIdToDeployIn()); 
            if (servers.size() == 0) {
                throw new CloudRuntimeException("Cannot find PXE server, please make sure there is one PXE server per zone");
            }
            HostVO pxeServer = servers.get(0);
            params = new HashMap<VirtualMachineProfile.Param, Object>();
            params.put(Param.PxeSeverType, _pxeMgr.getPxeServerType(pxeServer));
        }
        
        Pair<UserVmVO, Map<VirtualMachineProfile.Param, Object>> vmDetailsPair = super.startVirtualMachine(vm.getId(), cmd.getHostId(), params);
        return vmDetailsPair.first();
    }

	@Override
	public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
		_name = name;

		ComponentLocator locator = ComponentLocator.getCurrentLocator();
		_configDao = locator.getDao(ConfigurationDao.class);
		if (_configDao == null) {
			throw new ConfigurationException("Unable to get the configuration dao.");
		}

		Map<String, String> configs = _configDao.getConfiguration("AgentManager", params);

		_instance = configs.get("instance.name");
		if (_instance == null) {
			_instance = "DEFAULT";
		}

		String workers = configs.get("expunge.workers");
		int wrks = NumbersUtil.parseInt(workers, 10);

		String time = configs.get("expunge.interval");
		_expungeInterval = NumbersUtil.parseInt(time, 86400);

		time = configs.get("expunge.delay");
		_expungeDelay = NumbersUtil.parseInt(time, _expungeInterval);

		_executor = Executors.newScheduledThreadPool(wrks, new NamedThreadFactory("UserVm-Scavenger"));

		_itMgr.registerGuru(Type.UserBareMetal, this);
		VirtualMachine.State.getStateMachine().registerListener(this);

		s_logger.info("User VM Manager is configured.");

		return true;
	}
	
	@Override
	public boolean finalizeVirtualMachineProfile(VirtualMachineProfile<UserVmVO> profile, DeployDestination dest, ReservationContext context) {
        UserVmVO vm = profile.getVirtualMachine();
	    Account owner = _accountDao.findById(vm.getAccountId());
	    
	    if (owner == null || owner.getState() == Account.State.disabled) {
	        throw new PermissionDeniedException("The owner of " + vm + " either does not exist or is disabled: " + vm.getAccountId());
	    }
	    
	    PxeServerType pxeType = (PxeServerType) profile.getParameter(Param.PxeSeverType);
	    if (pxeType == null) {
	    	s_logger.debug("This is a normal IPMI start, skip prepartion of PXE server");
	    	return true;
	    }
	    s_logger.debug("This is a PXE start, prepare PXE server first");
	    
	    List<HostVO> servers = _resourceMgr.listAllUpAndEnabledHosts(Host.Type.PxeServer, null, dest.getPod().getId(), dest.getDataCenter().getId()); 
	    if (servers.size() == 0) {
	    	throw new CloudRuntimeException("Cannot find PXE server, please make sure there is one PXE server per zone");
	    }
	    if (servers.size() > 1) {
	    	throw new CloudRuntimeException("Find more than one PXE server, please make sure there is only one PXE server per zone in pod " + dest.getPod().getId() + " zone " + dest.getDataCenter().getId());
	    }
	    HostVO pxeServer = servers.get(0);
	    
	    if (!_pxeMgr.prepare(pxeType, profile, dest, context, pxeServer.getId())) {
	    	throw new CloudRuntimeException("Pepare PXE server failed");
	    }
	    
	    profile.addBootArgs("PxeBoot");
	    
	    return true;
	}
	
	@Override
	public boolean finalizeDeployment(Commands cmds, VirtualMachineProfile<UserVmVO> profile, DeployDestination dest, ReservationContext context) {
		UserVmVO userVm = profile.getVirtualMachine();
		List<NicVO> nics = _nicDao.listByVmId(userVm.getId());
		for (NicVO nic : nics) {
			NetworkVO network = _networkDao.findById(nic.getNetworkId());
			if (network.getTrafficType() == TrafficType.Guest) {
				userVm.setPrivateIpAddress(nic.getIp4Address());
				userVm.setPrivateMacAddress(nic.getMacAddress());
			}
		}
		_vmDao.update(userVm.getId(), userVm);
		return true;
	}

	@Override
	public void finalizeStop(VirtualMachineProfile<UserVmVO> profile, StopAnswer answer) {
		super.finalizeStop(profile, answer);
	}

	@Override
	public UserVm destroyVm(long vmId) throws ResourceUnavailableException, ConcurrentOperationException {
		return super.destroyVm(vmId);
	}

	@Override
	public boolean preStateTransitionEvent(State oldState, Event event, State newState, VirtualMachine vo, boolean status, Object opaque) {
		return true;
	}

	@Override
	public boolean postStateTransitionEvent(State oldState, Event event, State newState, VirtualMachine vo, boolean status, Object opaque) {
		if (newState != State.Starting && newState != State.Error && newState != State.Expunging) {
			return true;
		}
		
		if (vo.getHypervisorType() != HypervisorType.BareMetal) {
		    return true;
		}
		
		HostVO host = _hostDao.findById(vo.getHostId());
		if (host == null) {
			s_logger.debug("Skip oldState " + oldState + " to " + "newState " + newState + " transimtion");
			return true;
		}
		_hostDao.loadDetails(host);
		
		if (newState == State.Starting) {
			host.setDetail("vmName", vo.getInstanceName());
			s_logger.debug("Add vmName " + host.getDetail("vmName") + " to host " + host.getId() + " details");
		} else {
			if (host.getDetail("vmName") != null && host.getDetail("vmName").equalsIgnoreCase(vo.getInstanceName())) {
				s_logger.debug("Remove vmName " + host.getDetail("vmName") + " from host " + host.getId() + " details");
				host.getDetails().remove("vmName");
			}
		}
		_hostDao.saveDetails(host);
		
		
		return true;
	}
}