Obtener información del sistema en Linux (con inxi, lspci y hwinfo)

Inxi es una pequeña utilidad que nos permite conocer cierta información básica de nuestro equipo como que procesador tenemos, que características posee, cuales son las particiones del disco, la tarjeta gráfica, distribución gnu/linux que tenemos y con que versión de kernel, versión del servidor gráfico, tarjeta de red y cantidad de memoria total y usada entre otra información. A veces conocer esta información es muy útil y en muchos casos cuando pedimos ayuda en un foro no está demás dar esta información básica de nuestro equipo para que nos puedan ayudar mejor a encontrar una solución al problema por el que preguntamos por si el mismo se debe a algún componente de nuestro equipo, del kernel o la versión del servidor gráfico.

Su uso es muy sencillo, basta con el siguiente comando para obtener la información que se muestra en la captura de pantalla:

$ inxi -Fpur

En la captura de pantalla se puede ver la información recopilada por inxi de una instalación de la distribución Arch Linux instalada en una máquina virtual de VirtualBox. En la página del manual de la herramienta (man inxi) podemos ver la lista completa de los parámetros y que hace cada una de ellos. Con el parámetro -c podemos modificar el esquema de colores que utiliza la herramienta en la salida.

$ inxi -Fpur -c 7

Para instalar esta herramienta en Arch Linux basta con que instalemos el paquete inxi. Para otras distribuciones bastará con instalar el paquete de inxi utilizando el gestor de paquetes de la distribución.

# pacman -S inxi

Otro comando útil es lpci que permite obtener información detallada de los buses pci de de los dispositivos del sistema.

$ lspci

Para terminar otro comando muy útil es hwinfo, este da una información muy detallada de todos los elementos del sistema. Algunos ejemplos de uso son:

$ hwinfo
$ hwinfo > "Información hwinfo.txt"
$ hwinfo --framebuffer

Para instalarlo en Arch Linux:

# pacman -S hwinfo

Referencia:
Página web inxi
Comando lspci

¡Hola Planeta Linux!

Esta es mi primera entrada para Planeta Linux y también será mi presentación en esta comunidad de bloggers de la que estoy muy contento de formar parte. Los motivos para unirme a Planeta Linux es poder llegar a más lectores, usuarios de GNU/Linux y del software libre y aumentar las visitas diárias y comentarios que recibo en el blog (aunque son más de las que pensaba recibir cuando empecé el blog), en cualquier caso lo hago realmente a gusto por sentir que quizá lo que escribo a alguien le ayude tal y como lo que otros escribieron me ayudó a mi.

Para los usuarios de GNU/Linux que han hecho la migración hace poco o tienen interés en el software libre recibir en su lector de feeds preferido es una buena forma de estar informado y aprender cosas nuevas sobre todo lo que le rodea a este sistema operativo.

La temática de mi blog es GNU/Linux y más concretamente la distribución que uso habitualmente a día de hoy, Arch Linux, cosas relacionadas con el software libre y programación principalmente en Java. Ya tiene un poco más de una año y quedáis invitados a visitar algunas de las entradas que he escrito hasta el momento, entre ellas:

Guía Instalación Arch Linux (Parte I, instalación base)
Guía Instalación Arch Linux (Parte II, entorno gráfico y programas)
Guía Instalación Arch Linux (Parte III, personalización)

De Windows a Arch Linux
Arch Linux cheat cube
Instalar Plymouth como arranque gráfico en Arch Linux
Juegos para GNU/Linux
Cambiar el prompt de la terminal bash
El sistema operativo Minix
Guía instalación Minix

Hola mundo con Apache Tapestry 5
Dcomentación sobre Apache Tapestry
Lenguajes de scripting sobre la plataforma Java

Publicado GNOME 3

Esta vez sí y cumpliendo con el calendario previsto el día 6 de abril fue publicada la versión 3 de gnome. Después de 9 años (la versión 2 fue lanzada en junio de 2002) gnome se actualiza con una revisión mayor del proyecto. Al ser una revisión mayor, esta nueva versión incorpora muchas novedades de las que parte están comentadas en las notas de lanzamiento no solo de cara a los usuarios del entorno de escritorio sino también para los desarrolladores sobre este entorno.

La evolución para los usuarios de este entorno de escritorio puede verse en las siguientes imágenes que van desde el hoy vetusto gnome 1 hasta la nueva versión de gnome 3.

