mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
495 lines
20 KiB
Java
495 lines
20 KiB
Java
/**
|
|
* Copyright (C) 2010 Cloud.com, Inc. All rights reserved.
|
|
*
|
|
* This software is licensed under the GNU General Public License v3 or later.
|
|
*
|
|
* It is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or any later version.
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
package com.cloud.hypervisor.xen.discoverer;
|
|
|
|
import java.net.InetAddress;
|
|
import java.net.URI;
|
|
import java.net.UnknownHostException;
|
|
import java.util.HashMap;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import javax.ejb.Local;
|
|
import javax.naming.ConfigurationException;
|
|
|
|
import org.apache.log4j.Logger;
|
|
import org.apache.xmlrpc.XmlRpcException;
|
|
|
|
import com.cloud.agent.AgentManager;
|
|
import com.cloud.agent.Listener;
|
|
import com.cloud.agent.api.AgentControlAnswer;
|
|
import com.cloud.agent.api.AgentControlCommand;
|
|
import com.cloud.agent.api.Answer;
|
|
import com.cloud.agent.api.Command;
|
|
import com.cloud.agent.api.StartupCommand;
|
|
import com.cloud.alert.AlertManager;
|
|
import com.cloud.configuration.Config;
|
|
import com.cloud.dc.ClusterVO;
|
|
import com.cloud.dc.dao.ClusterDao;
|
|
import com.cloud.exception.ConnectionException;
|
|
import com.cloud.exception.DiscoveryException;
|
|
import com.cloud.host.HostInfo;
|
|
import com.cloud.host.HostVO;
|
|
import com.cloud.host.Status;
|
|
import com.cloud.host.dao.HostDao;
|
|
import com.cloud.hypervisor.Hypervisor;
|
|
import com.cloud.hypervisor.Hypervisor.HypervisorType;
|
|
import com.cloud.hypervisor.xen.resource.CitrixResourceBase;
|
|
import com.cloud.hypervisor.xen.resource.XcpServerResource;
|
|
import com.cloud.hypervisor.xen.resource.XenServer56FP1Resource;
|
|
import com.cloud.hypervisor.xen.resource.XenServerConnectionPool;
|
|
import com.cloud.hypervisor.xen.resource.XenServerResource;
|
|
import com.cloud.resource.Discoverer;
|
|
import com.cloud.resource.DiscovererBase;
|
|
import com.cloud.resource.ServerResource;
|
|
import com.cloud.storage.Storage.ImageFormat;
|
|
import com.cloud.storage.Storage.TemplateType;
|
|
import com.cloud.storage.VMTemplateVO;
|
|
import com.cloud.storage.dao.VMTemplateDao;
|
|
import com.cloud.storage.dao.VMTemplateHostDao;
|
|
import com.cloud.user.Account;
|
|
import com.cloud.utils.NumbersUtil;
|
|
import com.cloud.utils.component.Inject;
|
|
import com.cloud.utils.exception.CloudRuntimeException;
|
|
import com.xensource.xenapi.Connection;
|
|
import com.xensource.xenapi.Host;
|
|
import com.xensource.xenapi.Pool;
|
|
import com.xensource.xenapi.Session;
|
|
import com.xensource.xenapi.Types.SessionAuthenticationFailed;
|
|
import com.xensource.xenapi.Types.XenAPIException;
|
|
|
|
@Local(value=Discoverer.class)
|
|
public class XcpServerDiscoverer extends DiscovererBase implements Discoverer, Listener {
|
|
private static final Logger s_logger = Logger.getLogger(XcpServerDiscoverer.class);
|
|
protected String _publicNic;
|
|
protected String _privateNic;
|
|
protected String _storageNic1;
|
|
protected String _storageNic2;
|
|
protected int _wait;
|
|
protected XenServerConnectionPool _connPool;
|
|
protected String _increase;
|
|
protected boolean _checkHvm;
|
|
protected String _guestNic;
|
|
|
|
@Inject protected AlertManager _alertMgr;
|
|
@Inject protected AgentManager _agentMgr;
|
|
@Inject protected HostDao _hostDao;
|
|
@Inject VMTemplateDao _tmpltDao;
|
|
@Inject VMTemplateHostDao _vmTemplateHostDao;
|
|
@Inject ClusterDao _clusterDao;
|
|
|
|
protected XcpServerDiscoverer() {
|
|
}
|
|
|
|
@Override
|
|
public Map<? extends ServerResource, Map<String, String>> find(long dcId, Long podId, Long clusterId, URI url, String username, String password) throws DiscoveryException {
|
|
Map<CitrixResourceBase, Map<String, String>> resources = new HashMap<CitrixResourceBase, Map<String, String>>();
|
|
Connection conn = null;
|
|
if (!url.getScheme().equals("http")) {
|
|
String msg = "urlString is not http so we're not taking care of the discovery for this: " + url;
|
|
s_logger.debug(msg);
|
|
return null;
|
|
}
|
|
if (clusterId == null) {
|
|
String msg = "must specify cluster Id when add host";
|
|
s_logger.debug(msg);
|
|
throw new RuntimeException(msg);
|
|
}
|
|
|
|
if (podId == null) {
|
|
String msg = "must specify pod Id when add host";
|
|
s_logger.debug(msg);
|
|
throw new RuntimeException(msg);
|
|
}
|
|
|
|
ClusterVO cluster = _clusterDao.findById(clusterId);
|
|
if(cluster == null || (cluster.getHypervisorType() != HypervisorType.XenServer && cluster.getHypervisorType() != HypervisorType.Xen)) {
|
|
if(s_logger.isInfoEnabled())
|
|
s_logger.info("invalid cluster id or cluster is not for Xen/XenServer hypervisors");
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
List<HostVO> eHosts = _hostDao.listByCluster(clusterId);
|
|
if( eHosts.size() > 0 ) {
|
|
HostVO eHost = eHosts.get(0);
|
|
_hostDao.loadDetails(eHost);
|
|
}
|
|
String hostname = url.getHost();
|
|
InetAddress ia = InetAddress.getByName(hostname);
|
|
String hostIp = ia.getHostAddress();
|
|
String masterIp = _connPool.getMasterIp(hostIp, username, password);
|
|
conn = _connPool.masterConnect(masterIp, username, password);
|
|
if (conn == null) {
|
|
String msg = "Unable to get a connection to " + url;
|
|
s_logger.debug(msg);
|
|
throw new DiscoveryException(msg);
|
|
}
|
|
|
|
Set<Pool> pools = Pool.getAll(conn);
|
|
Pool pool = pools.iterator().next();
|
|
Pool.Record pr = pool.getRecord(conn);
|
|
String poolUuid = pr.uuid;
|
|
Map<Host, Host.Record> hosts = Host.getAllRecords(conn);
|
|
|
|
/*set cluster hypervisor type to xenserver*/
|
|
ClusterVO clu = _clusterDao.findById(clusterId);
|
|
if ( clu.getGuid()== null ) {
|
|
clu.setGuid(poolUuid);
|
|
} else {
|
|
if( !clu.getGuid().equals(poolUuid)) {
|
|
if (hosts.size() == 1 ) {
|
|
if( !addHostsToPool(conn, hostIp, clusterId)){
|
|
String msg = "Unable to add host(" + hostIp + ") to cluster " + clusterId;
|
|
s_logger.warn(msg);
|
|
throw new DiscoveryException(msg);
|
|
}
|
|
} else {
|
|
String msg = "Host (" + hostIp + ") is already in pool(" + poolUuid +"), can to join pool(" + clu.getGuid() + ")";
|
|
s_logger.warn(msg);
|
|
throw new DiscoveryException(msg);
|
|
}
|
|
}
|
|
}
|
|
// can not use this conn after this point, because this host may join a pool, this conn is retired
|
|
if (conn != null) {
|
|
try{
|
|
Session.logout(conn);
|
|
} catch (Exception e ) {
|
|
}
|
|
conn.dispose();
|
|
conn = null;
|
|
}
|
|
|
|
poolUuid = clu.getGuid();
|
|
_clusterDao.update(clusterId, clu);
|
|
|
|
|
|
if (_checkHvm) {
|
|
for (Map.Entry<Host, Host.Record> entry : hosts.entrySet()) {
|
|
Host.Record record = entry.getValue();
|
|
|
|
boolean support_hvm = false;
|
|
for ( String capability : record.capabilities ) {
|
|
if(capability.contains("hvm")) {
|
|
support_hvm = true;
|
|
break;
|
|
}
|
|
}
|
|
if( !support_hvm ) {
|
|
String msg = "Unable to add host " + record.address + " because it doesn't support hvm";
|
|
_alertMgr.sendAlert(AlertManager.ALERT_TYPE_HOST, dcId, podId, msg, msg);
|
|
s_logger.debug(msg);
|
|
throw new RuntimeException(msg);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (Map.Entry<Host, Host.Record> entry : hosts.entrySet()) {
|
|
Host.Record record = entry.getValue();
|
|
String hostAddr = record.address;
|
|
|
|
String prodVersion = record.softwareVersion.get("product_version");
|
|
String xenVersion = record.softwareVersion.get("xen");
|
|
String hostOS = record.softwareVersion.get("product_brand");
|
|
String hostOSVer = prodVersion;
|
|
String hostKernelVer = record.softwareVersion.get("linux");
|
|
|
|
if (_hostDao.findByGuid(record.uuid) != null) {
|
|
s_logger.debug("Skipping " + record.address + " because " + record.uuid + " is already in the database.");
|
|
continue;
|
|
}
|
|
|
|
CitrixResourceBase resource = createServerResource(dcId, podId, record);
|
|
s_logger.info("Found host " + record.hostname + " ip=" + record.address + " product version=" + prodVersion);
|
|
|
|
Map<String, String> details = new HashMap<String, String>();
|
|
Map<String, Object> params = new HashMap<String, Object>();
|
|
details.put("url", hostAddr);
|
|
details.put("username", username);
|
|
params.put("username", username);
|
|
details.put("password", password);
|
|
params.put("password", password);
|
|
params.put("zone", Long.toString(dcId));
|
|
params.put("guid", record.uuid);
|
|
params.put("pod", podId.toString());
|
|
params.put("cluster", clusterId.toString());
|
|
params.put("pool", poolUuid);
|
|
params.put("ipaddress", record.address);
|
|
|
|
if (_increase != null) {
|
|
params.put(Config.XenPreallocatedLunSizeRange.name(), _increase);
|
|
}
|
|
details.put(HostInfo.HOST_OS, hostOS);
|
|
details.put(HostInfo.HOST_OS_VERSION, hostOSVer);
|
|
details.put(HostInfo.HOST_OS_KERNEL_VERSION, hostKernelVer);
|
|
details.put(HostInfo.HYPERVISOR_VERSION, xenVersion);
|
|
|
|
if (!params.containsKey("public.network.device") && _publicNic != null) {
|
|
params.put("public.network.device", _publicNic);
|
|
details.put("public.network.device", _publicNic);
|
|
}
|
|
|
|
if (!params.containsKey("guest.network.device") && _guestNic != null) {
|
|
params.put("guest.network.device", _guestNic);
|
|
details.put("guest.network.device", _guestNic);
|
|
}
|
|
|
|
if (!params.containsKey("private.network.device") && _privateNic != null) {
|
|
params.put("private.network.device", _privateNic);
|
|
details.put("private.network.device", _privateNic);
|
|
}
|
|
|
|
if (!params.containsKey("storage.network.device1") && _storageNic1 != null) {
|
|
params.put("storage.network.device1", _storageNic1);
|
|
details.put("storage.network.device1", _storageNic1);
|
|
}
|
|
|
|
if (!params.containsKey("storage.network.device2") && _storageNic2 != null) {
|
|
params.put("storage.network.device2", _storageNic2);
|
|
details.put("storage.network.device2", _storageNic2);
|
|
}
|
|
params.put(Config.Wait.toString().toLowerCase(), Integer.toString(_wait));
|
|
details.put(Config.Wait.toString().toLowerCase(), Integer.toString(_wait));
|
|
try {
|
|
resource.configure("Xen Server", params);
|
|
} catch (ConfigurationException e) {
|
|
_alertMgr.sendAlert(AlertManager.ALERT_TYPE_HOST, dcId, podId, "Unable to add " + record.address, "Error is " + e.getMessage());
|
|
s_logger.warn("Unable to instantiate " + record.address, e);
|
|
continue;
|
|
}
|
|
resource.start();
|
|
resources.put(resource, details);
|
|
}
|
|
} catch (SessionAuthenticationFailed e) {
|
|
s_logger.warn("Authentication error", e);
|
|
return null;
|
|
} catch (XenAPIException e) {
|
|
s_logger.warn("XenAPI exception", e);
|
|
return null;
|
|
} catch (XmlRpcException e) {
|
|
s_logger.warn("Xml Rpc Exception", e);
|
|
return null;
|
|
} catch (UnknownHostException e) {
|
|
s_logger.warn("Unable to resolve the host name", e);
|
|
return null;
|
|
} catch (Exception e) {
|
|
s_logger.debug("other exceptions: " + e.toString(), e);
|
|
return null;
|
|
}
|
|
return resources;
|
|
}
|
|
|
|
String getPoolUuid(Connection conn) throws XenAPIException, XmlRpcException {
|
|
Map<Pool, Pool.Record> pools = Pool.getAllRecords(conn);
|
|
assert pools.size() == 1 : "Pools size is " + pools.size();
|
|
return pools.values().iterator().next().uuid;
|
|
}
|
|
|
|
protected void addSamePool(Connection conn, Map<CitrixResourceBase, Map<String, String>> resources) throws XenAPIException, XmlRpcException {
|
|
Map<Pool, Pool.Record> hps = Pool.getAllRecords(conn);
|
|
assert (hps.size() == 1) : "How can it be more than one but it's actually " + hps.size();
|
|
|
|
// This is the pool.
|
|
String poolUuid = hps.values().iterator().next().uuid;
|
|
|
|
for (Map<String, String> details : resources.values()) {
|
|
details.put("pool", poolUuid);
|
|
}
|
|
}
|
|
|
|
protected boolean addHostsToPool(Connection conn, String hostIp, Long clusterId) throws XenAPIException, XmlRpcException, DiscoveryException {
|
|
|
|
List<HostVO> hosts;
|
|
hosts = _hostDao.listByCluster(clusterId);
|
|
|
|
String masterIp = null;
|
|
String username = null;
|
|
String password = null;
|
|
for (HostVO host : hosts) {
|
|
_hostDao.loadDetails(host);
|
|
username = host.getDetail("username");
|
|
password = host.getDetail("password");
|
|
String address = host.getPrivateIpAddress();
|
|
Connection hostConn = _connPool.slaveConnect(address, username, password);
|
|
if (hostConn == null) {
|
|
continue;
|
|
}
|
|
try {
|
|
Set<Pool> pools = Pool.getAll(hostConn);
|
|
Pool pool = pools.iterator().next();
|
|
masterIp = pool.getMaster(hostConn).getAddress(hostConn);
|
|
break;
|
|
|
|
} catch (Exception e ) {
|
|
s_logger.warn("Can not get master ip address from host " + address);
|
|
} finally {
|
|
try{
|
|
Session.localLogout(hostConn);
|
|
} catch (Exception e ) {
|
|
}
|
|
hostConn.dispose();
|
|
hostConn = null;
|
|
}
|
|
}
|
|
|
|
if (masterIp == null) {
|
|
s_logger.warn("Unable to reach the pool master of the existing cluster");
|
|
throw new CloudRuntimeException("Unable to reach the pool master of the existing cluster");
|
|
}
|
|
|
|
if( !_connPool.joinPool(conn, hostIp, masterIp, username, password) ){
|
|
s_logger.warn("Unable to join the pool");
|
|
throw new DiscoveryException("Unable to join the pool");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
protected CitrixResourceBase createServerResource(long dcId, Long podId, Host.Record record) {
|
|
String prodBrand = record.softwareVersion.get("product_brand").trim();
|
|
String prodVersion = record.softwareVersion.get("product_version").trim();
|
|
|
|
if(prodBrand.equals("XenCloudPlatform") && prodVersion.equals("0.1.1"))
|
|
return new XcpServerResource();
|
|
|
|
if(prodBrand.equals("XenServer") && prodVersion.equals("5.6.0"))
|
|
return new XenServerResource();
|
|
|
|
if(prodBrand.equals("XenServer") && prodVersion.equals("5.6.100"))
|
|
return new XenServer56FP1Resource();
|
|
|
|
String msg = "Only support XCP 0.1.1, XenServer 5.6 and XenServer 5.6 FP1 , but this one is " + prodBrand + " " + prodVersion;
|
|
_alertMgr.sendAlert(AlertManager.ALERT_TYPE_HOST, dcId, podId, msg, msg);
|
|
s_logger.debug(msg);
|
|
throw new RuntimeException(msg);
|
|
}
|
|
|
|
protected void serverConfig() {
|
|
|
|
}
|
|
|
|
@Override
|
|
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
|
|
super.configure(name, params);
|
|
serverConfig();
|
|
|
|
_publicNic = _params.get(Config.XenPublicNetwork.key());
|
|
_privateNic = _params.get(Config.XenPrivateNetwork.key());
|
|
|
|
_storageNic1 = _params.get(Config.XenStorageNetwork1.key());
|
|
_storageNic2 = _params.get(Config.XenStorageNetwork2.key());
|
|
|
|
_guestNic = _params.get(Config.XenGuestNetwork.key());
|
|
|
|
_increase = _params.get(Config.XenPreallocatedLunSizeRange.key());
|
|
|
|
String value = _params.get(Config.Wait.toString());
|
|
_wait = NumbersUtil.parseInt(value, Integer.parseInt(Config.Wait.getDefaultValue()));
|
|
|
|
value = _params.get(Config.XenSetupMultipath.key());
|
|
Boolean.parseBoolean(value);
|
|
|
|
value = _params.get("xen.check.hvm");
|
|
_checkHvm = value == null ? true : Boolean.parseBoolean(value);
|
|
|
|
_connPool = XenServerConnectionPool.getInstance();
|
|
|
|
_agentMgr.registerForHostEvents(this, true, false, true);
|
|
|
|
createXsToolsISO();
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean matchHypervisor(String hypervisor) {
|
|
if(hypervisor == null)
|
|
return true;
|
|
return Hypervisor.HypervisorType.XenServer.toString().equalsIgnoreCase(hypervisor);
|
|
}
|
|
|
|
@Override
|
|
public Hypervisor.HypervisorType getHypervisorType() {
|
|
return Hypervisor.HypervisorType.XenServer;
|
|
}
|
|
|
|
@Override
|
|
public void postDiscovery(List<HostVO> hosts, long msId) throws DiscoveryException{
|
|
//do nothing
|
|
}
|
|
|
|
@Override
|
|
public int getTimeout() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public boolean isRecurring() {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean processAnswers(long agentId, long seq, Answer[] answers) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean processCommands(long agentId, long seq, Command[] commands) {
|
|
return false;
|
|
}
|
|
|
|
private void createXsToolsISO() {
|
|
String isoName = "xs-tools.iso";
|
|
VMTemplateVO tmplt = _tmpltDao.findByTemplateName(isoName);
|
|
Long id;
|
|
if (tmplt == null) {
|
|
id = _tmpltDao.getNextInSequence(Long.class, "id");
|
|
VMTemplateVO template = new VMTemplateVO(id, isoName, isoName, ImageFormat.ISO, true, true,
|
|
TemplateType.PERHOST, null, null, true, 64,
|
|
Account.ACCOUNT_ID_SYSTEM, null, "xen-pv-drv-iso", false, 1, false, HypervisorType.None);
|
|
_tmpltDao.persist(template);
|
|
} else {
|
|
id = tmplt.getId();
|
|
tmplt.setTemplateType(TemplateType.PERHOST);
|
|
tmplt.setUrl(null);
|
|
_tmpltDao.update(id, tmplt);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void processConnect(HostVO agent, StartupCommand cmd) throws ConnectionException {
|
|
}
|
|
|
|
@Override
|
|
public AgentControlAnswer processControlCommand(long agentId, AgentControlCommand cmd) {
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public boolean processDisconnect(long agentId, Status state) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean processTimeout(long agentId, long seq) {
|
|
return false;
|
|
}
|
|
|
|
}
|