org.rhq.plugins.virt.LibVirtConnection Maven / Gradle / Ivy

Go to download
/*
 * RHQ Management Platform
 * Copyright (C) 2005-2008 Red Hat, Inc.
 * All rights reserved.
 *
 * This program 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 version 2 of the License.
 *
 * 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, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
package org.rhq.plugins.virt;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import com.sun.jna.Pointer;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.libvirt.Connect;
import org.libvirt.Domain;
import org.libvirt.DomainBlockStats;
import org.libvirt.DomainInterfaceStats;
import org.libvirt.LibvirtException;
import org.libvirt.Network;
import org.libvirt.DomainInfo.DomainState;
import org.libvirt.jna.virError;

/**
 * Represents a connection, via libVirt to domain management.
 *
 * @author Greg Hinkle
 */
public class LibVirtConnection {

    private static int SUCCESS = 0;

    private Connect connection;

    private Log log = LogFactory.getLog(LibVirtConnection.class);

    private boolean connected = false;

    public LibVirtConnection(String uri) throws LibvirtException {
        try {
            Connect.setErrorCallback(Logger.INSTANCE);
            connection = new Connect(uri);
            connected = true;
            connection.setConnectionErrorCallback(Logger.INSTANCE);
        } catch (LibvirtException e) {
            log.warn("Can not obtain an instance of libvirt");
            connection = null;
            throw e;
            /*try {
                log.warn("Can not obtain an instance of libvirt, trying read only");
                connection = new Connect(uri, true);
                connection.setConnectionErrorCallback(Logger.INSTANCE);
                connected = true;
            } catch (LibvirtException ie) {
                throw ie;
            }*/
        } finally {
            Connect.setErrorCallback(null);
        }
    }

    public String getConnectionURI() throws LibvirtException {
        return connection.getURI();
    }

    public List getDomainNames() throws LibvirtException {

        if (connection == null) {
            return new ArrayList(); // Return empty list, so VirtualizationDiscovery will find no hosts.
        } else {
            return Arrays.asList(connection.listDefinedDomains());
        }
    }

    protected void finalize() throws Throwable {
        super.finalize();
        if (connected) {
            connection.close();
            connected = false;
        }
    }

    public boolean isConnected() {
        return connected;
    }

    public int[] getDomainIds() throws Exception {
        if (connection == null) {
            return new int[0]; // Return empty list, so VirtualizationDiscovery will find no hosts.
        } else {
            return connection.listDomains();
        }
    }

    public void printDomainInfo(DomainInfo domainInfo) {
        System.out.println("\tDOMAIN INFO: \n\tstate=" + String.valueOf(domainInfo.domainInfo.state) + "\n\tmem="
            + domainInfo.domainInfo.maxMem + "\n\tfree=" + domainInfo.domainInfo.memory + "\n\tCPUs="
            + domainInfo.domainInfo.nrVirtCpu + "\n\tcpu=" + domainInfo.domainInfo.cpuTime);
    }

    public DomainInfo getDomainInfo(String domainName) throws LibvirtException {
        try {
            Domain domain = getDomain(domainName);
            try {
                DomainInfo info = new DomainInfo();
                info.domainInfo = domain.getInfo();
                info.name = domainName;
                info.uuid = domain.getUUIDString();

                return info;
            } finally {
                domain.free();
            }
        } catch (LibvirtException e) {
            log.error("Error looking up domain with name " + domainName, e);
            throw e;
        }
    }

    public DomainInfo getDomainInfo(int id) throws LibvirtException {
        try {
            Domain domain = connection.domainLookupByID(id);
            if (domain == null) {
                throw new IllegalArgumentException("No domain found with ID: " + id);
            }
            try {
                DomainInfo info = new DomainInfo();
                info.domainInfo = domain.getInfo();
                info.name = domain.getName();
                info.uuid = domain.getUUIDString();

                return info;
            } finally {
                domain.free();
            }
        } catch (LibvirtException e) {
            log.error("Error looking up domain with id " + id, e);
            throw e;
        }
    }

    public String getDomainXML(String domainName) throws LibvirtException {
        Domain domain = getDomain(domainName);
        try {
            return domain.getXMLDesc(0);
        } finally {
            domain.free();
        }
    }