Ya han sido publicados varios artículos revisando las principales novedades de gnome que puedes consultar en el aparatado referencia al final de esta entrada. Yo me limitaré a añadir algo que no ha sido tan comentado y es que gnome es algo más que el entorno de escritorio, como la nueva infraestructura para el desarrollo y que sin duda permitirá a los desarrolladores realizar mejores aplicaciones y más fácilmente. En el siguiente vista de la plataforma puede verse los principales componentes sobre los que se basarán las aplicaciones de gnome.

Llendo al centro para desarrolladores y pulsando sobre cada uno de los componentes podemos ver que hace cada uno de ellos y encontrar ejemplos y documentación de referencia. Brevemente comentaré:

Interfaz de usuario:
- GTK+: Propociona los controles (botones, menús, radios, checkboxes, campos de entrada, ...) para construir las interfaces de las aplicaciones, distribuir los componentes en las ventanas. Tiene una API orientada a objetos.
- Cairo: proporciona la funcionalidad para trabajar con gráficos vectoriales en dos dimensiones (2D) y antialias. Si GTK+ no proporiona la funcionalidad necesaria se puede hacer uso de esta librería para hacer el dibujado.
- Clutter: es una librería para construir interfaces dinámicas basándose en OpenGL para hacer el dibujado.
- ATK: hace que los componentes sean accesibles a personas con alguna discapacidad tales como visuales, de coordinación, movimientos descoordinados, impedimentos auditivos, impedimentos cognitivos y del lenguaje y desordenes de apoplejías.
- Pango: gestiona el texto y las tipografías y es usado por GTK+.
- Webkit: es el motor para el tratamiento de HTML.

Núcleo:
- GIO: proporciona una abtracción para el acceso a flujos de información ya sea de archivos en local o a través de la red.
- Glib: es una biblioteca con utilidades para el desarrollo de aplicaciones en gnome.
- GObject: proporciona soporte para varios lenguajes de programción a través de bindings que permite interoperabilidad entre diferentes lenguajes.

Existe toda otra infraestructura para otras áreas como multimedia (GStreamer, Canberra, Pulseaudio), comunicación (Telepathy, Avahi, GUPnP), almacenamiento de datos (EDS, GDA, Tracker), utilidades (Champlain, Enchant, Poppler, GeoClue), integración del sistema (upower, udisks, policykit) e integración de escritorio (packagekit, libnotify, seahorse).

En definitiva un gran paso tanto para usuarios y desarrolladores y del que veremos sus frutos en los siguientes meses y versiones.

Por supuesto, los usuarios de Arch Linux seremos unos de los primeros en disfrutar de esta nueva versión de gnome, a día de hoy los paquetes ya se encuentran en el repositorio testing y no pasará mucho tiempo hasta que se muevan al repositorio extra. Pero si no quieres esperar puedes descargarte alguna de las imágenes vivas listas para probarlo.

Ahora toca decidir y evaluar a los usuarios si este actualizado entorno de escritorio cumple sus expectativas. Seguramente se echarán en falta cosas y otras se querrá que se cambien como es habitual en un cambio tan profundo de la plataforma, simplemente tener en cuenta que esta es la primera versión de la rama 3 y a medida que se vayan liberando revisiones menores el proyecto ganará en caraterísticas y funcionalidades como es habitual en el desarrollo del software.

La versión 3.2 está planeada para semtiembre/octubre de 2011. Al final de las notas de publicación puedes ver algunas de las novedades que incorporará.

A todos los que ha hecho posible esta versión de GNOME... ¡Gracias! y mientras tanto... ¡a disfrutar de esta excelente plataforma!

Referencia:
http://library.gnome.org/misc/release-notes/3.0/
http://www.gnome.org/gnome-3/
http://www.genbeta.com/a-fondo/gnome-3-a-fondo
http://arstechnica.com/open-source/reviews/2011/04/ars-reviews-gnome-30-a-shiny-new-ornament-for-your-linux-lawn.ars
https://live.gnome.org/GnomeShell/CheatSheet
http://www.archlinux.org/news/gnome3-in-testing/
http://gnome3.org/tryit.html
http://en.wikipedia.org/wiki/GNOME
https://wiki.archlinux.org/index.php/GNOME_3

Para desarrolladores:
http://developer.gnome.org/
http://developer.gnome.org/platform-overview/stable/
https://live.gnome.org/GnomeLove
https://live.gnome.org/GnomeLove/HowToStart%20Es

Poner en color pacman y yaourt

