Obtener información del sistema [memoria disponible, %CPU, espacio en disco] en Java

En esta guía aprenderemos a obtener información de los recursos sistema en Java, usando la librería Sigar. Los datos que podremos extraer son los siguientes:

• Información de la CPU.
• Espacio en disco disponible.
• Cantidad de espacio que consume un directorio en específico.
• Cantidad de memoria RAM disponible y en uso.
• Información de red (dirección IP, nombre de la NIC, puertos abiertos, tablas de enrutamiento, etc.)
• Información de los procesos que se están ejecutando en el sistema.
• Asignación de variables de entorno.
• Uptime, o cantidad de tiempo que el equipo ha estado encendido.
• Nombre y versión del sistema operativo.
• Usuarios logueados actualmente.

Resaltadas en negrita está la información en la que nos concentraremos en el ejemplo. Pero antes aclaremos un poco que es Sigar: el API de Sigar nos proporciona una serie de métodos que nos permiten obtener información del sistema operativo; consta de una librería de Java (.jar) y otras librerías nativas específicas para cada sistema operativo soportado (libsigar-amd64-linux.so, para Linux de 64 bits o sigar-x86-winnt.dll para Windows de 32 bits, por poner un ejemplo).

Teniendo esto en cuenta, para hacer funcionar dicha API en una de nuestras aplicaciones, bastaría con tener el archivo .jar y la librería específica de nuestro sistema operativo. En el desarrollo del ejemplo se usará Eclipse y, aunque se explicará cómo añadir las librerías en el proyecto, se da por conocido el funcionamiento del flag --classpath de los comandos javac y java (obligatorio si no se usa ningún IDE).

El resultado…

Siempre pongo primero el resultado ya que nos aclara la visión de hacia donde vamos, y de paso saber si lo que está aquí es lo que buscamos. Esta es la salida del programa en mi Gentoo Linux:

====Informacion del sistema====
Descripcion del SO	Gentoo 2.1.6
Nombre del SO		Linux
Arquitectura del SO	x86_64
Version del SO		2.6.31-gentoo
Nivel de parches	unknown
Fabricante		Gentoo
Version SO		2.1.6
Encendido durante:	6:15

==== Informacion de la CPU ====
Fabricante:		Intel
Modelo			Core(TM)2 Duo CPU     T5750  @ 2.00GHz
Mhz			1994
Total CPUs		2
CPUs fisiscas		1
Nucleos por CPU		2
Tamanio cache		2048

Consumo de CPU 0	22.0%
Consumo de CPU 1	2.0%
Consumo total de CPU	6.0%

====Informacion del sistema de archivos====

dispos.|total|usado|disponible|%uso|dir|tipo

/dev/root|24042944|10698228|12123376|47%|/|ext4
/dev/sda1|175457764|155825380|10719932|94%|/home|ext3

====Informacion de la memoria====
Cantidad de memoria RAM: 3968MB
Total: 4056984
Usada: 2307076
Disponible: 1749908
Memoria SWAP total: 1052248
Memoria SWAP usada: 0
Memoria SWAP libre: 1052248

Descargar Sigar

Puedes descargar Sigar de la página oficial: http://support.hyperic.com/display/SIGAR/Home que incluye además ejemplos para Java, Perl, C, Python, Ruby, y más. Puedes además descargar el código fuente que se encuentra licenciado bajo la GPL2.

Creación del proyecto en Eclipse

Voy a usar este ejemplo para además enseñar a manipular librerías externas en Eclipse; si lo que te interesa es conocer el código, puedes saltarte a dicha sección directamente.

Creamos un proyecto en Eclipse llamado InfoSistema:

Ahora creamos una carpeta dentro del proyecto llamada lib, en donde guardaremos las librerías de Sigar (.jar, .so, .dll, etc.):

Ahora descomprimimos el archivo que descargamos de Sigar, y copiamos los archivos que se encuentran en la carpeta sigar-bin/lib a la carpeta lib de nuestro proyecto. En mi caso la copia la hice con este comando:

Cabe resaltar que bastaría con copiar el archivo llamado sigar.jar y la librería del sistema donde vamos a correr nuestro programa (libsigar-amd64-linux.so en mi caso).

Una vez hecha la copia, hacemos clic en la raiz del proyecto en Eclipse y presionamos F5 para actualizar el árbol de ficheros; de esta manera Eclipse sabrá de los nuevos archivos que hemos copiado. Y lo que haremos a continuación será enlazar la librería sigar.jar a nuestro proyecto, para lo cual hacemos clic derecho en el mismo, Build Path -> Configure Build Path…

En la ventana que aparece, seleccionaremos la pestaña Libraries y hacemos clic en el botón Add JARs… Seleccionamos el archivo sigar.jar y hacemos clic en OK:

Ahora que la librería se encuentra añadida, podemos utilizar el API que Sigar nos ofrece. ¡Pasemos entonces al código!

Información del sistema…