    public int domainReboot(String domainName) throws LibvirtException {
        Domain domain = getDomain(domainName);
        try {
            domain.reboot(0);
            return SUCCESS;
        } finally {
            domain.free();
        }
    }

    public int domainRestore(String toPath) throws LibvirtException {
        connection.restore(toPath);
        return SUCCESS;
    }

    public int domainDestroy(String domainName) throws LibvirtException {
        Domain domain = getDomain(domainName);
        try {
            domain.destroy();
            return SUCCESS;
        } finally {
            domain.free();
        }
    }

    public int domainDelete(String domainName) throws LibvirtException {
        Domain domain = getDomain(domainName);
        try {
            DomainState state = domain.getInfo().state;
    
            if ((state != DomainState.VIR_DOMAIN_SHUTDOWN) && (state != DomainState.VIR_DOMAIN_SHUTOFF)) {
                domain.destroy();
            }
            domain.undefine();
            
            return SUCCESS;
        } finally {
            domain.free();            
        }
    }

    public int domainSave(String domainName, String toPath) throws LibvirtException {
        Domain domain = getDomain(domainName);
        try {
            domain.save(toPath);
            return SUCCESS;
        } finally {
            domain.free();
        }
    }

    public int domainResume(String domainName) throws LibvirtException {
        Domain domain = getDomain(domainName);
        try {
            domain.resume();
            return SUCCESS;
        } finally {
            domain.free();
        }
    }

    public int domainShutdown(String domainName) throws LibvirtException {
        Domain domain = getDomain(domainName);
        try {
            domain.shutdown();
            return SUCCESS;
        } finally {
            domain.free();            
        }
    }

    public int domainSuspend(String domainName) throws LibvirtException {
        Domain domain = getDomain(domainName);
        try {
            domain.suspend();
            return SUCCESS;
        } finally {
            domain.free();
        }
    }

    public int domainCreate(String domainName) throws LibvirtException {
        Domain domain = getDomain(domainName);
        try {
            domain.create();
            return SUCCESS;
        } finally {
            domain.free();
        }
    }

    public boolean defineDomain(String xml) throws LibvirtException {
        Domain dom = connection.domainDefineXML(xml);
        boolean returnValue = (dom != null);
        if (returnValue) {
            dom.free();
        }
        return returnValue;
    }

    public void setMaxMemory(String domainName, long size) throws LibvirtException {
        Domain domain = getDomain(domainName);
        try {
            domain.setMaxMemory(size);
        } finally {
            domain.free();
        }
    }

    public void setMemory(String domainName, long size) throws LibvirtException {
        Domain domain = getDomain(domainName);
        try {
            domain.setMemory(size);
        } finally {
            domain.free();
        }
    }

    public void setVcpus(String domainName, int count) throws LibvirtException {
        Domain domain = getDomain(domainName);
        try {
            domain.setVcpus(count);
        } finally {
            domain.free();
        }
    }

    public DomainInterfaceStats getDomainInterfaceStats(String domainName, String path) throws LibvirtException {
        Domain domain = getDomain(domainName);
        try {
            return domain.interfaceStats(path);
        } finally {
            domain.free();
        }
    }

    public DomainBlockStats getDomainBlockStats(String domainName, String path) throws LibvirtException {
        Domain domain = getDomain(domainName);
        try {
            return domain.blockStats(path);
        } finally {
            domain.free();
        }
    }

    public int close() throws LibvirtException {
        if (connected) {
            connected = false;
            return connection.close();
        } else {
            return 0;
        }
    }

    public double getMemoryPercentage() throws LibvirtException {
        double memory = connection.nodeInfo().memory;
        double usedMemory = 0;
        for (int id : connection.listDomains()) {
            Domain domain = connection.domainLookupByID(id);
            if (domain != null) {
                usedMemory += domain.getInfo().memory;
                domain.free();
            }
        }
        return usedMemory / memory;
    }

    public long getCPUTime() throws LibvirtException {
        long cpuTime = 0;
        for (int id : connection.listDomains()) {
            Domain domain = connection.domainLookupByID(id);
            if (domain != null) {
                cpuTime += domain.getInfo().cpuTime;
                domain.free();
            }
        }
        return cpuTime;
    }