Siguiendo con el tema de personalización de arch linux podemos hacer que pacman y yaourt, los dos comandos para administrar los paquetes en arch, se muestren con colores para resaltar la información que muestran. Basta con instalar el paquete pacman-color con:

# pacman -S pacman-color

pacman-color es un nuevo comando que podremos usar como reemplazo de pacman, tiene los mismos parámetros y su funcionamiento es el mismo pero que mostrará la salida con colores. A partir de este momento pacman-color y yaourt se mostrarán de la siguiente forma.

Para hacer que yaourt se muestre tambien con colores deberemos editar el archivo /etc/yaourtrc y sustituir el comando que utiliza yaourt de pacman modificándolo a pacman-color:

# nano /etc/yaourtrc

PACMAN="pacman-color"

Instalar Plymouth como arranque gráfico en Arch Linux

Los que usamos Arch Linux estamos acostumbrados a ver mientras se inicia nuestro sistema una serie de mensajes con los servicios que se van iniciando. Si queremos darle un toque más atractivo al inicio de nuestro sistema hay varias opciones, principalmente Usplash que utilizaba ubuntu hasta hace poco y desde hace un tiempo Plymouth, desarrollado por RedHat como reemplazo de su RHGB (Red Hat Graphical Boot). Plymouth proporciona una animación gráfica atractiva mientras se inicia el sistema y sin parpadeos producidos por cambios de resolución de la pantalla lo que tambien contribuye a iniciar el sistema más rápido. Para hacer uso de Plymouth se necesita Kernel Mode Setting (que es lo que evita los parpadedos, cambios de resolución de la pantalla, entre otras cosas) siendo el kernel en que ajusta la resolución de la pantalla al inicio del sistema. A día de hoy no todos los controladores gráficos soportan KMS (principalmente los privativos de nvidia) pero Plymouth también puede ser usado con el framebuffer.

La instalación y configuración de Plymouth no es complicada pero se hace «a la manera Arch». Todo esto lo he probado dentro de una máquina virtual en VirtuaBox pero debería funcionar perfectamente en un máquina real. Antes de empezar deberemos tener instalado yaourt para poder instalar paquetes del repositorio AUR de Arch Linux, consulta la Wiki Arch si es necesario.

Primeramente instalaremos el paquete de plymouth con:

$ yaourt -S plymouth-git

El siguiente paso será añadir plymouth a los HOOKS que se ejecutan cuando se construye la imagen del kernel.

# nano /etc/mkinitcpio.conf

HOOKS="base udev autodetect plymouth ..."

Ahora que tenemos en los hooks del kernel plymouth haremos una reconstrucción del mismo con:

# mkinitcpio -p kernel26

Si alguna vez nos cansamos de plymouth bastará con eliminar el HOOK añadido, volver a hacer un mkinitcpio y eliminar el paquete plymouth-git. Ahora deberemos modificar unos parámetros de grub:

/* Para Grub2 */
# nano /etc/default/grub

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"
GRUB_CMDLINE_LINUX=" splash"

Y regeneramos el archivo de grub:

# grub-mkconfig -o /boot/grub/grub.cfg

Hacemos que una vez arrancado el sistema plymouth se deje de ejecutar:

# nano /etc/rc.local

/bin/plymouth quit --retain-splash

Cuando instalamos el paquete de plymouth podemos elegir entre varios temas (fade-in, glow, solar, spinfinity, script, text) y podemos cambiar de uno a otro en cualquier momento. Cada vez que queramos cambiar de tema tendremos que ejecutar:

/* para listar los temas disponibles */
# plymouth-set-default-theme -l 
# plymouth-set-default-theme solar
# mkinitcpio -p kernel26

También podemos probar el tema sin tener que reiniciar el sistema:

# plymouthd
# plymouth --show-splash

Para detener la previsualización debemos cambiar de terminal tty (ALT+F2, inicar sesión si es necesario) y ejecutar:

# plymouth --quit

Si hay alguna vez que queremos ver los mensajes de inicio de Arch Linux en vez de la animación de Plymouth solo debemos pulsar la tecla Escape o si queremos ver los mensajes más tarde los tenemos en el archivo /var/log/boot.log. Y si de los temas por defecto no nos gusta ninguno podemos desarrollar uno nuevo para lo nos servirá de mucha ayuda la siguiente docmentación de como crearlos. Pero no hace falta que desarrollemos uno desde cero lo más aconsejable es partir de uno ya hecho, los temas por defecto se encuentran en /usr/share/plymouth/themes deberemos copiar uno, cambiarle de nombre, modificar las imágenes y tal vez hacer un script que controle la animación.

