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

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

    private String                           _name;

    @Inject

    AccountManager                           _accountMgr;

    @Inject

    AgentManager                             _agentMgr;

    @Inject

    StorageManager                           _storageMgr;

    @Inject

    protected SecondaryStorageVmManager      _secondaryStorageMgr;

    @Inject

    protected DataCenterDao                  _dcDao;

    @Inject

    protected HostPodDao                     _podDao;

    @Inject

    protected ClusterDetailsDao              _clusterDetailsDao;

    @Inject

    protected ClusterDao                     _clusterDao;

    @Inject

    protected CapacityDao            _capacityDao;

    @Inject

    protected HostDao                        _hostDao;

    @Inject

    protected SwiftManager _swiftMgr;

    @Inject

    protected HostDetailsDao                 _hostDetailsDao;

    @Inject

    protected ConfigurationDao _configDao;

    @Inject

    protected HostTagsDao                    _hostTagsDao;   

    @Inject

    protected GuestOSCategoryDao             _guestOSCategoryDao;

    @Inject

    protected StoragePoolDao                _storagePoolDao;

    @Inject

    protected DataCenterIpAddressDao         _privateIPAddressDao;

    @Inject

    protected IPAddressDao                   _publicIPAddressDao;

    @Inject

    protected VirtualMachineManager          _vmMgr;

    @Inject

    protected VMInstanceDao                  _vmDao; 

    @Inject

    protected HighAvailabilityManager        _haMgr;

    @Inject

    protected StorageService                 _storageSvr;

    @Inject(adapter = Discoverer.class)

    protected Adapters<? extends Discoverer> _discoverers;

    @Inject

    protected ClusterManager                 _clusterMgr;

    @Inject

    protected StoragePoolHostDao             _storagePoolHostDao;

    @Inject(adapter = PodAllocator.class)

    protected Adapters<PodAllocator> _podAllocators = null;

    @Inject

    protected VMTemplateDao  _templateDao;

    @Inject

    protected ConfigurationManager        _configMgr;

    @Inject

    protected ClusterVSMMapDao         _clusterVSMMapDao;

    protected long                           _nodeId  = ManagementServerNode.getManagementServerId();

    protected HashMap<String, ResourceStateAdapter> _resourceStateAdapters = new HashMap<String, ResourceStateAdapter>();

    protected HashMap<Integer, List<ResourceListener>> _lifeCycleListeners = new HashMap<Integer, List<ResourceListener>>();

    private HypervisorType _defaultSystemVMHypervisor;

    private void insertListener(Integer event, ResourceListener listener) {

        List<ResourceListener> lst = _lifeCycleListeners.get(event);

        if (lst == null) {

            lst = new ArrayList<ResourceListener>();

            _lifeCycleListeners.put(event, lst);

        }

        if (lst.contains(listener)) {

            throw new CloudRuntimeException("Duplicate resource lisener:" + listener.getClass().getSimpleName());

        }

        lst.add(listener);

    }

    @Override

    public void registerResourceEvent(Integer event, ResourceListener listener) {

        synchronized (_lifeCycleListeners) {

            if ((event & ResourceListener.EVENT_DISCOVER_BEFORE) != 0) {

                insertListener(ResourceListener.EVENT_DISCOVER_BEFORE, listener);

            }

            if ((event & ResourceListener.EVENT_DISCOVER_AFTER) != 0) {

                insertListener(ResourceListener.EVENT_DISCOVER_AFTER, listener);

            }

            if ((event & ResourceListener.EVENT_DELETE_HOST_BEFORE) != 0) {

                insertListener(ResourceListener.EVENT_DELETE_HOST_BEFORE, listener);

            }

            if ((event & ResourceListener.EVENT_DELETE_HOST_AFTER) != 0) {

                insertListener(ResourceListener.EVENT_DELETE_HOST_AFTER, listener);

            }

            if ((event & ResourceListener.EVENT_CANCEL_MAINTENANCE_BEFORE) != 0) {

                insertListener(ResourceListener.EVENT_CANCEL_MAINTENANCE_BEFORE, listener);

            }

            if ((event & ResourceListener.EVENT_CANCEL_MAINTENANCE_AFTER) != 0) {

                insertListener(ResourceListener.EVENT_CANCEL_MAINTENANCE_AFTER, listener);

            }

            if ((event & ResourceListener.EVENT_PREPARE_MAINTENANCE_BEFORE) != 0) {

                insertListener(ResourceListener.EVENT_PREPARE_MAINTENANCE_BEFORE, listener);

            }

            if ((event & ResourceListener.EVENT_PREPARE_MAINTENANCE_AFTER) != 0) {

                insertListener(ResourceListener.EVENT_PREPARE_MAINTENANCE_AFTER, listener);

            }

        }

    }

    @Override

    public void unregisterResourceEvent(ResourceListener listener) {

        synchronized (_lifeCycleListeners) {

            Iterator it = _lifeCycleListeners.entrySet().iterator();

            while (it.hasNext()) {

                Map.Entry<Integer, List<ResourceListener>> items = (Map.Entry<Integer, List<ResourceListener>>)it.next();

                List<ResourceListener> lst = items.getValue();

                lst.remove(listener);

            }

        }

    }

    protected void processResourceEvent(Integer event, Object...params) {

        List<ResourceListener> lst = _lifeCycleListeners.get(event);

        if (lst == null || lst.size() == 0) {

            return;

        }

        String eventName;

        for (ResourceListener l : lst) {

            if (event == ResourceListener.EVENT_DISCOVER_BEFORE) {

                l.processDiscoverEventBefore((Long) params[0], (Long) params[1], (Long) params[2], (URI) params[3], (String) params[4], (String) params[5],

                        (List<String>) params[6]);

                eventName = "EVENT_DISCOVER_BEFORE";

            } else if (event == ResourceListener.EVENT_DISCOVER_AFTER) {

                l.processDiscoverEventAfter((Map<? extends ServerResource, Map<String, String>>) params[0]);

                eventName = "EVENT_DISCOVER_AFTER";

            } else if (event == ResourceListener.EVENT_DELETE_HOST_BEFORE) {

                l.processDeleteHostEventBefore((HostVO) params[0]);

                eventName = "EVENT_DELETE_HOST_BEFORE";

            } else if (event == ResourceListener.EVENT_DELETE_HOST_AFTER) {

                l.processDeletHostEventAfter((HostVO) params[0]);

                eventName = "EVENT_DELETE_HOST_AFTER";

            } else if (event == ResourceListener.EVENT_CANCEL_MAINTENANCE_BEFORE) {

                l.processCancelMaintenaceEventBefore((Long) params[0]);

                eventName = "EVENT_CANCEL_MAINTENANCE_BEFORE";

            } else if (event == ResourceListener.EVENT_CANCEL_MAINTENANCE_AFTER) {

                l.processCancelMaintenaceEventAfter((Long) params[0]);

                eventName = "EVENT_CANCEL_MAINTENANCE_AFTER";

            } else if (event == ResourceListener.EVENT_PREPARE_MAINTENANCE_BEFORE) {

                l.processPrepareMaintenaceEventBefore((Long) params[0]);

                eventName = "EVENT_PREPARE_MAINTENANCE_BEFORE";

            } else if (event == ResourceListener.EVENT_PREPARE_MAINTENANCE_AFTER) {

                l.processPrepareMaintenaceEventAfter((Long) params[0]);

                eventName = "EVENT_PREPARE_MAINTENANCE_AFTER";

            } else {

                throw new CloudRuntimeException("Unknown resource event:" + event);

            }

            s_logger.debug("Sent resource event " + eventName + " to listener " + l.getClass().getSimpleName());

        }

    }

    @DB

    @Override

    public List<? extends Cluster> discoverCluster(AddClusterCmd cmd) throws IllegalArgumentException, DiscoveryException, ResourceInUseException {

        long dcId = cmd.getZoneId();

        long podId = cmd.getPodId();

        String clusterName = cmd.getClusterName();

        String url = cmd.getUrl();

        String username = cmd.getUsername();

        String password = cmd.getPassword();

        if (url != null) {

            url = URLDecoder.decode(url);

        }

        URI uri = null;

        // Check if the zone exists in the system

        DataCenterVO zone = _dcDao.findById(dcId);

        if (zone == null) {

            InvalidParameterValueException ex = new InvalidParameterValueException("Can't find zone by the id specified");

            ex.addProxyObject(zone, dcId, "dcId");

            throw ex;

        }

        Account account = UserContext.current().getCaller();

        if (Grouping.AllocationState.Disabled == zone.getAllocationState() && !_accountMgr.isRootAdmin(account.getType())) {

            PermissionDeniedException ex = new PermissionDeniedException("Cannot perform this operation, Zone with specified id is currently disabled");

            ex.addProxyObject(zone, dcId, "dcId");

            throw ex;

        }

        HostPodVO pod = _podDao.findById(podId);

        if (pod == null) {

            throw new InvalidParameterValueException("Can't find pod with specified podId " + podId);

        }

        // Check if the pod exists in the system

        if (_podDao.findById(podId) == null) {

            throw new InvalidParameterValueException("Can't find pod by id " + podId);

        }

        // check if pod belongs to the zone

        if (!Long.valueOf(pod.getDataCenterId()).equals(dcId)) {

            InvalidParameterValueException ex = new InvalidParameterValueException("Pod with specified id doesn't belong to the zone " + dcId);

            ex.addProxyObject(pod, podId, "podId");

            ex.addProxyObject(zone, dcId, "dcId");

            throw ex;

        }

        // Verify cluster information and create a new cluster if needed

        if (clusterName == null || clusterName.isEmpty()) {

            throw new InvalidParameterValueException("Please specify cluster name");

        }

        if (cmd.getHypervisor() == null || cmd.getHypervisor().isEmpty()) {

            throw new InvalidParameterValueException("Please specify a hypervisor");

        }

        Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.getType(cmd.getHypervisor());

        if (hypervisorType == null) {

            s_logger.error("Unable to resolve " + cmd.getHypervisor() + " to a valid supported hypervisor type");

            throw new InvalidParameterValueException("Unable to resolve " + cmd.getHypervisor() + " to a supported ");

        }

        Cluster.ClusterType clusterType = null;

        if (cmd.getClusterType() != null && !cmd.getClusterType().isEmpty()) {

            clusterType = Cluster.ClusterType.valueOf(cmd.getClusterType());

        }

        if (clusterType == null) {

            clusterType = Cluster.ClusterType.CloudManaged;

        }

        Grouping.AllocationState allocationState = null;

        if (cmd.getAllocationState() != null && !cmd.getAllocationState().isEmpty()) {

            try {

                allocationState = Grouping.AllocationState.valueOf(cmd.getAllocationState());

            } catch (IllegalArgumentException ex) {

                throw new InvalidParameterValueException("Unable to resolve Allocation State '" + cmd.getAllocationState() + "' to a supported state");

            }

        }

        if (allocationState == null) {

            allocationState = Grouping.AllocationState.Enabled;

        }

        Discoverer discoverer = getMatchingDiscover(hypervisorType);

        if (discoverer == null) {

            throw new InvalidParameterValueException("Could not find corresponding resource manager for " + cmd.getHypervisor());

        }

        List<ClusterVO> result = new ArrayList<ClusterVO>();

        long clusterId = 0;

        ClusterVO cluster = new ClusterVO(dcId, podId, clusterName);

        cluster.setHypervisorType(cmd.getHypervisor());

        cluster.setClusterType(clusterType);

        cluster.setAllocationState(allocationState);

        try {

            cluster = _clusterDao.persist(cluster);

        } catch (Exception e) {

            // no longer tolerate exception during the cluster creation phase

            CloudRuntimeException ex = new CloudRuntimeException("Unable to create cluster " + clusterName + " in pod and data center with specified ids", e);

            // Get the pod VO object's table name.

            ex.addProxyObject(pod, podId, "podId");

            ex.addProxyObject(zone, dcId, "dcId");

            throw ex;

        }

        clusterId = cluster.getId();

        result.add(cluster);

        if (clusterType == Cluster.ClusterType.CloudManaged) {

            return result;

        }

        // save cluster details for later cluster/host cross-checking

        Map<String, String> details = new HashMap<String, String>();

        details.put("url", url);

        details.put("username", username);

        details.put("password", password);

        _clusterDetailsDao.persist(cluster.getId(), details);

        boolean success = false;

        try {

            try {

                uri = new URI(UriUtils.encodeURIComponent(url));

                if (uri.getScheme() == null) {

                    throw new InvalidParameterValueException("uri.scheme is null " + url + ", add http:// as a prefix");

                } else if (uri.getScheme().equalsIgnoreCase("http")) {

                    if (uri.getHost() == null || uri.getHost().equalsIgnoreCase("") || uri.getPath() == null || uri.getPath().equalsIgnoreCase("")) {

                        throw new InvalidParameterValueException("Your host and/or path is wrong.  Make sure it's of the format http://hostname/path");

                    }

                }

            } catch (URISyntaxException e) {

                throw new InvalidParameterValueException(url + " is not a valid uri");

            }

            List<HostVO> hosts = new ArrayList<HostVO>();

            Map<? extends ServerResource, Map<String, String>> resources = null;

            resources = discoverer.find(dcId, podId, clusterId, uri, username, password, null);

            if (resources != null) {

                for (Map.Entry<? extends ServerResource, Map<String, String>> entry : resources.entrySet()) {

                    ServerResource resource = entry.getKey();

                    // For Hyper-V, we are here means agent have already started and connected to management server

                    if (hypervisorType == Hypervisor.HypervisorType.Hyperv) {

                        break;

                    }

                    HostVO host = (HostVO)createHostAndAgent(resource, entry.getValue(), true, null, false);

                    if (host != null) {

                        hosts.add(host);

                    }

                    discoverer.postDiscovery(hosts, _nodeId);

                }

                s_logger.info("External cluster has been successfully discovered by " + discoverer.getName());

                success = true;

                return result;

            }

            s_logger.warn("Unable to find the server resources at " + url);

            throw new DiscoveryException("Unable to add the external cluster");

        } finally {

            if (!success) {

                _clusterDetailsDao.deleteDetails(clusterId);

                _clusterDao.remove(clusterId);

            }

        }

    }

    @Override

    public Discoverer getMatchingDiscover(Hypervisor.HypervisorType hypervisorType) {

        Enumeration<? extends Discoverer> en = _discoverers.enumeration();

        while (en.hasMoreElements()) {

            Discoverer discoverer = en.nextElement();

            if (discoverer.getHypervisorType() == hypervisorType) {

                return discoverer;

            }

        }

        return null;

    }

    @Override

    public List<? extends Host> discoverHosts(AddHostCmd cmd) throws IllegalArgumentException, DiscoveryException, InvalidParameterValueException {

        Long dcId = cmd.getZoneId();

        Long podId = cmd.getPodId();

        Long clusterId = cmd.getClusterId();

        String clusterName = cmd.getClusterName();

        String url = cmd.getUrl();

        String username = cmd.getUsername();

        String password = cmd.getPassword();

        List<String> hostTags = cmd.getHostTags();

        dcId = _accountMgr.checkAccessAndSpecifyAuthority(UserContext.current().getCaller(), dcId);

        // this is for standalone option

        if (clusterName == null && clusterId == null) {

            clusterName = "Standalone-" + url;

        }

        if (clusterId != null) {

            ClusterVO cluster = _clusterDao.findById(clusterId);

            if (cluster == null) {

                InvalidParameterValueException ex = new InvalidParameterValueException("can not find cluster for specified clusterId");

                ex.addProxyObject(cluster, clusterId, "clusterId");

                throw ex;

            } else {

                if (cluster.getGuid() == null) {

                    List<HostVO> hosts = listAllHostsInCluster(clusterId);

                    if (!hosts.isEmpty()) {

                        CloudRuntimeException ex = new CloudRuntimeException("Guid is not updated for cluster with specified cluster id; need to wait for hosts in this cluster to come up");

                        ex.addProxyObject(cluster, clusterId, "clusterId");

                        throw ex;

                    }

                }

            }

        }

        return discoverHostsFull(dcId, podId, clusterId, clusterName, url, username, password, cmd.getHypervisor(), hostTags, cmd.getFullUrlParams());

    }

    @Override

    public List<? extends Host> discoverHosts(AddSecondaryStorageCmd cmd) throws IllegalArgumentException, DiscoveryException, InvalidParameterValueException {

        Long dcId = cmd.getZoneId();

        String url = cmd.getUrl();

        return discoverHostsFull(dcId, null, null, null, url, null, null, "SecondaryStorage", null, null);

    }

    @Override

    public Swift discoverSwift(AddSwiftCmd cmd) throws DiscoveryException {

        return _swiftMgr.addSwift(cmd);

    }

    @Override

    public List<SwiftVO> listSwifts(ListSwiftsCmd cmd) {

        return _swiftMgr.listSwifts(cmd);

    }

    private List<HostVO> discoverHostsFull(Long dcId, Long podId, Long clusterId, String clusterName, String url, String username, String password, String hypervisorType, List<String> hostTags,

            Map<String, String> params) throws IllegalArgumentException, DiscoveryException, InvalidParameterValueException {

        URI uri = null;

        // Check if the zone exists in the system

        DataCenterVO zone = _dcDao.findById(dcId);

        if (zone == null) {

            throw new InvalidParameterValueException("Can't find zone by id " + dcId);

        }

        Account account = UserContext.current().getCaller();

        if (Grouping.AllocationState.Disabled == zone.getAllocationState() && !_accountMgr.isRootAdmin(account.getType())) {

            PermissionDeniedException ex = new PermissionDeniedException("Cannot perform this operation, Zone with specified id is currently disabled");

            ex.addProxyObject(zone, dcId, "dcId");

            throw ex;

        }

        // Check if the pod exists in the system

        if (podId != null) {

            HostPodVO pod = _podDao.findById(podId);

            if (pod == null) {

                throw new InvalidParameterValueException("Can't find pod by id " + podId);

            }

            // check if pod belongs to the zone           

            if (!Long.valueOf(pod.getDataCenterId()).equals(dcId)) {

                InvalidParameterValueException ex = new InvalidParameterValueException("Pod with specified podId" + podId + " doesn't belong to the zone with specified zoneId" + dcId);

                ex.addProxyObject(pod, podId, "podId");

                ex.addProxyObject(zone, dcId, "dcId");

                throw ex;

            }

        }

        // Verify cluster information and create a new cluster if needed

        if (clusterName != null && clusterId != null) {

            throw new InvalidParameterValueException("Can't specify cluster by both id and name");

        }

        if (hypervisorType == null || hypervisorType.isEmpty()) {

            throw new InvalidParameterValueException("Need to specify Hypervisor Type");

        }

        if ((clusterName != null || clusterId != null) && podId == null) {

            throw new InvalidParameterValueException("Can't specify cluster without specifying the pod");

        }

        if (clusterId != null) {

            if (_clusterDao.findById(clusterId) == null) {

                throw new InvalidParameterValueException("Can't find cluster by id " + clusterId);

            }

            if(hypervisorType.equalsIgnoreCase(HypervisorType.VMware.toString())) {

                // VMware only allows adding host to an existing cluster, as we already have a lot of information

                // in cluster object, to simplify user input, we will construct neccessary information here

                Map<String, String> clusterDetails = this._clusterDetailsDao.findDetails(clusterId);

                username = clusterDetails.get("username");

                assert(username != null);

                password = clusterDetails.get("password");

                assert(password != null);

                try {

                    uri = new URI(UriUtils.encodeURIComponent(url));

                    url = clusterDetails.get("url") + "/" + uri.getHost();

                } catch (URISyntaxException e) {

                    throw new InvalidParameterValueException(url + " is not a valid uri");

                }

            }

        }

        if (clusterName != null) {

            HostPodVO pod = _podDao.findById(podId);

            if (pod == null) {

                throw new InvalidParameterValueException("Can't find pod by id " + podId);

            }

            ClusterVO cluster = new ClusterVO(dcId, podId, clusterName);

            cluster.setHypervisorType(hypervisorType);

            try {

                cluster = _clusterDao.persist(cluster);

            } catch (Exception e) {

                cluster = _clusterDao.findBy(clusterName, podId);

                if (cluster == null) {

                    CloudRuntimeException ex = new CloudRuntimeException("Unable to create cluster " + clusterName + " in pod with specified podId and data center with specified dcID", e);

                    ex.addProxyObject(pod, podId, "podId");

                    ex.addProxyObject(zone, dcId, "dcId");

                    throw ex;  

                }

            }

            clusterId = cluster.getId();

        }

        try {

            uri = new URI(UriUtils.encodeURIComponent(url));

            if (uri.getScheme() == null) {

                throw new InvalidParameterValueException("uri.scheme is null " + url + ", add nfs:// as a prefix");

            } else if (uri.getScheme().equalsIgnoreCase("nfs")) {

                if (uri.getHost() == null || uri.getHost().equalsIgnoreCase("") || uri.getPath() == null || uri.getPath().equalsIgnoreCase("")) {

                    throw new InvalidParameterValueException("Your host and/or path is wrong.  Make sure it's of the format nfs://hostname/path");

                }

            }

        } catch (URISyntaxException e) {

            throw new InvalidParameterValueException(url + " is not a valid uri");

        }

        List<HostVO> hosts = new ArrayList<HostVO>();

        s_logger.info("Trying to add a new host at " + url + " in data center " + dcId);

        Enumeration<? extends Discoverer> en = _discoverers.enumeration();

        boolean isHypervisorTypeSupported = false;

        while (en.hasMoreElements()) {

            Discoverer discoverer = en.nextElement();

            if (params != null) {

                discoverer.putParam(params);

            }

            if (!discoverer.matchHypervisor(hypervisorType)) {

                continue;

            }

            isHypervisorTypeSupported = true;

            Map<? extends ServerResource, Map<String, String>> resources = null;

            processResourceEvent(ResourceListener.EVENT_DISCOVER_BEFORE, dcId, podId, clusterId, uri, username, password, hostTags);

            try {

                resources = discoverer.find(dcId, podId, clusterId, uri, username, password, hostTags);

            } catch(DiscoveryException e) {

                throw e;

            } catch (Exception e) {

                s_logger.info("Exception in host discovery process with discoverer: " + discoverer.getName() + ", skip to another discoverer if there is any");

            }

            processResourceEvent(ResourceListener.EVENT_DISCOVER_AFTER, resources);

            if (resources != null) {

                for (Map.Entry<? extends ServerResource, Map<String, String>> entry : resources.entrySet()) {

                    ServerResource resource = entry.getKey();

                    /*

                     * For KVM, if we go to here, that means kvm agent is already connected to mgt svr.

                     */

                    if (resource instanceof KvmDummyResourceBase) {

                        Map<String, String> details = entry.getValue();

                        String guid = details.get("guid");

                        List<HostVO> kvmHosts = listAllUpAndEnabledHosts(Host.Type.Routing, clusterId, podId, dcId);

                        for (HostVO host : kvmHosts) {

                            if (host.getGuid().equalsIgnoreCase(guid)) {

                                if(hostTags != null){

                                    if(s_logger.isTraceEnabled()){

                                        s_logger.trace("Adding Host Tags for KVM host, tags:  :"+hostTags);

                                    }

                                    _hostTagsDao.persist(host.getId(), hostTags);

                                }

                                hosts.add(host);

                                return hosts;

                            }

                        }

                        return null;

                    }

                    HostVO host = (HostVO)createHostAndAgent(resource, entry.getValue(), true, hostTags, false);

                    if (host != null) {

                        hosts.add(host);

                    }

                    discoverer.postDiscovery(hosts, _nodeId);

                }

                s_logger.info("server resources successfully discovered by " + discoverer.getName());

                return hosts;

            }

        }

        if (!isHypervisorTypeSupported) {

            String msg = "Do not support HypervisorType " + hypervisorType + " for " + url;

            s_logger.warn(msg);

            throw new DiscoveryException(msg);

        }

        s_logger.warn("Unable to find the server resources at " + url);

        throw new DiscoveryException("Unable to add the host");

    }

    @Override

    public Host getHost(long hostId) {

        return _hostDao.findById(hostId);

    }

    @DB

    protected boolean doDeleteHost(long hostId, boolean isForced, boolean isForceDeleteStorage) {

        User caller = _accountMgr.getActiveUser(UserContext.current().getCallerUserId());

        // Verify that host exists

        HostVO host = _hostDao.findById(hostId);

        if (host == null) {

            throw new InvalidParameterValueException("Host with id " + hostId + " doesn't exist");           

        }

        _accountMgr.checkAccessAndSpecifyAuthority(UserContext.current().getCaller(), host.getDataCenterId());

        /*

         * TODO: check current agent status and updateAgentStatus to removed. If it was already removed, that means

         * someone is deleting host concurrently, return. And consider the situation of CloudStack shutdown during delete.

         * A global lock?

         *

         */

        AgentAttache attache = _agentMgr.findAttache(hostId);

        // Get storage pool host mappings here because they can be removed as a part of handleDisconnect later

        //TODO: find out the bad boy, what's a buggy logic!

        List<StoragePoolHostVO> pools = _storagePoolHostDao.listByHostIdIncludingRemoved(hostId);

        ResourceStateAdapter.DeleteHostAnswer answer = (ResourceStateAdapter.DeleteHostAnswer) dispatchToStateAdapters(ResourceStateAdapter.Event.DELETE_HOST, false, host, new Boolean(isForced), new Boolean(isForceDeleteStorage));

        if (answer == null) {

            throw new CloudRuntimeException("No resource adapter respond to DELETE_HOST event for " + host.getName() + " id = " + hostId + ", hypervisorType is " + host.getHypervisorType() + ", host type is " + host.getType());

        }

        if (answer.getIsException()) {

            return false;

        }

        if (!answer.getIsContinue()) {

            return true;

        }

        Transaction txn = Transaction.currentTxn();

        txn.start();

        _dcDao.releasePrivateIpAddress(host.getPrivateIpAddress(), host.getDataCenterId(), null);

        _agentMgr.disconnectWithoutInvestigation(hostId, Status.Event.Remove);

        // delete host details

        _hostDetailsDao.deleteDetails(hostId);

        host.setGuid(null);

        Long clusterId = host.getClusterId();

        host.setClusterId(null);

        _hostDao.update(host.getId(), host);

        _hostDao.remove(hostId);

        if (clusterId != null) {

            List<HostVO> hosts = listAllHostsInCluster(clusterId);

            if (hosts.size() == 0) {

                ClusterVO cluster = _clusterDao.findById(clusterId);

                cluster.setGuid(null);

                _clusterDao.update(clusterId, cluster);

            }

        }

        try {

            resourceStateTransitTo(host, ResourceState.Event.DeleteHost, _nodeId);

        } catch (NoTransitionException e) {

            s_logger.debug("Cannot transmit host " + host.getId() + "to Enabled state", e);

        }

        // Delete the associated entries in host ref table

        _storagePoolHostDao.deletePrimaryRecordsForHost(hostId);

        // For pool ids you got, delete local storage host entries in pool table where

        for (StoragePoolHostVO pool : pools) {

            Long poolId = pool.getPoolId();

            StoragePoolVO storagePool = _storagePoolDao.findById(poolId);

            if (storagePool.isLocal() && isForceDeleteStorage) {

                storagePool.setUuid(null);

                storagePool.setClusterId(null);

                _storagePoolDao.update(poolId, storagePool);

                _storagePoolDao.remove(poolId);

                s_logger.debug("Local storage id=" + poolId + " is removed as a part of host removal id=" + hostId);

            }

        }

        // delete the op_host_capacity entry

        Object[] capacityTypes = { Capacity.CAPACITY_TYPE_CPU, Capacity.CAPACITY_TYPE_MEMORY };

        SearchCriteria<CapacityVO> hostCapacitySC = _capacityDao.createSearchCriteria();

        hostCapacitySC.addAnd("hostOrPoolId", SearchCriteria.Op.EQ, hostId);