    public HVInfo getHVInfo() throws LibvirtException {
        HVInfo hvInfo = new HVInfo();
        hvInfo.libvirtVersion = connection.getLibVirVersion();
        hvInfo.hvType = connection.getType();
        hvInfo.uri = connection.getURI();
        hvInfo.version = connection.getVersion();
        hvInfo.hostname = connection.getHostName();
        hvInfo.nodeInfo = connection.nodeInfo();
        return hvInfo;
    }

    public List getNetworks() throws LibvirtException {
        if (connection == null) {
            return Arrays.asList(new String[0]);
        } else {
            return Arrays.asList(connection.listNetworks());
        }
    }

    public List getDefinedNetworks() throws LibvirtException {
        if (connection == null) {
            return Arrays.asList(new String[0]);
        } else {
            return Arrays.asList(connection.listDefinedNetworks());
        }
    }

    public boolean isNetworkActive(String name) throws LibvirtException {
        return getNetworks().contains(name);
    }

    public NetworkInfo getNetwork(String name) throws LibvirtException {
        Network net = getLibVirtNetwork(name);
        
        try {
            NetworkInfo info = new NetworkInfo();
            info.name = net.getName();
            info.autostart = net.getAutostart();
            info.bridgeName = net.getBridgeName();
            return info;
        } finally {
            net.free();
        }
    }

    public String getNetworkXML(String name) throws LibvirtException {
        Network network = getLibVirtNetwork(name);
        try {
            return network.getXMLDesc(0);
        } finally {
            network.free();
        }
    }

    public void updateNetwork(String name, String xml, boolean autostart) throws LibvirtException {
        connection.networkDefineXML(xml);
        Network network = getLibVirtNetwork(name);
        try {
            network.setAutostart(autostart);
        } finally {
            network.free();
        }
    }

    public static class DomainInfo {
        public int id;
        public String name;
        public String uuid;
        public org.libvirt.DomainInfo domainInfo;
    }

    public static class NetworkInfo {
        public String name;
        public boolean autostart;
        public String bridgeName;
    }

    public static class HVInfo {
        public long libvirtVersion;
        public String hvType;
        public String uri;
        public String hostname;
        public long version;
        public org.libvirt.NodeInfo nodeInfo;
    }

    public static void main(String args[]) throws Exception {
        //LibVirtConnection conn = new LibVirtConnection("qemu:///system");
        LibVirtConnection conn = new LibVirtConnection("");
        HVInfo hi = conn.getHVInfo();

        System.out.println("HV Version:" + hi.version);
        System.out.println("LV Version:" + hi.libvirtVersion);
        System.out.println("HV Type:" + hi.hvType);
        System.out.println("HV URI:" + hi.uri);
        for (int foo : conn.getDomainIds()) {
            System.out.println(foo);
            System.out.println(conn.connection.domainLookupByID(foo).interfaceStats(""));
        }
        for (String foo : conn.getDomainNames()) {
            System.out.println(foo);
            System.out.println(conn.connection.domainLookupByName(foo).getXMLDesc(0));
        }
    }
    
    private Domain getDomain(String domainName) throws LibvirtException, IllegalArgumentException {
        Domain ret = connection.domainLookupByName(domainName);
        if (ret == null) {
            throw new IllegalArgumentException("Could not find a domain called '" + domainName + "'.");
        }
        
        return ret;
    }
    
    private Network getLibVirtNetwork(String networkName) throws LibvirtException, IllegalArgumentException {
        Network ret = connection.networkLookupByName(networkName);
        if (ret == null) {
            throw new IllegalArgumentException("Could not find a netword called '" + networkName + "'.");
        }
        
        return ret;
    }
}

class Logger extends org.libvirt.ErrorCallback {

    // Make this static so the callback will always have an object
    // to reference. If the object is GC'ed a core dump will occur.
    public static Logger INSTANCE = new Logger();

    private Log log = LogFactory.getLog(Logger.class);

    @Override
    public void errorCallback(Pointer arg0, virError arg1) {
        log.warn("Libvirt Error: " + arg1.message);
    }
}