cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From seb...@apache.org
Subject [04/16] Cleanup of Xen and XenServer terms. Cloned xen plugin creating a xenserver plugin, then removed xen plugin
Date Sat, 07 Jun 2014 08:50:44 GMT
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/a8212d9e/plugins/hypervisors/xenserver/src/com/cloud/hypervisor/xenserver/resource/XenServerConnectionPool.java
----------------------------------------------------------------------
diff --git a/plugins/hypervisors/xenserver/src/com/cloud/hypervisor/xenserver/resource/XenServerConnectionPool.java
b/plugins/hypervisors/xenserver/src/com/cloud/hypervisor/xenserver/resource/XenServerConnectionPool.java
new file mode 100644
index 0000000..d4360cf
--- /dev/null
+++ b/plugins/hypervisors/xenserver/src/com/cloud/hypervisor/xenserver/resource/XenServerConnectionPool.java
@@ -0,0 +1,509 @@
+// 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.hypervisor.xenserver.resource;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.net.URL;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Queue;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.SSLSession;
+
+import org.apache.log4j.Logger;
+import org.apache.xmlrpc.XmlRpcException;
+import org.apache.xmlrpc.client.XmlRpcClientException;
+
+import com.xensource.xenapi.APIVersion;
+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;
+import com.xensource.xenapi.Types.BadServerResponse;
+import com.xensource.xenapi.Types.XenAPIException;
+
+import com.cloud.utils.NumbersUtil;
+import com.cloud.utils.PropertiesUtil;
+import com.cloud.utils.exception.CloudRuntimeException;
+
+public class XenServerConnectionPool {
+    private static final Logger s_logger = Logger.getLogger(XenServerConnectionPool.class);
+    protected HashMap<String /* poolUuid */, XenServerConnection> _conns = new HashMap<String,
XenServerConnection>();
+    protected int _retries;
+    protected int _interval;
+    protected int _connWait = 5;
+    protected static long s_sleepOnError = 10 * 1000; // in ms
+    static {
+        File file = PropertiesUtil.findConfigFile("environment.properties");
+        if (file == null) {
+            s_logger.debug("Unable to find environment.properties");
+        } else {
+            FileInputStream finputstream;
+            try {
+                finputstream = new FileInputStream(file);
+                final Properties props = new Properties();
+                props.load(finputstream);
+                finputstream.close();
+                String search = props.getProperty("sleep.interval.on.error");
+                if (search != null) {
+                    s_sleepOnError = NumbersUtil.parseInterval(search, 10) * 1000;
+                }
+                s_logger.info("XenServer Connection Pool Configs: sleep.interval.on.error="
+ s_sleepOnError);
+            } catch (FileNotFoundException e) {
+                s_logger.debug("File is not found", e);
+            } catch (IOException e) {
+                s_logger.debug("IO Exception while reading file", e);
+            }
+        }
+        try {
+            javax.net.ssl.TrustManager[] trustAllCerts = new javax.net.ssl.TrustManager[1];
+            javax.net.ssl.TrustManager tm = new TrustAllManager();
+            trustAllCerts[0] = tm;
+            javax.net.ssl.SSLContext sc = javax.net.ssl.SSLContext.getInstance("TLS");
+            sc.init(null, trustAllCerts, null);
+            javax.net.ssl.HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
+            HostnameVerifier hv = new HostnameVerifier() {
+                @Override
+                public boolean verify(String hostName, SSLSession session) {
+                    return true;
+                }
+            };
+            HttpsURLConnection.setDefaultHostnameVerifier(hv);
+        } catch (NoSuchAlgorithmException e) {
+            //ignore this
+        } catch (KeyManagementException e) {
+            s_logger.debug("Init SSLContext failed ", e);
+        }
+    }
+
+    protected XenServerConnectionPool() {
+        _retries = 1;
+        _interval = 3;
+    }
+
+    private void addConnect(String poolUuid, XenServerConnection conn) {
+        if (poolUuid == null)
+            return;
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Add master connection through " + conn.getIp() + " for pool("
+ conn.getPoolUuid() + ")");
+        }
+        synchronized (_conns) {
+            _conns.put(poolUuid, conn);
+        }
+    }
+
+    private XenServerConnection getConnect(String poolUuid) {
+        if (poolUuid == null)
+            return null;
+        synchronized (_conns) {
+            return _conns.get(poolUuid);
+        }
+    }
+
+    private void removeConnect(String poolUuid) {
+        if (poolUuid == null) {
+            return;
+        }
+        XenServerConnection conn = null;
+        synchronized (_conns) {
+            conn = _conns.remove(poolUuid);
+        }
+        if (conn != null) {
+            if (s_logger.isDebugEnabled()) {
+                s_logger.debug("Remove master connection through " + conn.getIp() + " for
pool(" + conn.getPoolUuid() + ")");
+            }
+
+        }
+    }
+
+    static void forceSleep(long sec) {
+        long firetime = System.currentTimeMillis() + (sec * 1000);
+        long msec = sec * 1000;
+        while (true) {
+            if (msec < 100)
+                break;
+            try {
+                Thread.sleep(msec);
+                return;
+            } catch (InterruptedException e) {
+                msec = firetime - System.currentTimeMillis();
+            }
+        }
+    }
+
+    public Connection getConnect(String ip, String username, Queue<String> password)
{
+        Connection conn = new Connection(getURL(ip), 10, _connWait);
+        try {
+            loginWithPassword(conn, username, password, APIVersion.latest().toString());
+        }  catch (Types.HostIsSlave e) {
+            String maddress = e.masterIPAddress;
+            conn = new Connection(getURL(maddress), 10, _connWait);
+            try {
+                loginWithPassword(conn, username, password, APIVersion.latest().toString());
+            }  catch (Exception e1) {
+                String msg = "Unable to create master connection to host(" + maddress +")
, due to " + e1.toString();
+                s_logger.debug(msg);
+                throw new CloudRuntimeException(msg, e1);
+            }
+        } catch (Exception e) {
+            String msg = "Unable to create master connection to host(" + ip +") , due to
" + e.toString();
+            s_logger.debug(msg);
+            throw new CloudRuntimeException(msg, e);
+        }
+        return conn;
+    }
+
+    public URL getURL(String ip) {
+        try {
+            return new URL("https://" + ip);
+        } catch (Exception e) {
+            String msg = "Unable to convert IP " + ip + " to URL due to " + e.toString();
+            if (s_logger.isDebugEnabled()) {
+                s_logger.debug(msg);
+            }
+            throw new CloudRuntimeException(msg, e);
+        }
+    }
+
+    public Connection connect(String hostUuid, String poolUuid, String ipAddress,
+            String username, Queue<String> password, int wait) {
+        XenServerConnection mConn = null;
+        if (hostUuid == null || poolUuid == null || ipAddress == null || username == null
|| password == null) {
+            String msg = "Connect some parameter are null hostUuid:" + hostUuid + " ,poolUuid:"
+ poolUuid
+                    + " ,ipAddress:" + ipAddress;
+            s_logger.debug(msg);
+            throw new CloudRuntimeException(msg);
+        }
+        synchronized (poolUuid.intern()) {
+            mConn = getConnect(poolUuid);
+            if (mConn != null){
+                try{
+                    Host host = Host.getByUuid(mConn, hostUuid);
+                    if (!host.getEnabled(mConn)) {
+                        String msg = "Cannot connect this host " + ipAddress + " due to the
host is not enabled";
+                        s_logger.debug(msg);
+                        if (mConn.getIp().equalsIgnoreCase(ipAddress)) {
+                            removeConnect(poolUuid);
+                            mConn = null;
+                        }
+                        throw new CloudRuntimeException(msg);
+                    }
+                    return mConn;
+                } catch (CloudRuntimeException e) {
+                        throw e;
+                } catch (Exception e) {
+                    if (s_logger.isDebugEnabled()) {
+                        s_logger.debug("connect through IP(" + mConn.getIp() + " for pool("
+ poolUuid + ") is broken due to " + e.toString());
+                    }
+                    removeConnect(poolUuid);
+                    mConn = null;
+                }
+            }
+
+            if ( mConn == null ) {
+                try {
+                    Connection conn = new Connection(getURL(ipAddress), 5, _connWait);
+                    Session sess = loginWithPassword(conn, username, password, APIVersion.latest().toString());
+                    Host host = sess.getThisHost(conn);
+                    Boolean hostenabled = host.getEnabled(conn);
+                    if( sess != null ){
+                        try{
+                            Session.logout(conn);
+                        } catch (Exception e) {
+                            s_logger.debug("Caught exception during logout", e);
+                        }
+                        conn.dispose();
+                    }
+                    if (!hostenabled) {
+                        String msg = "Unable to create master connection, due to master Host
" + ipAddress + " is not enabled";
+                        s_logger.debug(msg);
+                        throw new CloudRuntimeException(msg);
+                    }
+                    mConn = new XenServerConnection(getURL(ipAddress), ipAddress, username,
password, _retries, _interval, wait, _connWait);
+                    loginWithPassword(mConn, username, password, APIVersion.latest().toString());
+                }  catch (Types.HostIsSlave e) {
+                    String maddress = e.masterIPAddress;
+                    mConn = new XenServerConnection(getURL(maddress), maddress, username,
password, _retries, _interval, wait, _connWait);
+                    try {
+                        Session session = loginWithPassword(mConn, username, password, APIVersion.latest().toString());
+                        Host host = session.getThisHost(mConn);
+                        if (!host.getEnabled(mConn)) {
+                            String msg = "Unable to create master connection, due to master
Host " + maddress + " is not enabled";
+                            s_logger.debug(msg);
+                            throw new CloudRuntimeException(msg);
+                        }
+                    }  catch (Exception e1) {
+                        String msg = "Unable to create master connection to host(" + maddress
+") , due to " + e1.toString();
+                        s_logger.debug(msg);
+                        throw new CloudRuntimeException(msg, e1);
+
+                    }
+                } catch (CloudRuntimeException e) {
+                        throw e;
+                } catch (Exception e) {
+                    String msg = "Unable to create master connection to host(" + ipAddress
+") , due to " + e.toString();
+                    s_logger.debug(msg);
+                    throw new CloudRuntimeException(msg, e);
+                }
+                addConnect(poolUuid, mConn);
+            }
+        }
+        return mConn;
+    }
+
+
+
+    protected Session slaveLocalLoginWithPassword(Connection conn, String username, Queue<String>
password) throws BadServerResponse, XenAPIException, XmlRpcException {
+        Session s = null;
+        boolean logged_in = false;
+        Exception ex = null;
+        while (!logged_in) {
+            try {
+                s = Session.slaveLocalLoginWithPassword(conn, username, password.peek());
+                logged_in = true;
+            } catch (BadServerResponse e) {
+                logged_in = false;
+                ex = e;
+            } catch (XenAPIException e) {
+                logged_in = false;
+                ex = e;
+            } catch (XmlRpcException e) {
+                logged_in = false;
+                ex = e;
+            }
+            if (logged_in && conn != null) {
+                break;
+            } else {
+                if (password.size() > 1) {
+                    password.remove();
+                    continue;
+                } else {
+                    // the last password did not work leave it and flag error
+                    if (ex instanceof BadServerResponse) {
+                        throw (BadServerResponse)ex;
+                    } else if (ex instanceof XmlRpcException) {
+                        throw (XmlRpcException)ex;
+                    } else if (ex instanceof Types.SessionAuthenticationFailed) {
+                        throw (Types.SessionAuthenticationFailed)ex;
+                    } else if (ex instanceof XenAPIException) {
+                        throw (XenAPIException)ex;
+                    }
+                    break;
+                }
+            }
+        }
+        return s;
+    }
+
+    protected Session loginWithPassword(Connection conn, String username, Queue<String>
password, String version) throws BadServerResponse, XenAPIException,
+        XmlRpcException {
+        Session s = null;
+        boolean logged_in = false;
+        Exception ex = null;
+        while (!logged_in) {
+            try {
+                s = Session.loginWithPassword(conn, username, password.peek(), APIVersion.latest().toString());
+                logged_in = true;
+            } catch (BadServerResponse e) {
+                logged_in = false;
+                ex = e;
+            } catch (XenAPIException e) {
+                logged_in = false;
+                ex = e;
+            } catch (XmlRpcException e) {
+                logged_in = false;
+                ex = e;
+            }
+
+            if (logged_in && conn != null) {
+                break;
+            } else {
+                if (password.size() > 1) {
+                    password.remove();
+                    continue;
+                } else {
+                    // the last password did not work leave it and flag error
+                    if (ex instanceof BadServerResponse) {
+                        throw (BadServerResponse)ex;
+                    } else if (ex instanceof XmlRpcException) {
+                        throw (XmlRpcException)ex;
+                    } else if (ex instanceof Types.SessionAuthenticationFailed) {
+                        throw (Types.SessionAuthenticationFailed)ex;
+                    } else if (ex instanceof XenAPIException) {
+                        throw (XenAPIException)ex;
+                    }
+                }
+            }
+        }
+        return s;
+    }
+
+    protected void join(Connection conn, String masterIp, String username, Queue<String>
password) throws BadServerResponse, XenAPIException, XmlRpcException,
+        Types.JoiningHostCannotContainSharedSrs {
+
+        boolean logged_in = false;
+        Exception ex = null;
+        while (!logged_in) {
+            try {
+                Pool.join(conn, masterIp, username, password.peek());
+                logged_in = true;
+            } catch (BadServerResponse e) {
+                logged_in = false;
+                ex = e;
+            } catch (XenAPIException e) {
+                logged_in = false;
+                ex = e;
+            } catch (XmlRpcException e) {
+                logged_in = false;
+                ex = e;
+            }
+            if (logged_in && conn != null) {
+                break;
+            } else {
+                if (password.size() > 1) {
+                    password.remove();
+                    continue;
+                } else {
+                    // the last password did not work leave it and flag error
+                    if (ex instanceof BadServerResponse) {
+                        throw (BadServerResponse)ex;
+                    } else if (ex instanceof XmlRpcException) {
+                        throw (XmlRpcException)ex;
+                    } else if (ex instanceof Types.SessionAuthenticationFailed) {
+                        throw (Types.SessionAuthenticationFailed)ex;
+                    } else if (ex instanceof XenAPIException) {
+                        throw (XenAPIException)ex;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    static public Pool.Record getPoolRecord(Connection conn) throws XmlRpcException, XenAPIException
{
+        Map<Pool, Pool.Record> pools = Pool.getAllRecords(conn);
+        assert pools.size() == 1 : "Pool size is not one....hmmm....wth? " + pools.size();
+
+        return pools.values().iterator().next();
+    }
+
+    private static final XenServerConnectionPool s_instance = new XenServerConnectionPool();
+
+    public static XenServerConnectionPool getInstance() {
+        return s_instance;
+    }
+
+    public class XenServerConnection extends Connection {
+        long _interval;
+        int _retries;
+        String _ip;
+        String _username;
+        Queue<String> _password;
+        String _poolUuid;
+
+        public XenServerConnection(URL url, String ip, String username, Queue<String>
password, int retries, int interval, int wait, int connwait) {
+            super(url, wait, connwait);
+            _ip = ip;
+            _retries = retries;
+            _username = username;
+            _password = password;
+            _interval = (long)interval * 1000;
+
+        }
+
+        public String getPoolUuid() {
+            return _poolUuid;
+        }
+
+        public String getUsername() {
+            return _username;
+        }
+
+        public Queue<String> getPassword() {
+            return _password;
+        }
+
+        public String getIp() {
+            return _ip;
+        }
+
+        @Override
+        protected Map dispatch(String methodcall, Object[] methodparams)  throws XmlRpcException,
XenAPIException {
+            if (methodcall.equals("session.local_logout")
+                    || methodcall.equals("session.slave_local_login_with_password")
+                    || methodcall.equals("session.logout")
+                    || methodcall.equals("session.login_with_password")) {
+                return super.dispatch(methodcall, methodparams);
+            }
+
+            try {
+                return super.dispatch(methodcall, methodparams);
+            } catch (Types.SessionInvalid e) {
+                s_logger.debug("Session is invalid for method: " + methodcall + " due to
" + e.toString());
+                removeConnect(_poolUuid);
+                throw e;
+            } catch (XmlRpcClientException e) {
+                s_logger.debug("XmlRpcClientException for method: " + methodcall + " due
to " + e.toString());
+                removeConnect(_poolUuid);
+                throw e;
+            } catch (XmlRpcException e) {
+                s_logger.debug("XmlRpcException for method: " + methodcall + " due to " +
e.toString());
+                removeConnect(_poolUuid);
+                throw e;
+            } catch (Types.HostIsSlave e) {
+                 s_logger.debug("HostIsSlave Exception for method: " + methodcall + " due
to " + e.toString());
+                 removeConnect(_poolUuid);
+                 throw e;
+            }
+        }
+    }
+
+    public static class TrustAllManager implements javax.net.ssl.TrustManager, javax.net.ssl.X509TrustManager
{
+        @Override
+        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
+            return null;
+        }
+
+        public boolean isServerTrusted(java.security.cert.X509Certificate[] certs) {
+            return true;
+        }
+
+        public boolean isClientTrusted(java.security.cert.X509Certificate[] certs) {
+            return true;
+        }
+
+        @Override
+        public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String
authType) throws java.security.cert.CertificateException {
+            return;
+        }
+
+        @Override
+        public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String
authType) throws java.security.cert.CertificateException {
+            return;
+        }
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/a8212d9e/plugins/hypervisors/xenserver/src/com/cloud/hypervisor/xenserver/resource/XenServerPoolVms.java
----------------------------------------------------------------------
diff --git a/plugins/hypervisors/xenserver/src/com/cloud/hypervisor/xenserver/resource/XenServerPoolVms.java
b/plugins/hypervisors/xenserver/src/com/cloud/hypervisor/xenserver/resource/XenServerPoolVms.java
new file mode 100644
index 0000000..8042209
--- /dev/null
+++ b/plugins/hypervisors/xenserver/src/com/cloud/hypervisor/xenserver/resource/XenServerPoolVms.java
@@ -0,0 +1,90 @@
+// 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.hypervisor.xenserver.resource;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.utils.Pair;
+import com.cloud.vm.VirtualMachine.State;
+
+public class XenServerPoolVms {
+    private static final Logger s_logger = Logger.getLogger(XenServerPoolVms.class);
+    private final Map<String/* clusterId */, HashMap<String/* vm name */, Pair<String/*
host uuid */, State/* vm state */>>> _clusterVms =
+        new ConcurrentHashMap<String, HashMap<String, Pair<String, State>>>();
+
+    public HashMap<String, Pair<String, State>> getClusterVmState(String clusterId)
{
+        HashMap<String, Pair<String, State>> _vms = _clusterVms.get(clusterId);
+        if (_vms == null) {
+            HashMap<String, Pair<String, State>> vmStates = new HashMap<String,
Pair<String, State>>();
+            _clusterVms.put(clusterId, vmStates);
+            return vmStates;
+        } else
+            return _vms;
+    }
+
+    public void clear(String clusterId) {
+        HashMap<String, Pair<String, State>> _vms = getClusterVmState(clusterId);
+        _vms.clear();
+    }
+
+    public State getState(String clusterId, String name) {
+        HashMap<String, Pair<String, State>> vms = getClusterVmState(clusterId);
+        Pair<String, State> pv = vms.get(name);
+        return pv == null ? State.Stopped : pv.second(); // if a VM is absent on the cluster,
it is effectively in stopped state.
+    }
+
+    public Pair<String, State> get(String clusterId, String name) {
+        HashMap<String, Pair<String, State>> vms = getClusterVmState(clusterId);
+        return vms.get(name);
+    }
+
+    public void put(String clusterId, String hostUuid, String name, State state) {
+        HashMap<String, Pair<String, State>> vms = getClusterVmState(clusterId);
+        vms.put(name, new Pair<String, State>(hostUuid, state));
+    }
+
+    public void remove(String clusterId, String hostUuid, String name) {
+        HashMap<String, Pair<String, State>> vms = getClusterVmState(clusterId);
+        vms.remove(name);
+    }
+
+    public void putAll(String clusterId, HashMap<String, Pair<String, State>>
newVms) {
+        HashMap<String, Pair<String, State>> vms = getClusterVmState(clusterId);
+        vms.putAll(newVms);
+    }
+
+    public int size(String clusterId) {
+        HashMap<String, Pair<String, State>> vms = getClusterVmState(clusterId);
+        return vms.size();
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sbuf = new StringBuilder("PoolVms=");
+        for (HashMap<String/* vm name */, Pair<String/* host uuid */, State/* vm state
*/>> clusterVM : _clusterVms.values()) {
+            for (String vmname : clusterVM.keySet()) {
+                sbuf.append(vmname).append("-").append(clusterVM.get(vmname).second()).append(",");
+            }
+        }
+        return sbuf.toString();
+    }
+
+}


Mime
View raw message