Las siguientes imágenes son de los temas que he podido probar correctamente, el tema text me ha dado el error "unexpedtedly disconectend from boot status daemon" y no he podido probarlo.

¿Alguien se anima a hacer un theme bonito para plymouth?

Referencia:
https://wiki.archlinux.org/index.php/Plymouth
http://es.wikipedia.org/wiki/Plymouth_(software)
http://en.wikipedia.org/wiki/Mode-setting
http://es.wikipedia.org/wiki/Framebuffer
https://wiki.archlinux.org/index.php/Yaourt
https://wiki.ubuntu.com/Artwork/Documentation/Plymouth
http://www.freedesktop.org/wiki/Software/Plymouth/Scripts

Implementación de un Comparator genérico en Java con ayuda de Groovy

Al programar en Java ¿no has tenido la necesidad de hacer unas cuantas clases que implementen la interfaz Comparator para realizar ordenaciones con el método Collections.sort pero no querías hacer una clase por cada una de ellas con unas pocas líneas? Cuando necesitas uno o dos Comparator puede valer hacer una clase para cada una de ellas pero cuanto empiezas a tener muchas la cosa empieza a exasperar por tener que hacer todo el rato lo mismo con un pequeño cambio, que es la expresión que obtiene los objetos que se comparan.

Para evitar tener que crear una clase por cada Comparator que queramos podemos hacer uso del soporte de Java 6 para los lenguajes de scripting (Consulta el enlace para ver como poder hacer uso de Groovy en Java) para crear un Comparator genérico. Básicamente la siguiente implementación de la interfaz Comparator, GroovyComparator, recibirá un script de groovy que lo aplicará a cada uno de los objetos del método compare de la interfaz Comparator y que devolverá un objeto que implememnte la interfaz Comparable por el que haremos la comparación entre los dos objetos.

package com.blogspot.elblogdepicodev.util;

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

import javax.script.Bindings;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class GroovyComparator implements Comparator {

 private String script;
 private Map bindings;

 public GroovyComparator(String script) {
  this(script, null);
 }

 public GroovyComparator(String script, Map bindings) {
  this.script = script;
  this.bindings = bindings;
 }

 @SuppressWarnings({ "unchecked" })
 @Override
 public int compare(T o1, T o2) {
  try {
   ScriptEngineManager manager = new ScriptEngineManager();
   engine = manager.getEngineByName(Constantes.GROOVY_ENGINE_NAME);
   
   Bindings b = engine.createBindings();
   if (bindings != null) {
    b.putAll(bindings);
   }

   b.put("it", o1);
   Comparable r1 = (Comparable) engine.eval(script, b);

   b.put("it", o2);
   Comparable r2 = (Comparable) engine.eval(script, b);

   return r1.compareTo(r2);
  } catch (ScriptException e) {
   throw new RuntimeException(e);
  }
 }
}

Suponiendo que tengamos una lista de objetos con una propiedad nombre (String) y queramos ordenar la lista por esa propiedad:

List l = ...;
 ...
 Collections.sort(l, new GroovyComparator("it.nombre"));

La verdad es que utilizando los lenguajes de scripting para hacer ciertas tareas se nos puede hacer la vida más fácil a los programadores.

Referencia:
Lenguajes de scripting sobre la plataforma Java
Scripting for the Java Platform
The Mustang Meets the Rhino: Scripting in Java 6

Enviar correos electrónicos mediante Java Mail

En algún caso puede que necesitemos enviar correos electrónicos desde una aplicación java. En esta entrada vamos a ver como realizarlo desde una aplicación web desplegada en un servidor tomcat y a través de una cuenta de correo de gmail.

Con estas premisas, sin más, el código java para enviar un correo elctrónico es el siguiente, que no sería muy distinto si utilizásemos otro servidor de aplicaciones e incluso no fuese una aplicación web:

...

import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.NoSuchProviderException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

