etan39
/
cloudstack
mirror of https://github.com/apache/cloudstack.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
cloudstack/server/src/com/cloud/resource/ResourceManagerImpl.java

2839 lines
105 KiB
Java
Executable File
Raw Blame History

// 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.resource;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.ejb.Local;
import javax.inject.Inject;
import javax.naming.ConfigurationException;
import com.cloud.dc.*;
import org.apache.cloudstack.api.ApiConstants;
import org.apache.cloudstack.api.command.admin.cluster.AddClusterCmd;
import org.apache.cloudstack.api.command.admin.cluster.DeleteClusterCmd;
import org.apache.cloudstack.api.command.admin.host.AddHostCmd;
import org.apache.cloudstack.api.command.admin.host.AddSecondaryStorageCmd;
import org.apache.cloudstack.api.command.admin.host.CancelMaintenanceCmd;
import org.apache.cloudstack.api.command.admin.host.PrepareForMaintenanceCmd;
import org.apache.cloudstack.api.command.admin.host.ReconnectHostCmd;
import org.apache.cloudstack.api.command.admin.host.UpdateHostCmd;
import org.apache.cloudstack.api.command.admin.host.UpdateHostPasswordCmd;
import org.apache.cloudstack.api.command.admin.storage.AddS3Cmd;
import org.apache.cloudstack.api.command.admin.storage.ListS3sCmd;
import org.apache.cloudstack.api.command.admin.swift.AddSwiftCmd;
import org.apache.cloudstack.api.command.admin.swift.ListSwiftsCmd;
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
import com.cloud.agent.AgentManager;
import com.cloud.agent.AgentManager.TapAgentsAction;
import com.cloud.agent.api.Answer;
import com.cloud.agent.api.GetHostStatsAnswer;
import com.cloud.agent.api.GetHostStatsCommand;
import com.cloud.agent.api.MaintainAnswer;
import com.cloud.agent.api.MaintainCommand;
import com.cloud.agent.api.StartupCommand;
import com.cloud.agent.api.StartupRoutingCommand;
import com.cloud.agent.api.UnsupportedAnswer;
import com.cloud.agent.api.UpdateHostPasswordCommand;
import com.cloud.agent.manager.AgentAttache;
import com.cloud.agent.manager.ClusteredAgentManagerImpl;
import com.cloud.agent.manager.allocator.PodAllocator;
import com.cloud.agent.transport.Request;
import com.cloud.api.ApiDBUtils;
import com.cloud.capacity.Capacity;
import com.cloud.capacity.CapacityVO;
import com.cloud.capacity.dao.CapacityDao;
import com.cloud.cluster.ClusterManager;
import com.cloud.cluster.ManagementServerNode;
import com.cloud.configuration.Config;
import com.cloud.configuration.ConfigurationManager;
import com.cloud.configuration.dao.ConfigurationDao;
import com.cloud.dc.dao.ClusterDao;
import com.cloud.dc.dao.ClusterVSMMapDao;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.dc.dao.DataCenterIpAddressDao;
import com.cloud.dc.dao.HostPodDao;
import com.cloud.exception.AgentUnavailableException;
import com.cloud.exception.DiscoveryException;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.PermissionDeniedException;
import com.cloud.exception.ResourceInUseException;
import com.cloud.ha.HighAvailabilityManager;
import com.cloud.ha.HighAvailabilityManager.WorkType;
import com.cloud.host.DetailVO;
import com.cloud.host.Host;
import com.cloud.host.Host.Type;
import com.cloud.host.HostStats;
import com.cloud.host.HostVO;
import com.cloud.host.Status;
import com.cloud.host.Status.Event;
import com.cloud.host.dao.HostDao;
import com.cloud.host.dao.HostDetailsDao;
import com.cloud.host.dao.HostTagsDao;
import com.cloud.hypervisor.Hypervisor;
import com.cloud.hypervisor.Hypervisor.HypervisorType;
import com.cloud.hypervisor.kvm.discoverer.KvmDummyResourceBase;
import com.cloud.network.dao.IPAddressDao;
import com.cloud.network.dao.IPAddressVO;
import com.cloud.org.Cluster;
import com.cloud.org.Grouping;
import com.cloud.org.Grouping.AllocationState;
import com.cloud.org.Managed;
import com.cloud.service.ServiceOfferingVO;
import com.cloud.storage.GuestOSCategoryVO;
import com.cloud.storage.S3;
import com.cloud.storage.S3VO;
import com.cloud.storage.StorageManager;
import com.cloud.storage.StoragePool;
import com.cloud.storage.StoragePoolHostVO;
import com.cloud.storage.StoragePoolStatus;
import com.cloud.storage.StorageService;
import com.cloud.storage.Swift;
import com.cloud.storage.SwiftVO;
import com.cloud.storage.VMTemplateVO;
import com.cloud.storage.dao.GuestOSCategoryDao;
import com.cloud.storage.dao.StoragePoolDao;
import com.cloud.storage.dao.StoragePoolHostDao;
import com.cloud.storage.dao.VMTemplateDao;
import com.cloud.storage.s3.S3Manager;
import com.cloud.storage.secondary.SecondaryStorageVmManager;
import com.cloud.storage.swift.SwiftManager;
import com.cloud.template.VirtualMachineTemplate;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.User;
import com.cloud.user.UserContext;
import com.cloud.utils.Pair;
import com.cloud.utils.StringUtils;
import com.cloud.utils.UriUtils;
import com.cloud.utils.component.Manager;
import com.cloud.utils.component.ManagerBase;
import com.cloud.utils.db.DB;
import com.cloud.utils.db.GlobalLock;
import com.cloud.utils.db.SearchBuilder;
import com.cloud.utils.db.SearchCriteria;
import com.cloud.utils.db.SearchCriteria.Op;
import com.cloud.utils.db.SearchCriteria2;
import com.cloud.utils.db.SearchCriteriaService;
import com.cloud.utils.db.Transaction;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.utils.fsm.NoTransitionException;
import com.cloud.utils.net.Ip;
import com.cloud.utils.net.NetUtils;
import com.cloud.utils.ssh.SSHCmdHelper;
import com.cloud.utils.ssh.sshException;
import com.cloud.vm.VMInstanceVO;
import com.cloud.vm.VirtualMachine.State;
import com.cloud.vm.VirtualMachineManager;
import com.cloud.vm.dao.VMInstanceDao;
@Component
@Local({ ResourceManager.class, ResourceService.class })
public class ResourceManagerImpl extends ManagerBase implements ResourceManager, ResourceService,
Manager {
private static final Logger s_logger = Logger
.getLogger(ResourceManagerImpl.class);
@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 S3Manager _s3Mgr;
@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;
// @com.cloud.utils.component.Inject(adapter = Discoverer.class)
@Inject
protected List<? extends Discoverer> _discoverers;
@Inject
protected ClusterManager _clusterMgr;
@Inject
protected StoragePoolHostDao _storagePoolHostDao;
// @com.cloud.utils.component.Inject(adapter = PodAllocator.class)
@Inject
protected List<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 static final int ACQUIRE_GLOBAL_LOCK_TIMEOUT_FOR_COOPERATION = 30; // seconds
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);
ClusterDetailsVO cluster_detail_cpu = new ClusterDetailsVO(clusterId, "cpuOvercommitRatio", Float.toString(cmd.getCpuOvercommitRatio()));
ClusterDetailsVO cluster_detail_ram = new ClusterDetailsVO(clusterId, "memoryOvercommitRatio", Float.toString(cmd.getMemoryOvercommitRaito()));
_clusterDetailsDao.persist(cluster_detail_cpu);
_clusterDetailsDao.persist(cluster_detail_ram);
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);
_clusterDetailsDao.persist(cluster_detail_cpu);
_clusterDetailsDao.persist(cluster_detail_ram);
//create a new entry only if the overcommit ratios are greater than 1.
if(cmd.getCpuOvercommitRatio().compareTo(1f) > 0) {
cluster_detail_cpu = new ClusterDetailsVO(clusterId, "cpuOvercommitRatio", Float.toString(cmd.getCpuOvercommitRatio()));
_clusterDetailsDao.persist(cluster_detail_cpu);
}
if(cmd.getMemoryOvercommitRaito().compareTo(1f) > 0) {
cluster_detail_ram = new ClusterDetailsVO(clusterId, "memoryOvercommitRatio", Float.toString(cmd.getMemoryOvercommitRaito()));
_clusterDetailsDao.persist(cluster_detail_ram);
}
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) {
for (Discoverer discoverer : _discoverers) {
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(), true);
}
@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, false);
}
@Override
public Swift discoverSwift(AddSwiftCmd cmd) throws DiscoveryException {
return _swiftMgr.addSwift(cmd);
}
@Override
public Pair<List<? extends Swift>, Integer> listSwifts(ListSwiftsCmd cmd) {
Pair<List<SwiftVO>, Integer> swifts = _swiftMgr.listSwifts(cmd);
return new Pair<List<? extends Swift>, Integer>(swifts.first(), swifts.second());
}
@Override
public S3 discoverS3(final AddS3Cmd cmd) throws DiscoveryException {
return this._s3Mgr.addS3(cmd);
}
@Override
public List<S3VO> listS3s(final ListS3sCmd cmd) {
return this._s3Mgr.listS3s(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, boolean deferAgentCreation) 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);
boolean isHypervisorTypeSupported = false;
for (Discoverer discoverer : _discoverers) {
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 = null;
if (deferAgentCreation) {
host = (HostVO)createHostAndAgentDeferred(resource, entry.getValue(), true, hostTags, false);
} else {
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);
hostCapacitySC.addAnd("capacityType", SearchCriteria.Op.IN,
capacityTypes);
_capacityDao.remove(hostCapacitySC);
txn.commit();
return true;
}
@Override
public boolean deleteHost(long hostId, boolean isForced,
boolean isForceDeleteStorage) {
try {
Boolean result = _clusterMgr.propagateResourceEvent(hostId,
ResourceState.Event.DeleteHost);
if (result != null) {
return result;
}
} catch (AgentUnavailableException e) {
return false;
}
return doDeleteHost(hostId, isForced, isForceDeleteStorage);
}
@Override
@DB
public boolean deleteCluster(DeleteClusterCmd cmd) {
Transaction txn = Transaction.currentTxn();
try {
txn.start();
ClusterVO cluster = _clusterDao.lockRow(cmd.getId(), true);
if (cluster == null) {
if (s_logger.isDebugEnabled()) {
s_logger.debug("Cluster: " + cmd.getId()
+ " does not even exist. Delete call is ignored.");
}
txn.rollback();
throw new CloudRuntimeException("Cluster: " + cmd.getId()
+ " does not exist");
}
Hypervisor.HypervisorType hypervisorType = cluster
.getHypervisorType();
List<HostVO> hosts = listAllHostsInCluster(cmd.getId());
if (hosts.size() > 0) {
if (s_logger.isDebugEnabled()) {
s_logger.debug("Cluster: " + cmd.getId()
+ " still has hosts, can't remove");
}
txn.rollback();
throw new CloudRuntimeException("Cluster: " + cmd.getId()
+ " cannot be removed. Cluster still has hosts");
}
// don't allow to remove the cluster if it has non-removed storage
// pools
List<StoragePoolVO> storagePools = _storagePoolDao
.listPoolsByCluster(cmd.getId());
if (storagePools.size() > 0) {
if (s_logger.isDebugEnabled()) {
s_logger.debug("Cluster: " + cmd.getId()
+ " still has storage pools, can't remove");
}
txn.rollback();
throw new CloudRuntimeException("Cluster: " + cmd.getId()
+ " cannot be removed. Cluster still has storage pools");
}
if (_clusterDao.remove(cmd.getId())) {
_capacityDao.removeBy(null, null, null, cluster.getId(), null);
// If this cluster is of type vmware, and if the nexus vswitch
// global parameter setting is turned
// on, remove the row in cluster_vsm_map for this cluster id.
if (hypervisorType == HypervisorType.VMware
&& Boolean.parseBoolean(_configDao
.getValue(Config.VmwareUseNexusVSwitch
.toString()))) {
_clusterVSMMapDao.removeByClusterId(cmd.getId());
}
}
txn.commit();
return true;
} catch (CloudRuntimeException e) {
throw e;
} catch (Throwable t) {
s_logger.error("Unable to delete cluster: " + cmd.getId(), t);
txn.rollback();
return false;
}
}
@Override
@DB
public Cluster updateCluster(Cluster clusterToUpdate, String clusterType,
String hypervisor, String allocationState, String managedstate,Float memoryovercommitratio, Float cpuovercommitratio) {
ClusterVO cluster = (ClusterVO) clusterToUpdate;
// Verify cluster information and update the cluster if needed
boolean doUpdate = false;
if (hypervisor != null && !hypervisor.isEmpty()) {
Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType
.getType(hypervisor);
if (hypervisorType == null) {
s_logger.error("Unable to resolve " + hypervisor
+ " to a valid supported hypervisor type");
throw new InvalidParameterValueException("Unable to resolve "
+ hypervisor + " to a supported type");
} else {
cluster.setHypervisorType(hypervisor);
doUpdate = true;
}
}
Cluster.ClusterType newClusterType = null;
if (clusterType != null && !clusterType.isEmpty()) {
try {
newClusterType = Cluster.ClusterType.valueOf(clusterType);
} catch (IllegalArgumentException ex) {
throw new InvalidParameterValueException("Unable to resolve "
+ clusterType + " to a supported type");
}
if (newClusterType == null) {
s_logger.error("Unable to resolve " + clusterType
+ " to a valid supported cluster type");
throw new InvalidParameterValueException("Unable to resolve "
+ clusterType + " to a supported type");
} else {
cluster.setClusterType(newClusterType);
doUpdate = true;
}
}
Grouping.AllocationState newAllocationState = null;
if (allocationState != null && !allocationState.isEmpty()) {
try {
newAllocationState = Grouping.AllocationState
.valueOf(allocationState);
} catch (IllegalArgumentException ex) {
throw new InvalidParameterValueException(
"Unable to resolve Allocation State '"
+ allocationState + "' to a supported state");
}
if (newAllocationState == null) {
s_logger.error("Unable to resolve " + allocationState
+ " to a valid supported allocation State");
throw new InvalidParameterValueException("Unable to resolve "
+ allocationState + " to a supported state");
} else {
_capacityDao.updateCapacityState(null, null, cluster.getId(),
null, allocationState);
cluster.setAllocationState(newAllocationState);
doUpdate = true;
}
}
Managed.ManagedState newManagedState = null;
Managed.ManagedState oldManagedState = cluster.getManagedState();
if (managedstate != null && !managedstate.isEmpty()) {
try {
newManagedState = Managed.ManagedState.valueOf(managedstate);
} catch (IllegalArgumentException ex) {
throw new InvalidParameterValueException(
"Unable to resolve Managed State '" + managedstate
+ "' to a supported state");
}
if (newManagedState == null) {
s_logger.error("Unable to resolve Managed State '"
+ managedstate + "' to a supported state");
throw new InvalidParameterValueException(
"Unable to resolve Managed State '" + managedstate
+ "' to a supported state");
} else {
doUpdate = true;
}
}
ClusterDetailsVO memory_detail = _clusterDetailsDao.findDetail(cluster.getId(),"memoryOvercommitRatio");
if( memory_detail == null){
if (memoryovercommitratio.compareTo(1f) > 0){
memory_detail = new ClusterDetailsVO(cluster.getId(),"memoryOvercommitRatio",Float.toString(memoryovercommitratio));
_clusterDetailsDao.persist(memory_detail);
}
}
else {
memory_detail.setValue(Float.toString(memoryovercommitratio));
_clusterDetailsDao.update(memory_detail.getId(),memory_detail);
}
ClusterDetailsVO cpu_detail = _clusterDetailsDao.findDetail(cluster.getId(),"cpuOvercommitRatio");
if( cpu_detail == null){
if (cpuovercommitratio.compareTo(1f) > 0){
cpu_detail = new ClusterDetailsVO(cluster.getId(),"cpuOvercommitRatio",Float.toString(cpuovercommitratio));
_clusterDetailsDao.persist(cpu_detail);
}
}
else {
cpu_detail.setValue(Float.toString(cpuovercommitratio));
_clusterDetailsDao.update(cpu_detail.getId(),cpu_detail);
}
if (doUpdate) {
Transaction txn = Transaction.currentTxn();
try {
txn.start();
_clusterDao.update(cluster.getId(), cluster);
txn.commit();
} catch (Exception e) {
s_logger.error(
"Unable to update cluster due to " + e.getMessage(), e);
throw new CloudRuntimeException(
"Failed to update cluster. Please contact Cloud Support.");
}
}
if (newManagedState != null && !newManagedState.equals(oldManagedState)) {
Transaction txn = Transaction.currentTxn();
if (newManagedState.equals(Managed.ManagedState.Unmanaged)) {
boolean success = false;
try {
txn.start();
cluster.setManagedState(Managed.ManagedState.PrepareUnmanaged);
_clusterDao.update(cluster.getId(), cluster);
txn.commit();
List<HostVO> hosts = listAllUpAndEnabledHosts(
Host.Type.Routing, cluster.getId(),
cluster.getPodId(), cluster.getDataCenterId());
for (HostVO host : hosts) {
if (host.getType().equals(Host.Type.Routing)
&& !host.getStatus().equals(Status.Down)
&& !host.getStatus()
.equals(Status.Disconnected)
&& !host.getStatus().equals(Status.Up)
&& !host.getStatus().equals(Status.Alert)) {
String msg = "host " + host.getPrivateIpAddress()
+ " should not be in "
+ host.getStatus().toString() + " status";
throw new CloudRuntimeException(
"PrepareUnmanaged Failed due to " + msg);
}
}
for (HostVO host : hosts) {
if (host.getStatus().equals(Status.Up)) {
umanageHost(host.getId());
}
}
int retry = 40;
boolean lsuccess = true;
for (int i = 0; i < retry; i++) {
lsuccess = true;
try {
Thread.sleep(5 * 1000);
} catch (Exception e) {
}
hosts = listAllUpAndEnabledHosts(Host.Type.Routing,
cluster.getId(), cluster.getPodId(),
cluster.getDataCenterId());
for (HostVO host : hosts) {
if (!host.getStatus().equals(Status.Down)
&& !host.getStatus().equals(
Status.Disconnected)
&& !host.getStatus().equals(Status.Alert)) {
lsuccess = false;
break;
}
}
if (lsuccess == true) {
success = true;
break;
}
}
if (success == false) {
throw new CloudRuntimeException(
"PrepareUnmanaged Failed due to some hosts are still in UP status after 5 Minutes, please try later ");
}
} finally {
txn.start();
cluster.setManagedState(success ? Managed.ManagedState.Unmanaged
: Managed.ManagedState.PrepareUnmanagedError);
_clusterDao.update(cluster.getId(), cluster);
txn.commit();
}
} else if (newManagedState.equals(Managed.ManagedState.Managed)) {
txn.start();
cluster.setManagedState(Managed.ManagedState.Managed);
_clusterDao.update(cluster.getId(), cluster);
txn.commit();
}
}
return cluster;
}
@Override
public Host cancelMaintenance(CancelMaintenanceCmd cmd) {
Long hostId = cmd.getId();
// verify input parameters
HostVO host = _hostDao.findById(hostId);
if (host == null || host.getRemoved() != null) {
throw new InvalidParameterValueException("Host with id "
+ hostId.toString() + " doesn't exist");
}
processResourceEvent(ResourceListener.EVENT_CANCEL_MAINTENANCE_BEFORE,
hostId);
boolean success = cancelMaintenance(hostId);
processResourceEvent(ResourceListener.EVENT_CANCEL_MAINTENANCE_AFTER,
hostId);
if (!success) {
throw new CloudRuntimeException(
"Internal error cancelling maintenance.");
}
return host;
}
@Override
public Host reconnectHost(ReconnectHostCmd cmd) {
Long hostId = cmd.getId();
HostVO host = _hostDao.findById(hostId);
if (host == null) {
throw new InvalidParameterValueException("Host with id "
+ hostId.toString() + " doesn't exist");
}
return (_agentMgr.reconnect(hostId) ? host : null);
}
@Override
public boolean resourceStateTransitTo(Host host, ResourceState.Event event,
long msId) throws NoTransitionException {
ResourceState currentState = host.getResourceState();
ResourceState nextState = currentState.getNextState(event);
if (nextState == null) {
throw new NoTransitionException(
"No next resource state found for current state ="
+ currentState + " event =" + event);
}
// TO DO - Make it more granular and have better conversion into
// capacity type
if (host.getType() == Type.Routing && host.getClusterId() != null) {
AllocationState capacityState = _configMgr
.findClusterAllocationState(ApiDBUtils.findClusterById(host
.getClusterId()));
if (capacityState == AllocationState.Enabled
&& nextState != ResourceState.Enabled) {
capacityState = AllocationState.Disabled;
}
_capacityDao.updateCapacityState(null, null, null, host.getId(),
capacityState.toString());
}
return _hostDao.updateResourceState(currentState, event, nextState,
host);
}
private boolean doMaintain(final long hostId) {
HostVO host = _hostDao.findById(hostId);
MaintainAnswer answer = (MaintainAnswer) _agentMgr.easySend(hostId,
new MaintainCommand());
if (answer == null || !answer.getResult()) {
s_logger.warn("Unable to send MaintainCommand to host: " + hostId);
}
try {
resourceStateTransitTo(host,
ResourceState.Event.AdminAskMaintenace, _nodeId);
} catch (NoTransitionException e) {
String err = "Cannot transimit resource state of host "
+ host.getId() + " to " + ResourceState.Maintenance;
s_logger.debug(err, e);
throw new CloudRuntimeException(err + e.getMessage());
}
_agentMgr.pullAgentToMaintenance(hostId);
/* TODO: move below to listener */
if (host.getType() == Host.Type.Routing) {
final List<VMInstanceVO> vms = _vmDao.listByHostId(hostId);
if (vms.size() == 0) {
return true;
}
List<HostVO> hosts = listAllUpAndEnabledHosts(Host.Type.Routing,
host.getClusterId(), host.getPodId(),
host.getDataCenterId());
for (final VMInstanceVO vm : vms) {
if (hosts == null || hosts.isEmpty() || !answer.getMigrate()) {
// for the last host in this cluster, stop all the VMs
_haMgr.scheduleStop(vm, hostId, WorkType.ForceStop);
} else {
_haMgr.scheduleMigration(vm);
}
}
}
return true;
}
@Override
public boolean maintain(final long hostId) throws AgentUnavailableException {
Boolean result = _clusterMgr.propagateResourceEvent(hostId,
ResourceState.Event.AdminAskMaintenace);
if (result != null) {
return result;
}
return doMaintain(hostId);
}
@Override
public Host maintain(PrepareForMaintenanceCmd cmd) {
Long hostId = cmd.getId();
HostVO host = _hostDao.findById(hostId);
if (host == null) {
s_logger.debug("Unable to find host " + hostId);
throw new InvalidParameterValueException(
"Unable to find host with ID: " + hostId
+ ". Please specify a valid host ID.");
}
if (_hostDao.countBy(host.getClusterId(),
ResourceState.PrepareForMaintenance,
ResourceState.ErrorInMaintenance) > 0) {
throw new InvalidParameterValueException(
"There are other servers in PrepareForMaintenance OR ErrorInMaintenance STATUS in cluster "
+ host.getClusterId());
}
if (_storageMgr.isLocalStorageActiveOnHost(host.getId())) {
throw new InvalidParameterValueException(
"There are active VMs using the host's local storage pool. Please stop all VMs on this host that use local storage.");
}
try {
processResourceEvent(
ResourceListener.EVENT_PREPARE_MAINTENANCE_BEFORE, hostId);
if (maintain(hostId)) {
processResourceEvent(
ResourceListener.EVENT_PREPARE_MAINTENANCE_AFTER,
hostId);
return _hostDao.findById(hostId);
} else {
throw new CloudRuntimeException(
"Unable to prepare for maintenance host " + hostId);
}
} catch (AgentUnavailableException e) {
throw new CloudRuntimeException(
"Unable to prepare for maintenance host " + hostId);
}
}
@Override
public Host updateHost(UpdateHostCmd cmd) throws NoTransitionException {
Long hostId = cmd.getId();
Long guestOSCategoryId = cmd.getOsCategoryId();
// Verify that the host exists
HostVO host = _hostDao.findById(hostId);
if (host == null) {
throw new InvalidParameterValueException("Host with id " + hostId
+ " doesn't exist");
}
if (cmd.getAllocationState() != null) {
ResourceState.Event resourceEvent = ResourceState.Event.toEvent(cmd
.getAllocationState());
if (resourceEvent != ResourceState.Event.Enable
&& resourceEvent != ResourceState.Event.Disable) {
throw new CloudRuntimeException("Invalid allocation state:"
+ cmd.getAllocationState()
+ ", only Enable/Disable are allowed");
}
resourceStateTransitTo(host, resourceEvent, _nodeId);
}
if (guestOSCategoryId != null) {
// Verify that the guest OS Category exists
if (guestOSCategoryId > 0) {
if (_guestOSCategoryDao.findById(guestOSCategoryId) == null) {
throw new InvalidParameterValueException(
"Please specify a valid guest OS category.");
}
}
GuestOSCategoryVO guestOSCategory = _guestOSCategoryDao
.findById(guestOSCategoryId);
Map<String, String> hostDetails = _hostDetailsDao
.findDetails(hostId);
if (guestOSCategory != null
&& !GuestOSCategoryVO.CATEGORY_NONE
.equalsIgnoreCase(guestOSCategory.getName())) {
// Save a new entry for guest.os.category.id
hostDetails.put("guest.os.category.id",
String.valueOf(guestOSCategory.getId()));
} else {
// Delete any existing entry for guest.os.category.id
hostDetails.remove("guest.os.category.id");
}
_hostDetailsDao.persist(hostId, hostDetails);
}
List<String> hostTags = cmd.getHostTags();
if (hostTags != null) {
if (s_logger.isDebugEnabled()) {
s_logger.debug("Updating Host Tags to :" + hostTags);
}
_hostTagsDao.persist(hostId, hostTags);
}
String url = cmd.getUrl();
if (url != null) {
_storageMgr.updateSecondaryStorage(cmd.getId(), cmd.getUrl());
}
HostVO updatedHost = _hostDao.findById(hostId);
return updatedHost;
}
@Override
public Cluster getCluster(Long clusterId) {
return _clusterDao.findById(clusterId);
}
@Override
public boolean configure(String name, Map<String, Object> params)
throws ConfigurationException {
_defaultSystemVMHypervisor = HypervisorType.getType(_configDao
.getValue(Config.SystemVMDefaultHypervisor.toString()));
return true;
}
@Override
public List<HypervisorType> getSupportedHypervisorTypes(long zoneId,
boolean forVirtualRouter, Long podId) {
List<HypervisorType> hypervisorTypes = new ArrayList<HypervisorType>();
List<ClusterVO> clustersForZone = new ArrayList<ClusterVO>();
if (podId != null) {
clustersForZone = _clusterDao.listByPodId(podId);
} else {
clustersForZone = _clusterDao.listByZoneId(zoneId);
}
for (ClusterVO cluster : clustersForZone) {
HypervisorType hType = cluster.getHypervisorType();
if (!forVirtualRouter
|| (forVirtualRouter && hType != HypervisorType.BareMetal && hType != HypervisorType.Ovm)) {
hypervisorTypes.add(hType);
}
}
return hypervisorTypes;
}
@Override
public HypervisorType getDefaultHypervisor(long zoneId) {
HypervisorType defaultHyper = HypervisorType.None;
if (_defaultSystemVMHypervisor != HypervisorType.None) {
defaultHyper = _defaultSystemVMHypervisor;
}
DataCenterVO dc = _dcDao.findById(zoneId);
if (dc == null) {
return HypervisorType.None;
}
_dcDao.loadDetails(dc);
String defaultHypervisorInZone = dc
.getDetail("defaultSystemVMHypervisorType");
if (defaultHypervisorInZone != null) {
defaultHyper = HypervisorType.getType(defaultHypervisorInZone);
}
List<VMTemplateVO> systemTemplates = _templateDao
.listAllSystemVMTemplates();
boolean isValid = false;
for (VMTemplateVO template : systemTemplates) {
if (template.getHypervisorType() == defaultHyper) {
isValid = true;
break;
}
}
if (isValid) {
List<ClusterVO> clusters = _clusterDao.listByDcHyType(zoneId,
defaultHyper.toString());
if (clusters.size() <= 0) {
isValid = false;
}
}
if (isValid) {
return defaultHyper;
} else {
return HypervisorType.None;
}
}
@Override
public HypervisorType getAvailableHypervisor(long zoneId) {
HypervisorType defaultHype = getDefaultHypervisor(zoneId);
if (defaultHype == HypervisorType.None) {
List<HypervisorType> supportedHypes = getSupportedHypervisorTypes(
zoneId, false, null);
if (supportedHypes.size() > 0) {
defaultHype = supportedHypes.get(0);
}
}
if (defaultHype == HypervisorType.None) {
defaultHype = HypervisorType.Any;
}
return defaultHype;
}
@Override
public void registerResourceStateAdapter(String name,
ResourceStateAdapter adapter) {
if (_resourceStateAdapters.get(name) != null) {
throw new CloudRuntimeException(name + " has registered");
}
synchronized (_resourceStateAdapters) {
_resourceStateAdapters.put(name, adapter);
}
}
@Override
public void unregisterResourceStateAdapter(String name) {
synchronized (_resourceStateAdapters) {
_resourceStateAdapters.remove(name);
}
}
private Object dispatchToStateAdapters(ResourceStateAdapter.Event event,
boolean singleTaker, Object... args) {
synchronized (_resourceStateAdapters) {
Iterator it = _resourceStateAdapters.entrySet().iterator();
Object result = null;
while (it.hasNext()) {
Map.Entry<String, ResourceStateAdapter> item = (Map.Entry<String, ResourceStateAdapter>) it
.next();
ResourceStateAdapter adapter = item.getValue();
String msg = new String("Dispatching resource state event "
+ event + " to " + item.getKey());
s_logger.debug(msg);
if (event == ResourceStateAdapter.Event.CREATE_HOST_VO_FOR_CONNECTED) {
result = adapter.createHostVOForConnectedAgent(
(HostVO) args[0], (StartupCommand[]) args[1]);
if (result != null && singleTaker) {
break;
}
} else if (event == ResourceStateAdapter.Event.CREATE_HOST_VO_FOR_DIRECT_CONNECT) {
result = adapter.createHostVOForDirectConnectAgent(
(HostVO) args[0], (StartupCommand[]) args[1],
(ServerResource) args[2],
(Map<String, String>) args[3],
(List<String>) args[4]);
if (result != null && singleTaker) {
break;
}
} else if (event == ResourceStateAdapter.Event.DELETE_HOST) {
try {
result = adapter.deleteHost((HostVO) args[0],
(Boolean) args[1], (Boolean) args[2]);
if (result != null) {
break;
}
} catch (UnableDeleteHostException e) {
s_logger.debug("Adapter " + adapter.getName()
+ " says unable to delete host", e);
result = new ResourceStateAdapter.DeleteHostAnswer(
false, true);
}
} else {
throw new CloudRuntimeException(
"Unknown resource state event:" + event);
}
}
return result;
}
}
@Override
public void checkCIDR(HostPodVO pod, DataCenterVO dc,
String serverPrivateIP, String serverPrivateNetmask)
throws IllegalArgumentException {
if (serverPrivateIP == null) {
return;
}
// Get the CIDR address and CIDR size
String cidrAddress = pod.getCidrAddress();
long cidrSize = pod.getCidrSize();
// If the server's private IP address is not in the same subnet as the
// pod's CIDR, return false
String cidrSubnet = NetUtils.getCidrSubNet(cidrAddress, cidrSize);
String serverSubnet = NetUtils.getSubNet(serverPrivateIP,
serverPrivateNetmask);
if (!cidrSubnet.equals(serverSubnet)) {
s_logger.warn("The private ip address of the server ("
+ serverPrivateIP
+ ") is not compatible with the CIDR of pod: "
+ pod.getName() + " and zone: " + dc.getName());
throw new IllegalArgumentException(
"The private ip address of the server (" + serverPrivateIP
+ ") is not compatible with the CIDR of pod: "
+ pod.getName() + " and zone: " + dc.getName());
}
// If the server's private netmask is less inclusive than the pod's CIDR
// netmask, return false
String cidrNetmask = NetUtils
.getCidrSubNet("255.255.255.255", cidrSize);
long cidrNetmaskNumeric = NetUtils.ip2Long(cidrNetmask);
long serverNetmaskNumeric = NetUtils.ip2Long(serverPrivateNetmask);
if (serverNetmaskNumeric > cidrNetmaskNumeric) {
throw new IllegalArgumentException(
"The private ip address of the server (" + serverPrivateIP
+ ") is not compatible with the CIDR of pod: "
+ pod.getName() + " and zone: " + dc.getName());
}
}
private boolean checkCIDR(HostPodVO pod, String serverPrivateIP,
String serverPrivateNetmask) {
if (serverPrivateIP == null) {
return true;
}
// Get the CIDR address and CIDR size
String cidrAddress = pod.getCidrAddress();
long cidrSize = pod.getCidrSize();
// If the server's private IP address is not in the same subnet as the
// pod's CIDR, return false
String cidrSubnet = NetUtils.getCidrSubNet(cidrAddress, cidrSize);
String serverSubnet = NetUtils.getSubNet(serverPrivateIP,
serverPrivateNetmask);
if (!cidrSubnet.equals(serverSubnet)) {
return false;
}
// If the server's private netmask is less inclusive than the pod's CIDR
// netmask, return false
String cidrNetmask = NetUtils
.getCidrSubNet("255.255.255.255", cidrSize);
long cidrNetmaskNumeric = NetUtils.ip2Long(cidrNetmask);
long serverNetmaskNumeric = NetUtils.ip2Long(serverPrivateNetmask);
if (serverNetmaskNumeric > cidrNetmaskNumeric) {
return false;
}
return true;
}
protected HostVO createHostVO(StartupCommand[] cmds,
ServerResource resource, Map<String, String> details,
List<String> hostTags, ResourceStateAdapter.Event stateEvent) {
StartupCommand startup = cmds[0];
HostVO host = findHostByGuid(startup.getGuid());
boolean isNew = false;
if (host == null) {
host = findHostByGuid(startup.getGuidWithoutResource());
}
if (host == null) {
host = new HostVO(startup.getGuid());
isNew = true;
}
String dataCenter = startup.getDataCenter();
String pod = startup.getPod();
String cluster = startup.getCluster();
if (pod != null && dataCenter != null
&& pod.equalsIgnoreCase("default")
&& dataCenter.equalsIgnoreCase("default")) {
List<HostPodVO> pods = _podDao.listAllIncludingRemoved();
for (HostPodVO hpv : pods) {
if (checkCIDR(hpv, startup.getPrivateIpAddress(),
startup.getPrivateNetmask())) {
pod = hpv.getName();
dataCenter = _dcDao.findById(hpv.getDataCenterId())
.getName();
break;
}
}
}
long dcId = -1;
DataCenterVO dc = _dcDao.findByName(dataCenter);
if (dc == null) {
try {
dcId = Long.parseLong(dataCenter);
dc = _dcDao.findById(dcId);
} catch (final NumberFormatException e) {
}
}
if (dc == null) {
throw new IllegalArgumentException("Host "
+ startup.getPrivateIpAddress()
+ " sent incorrect data center: " + dataCenter);
}
dcId = dc.getId();
HostPodVO p = _podDao.findByName(pod, dcId);
if (p == null) {
try {
final long podId = Long.parseLong(pod);
p = _podDao.findById(podId);
} catch (final NumberFormatException e) {
}
}
/*
* ResourceStateAdapter is responsible for throwing Exception if Pod is
* null and non-null is required. for example, XcpServerDiscoever.
* Others, like PxeServer, ExternalFireware don't require Pod
*/
Long podId = (p == null ? null : p.getId());
Long clusterId = null;
if (cluster != null) {
try {
clusterId = Long.valueOf(cluster);
} catch (NumberFormatException e) {
ClusterVO c = _clusterDao.findBy(cluster, podId);
if (c == null) {
c = new ClusterVO(dcId, podId, cluster);
c = _clusterDao.persist(c);
}
clusterId = c.getId();
}
}
host.setDataCenterId(dc.getId());
host.setPodId(podId);
host.setClusterId(clusterId);
host.setPrivateIpAddress(startup.getPrivateIpAddress());
host.setPrivateNetmask(startup.getPrivateNetmask());
host.setPrivateMacAddress(startup.getPrivateMacAddress());
host.setPublicIpAddress(startup.getPublicIpAddress());
host.setPublicMacAddress(startup.getPublicMacAddress());
host.setPublicNetmask(startup.getPublicNetmask());
host.setStorageIpAddress(startup.getStorageIpAddress());
host.setStorageMacAddress(startup.getStorageMacAddress());
host.setStorageNetmask(startup.getStorageNetmask());
host.setVersion(startup.getVersion());
host.setName(startup.getName());
host.setManagementServerId(_nodeId);
host.setStorageUrl(startup.getIqn());
host.setLastPinged(System.currentTimeMillis() >> 10);
host.setHostTags(hostTags);
host.setDetails(details);
if (startup.getStorageIpAddressDeux() != null) {
host.setStorageIpAddressDeux(startup.getStorageIpAddressDeux());
host.setStorageMacAddressDeux(startup.getStorageMacAddressDeux());
host.setStorageNetmaskDeux(startup.getStorageNetmaskDeux());
}
if (resource != null) {
/* null when agent is connected agent */
host.setResource(resource.getClass().getName());
}
host = (HostVO) dispatchToStateAdapters(stateEvent, true, host, cmds,
resource, details, hostTags);
if (host == null) {
throw new CloudRuntimeException(
"No resource state adapter response");
}
if (isNew) {
host = _hostDao.persist(host);
} else {
_hostDao.update(host.getId(), host);
}
try {
resourceStateTransitTo(host, ResourceState.Event.InternalCreated,
_nodeId);
/* Agent goes to Connecting status */
_agentMgr.agentStatusTransitTo(host, Status.Event.AgentConnected,
_nodeId);
} catch (Exception e) {
s_logger.debug("Cannot transmit host " + host.getId()
+ " to Creating state", e);
_agentMgr.agentStatusTransitTo(host, Status.Event.Error, _nodeId);
try {
resourceStateTransitTo(host, ResourceState.Event.Error, _nodeId);
} catch (NoTransitionException e1) {
s_logger.debug("Cannot transmit host " + host.getId()
+ "to Error state", e);
}
}
return host;
}
private boolean isFirstHostInCluster(HostVO host)
{
boolean isFirstHost = true;
if (host.getClusterId() != null) {
SearchBuilder<HostVO> sb = _hostDao.createSearchBuilder();
sb.and("removed", sb.entity().getRemoved(), SearchCriteria.Op.NULL);
sb.and("cluster", sb.entity().getClusterId(), SearchCriteria.Op.EQ);
sb.done();
SearchCriteria<HostVO> sc = sb.create();
sc.setParameters("cluster", host.getClusterId());
List<HostVO> hosts = _hostDao.search(sc, null);
if (hosts != null && hosts.size() > 1) {
isFirstHost = false;
}
}
return isFirstHost;
}
private void markHostAsDisconnected(HostVO host, StartupCommand[] cmds) {
if (host == null) { // in case host is null due to some errors, try reloading the host from db
if (cmds != null) {
StartupCommand firstCmd = cmds[0];
host = findHostByGuid(firstCmd.getGuid());
if (host == null) {
host = findHostByGuid(firstCmd.getGuidWithoutResource());
}
}
}
if (host != null) {
// Change agent status to Alert, so that host is considered for reconnection next time
_agentMgr.agentStatusTransitTo(host, Status.Event.AgentDisconnected, _nodeId);
}
}
private Host createHostAndAgent(ServerResource resource, Map<String, String> details, boolean old, List<String> hostTags,
boolean forRebalance) {
HostVO host = null;
AgentAttache attache = null;
StartupCommand[] cmds = null;
boolean hostExists = false;
try {
cmds = resource.initialize();
if (cmds == null) {
s_logger.info("Unable to fully initialize the agent because no StartupCommands are returned");
return null;
}
/* Generate a random version in a dev setup situation */
if (this.getClass().getPackage().getImplementationVersion() == null) {
for (StartupCommand cmd : cmds) {
if (cmd.getVersion() == null) {
cmd.setVersion(Long.toString(System.currentTimeMillis()));
}
}
}
if (s_logger.isDebugEnabled()) {
new Request(-1l, -1l, cmds, true, false).logD(
"Startup request from directly connected host: ", true);
}
if (old) {
StartupCommand firstCmd = cmds[0];
host = findHostByGuid(firstCmd.getGuid());
if (host == null) {
host = findHostByGuid(firstCmd.getGuidWithoutResource());
}
if (host != null && host.getRemoved() == null) { // host already added, no need to add again
s_logger.debug("Found the host " + host.getId() + " by guid: " + firstCmd.getGuid() + ", old host reconnected as new");
hostExists = true; // ensures that host status is left unchanged in case of adding same one again
return null;
}
}
host = createHostVO(
cmds,
resource,
details,
hostTags,
ResourceStateAdapter.Event.CREATE_HOST_VO_FOR_DIRECT_CONNECT);
if (host != null) {
attache = _agentMgr.handleDirectConnectAgent(host, cmds,
resource, forRebalance);
/* reload myself from database */
host = _hostDao.findById(host.getId());
}
} catch (Exception e) {
s_logger.warn("Unable to connect due to ", e);
} finally {
if (hostExists) {
if (cmds != null) {
resource.disconnected();
}
} else {
if (attache == null) {
if (cmds != null) {
resource.disconnected();
}
markHostAsDisconnected(host, cmds);
}
}
}
return host;
}
private Host createHostAndAgentDeferred(ServerResource resource, Map<String, String> details, boolean old, List<String> hostTags,
boolean forRebalance) {
HostVO host = null;
AgentAttache attache = null;
StartupCommand[] cmds = null;
boolean hostExists = false;
boolean deferAgentCreation = true;
try {
cmds = resource.initialize();
if (cmds == null) {
s_logger.info("Unable to fully initialize the agent because no StartupCommands are returned");
return null;
}
/* Generate a random version in a dev setup situation */
if ( this.getClass().getPackage().getImplementationVersion() == null ) {
for ( StartupCommand cmd : cmds ) {
if ( cmd.getVersion() == null ) {
cmd.setVersion(Long.toString(System.currentTimeMillis()));
}
}
}
if (s_logger.isDebugEnabled()) {
new Request(-1l, -1l, cmds, true, false).logD("Startup request from directly connected host: ", true);
}
if (old) {
StartupCommand firstCmd = cmds[0];
host = findHostByGuid(firstCmd.getGuid());
if (host == null) {
host = findHostByGuid(firstCmd.getGuidWithoutResource());
}
if (host != null && host.getRemoved() == null) { // host already added, no need to add again
s_logger.debug("Found the host " + host.getId() + " by guid: " + firstCmd.getGuid() + ", old host reconnected as new");
hostExists = true; // ensures that host status is left unchanged in case of adding same one again
return null;
}
}
host = null;
GlobalLock addHostLock = GlobalLock.getInternLock("AddHostLock");
try {
if (addHostLock.lock(ACQUIRE_GLOBAL_LOCK_TIMEOUT_FOR_COOPERATION)) { // to safely determine first host in cluster in multi-MS scenario
try {
host = createHostVO(cmds, resource, details, hostTags, ResourceStateAdapter.Event.CREATE_HOST_VO_FOR_DIRECT_CONNECT);
if (host != null) {
deferAgentCreation = !isFirstHostInCluster(host); // if first host in cluster no need to defer agent creation
}
} finally {
addHostLock.unlock();
}
}
} finally {
addHostLock.releaseRef();
}
if (host != null) {
if (!deferAgentCreation) { // if first host in cluster then create agent otherwise defer it to scan task
attache = _agentMgr.handleDirectConnectAgent(host, cmds, resource, forRebalance);
host = _hostDao.findById(host.getId()); // reload
} else {
host = _hostDao.findById(host.getId()); // reload
// force host status to 'Alert' so that it is loaded for connection during next scan task
_agentMgr.agentStatusTransitTo(host, Status.Event.AgentDisconnected, _nodeId);
host = _hostDao.findById(host.getId()); // reload
host.setLastPinged(0); // so that scan task can pick it up
_hostDao.update(host.getId(), host);
// schedule a scan task immediately
if (_agentMgr instanceof ClusteredAgentManagerImpl) {
ClusteredAgentManagerImpl clusteredAgentMgr = (ClusteredAgentManagerImpl)_agentMgr;
if (s_logger.isDebugEnabled()) {
s_logger.debug("Scheduling a host scan task");
}
// schedule host scan task on current MS
clusteredAgentMgr.scheduleHostScanTask();
if (s_logger.isDebugEnabled()) {
s_logger.debug("Notifying all peer MS to schedule host scan task");
}
// notify peers to schedule a host scan task as well
clusteredAgentMgr.notifyNodesInClusterToScheduleHostScanTask();
}
}
}
} catch (Exception e) {
s_logger.warn("Unable to connect due to ", e);
} finally {
if (hostExists) {
if (cmds != null) {
resource.disconnected();
}
} else {
if (!deferAgentCreation && attache == null) {
if (cmds != null) {
resource.disconnected();
}
markHostAsDisconnected(host, cmds);
}
}
}
return host;
}
@Override
public Host createHostAndAgent(Long hostId, ServerResource resource,
Map<String, String> details, boolean old, List<String> hostTags,
boolean forRebalance) {
_agentMgr.tapLoadingAgents(hostId, TapAgentsAction.Add);
Host host = createHostAndAgent(resource, details, old, hostTags,
forRebalance);
_agentMgr.tapLoadingAgents(hostId, TapAgentsAction.Del);
return host;
}
@Override
public Host addHost(long zoneId, ServerResource resource, Type hostType,
Map<String, String> hostDetails) {
// Check if the zone exists in the system
if (_dcDao.findById(zoneId) == null) {
throw new InvalidParameterValueException("Can't find zone with id "
+ zoneId);
}
Map<String, String> details = hostDetails;
String guid = details.get("guid");
List<HostVO> currentHosts = this
.listAllUpAndEnabledHostsInOneZoneByType(hostType, zoneId);
for (HostVO currentHost : currentHosts) {
if (currentHost.getGuid().equals(guid)) {
return currentHost;
}
}
return createHostAndAgent(resource, hostDetails, true, null, false);
}
@Override
public HostVO createHostVOForConnectedAgent(StartupCommand[] cmds) {
return createHostVO(cmds, null, null, null,
ResourceStateAdapter.Event.CREATE_HOST_VO_FOR_CONNECTED);
}
private void checkIPConflicts(HostPodVO pod, DataCenterVO dc,
String serverPrivateIP, String serverPrivateNetmask,
String serverPublicIP, String serverPublicNetmask) {
// If the server's private IP is the same as is public IP, this host has
// a host-only private network. Don't check for conflicts with the
// private IP address table.
if (serverPrivateIP != serverPublicIP) {
if (!_privateIPAddressDao.mark(dc.getId(), pod.getId(),
serverPrivateIP)) {
// If the server's private IP address is already in the
// database, return false
List<DataCenterIpAddressVO> existingPrivateIPs = _privateIPAddressDao
.listByPodIdDcIdIpAddress(pod.getId(), dc.getId(),
serverPrivateIP);
assert existingPrivateIPs.size() <= 1 : " How can we get more than one ip address with "
+ serverPrivateIP;
if (existingPrivateIPs.size() > 1) {
throw new IllegalArgumentException(
"The private ip address of the server ("
+ serverPrivateIP
+ ") is already in use in pod: "
+ pod.getName() + " and zone: "
+ dc.getName());
}
if (existingPrivateIPs.size() == 1) {
DataCenterIpAddressVO vo = existingPrivateIPs.get(0);
if (vo.getInstanceId() != null) {
throw new IllegalArgumentException(
"The private ip address of the server ("
+ serverPrivateIP
+ ") is already in use in pod: "
+ pod.getName() + " and zone: "
+ dc.getName());
}
}
}
}
if (serverPublicIP != null
&& !_publicIPAddressDao
.mark(dc.getId(), new Ip(serverPublicIP))) {
// If the server's public IP address is already in the database,
// return false
List<IPAddressVO> existingPublicIPs = _publicIPAddressDao
.listByDcIdIpAddress(dc.getId(), serverPublicIP);
if (existingPublicIPs.size() > 0) {
throw new IllegalArgumentException(
"The public ip address of the server ("
+ serverPublicIP
+ ") is already in use in zone: "
+ dc.getName());
}
}
}
@Override
public HostVO fillRoutingHostVO(HostVO host, StartupRoutingCommand ssCmd,
HypervisorType hyType, Map<String, String> details,
List<String> hostTags) {
if (host.getPodId() == null) {
s_logger.error("Host " + ssCmd.getPrivateIpAddress()
+ " sent incorrect pod, pod id is null");
throw new IllegalArgumentException("Host "
+ ssCmd.getPrivateIpAddress()
+ " sent incorrect pod, pod id is null");
}
ClusterVO clusterVO = _clusterDao.findById(host.getClusterId());
if (clusterVO.getHypervisorType() != hyType) {
throw new IllegalArgumentException(
"Can't add host whose hypervisor type is: " + hyType
+ " into cluster: " + clusterVO.getId()
+ " whose hypervisor type is: "
+ clusterVO.getHypervisorType());
}
final Map<String, String> hostDetails = ssCmd.getHostDetails();
if (hostDetails != null) {
if (details != null) {
details.putAll(hostDetails);
} else {
details = hostDetails;
}
}
HostPodVO pod = _podDao.findById(host.getPodId());
DataCenterVO dc = _dcDao.findById(host.getDataCenterId());
checkIPConflicts(pod, dc, ssCmd.getPrivateIpAddress(),
ssCmd.getPublicIpAddress(), ssCmd.getPublicIpAddress(),
ssCmd.getPublicNetmask());
host.setType(com.cloud.host.Host.Type.Routing);
host.setDetails(details);
host.setCaps(ssCmd.getCapabilities());
host.setCpus(ssCmd.getCpus());
host.setTotalMemory(ssCmd.getMemory());
host.setSpeed(ssCmd.getSpeed());
host.setHypervisorType(hyType);
host.setHypervisorVersion(ssCmd.getHypervisorVersion());
return host;
}
@Override
public void deleteRoutingHost(HostVO host, boolean isForced,
boolean forceDestroyStorage) throws UnableDeleteHostException {
if (host.getType() != Host.Type.Routing) {
throw new CloudRuntimeException(
"Non-Routing host gets in deleteRoutingHost, id is "
+ host.getId());
}
if (s_logger.isDebugEnabled()) {
s_logger.debug("Deleting Host: " + host.getId() + " Guid:"
+ host.getGuid());
}
User caller = _accountMgr.getActiveUser(UserContext.current()
.getCallerUserId());
if (forceDestroyStorage) {
// put local storage into mainenance mode, will set all the VMs on
// this local storage into stopped state
StoragePoolVO storagePool = _storageMgr.findLocalStorageOnHost(host
.getId());
if (storagePool != null) {
if (storagePool.getStatus() == StoragePoolStatus.Up
|| storagePool.getStatus() == StoragePoolStatus.ErrorInMaintenance) {
try {
StoragePool pool = _storageSvr
.preparePrimaryStorageForMaintenance(storagePool
.getId());
if (pool == null) {
s_logger.debug("Failed to set primary storage into maintenance mode");
throw new UnableDeleteHostException(
"Failed to set primary storage into maintenance mode");
}
} catch (Exception e) {
s_logger.debug("Failed to set primary storage into maintenance mode, due to: "
+ e.toString());
throw new UnableDeleteHostException(
"Failed to set primary storage into maintenance mode, due to: "
+ e.toString());
}
}
List<VMInstanceVO> vmsOnLocalStorage = _storageMgr
.listByStoragePool(storagePool.getId());
for (VMInstanceVO vm : vmsOnLocalStorage) {
try {
if (!_vmMgr.destroy(vm, caller,
_accountMgr.getAccount(vm.getAccountId()))) {
String errorMsg = "There was an error Destory the vm: "
+ vm
+ " as a part of hostDelete id="
+ host.getId();
s_logger.warn(errorMsg);
throw new UnableDeleteHostException(errorMsg);
}
} catch (Exception e) {
String errorMsg = "There was an error Destory the vm: "
+ vm + " as a part of hostDelete id="
+ host.getId();
s_logger.debug(errorMsg, e);
throw new UnableDeleteHostException(errorMsg + ","
+ e.getMessage());
}
}
}
} else {
// Check if there are vms running/starting/stopping on this host
List<VMInstanceVO> vms = _vmDao.listByHostId(host.getId());
if (!vms.isEmpty()) {
if (isForced) {
// Stop HA disabled vms and HA enabled vms in Stopping state
// Restart HA enabled vms
for (VMInstanceVO vm : vms) {
if (!vm.isHaEnabled()
|| vm.getState() == State.Stopping) {
s_logger.debug("Stopping vm: " + vm
+ " as a part of deleteHost id="
+ host.getId());
try {
if (!_vmMgr.advanceStop(vm, true, caller,
_accountMgr.getAccount(vm
.getAccountId()))) {
String errorMsg = "There was an error stopping the vm: "
+ vm
+ " as a part of hostDelete id="
+ host.getId();
s_logger.warn(errorMsg);
throw new UnableDeleteHostException(
errorMsg);
}
} catch (Exception e) {
String errorMsg = "There was an error stopping the vm: "
+ vm
+ " as a part of hostDelete id="
+ host.getId();
s_logger.debug(errorMsg, e);
throw new UnableDeleteHostException(errorMsg
+ "," + e.getMessage());
}
} else if (vm.isHaEnabled()
&& (vm.getState() == State.Running || vm
.getState() == State.Starting)) {
s_logger.debug("Scheduling restart for vm: " + vm
+ " " + vm.getState() + " on the host id="
+ host.getId());
_haMgr.scheduleRestart(vm, false);
}
}
} else {
throw new UnableDeleteHostException(
"Unable to delete the host as there are vms in "
+ vms.get(0).getState()
+ " state using this host and isForced=false specified");
}
}
}
}
private boolean doCancelMaintenance(long hostId) {
HostVO host;
host = _hostDao.findById(hostId);
if (host == null || host.getRemoved() != null) {
s_logger.warn("Unable to find host " + hostId);
return true;
}
/*
* TODO: think twice about returning true or throwing out exception, I
* really prefer to exception that always exposes bugs
*/
if (host.getResourceState() != ResourceState.PrepareForMaintenance
&& host.getResourceState() != ResourceState.Maintenance
&& host.getResourceState() != ResourceState.ErrorInMaintenance) {
throw new CloudRuntimeException(
"Cannot perform cancelMaintenance when resource state is "
+ host.getResourceState() + ", hostId = " + hostId);
}
/* TODO: move to listener */
_haMgr.cancelScheduledMigrations(host);
List<VMInstanceVO> vms = _haMgr.findTakenMigrationWork();
for (VMInstanceVO vm : vms) {
if (vm.getHostId() != null && vm.getHostId() == hostId) {
s_logger.info("Unable to cancel migration because the vm is being migrated: "
+ vm);
return false;
}
}
try {
resourceStateTransitTo(host,
ResourceState.Event.AdminCancelMaintenance, _nodeId);
_agentMgr.pullAgentOutMaintenance(hostId);
// for kvm, need to log into kvm host, restart cloudstack-agent
if (host.getHypervisorType() == HypervisorType.KVM) {
_hostDao.loadDetails(host);
String password = host.getDetail("password");
String username = host.getDetail("username");
if (password == null || username == null) {
s_logger.debug("Can't find password/username");
return false;
}
com.trilead.ssh2.Connection connection = SSHCmdHelper
.acquireAuthorizedConnection(
host.getPrivateIpAddress(), 22, username,
password);
if (connection == null) {
s_logger.debug("Failed to connect to host: "
+ host.getPrivateIpAddress());
return false;
}
try {
SSHCmdHelper.sshExecuteCmdOneShot(connection,
"service cloudstack-agent restart");
} catch (sshException e) {
return false;
}
}
return true;
} catch (NoTransitionException e) {
s_logger.debug("Cannot transmit host " + host.getId()
+ "to Enabled state", e);
return false;
}
}
private boolean cancelMaintenance(long hostId) {
try {
Boolean result = _clusterMgr.propagateResourceEvent(hostId,
ResourceState.Event.AdminCancelMaintenance);
if (result != null) {
return result;
}
} catch (AgentUnavailableException e) {
return false;
}
return doCancelMaintenance(hostId);
}
@Override
public boolean executeUserRequest(long hostId, ResourceState.Event event)
throws AgentUnavailableException {
if (event == ResourceState.Event.AdminAskMaintenace) {
return doMaintain(hostId);
} else if (event == ResourceState.Event.AdminCancelMaintenance) {
return doCancelMaintenance(hostId);
} else if (event == ResourceState.Event.DeleteHost) {
/* TODO: Ask alex why we assume the last two parameters are false */
return doDeleteHost(hostId, false, false);
} else if (event == ResourceState.Event.Unmanaged) {
return doUmanageHost(hostId);
} else if (event == ResourceState.Event.UpdatePassword) {
return doUpdateHostPassword(hostId);
} else {
throw new CloudRuntimeException(
"Received an resource event we are not handling now, "
+ event);
}
}
private boolean doUmanageHost(long hostId) {
HostVO host = _hostDao.findById(hostId);
if (host == null) {
s_logger.debug("Cannot find host " + hostId
+ ", assuming it has been deleted, skip umanage");
return true;
}
if (host.getHypervisorType() == HypervisorType.KVM) {
MaintainAnswer answer = (MaintainAnswer) _agentMgr.easySend(hostId,
new MaintainCommand());
}
_agentMgr.disconnectWithoutInvestigation(hostId,
Event.ShutdownRequested);
return true;
}
@Override
public boolean umanageHost(long hostId) {
try {
Boolean result = _clusterMgr.propagateResourceEvent(hostId,
ResourceState.Event.Unmanaged);
if (result != null) {
return result;
}
} catch (AgentUnavailableException e) {
return false;
}
return doUmanageHost(hostId);
}
private boolean doUpdateHostPassword(long hostId) {
AgentAttache attache = _agentMgr.findAttache(hostId);
if (attache == null) {
return false;
}
DetailVO nv = _hostDetailsDao.findDetail(hostId, ApiConstants.USERNAME);
String username = nv.getValue();
nv = _hostDetailsDao.findDetail(hostId, ApiConstants.PASSWORD);
String password = nv.getValue();
UpdateHostPasswordCommand cmd = new UpdateHostPasswordCommand(username,
password);
attache.updatePassword(cmd);
return true;
}
@Override
public boolean updateHostPassword(UpdateHostPasswordCmd cmd) {
if (cmd.getClusterId() == null) {
// update agent attache password
try {
Boolean result = _clusterMgr.propagateResourceEvent(
cmd.getHostId(), ResourceState.Event.UpdatePassword);
if (result != null) {
return result;
}
} catch (AgentUnavailableException e) {
}
return doUpdateHostPassword(cmd.getHostId());
} else {
// get agents for the cluster
List<HostVO> hosts = this.listAllHostsInCluster(cmd.getClusterId());
for (HostVO h : hosts) {
try {
/*
* FIXME: this is a buggy logic, check with alex. Shouldn't
* return if propagation return non null
*/
Boolean result = _clusterMgr.propagateResourceEvent(
h.getId(), ResourceState.Event.UpdatePassword);
if (result != null) {
return result;
}
doUpdateHostPassword(h.getId());
} catch (AgentUnavailableException e) {
}
}
return true;
}
}
@Override
public boolean maintenanceFailed(long hostId) {
HostVO host = _hostDao.findById(hostId);
if (host == null) {
if (s_logger.isDebugEnabled()) {
s_logger.debug("Cant not find host " + hostId);
}
return false;
} else {
try {
return resourceStateTransitTo(host,
ResourceState.Event.UnableToMigrate, _nodeId);
} catch (NoTransitionException e) {
s_logger.debug(
"No next resource state for host " + host.getId()
+ " while current state is "
+ host.getResourceState() + " with event "
+ ResourceState.Event.UnableToMigrate, e);
return false;
}
}
}
@Override
public List<HostVO> findDirectlyConnectedHosts() {
/* The resource column is not null for direct connected resource */
SearchCriteriaService<HostVO, HostVO> sc = SearchCriteria2
.create(HostVO.class);
sc.addAnd(sc.getEntity().getResource(), Op.NNULL);
sc.addAnd(sc.getEntity().getResourceState(), Op.NIN,
ResourceState.Disabled);
return sc.list();
}
@Override
public List<HostVO> listAllUpAndEnabledHosts(Type type, Long clusterId,
Long podId, long dcId) {
SearchCriteriaService<HostVO, HostVO> sc = SearchCriteria2
.create(HostVO.class);
if (type != null) {
sc.addAnd(sc.getEntity().getType(), Op.EQ, type);
}
if (clusterId != null) {
sc.addAnd(sc.getEntity().getClusterId(), Op.EQ, clusterId);
}
if (podId != null) {
sc.addAnd(sc.getEntity().getPodId(), Op.EQ, podId);
}
sc.addAnd(sc.getEntity().getDataCenterId(), Op.EQ, dcId);
sc.addAnd(sc.getEntity().getStatus(), Op.EQ, Status.Up);
sc.addAnd(sc.getEntity().getResourceState(), Op.EQ,
ResourceState.Enabled);
return sc.list();
}
@Override
public List<HostVO> listAllUpAndEnabledNonHAHosts(Type type,
Long clusterId, Long podId, long dcId) {
String haTag = _haMgr.getHaTag();
return _hostDao.listAllUpAndEnabledNonHAHosts(type, clusterId, podId,
dcId, haTag);
}
@Override
public List<HostVO> findHostByGuid(long dcId, String guid) {
SearchCriteriaService<HostVO, HostVO> sc = SearchCriteria2
.create(HostVO.class);
sc.addAnd(sc.getEntity().getDataCenterId(), Op.EQ, dcId);
sc.addAnd(sc.getEntity().getGuid(), Op.EQ, guid);
return sc.list();
}
@Override
public List<HostVO> listAllHostsInCluster(long clusterId) {
SearchCriteriaService<HostVO, HostVO> sc = SearchCriteria2
.create(HostVO.class);
sc.addAnd(sc.getEntity().getClusterId(), Op.EQ, clusterId);
return sc.list();
}
@Override
public List<HostVO> listHostsInClusterByStatus(long clusterId, Status status) {
SearchCriteriaService<HostVO, HostVO> sc = SearchCriteria2
.create(HostVO.class);
sc.addAnd(sc.getEntity().getClusterId(), Op.EQ, clusterId);
sc.addAnd(sc.getEntity().getStatus(), Op.EQ, status);
return sc.list();
}
@Override
public List<HostVO> listAllUpAndEnabledHostsInOneZoneByType(Type type,
long dcId) {
SearchCriteriaService<HostVO, HostVO> sc = SearchCriteria2
.create(HostVO.class);
sc.addAnd(sc.getEntity().getType(), Op.EQ, type);
sc.addAnd(sc.getEntity().getDataCenterId(), Op.EQ, dcId);
sc.addAnd(sc.getEntity().getStatus(), Op.EQ, Status.Up);
sc.addAnd(sc.getEntity().getResourceState(), Op.EQ,
ResourceState.Enabled);
return sc.list();
}
@Override
public List<HostVO> listAllNotInMaintenanceHostsInOneZone(Type type,
Long dcId) {
SearchCriteriaService<HostVO, HostVO> sc = SearchCriteria2
.create(HostVO.class);
if (dcId != null) {
sc.addAnd(sc.getEntity().getDataCenterId(), Op.EQ, dcId);
}
sc.addAnd(sc.getEntity().getType(), Op.EQ, type);
sc.addAnd(sc.getEntity().getResourceState(), Op.NIN,
ResourceState.Maintenance, ResourceState.ErrorInMaintenance,
ResourceState.PrepareForMaintenance, ResourceState.Error);
return sc.list();
}
@Override
public List<HostVO> listAllHostsInOneZoneByType(Type type, long dcId) {
SearchCriteriaService<HostVO, HostVO> sc = SearchCriteria2
.create(HostVO.class);
sc.addAnd(sc.getEntity().getType(), Op.EQ, type);
sc.addAnd(sc.getEntity().getDataCenterId(), Op.EQ, dcId);
return sc.list();
}
@Override
public List<HostVO> listAllHostsInAllZonesByType(Type type) {
SearchCriteriaService<HostVO, HostVO> sc = SearchCriteria2
.create(HostVO.class);
sc.addAnd(sc.getEntity().getType(), Op.EQ, type);
return sc.list();
}
@Override
public List<HypervisorType> listAvailHypervisorInZone(Long hostId,
Long zoneId) {
SearchCriteriaService<HostVO, HostVO> sc = SearchCriteria2
.create(HostVO.class);
if (zoneId != null) {
sc.addAnd(sc.getEntity().getDataCenterId(), Op.EQ, zoneId);
}
if (hostId != null) {
sc.addAnd(sc.getEntity().getId(), Op.EQ, hostId);
}
sc.addAnd(sc.getEntity().getType(), Op.EQ, Host.Type.Routing);
List<HostVO> hosts = sc.list();
List<HypervisorType> hypers = new ArrayList<HypervisorType>(5);
for (HostVO host : hosts) {
hypers.add(host.getHypervisorType());
}
return hypers;
}
@Override
public HostVO findHostByGuid(String guid) {
SearchCriteriaService<HostVO, HostVO> sc = SearchCriteria2
.create(HostVO.class);
sc.addAnd(sc.getEntity().getGuid(), Op.EQ, guid);
return sc.find();
}
@Override
public HostVO findHostByName(String name) {
SearchCriteriaService<HostVO, HostVO> sc = SearchCriteria2
.create(HostVO.class);
sc.addAnd(sc.getEntity().getName(), Op.EQ, name);
return sc.find();
}
@Override
public List<HostVO> listHostsByNameLike(String name) {
SearchCriteriaService<HostVO, HostVO> sc = SearchCriteria2
.create(HostVO.class);
sc.addAnd(sc.getEntity().getName(), Op.LIKE, "%" + name + "%");
return sc.list();
}
@Override
public Pair<HostPodVO, Long> findPod(VirtualMachineTemplate template,
ServiceOfferingVO offering, DataCenterVO dc, long accountId,
Set<Long> avoids) {
for (PodAllocator allocator : _podAllocators) {
final Pair<HostPodVO, Long> pod = allocator.allocateTo(template,
offering, dc, accountId, avoids);
if (pod != null) {
return pod;
}
}
return null;
}
@Override
public HostStats getHostStatistics(long hostId) {
Answer answer = _agentMgr.easySend(hostId, new GetHostStatsCommand(
_hostDao.findById(hostId).getGuid(), _hostDao.findById(hostId)
.getName(), hostId));
if (answer != null && (answer instanceof UnsupportedAnswer)) {
return null;
}
if (answer == null || !answer.getResult()) {
String msg = "Unable to obtain host " + hostId + " statistics. ";
s_logger.warn(msg);
return null;
} else {
// now construct the result object
if (answer instanceof GetHostStatsAnswer) {
return ((GetHostStatsAnswer) answer).getHostStats();
}
}
return null;
}
@Override
public Long getGuestOSCategoryId(long hostId) {
HostVO host = _hostDao.findById(hostId);
if (host == null) {
return null;
} else {
_hostDao.loadDetails(host);
DetailVO detail = _hostDetailsDao.findDetail(hostId,
"guest.os.category.id");
if (detail == null) {
return null;
} else {
return Long.parseLong(detail.getValue());
}
}
}
@Override
public String getHostTags(long hostId) {
List<String> hostTags = _hostTagsDao.gethostTags(hostId);
if (hostTags == null) {
return null;
} else {
return StringUtils.listToCsvTags(hostTags);
}
}
@Override
public List<PodCluster> listByDataCenter(long dcId) {
List<HostPodVO> pods = _podDao.listByDataCenterId(dcId);
ArrayList<PodCluster> pcs = new ArrayList<PodCluster>();
for (HostPodVO pod : pods) {
List<ClusterVO> clusters = _clusterDao.listByPodId(pod.getId());
if (clusters.size() == 0) {
pcs.add(new PodCluster(pod, null));
} else {
for (ClusterVO cluster : clusters) {
pcs.add(new PodCluster(pod, cluster));
}
}
}
return pcs;
}
@Override
public List<HostVO> listAllUpAndEnabledHostsInOneZoneByHypervisor(
HypervisorType type, long dcId) {
SearchCriteriaService<HostVO, HostVO> sc = SearchCriteria2
.create(HostVO.class);
sc.addAnd(sc.getEntity().getHypervisorType(), Op.EQ, type);
sc.addAnd(sc.getEntity().getDataCenterId(), Op.EQ, dcId);
sc.addAnd(sc.getEntity().getStatus(), Op.EQ, Status.Up);
sc.addAnd(sc.getEntity().getResourceState(), Op.EQ,
ResourceState.Enabled);
return sc.list();
}
}
Reference in New Issue View Git Blame Copy Permalink