La siguiente clase nos permite obtener información del sistema operativo, como el nombre, la versión, la arquitectura, etc. Creamos una nueva clase llamada InfoSO con el siguiente código:

import org.hyperic.sigar.OperatingSystem;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;

public class InfoSO {
	private Sigar sigar = new Sigar();
	public void imprimirInfo() {
		OperatingSystem sys = OperatingSystem.getInstance();
		System.out.println("Descripcion del SO\t" + sys.getDescription());
		System.out.println("Nombre del SO\t\t" + sys.getName());
		System.out.println("Arquitectura del SO\t" + sys.getArch());
		System.out.println("Version del SO\t\t" + sys.getVersion());
		System.out.println("Nivel de parches\t" + sys.getPatchLevel());
		System.out.println("Fabricante\t\t" + sys.getVendor());
		System.out.println("Version SO\t\t" + sys.getVendorVersion());
		try {
			imprimirUptime();
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
	public void imprimirUptime() throws SigarException {
		double uptime = sigar.getUptime().getUptime();
		String resultado = "";
		int dias = (int) uptime / (60 * 60 * 24);
		int minutos, horas;
		if (dias != 0)
			resultado += dias + " " + ((dias > 1) ? "dias" : "dia") + ", ";
		minutos = (int) uptime / 60;
		horas = minutos / 60;
		horas %= 24;
		minutos %= 60;
		if (horas != 0)
			resultado += horas + ":" + (minutos < 10 ? "0" + minutos : minutos);
		else
			resultado += minutos + " min";
		System.out.println("Encendido durante:\t" + resultado);
	}
}

Aspectos importantes:

• La clase que nos proporciona los métodos para recuperar información del sistema operativo es OperatingSystem.
• Con los métodos getName y getDescription obtenemos el nombre del sistema operativo y descripción (por ejemplo: nombre = Linux; descripción = Gentoo 2.1.6).
• El método getUptime de la clase Sigar nos permite conocer cuanto tiempo ha estado prendido el equipo analizado.

Información de la CPU…

La siguiente clase nos permitirá conocer el modelo del procesador, sus capacidades, la cantidad de núcleos y el uso de los mismos, etc. Creamos una nueva clase llamada InfoCPU con el siguiente código:

import org.hyperic.sigar.CpuInfo;
import org.hyperic.sigar.CpuPerc;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;

public class InfoCPU {
	private Sigar sigar;

	public void imprimirInfoCPU() {
		sigar = new Sigar();
		CpuInfo[] infos = null;
		CpuPerc[] cpus = null;
		try {
			infos = sigar.getCpuInfoList();
			cpus = sigar.getCpuPercList();
		} catch (SigarException e) {
			e.printStackTrace();
		}

		CpuInfo info = infos[0];
		long tamanioCache = info.getCacheSize();
		System.out.println("Fabricante:\t\t" + info.getVendor());
		System.out.println("Modelo\t\t\t" + info.getModel());
		System.out.println("Mhz\t\t\t" + info.getMhz());
		System.out.println("Total CPUs\t\t" + info.getTotalCores());
		if ((info.getTotalCores() != info.getTotalSockets())
				|| (info.getCoresPerSocket() > info.getTotalCores())) {
			System.out.println("CPUs fisiscas\t\t" + info.getTotalSockets());
			System.out
					.println("Nucleos por CPU\t\t" + info.getCoresPerSocket());
		}

		if (tamanioCache != Sigar.FIELD_NOTIMPL)
			System.out.println("Tamanio cache\t\t" + tamanioCache);
		System.out.println("");

		for (int i = 0; i < cpus.length; i++)
			System.out.println("Consumo de CPU " + i + "\t"
					+ CpuPerc.format(cpus[i].getUser()));

		try {
			System.out.println("Consumo total de CPU\t"
					+ CpuPerc.format(sigar.getCpuPerc().getUser()));
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
}

Aspectos importantes:

• Se deben usar objetos de CpuInfo y CpuPerc que proporcionan los métodos para recuperar información del procesador. Dichos objetos se crean a partir de un objeto principal de tipo Sigar.
• Para extraer información acerca del procesador usamos los métodos de la clase CpuInfo (por ejemplo getVendor o getModel).
• Los datos específicos de cada núcleo de nuestro procesador se extraen con los métodos de la clase CpuPerc (getUser para obtener el uso de un núcleo, por ejemplo).

Información del sistema de archivos…

La siguiente clase nos permite obtener información del sistema de archivos: unidades montadas, espacio en disco, tipo de sistema de archivos, etc. Creamos una nueva clase llamada InfoSistemaArchivos con el siguiente código:

import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;
import org.hyperic.sigar.FileSystem;
import org.hyperic.sigar.FileSystemUsage;
import org.hyperic.sigar.NfsFileSystem;
import org.hyperic.sigar.SigarProxy;
import org.hyperic.sigar.SigarProxyCache;

public class InfoSistemaArchivos {
	private SigarProxy proxy;
	private Sigar sigar;

	public InfoSistemaArchivos() {
		sigar = new Sigar();
		proxy = SigarProxyCache.newInstance(sigar);
	}

	public void imprimirInfo() throws SigarException {
		FileSystem[] listaSistemaArchivos = proxy.getFileSystemList();
		System.out.println("\ndispos.|total|usado|disponible|%uso|dir|tipo\n");
		for (int i = 0; i < listaSistemaArchivos.length; i++)
			imprimirSistemaArchivos(listaSistemaArchivos[i]);
	}

	public void imprimirSistemaArchivos(FileSystem sistemaArchivos)
			throws SigarException {
		long usado, disponible, total, porcentaje;

		try {
			FileSystemUsage uso;
			if (sistemaArchivos instanceof NfsFileSystem) {
				NfsFileSystem nfs = (NfsFileSystem) sistemaArchivos;
				if (!nfs.ping()) {
					System.out.println(nfs.getUnreachableMessage());
					return;
				}
			}
			uso = sigar.getFileSystemUsage(sistemaArchivos.getDirName());

			usado = uso.getTotal() - uso.getFree();
			disponible = uso.getAvail();
			total = uso.getTotal();

			porcentaje = (long) (uso.getUsePercent() * 100);
		} catch (SigarException e) {
			// por ejemplo, si en al procesar D:\ en windows falla
			// con "Device not ready"
			usado = disponible = total = porcentaje = 0;
		}

		String porcentajeUso;
		if (porcentaje == 0)
			porcentajeUso = "-";
		else
			porcentajeUso = porcentaje + "%";

		System.out.print(sistemaArchivos.getDevName());
		System.out.print("|" + total);
		System.out.print("|" + usado);
		System.out.print("|" + disponible);
		System.out.print("|" + porcentajeUso);
		System.out.print("|" + sistemaArchivos.getDirName());
		System.out.println("|" + sistemaArchivos.getSysTypeName());
	}
}

Aspectos importantes:

• La clase que nos proporciona los métodos para obtener información de una unidad en específico es FileSystem.
• El método getDevName nos devuelve el nombre del dispositivo referenciado por el objeto de la clase FileSystem.
• Los métodos getTotal y getAvail devuelven un long que representa el espacio total del dispositivo y espacio disponible, respectivamente.
• Para conocer el tipo de sistema de archivos (ext4, ntfs, fat, btrfs, etc.) utilizamos el método getSysTypeName.

Información de la memoria…

La siguiente clase nos permite conocer la cantidad de memoria RAM que tiene el equipo, así como la que se está usando actualmente (tanto memoria física como virtual, aka, swap). Creamos una nueva clase llamada InfoMemoria con el siguiente código:

import org.hyperic.sigar.Mem;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.Swap;
import org.hyperic.sigar.SigarException;

public class InfoMemoria {
	private Sigar sigar = new Sigar();
	public void imprimirInfo() throws SigarException {
		Mem memoria = sigar.getMem();
		Swap intercambio = sigar.getSwap();

		System.out.println("Cantidad de memoria RAM: "+ memoria.getRam() + "MB");

		System.out.println("Total: "+enBytes(memoria.getTotal()));
		System.out.println("Usada: "+enBytes(memoria.getUsed()));
		System.out.println("Disponible: "+enBytes(memoria.getFree()));

		System.out.println("Memoria SWAP total: "+enBytes(intercambio.getTotal()));
		System.out.println("Memoria SWAP usada: "+enBytes(intercambio.getUsed()));
		System.out.println("Memoria SWAP libre: "+enBytes(intercambio.getFree()));

	}
	private Long enBytes(long valor) {
		return new Long(valor / 1024);
	}
}

Aspectos importantes:

• La clase Mem nos proporciona métodos para obtener información de la memoria del sistema.
• La clase Swap hace lo mismo que Mem, pero para la memoria virtual.
• Los métodos getTotal y getUsed nos devuelven un long que representa (en bits) la cantidad de memoria del equipo y lo que está usando, respectivamente.

La clase main…

El main de nuestro proyecto estará contenido en la clase InfoSistema:

import org.hyperic.sigar.SigarException;
public class InfoSistema {
	public static void main(String[] args) {
		try {
			System.out.println("====Informacion del sistema====");
			new InfoSO().imprimirInfo();
			System.out.println("\n==== Informacion de la CPU ====");
			new InfoCPU().imprimirInfoCPU();
			System.out.println("\n====Informacion del sistema de archivos====");
			new InfoSistemaArchivos().imprimirInfo();
			System.out.println("\n====Informacion de la memoria====");
			new InfoMemoria().imprimirInfo();
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
}

Eso es todo, solo nos queda ejecutar el proyecto y, opcionalmente, crear un archivo .jar para ejecutar en cualquier lado.

Descargas…

• Descarga del código fuente usado en esta entrada
• Descargar librerías de Sigar de SourceForge

33 Comentarios | deja el tuyo