...
try {
    // Obtener la sesión para enviar correos electrónicos del directorio JNDI
    Context ic = new InitialContext();
    Session session = (Session) ic.lookup("java:comp/env/mail/gmail");
   
    // Crear el mensaje a enviar
    MimeMessage mm = new MimeMessage(session);
  
    // Establecer las direcciones a las que será enviado 
    // el mensaje (test2@gmail.com y test3@gmail.com en copia oculta)
    mm.setFrom(new InternetAddress("test1@gmail.com"));
    mm.addRecipient(Message.RecipientType.TO, new InternetAddress("test2@gmail.com"));
    mm.addRecipient(Message.RecipientType.BCC, new InternetAddress("test3@gmail.com"));

    // Establecer el contenido del mensaje
    mm.setSubject("Hola mundo!");
    mm.setText("Hola mundo!");

    // Enviar el correo electrónico
    Transport.send(mm);
} catch (Exception e) {
    e.printStackTrace();
}

...

¿Pero donde se configura como nos conectamos al servidor de gmail para enviar los correos electrónicos? Pues bien, esto lo podemos hacer en la configuración de contexto para la aplicación. Estos  recursos se definen normalmente en un archivo «$TOMCAT_HOME/conf/Catalina/localhost/[contexto app].xml» y básicamente se asocia a un nombre del árbol JNDI un objeto de interfaz javax.mail.Session que será el que obtengamos en la aplicación y utilicemos para enviar los correos electrónicos. Esto es lo que hace la etiqueta Resource del ejemplo. JNDI es básicamente un registro donde se asocian nombres con servicios, en este caso el nombre «java:comp/env/mail/gmail» con objeto de interfaz javax.mail.Session que utilizaremos para enviar los correos electrónicos. La configuración para el tomcat sería:

<Context docBase="/home/tomcat/web">
    <Resource type="javax.sql.DataSource"
            auth="Container"
            maxActive="30" 
            maxIdle="10"
            maxWait="10000" 
            name="jdbc/db"
            driverClassName="com.mysql.jdbc.Driver"
            url="jdbc:mysql://localhost/db?autoReconnect=true"
            username="root"
            password=""/>
    <Resource type="javax.mail.Session"
            auth="Container"
            name="mail/gmail"
            mail.transport.protocol="smtp"
            mail.smtp.host="smtp.googlemail.com"
            mail.smtp.port="465"
            mail.smtp.auth="true"
            mail.smtp.user="test1@gmail.com"
            password=""
            mail.smtp.starttls.enable="true"
            mail.smtp.socketFactory.port="465"
            mail.smtp.socketFactory.class="javax.net.ssl.SSLSocketFactory"
            mail.smtp.socketFactory.fallback="false"
            mail.smtp.debug="true"/>
</Context>

Al igual que podemos configurar un recurso de tipo javax.sql.DataSource en el mismo archivo de configuración de la aplicación  para obtener conexiones a bases de datos configuramos un recurso de tipo javax.mail.Session, lo que logicamente cambiará serán los parametros para configurar uno y otro. En ambos casos el parámetro name indica en que punto del árbol JNDI donde se deja disponible el recurso. En el ejemplo los parámetros indicados son los necesarios para conectarse al servidor smtp con una cuenta de gmail.

¿Y porque configuramos el DataSource y la Sesion en el tomcat? Podríamos evitarnos esta configuración y meterla en el código de la aplicación pero esto tiene la desventaja de que para utilizar una nueva configuración necesitaríamos recompilar la aplicación, en el caso de tener la configuración externalizada en un archivo «$TOMCAT_HOME/conf/Catalina/localhost/[contexto app].xml» únicamente sería necesario un redespliegue de la aplicación lo que es más rápido y sencillo.

Para hacer uso de las clases java del paquete javax.mail.* necesitaremos la librerias de java mail (http://www.oracle.com/technetwork/java/javamail/index.html) pero también necesitaremos las clases de JAF (JavaBeans Activation Framework) (http://www.oracle.com/technetwork/java/javase/downloads/index-135046.html). Ambas librerias activation.jar y mail.jar deberemos colocarlas en el directorio lib de tomcat (en la versión 7.x). El lugar donde ponerlas es importante ya que si las colocamos en el directorio WEB-INF/lib de la aplicación java mail no va a funcionar.

Desde luego este es un ejemplo básico de como enviar un mensaje de correo electrónico de un texto plano desde java y si tenemos necesidad de enviar correos electrónicos puede que también necesitemos enviarlos en formato html para lo cual quizá nos convenga hacer uso de motores de plantillas como freemarker o velocity.

Referencia:
http://es.wikipedia.org/wiki/JNDI
http://tomcat.apache.org/tomcat-7.0-doc/config/context.html
http://tomcat.apache.org/tomcat-7.0-doc/config/resources.html
http://tomcat.apache.org/tomcat-7.0-doc/jndi-resources-howto.html