import org.libvirt.NodeInfo; //导入依赖的package包/类
private static Connect mockConnect(boolean cpu1, boolean wordSize32bits, int memoryInKB)
    throws IOException, LibvirtException {
    StringWriter capabilitiesXML = new StringWriter();
    Capabilities capabilities = new Capabilities();
    Guest guest = new Guest();
    Arch arch = new Arch();
    arch.setWordSize(getWordSize(wordSize32bits));
    arch.setName(getCpu(cpu1));
    guest.setArch(arch);
    capabilities.addGuest(guest);
    new CapabilitiesDom4jWriter().write(capabilitiesXML, capabilities);

    Connect connect = mock(Connect.class);
    when(connect.getCapabilities()).thenReturn(capabilitiesXML.toString());
    NodeInfo nodeInfo = new NodeInfo();
    nodeInfo.memory = memoryInKB;
    when(connect.nodeInfo()).thenReturn(nodeInfo);
    return connect;
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
private long calculateFreeMemory() throws IOException {
    NodeInfo nodeInfo = libvirtManager.getNodeInfo();
    long nodeMemoryInMB = nodeInfo.memory / ONE_THOUSAND_TWENTY_FOUR;

    xenConfigurationParser.init(this.xenConfigPath);
    long xenMinMemoryInMB = xenConfigurationParser.getLongValue("dom0-min-mem");

    LOG.debug(String.format("Available Node memory (from libvirt): %dMB, Memory reserved for dom0 in xen config: %dMB, Memory reserved for Xen in p2p-app-config: %dMB", nodeMemoryInMB, configReservedMem, xenMinMemoryInMB));

    long usedMemory = 0;
    Collection<Domain> allRunInstances = libvirtManager.getAllInstances();
    for (Domain domain : allRunInstances) {
        try {
            if (StringUtils.isBlank(domain.getName()) || !domain.getName().toLowerCase(Locale.UK).contains("domain"))
                usedMemory += domain.getMaxMemory() / ONE_THOUSAND_TWENTY_FOUR;
        } catch (LibvirtException e) {
            LOG.warn(String.format(UNABLE_TO_GET_NODE_INFORMATION_FOR_INSTANCE_IN_XEN_WITH_ID_S, domain), e);
        }
    }

    // deduct 64M as an extra buffer for xen
    long freeMemoryInMB = nodeMemoryInMB - usedMemory - xenMinMemoryInMB - configReservedMem - SIXTY_FOUR;

    LOG.debug(String.format("Free memory available in xen: %d", freeMemoryInMB));
    return freeMemoryInMB;
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
protected static long getCpuSpeed(final NodeInfo nodeInfo) {
    try (final Reader reader = new FileReader(
            "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq")) {
        return Long.parseLong(IOUtils.toString(reader).trim()) / 1000;
    } catch (IOException | NumberFormatException e) {
        logger.warn("Could not read cpuinfo_max_freq");
        return nodeInfo.mhz;
    }
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
public NodeInfo getNodeInfo() {
	try {
		return libvirtConn.nodeInfo();
	} catch (LibvirtException ex) {
		ex.printStackTrace();
		return null;
	}
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
protected static long getCpuSpeed(final NodeInfo nodeInfo) {
    try (final Reader reader = new FileReader(
            "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq")) {
        return Long.parseLong(IOUtils.toString(reader).trim()) / 1000;
    } catch (IOException | NumberFormatException e) {
        s_logger.warn("Could not read cpuinfo_max_freq");
        return nodeInfo.mhz;
    }
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
public NodeInfo getNodeInfo() {
    try {
        return connection.getNodeInfo();
    } catch (LibvirtException e) {
        processLibvirtException(e, "Unable to get the node info");
    }
    return null;
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
private int getFreeCores(int usedCpus) {
    int freeCpus = 0;
    if (configMaxCores > 0) {
        freeCpus = configMaxCores - usedCpus;
        LOG.debug(String.format("Using ConfigMaxCores - FreeCpus: %d", freeCpus));
    } else {
        NodeInfo nodeInfo = libvirtManager.getNodeInfo();
        freeCpus = nodeInfo.cpus - usedCpus;
        LOG.debug("Not using ConfigMaxCores - FreeCpus:" + freeCpus);
    }

    LOG.debug(String.format("Free cores available in Xen: %d", freeCpus));
    return freeCpus;
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
@Test
public void shouldReturnNodeInfo() throws Exception {
    // setup
    NodeInfo mockNodeInfo = mock(NodeInfo.class);
    when(mockConnection.getNodeInfo()).thenReturn(mockNodeInfo);

    // act
    NodeInfo nodeInfo = this.libvirtManager.getNodeInfo();

    // assert
    assertEquals(mockNodeInfo, nodeInfo);
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
@Override
public NodeInfo getNodeInfo() throws LibvirtException {
    addCommand("getNodeInfo");
    NodeInfo nodeInfo = new NodeInfo();
    nodeInfo.memory = FOUR_OH_NINE_SIX * ONE_OH_TWO_FOUR * ONE_OH_TWO_FOUR_LONG;
    nodeInfo.cpus = ONE_OH_TWO_FOUR;
    return nodeInfo;
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
/**
 * Get information about the host hardware
 */
public LibVirtNodeInfo nodeInfo()
{
    this.checkOpen();
    try
    {
        NodeInfo ni = this.connection.nodeInfo();
        return new LibVirtNodeInfo(ni.model, ni.memory * 1024L, ni.cpus, ni.mhz, ni.nodes, ni.sockets, ni.cores, ni.threads);
    }
    catch (LibvirtException e)
    {
        throw new DataException("Cannot get node info", e);
    }
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
protected List<Object> getHostInfo() {
    final ArrayList<Object> info = new ArrayList<>();
    long speed = 0;
    long cpus = 0;
    long ram = 0;
    int cpuSockets = 0;
    String cap = null;
    try {
        final Connect conn = LibvirtConnection.getConnection();
        final NodeInfo hosts = conn.nodeInfo();
        speed = getCpuSpeed(hosts);

  /*
   * Some CPUs report a single socket and multiple NUMA cells.
   * We need to multiply them to get the correct socket count.
   */
        cpuSockets = hosts.sockets;
        if (hosts.nodes > 0) {
            cpuSockets = hosts.sockets * hosts.nodes;
        }
        cpus = hosts.cpus;
        ram = hosts.memory * 1024L;
        final LibvirtCapXmlParser parser = new LibvirtCapXmlParser();
        parser.parseCapabilitiesXml(conn.getCapabilities());
        final ArrayList<String> oss = parser.getGuestOsType();
        for (final String s : oss) {
    /*
     * Even host supports guest os type more than hvm, we only report hvm to management server
     */
            if (s.equalsIgnoreCase("hvm")) {
                cap = "hvm";
            }
        }
    } catch (final LibvirtException e) {
        logger.trace("Ignoring libvirt error.", e);
    }

    if (isSnapshotSupported()) {
        cap = cap + ",snapshot";
    }

    info.add((int) cpus);
    info.add(speed);
    // Report system's RAM as actual RAM minus host OS reserved RAM
    final long dom0MinMem = getHostReservedMemMb();
    ram = ram - dom0MinMem;
    info.add(ram);
    info.add(cap);
    info.add(dom0MinMem);
    info.add(cpuSockets);
    logger.debug("cpus=" + cpus + ", speed=" + speed + ", ram=" + ram + ", _dom0MinMem=" + dom0MinMem + ", cpu sockets=" + cpuSockets);

    return info;
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
@Test
public void getCpuSpeed() {
    Assume.assumeTrue(SystemUtils.IS_OS_LINUX);
    final NodeInfo nodeInfo = Mockito.mock(NodeInfo.class);
    LibvirtComputingResource.getCpuSpeed(nodeInfo);
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
protected List<Object> getHostInfo() {
    final ArrayList<Object> info = new ArrayList<Object>();
    long speed = 0;
    long cpus = 0;
    long ram = 0;
    int cpuSockets = 0;
    String cap = null;
    try {
        final Connect conn = LibvirtConnection.getConnection();
        final NodeInfo hosts = conn.nodeInfo();
        speed = getCpuSpeed(hosts);

        /*
        * Some CPUs report a single socket and multiple NUMA cells.
        * We need to multiply them to get the correct socket count.
        */
        cpuSockets = hosts.sockets;
        if (hosts.nodes > 0) {
            cpuSockets = hosts.sockets * hosts.nodes;
        }
        cpus = hosts.cpus;
        ram = hosts.memory * 1024L;
        final LibvirtCapXMLParser parser = new LibvirtCapXMLParser();
        parser.parseCapabilitiesXML(conn.getCapabilities());
        final ArrayList<String> oss = parser.getGuestOsType();
        for (final String s : oss) {
            /*
             * Even host supports guest os type more than hvm, we only
             * report hvm to management server
             */
            if (s.equalsIgnoreCase("hvm")) {
                cap = "hvm";
            }
        }
    } catch (final LibvirtException e) {
        s_logger.trace("Ignoring libvirt error.", e);
    }

    if (isSnapshotSupported()) {
        cap = cap + ",snapshot";
    }

    info.add((int)cpus);
    info.add(speed);
    // Report system's RAM as actual RAM minus host OS reserved RAM
    ram = ram - _dom0MinMem + _dom0OvercommitMem;
    info.add(ram);
    info.add(cap);
    info.add(_dom0MinMem);
    info.add(cpuSockets);
    s_logger.debug("cpus=" + cpus + ", speed=" + speed + ", ram=" + ram + ", _dom0MinMem=" + _dom0MinMem + ", _dom0OvercommitMem=" + _dom0OvercommitMem + ", cpu sockets=" + cpuSockets);

    return info;
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
@Override
public NodeInfo getNodeInfo() throws LibvirtException {
    LOG.debug("getNodeInfo()");
    init();
    return this.connect.nodeInfo();
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
public void setUp(boolean isMockFile) throws Exception {
    if (isMockFile) {
        mockFile = mock(File.class);
        when(mockFile.exists()).thenReturn(true);
        when(mockFile.getFreeSpace()).thenReturn(1024 * 1024 * 1024L);
        systemResourceState = new SystemResourceState() {
            @Override
            protected File getFile(String instancePath) {
                return mockFile;
            }
        };
    } else
        systemResourceState = new SystemResourceState();

    libvirtManager = mock(LibvirtManager.class);
    systemResourceState.setLibvirtManager(libvirtManager);

    xenConfigurationParser = mock(XenConfigurationParser.class);
    systemResourceState.setXenConfigurationParser(xenConfigurationParser);

    mockNodeInfo = new NodeInfo();
    mockNodeInfo.cpus = 10;
    mockNodeInfo.memory = 2048 * 1024;

    domainInfo1 = new DomainInfo();
    domainInfo1.nrVirtCpu = 4;

    domainInfo2 = new DomainInfo();
    domainInfo2.nrVirtCpu = 2;

    mockDomain = mock(Domain.class);
    when(mockDomain.getInfo()).thenReturn(domainInfo1).thenReturn(domainInfo2);
    when(mockDomain.getMaxMemory()).thenReturn(768 * 1024L).thenReturn(256 * 1024L);

    setupLibvirtManagerExpectations(Arrays.asList(new Domain[] { mockDomain, mockDomain }));

    EhCacheFactoryBean ehCacheFactoryBean = new EhCacheFactoryBean();
    ehCacheFactoryBean.setCacheName("unittest");
    ehCacheFactoryBean.setTimeToIdle(cacheTTLSeconds);
    ehCacheFactoryBean.setTimeToLive(cacheTTLSeconds);
    ehCacheFactoryBean.afterPropertiesSet();
    this.cache = (Cache) ehCacheFactoryBean.getObject();

    systemResourceState.setCache(cache);
}
 

import org.libvirt.NodeInfo; //导入依赖的package包/类
NodeInfo getNodeInfo() throws LibvirtException;