PlowShare es un conjunto de scripts para el sistema operativo Linux con el fin de permitir administrar las descargas y subidas en sitios de file-sharing, del estilo de RapidShare, MegaUpload, HotFile, etc. Automatiza el reconocimiento de caracteres -CAPTCHA- y los tiempos de espera para comenzar la descarga. Además, es una aplicación de consola con requerimientos de recursos excepcionalmente bajos.

Los scripts son plowdown.sh, plowup.sh, plowdel.sh y plowlist.sh. Seguramente el más utilizado por el común de la gente sea plowdown, y éstas son sus opciones:

server ~ # plowdown
Usage: plowdown [OPTIONS] [MODULE_OPTIONS] URL|FILE [URL|FILE ...]

  Download files from file sharing servers.

  Available modules: rapidshare megaupload 2shared badongo mediafire 4shared zshare depositfiles storage_to uploaded_to uploading netload_in usershare sendspace x7_to hotfile divshare dl_free_fr humyo filefactory data_hu

Global options:

  -h, --help: Show help info
  --version: Return plowdown version
  -v LEVEL, --verbose=LEVEL: Set output verbose level: 0=none, 1=err, 2=notice (default), 3=dbg
  -q, --quiet: Alias for -v0
  -c, --check-link: Check if a link exists and return
  -m, --mark-downloaded: Mark downloaded links in (regular) FILE arguments
  -x, --no-overwrite: Do not overwrite existing files
  --get-module: Get module(s) for URL(s)
  -o DIRECTORY, --output-directory=DIRECTORY: Directory where files will be saved
  --temp-directory=DIRECTORY: Directory where files are temporarily downloaded
  -r SPEED, --limit-rate=SPEED: Limit speed to bytes/sec (suffixes: k=Kb, m=Mb, g=Gb)
  -i IFACE, --interface=IFACE: Force IFACE interface
  -t SECS, --timeout=SECS: Timeout after SECS seconds of waits
  --max-retries=N: Set maximum retries for loops
  --run-download=COMMAND: run down command (interpolations: %filename, %cookies, %url)

Options for module <rapidshare>:

  -a USER:PASSWORD, --auth=USER:PASSWORD: Use Premium-Zone account

Options for module <megaupload>:

  -a USER:PASSWORD, --auth=USER:PASSWORD: Free-membership or Premium account
  -p PASSWORD, --link-password=PASSWORD: Used in password-protected files

Options for module <x7_to>:

  -b USER:PASSWORD, --auth-free=USER:PASSWORD: Use Free account

Al script lo podemos invocar con la URL de un archivo a descargar, una lista de URLs de archivos a descargar o inclusive con la ruta a un archivo de texto que contiene la lista de links (uno por línea). En los últimos dos casos el script descargará los archivos en orden, siendo posible configurar que marque con el símbolo ‘#’ al principio de la línea del archivo cada archivo descargado correctamente (ver –mark-downloaded más abajo).

Algunas de las opciones importantes son:

• -o (–output-directory): determina el directorio de salida. Es el lugar en donde se ubicarán el o los archvos descargados.
• -r (–limit-rate): configura la velocidad de transferencia máxima, por ejemplo, -r=50kb, –limit-rate=1m.
• -c (–check-link): no descarga el o los archivos, sólo verifica que los links sean válidos.
• -m (–mark-downloaded): cuando se desea descargar todos los links listados en un archivo de texto, marca los archivos descargados correctamente con un ‘#’ al principio de la línea.

Veamos un ejemplo de invocación para descargar un archivo desde MegaUpload:

server ~ # plowdown -v 2 -o /tmp http://www.megaupload.com/?d=977IJRE0
Install aview or libcaca to display captcha image
Waiting 47 seconds... 37.. 27.. 17.. 7.. 0
File URL: http://www937.megaupload.com/files/927a093e5f4d388420ef7ecfcecd73c0/Weeds 5x01 - Seba357.rar
Filename: Weeds 5x01 - Seba357.rar
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
 51  233M   51  120M    0     0   209k      0  0:18:57  0:09:47  0:09:10  212k

En http://code.google.com/p/plowshare/wiki/Readme tenemos otros ejemplos de uso para descargar, subir, borrar y comprobar links en sitios de file-sharing.

El proyecto PlowShare está hosteado en Google Code. La página del proyecto es http://code.google.com/p/plowshare/.

Gentoo Linux tiene el paquete disponible en portage bajo el nombre net-misc/plowshare. Archlinux y (e incluso Mac OSX) también tiene paquete de instalación, para el resto de los sabores de Linux tenemos la posibilidad de instalarlo desde el código fuente.

Posts relacionados:

1. Copiar archivos utilizando SCP en Linux
2. Copiar archivo y particiones utilizando dd (Linux/UNIX)
3. Monitoreo en Linux: nmon

Para instalarlo, debemos bajar la herramienta desde la página del proyecto en SourceForge.net. Descomprimimos el archivo en el directorio que más nos guste (yo lo tengo en C:\UnxUtils) y agregamos el directorio [dir]\usr\local\wbin a la variable de entorno path, donde [dir] es el directorio elegido para descomprimir el archivo (en mi caso, agregué C:\UnxUtils\usr\local\wbin)

Otra forma, no tan rápida o directa de contar con este tipo de utilidades bajo Windows, pero más completa es instalar Cygwin. Para ello debemos bajar el instalador desde su página, y luego seguir las instrucciones de su guía para el usuario.

Posts relacionados:

1. Ejecutar aplicaciones gráficas de X11 (Linux y Unix) en Windows
2. Copiar archivo y particiones utilizando dd (Linux/UNIX)
3. Copiar archivos utilizando SCP en Linux
4. 64GB de RAM en un sistema operativo de 32 bits
5. Hotkeys del símbolo de sistema de Windows
6. Matar procesos en Windows (taskkill)
7. Listado de comandos de administración de Informix
8. Descargar archivos de sitios de file-sharing por consola en Linux
9. Monitoreo en Linux: nmon

A veces necesitamos ejecutar aplicaciones de un servidor Linux -o Unix- remoto estando conectados a través de SSH, pero estas aplicaciones tienen una interfaz gráfica. Una solución para este problema puede ser iniciar una sesión de VNC (un escritorio remoto de Linux) y ejecutar desde este ambiente nuestra aplicacion. Otra opción que veremos en este post es utilizando X11 tunneling en nuestra sesión SSH, con la ventaja de que agregamos encriptación sobre el canal de comunicaciones.

¿Qué es X11?

X11 es un software creado en los años 80 por el MIT (Massachusetts Institute of Technology) con el propósito de ser una interfaz gráfica para los sistemas Unix de la época.

Tiene una arquitectura cliente-servidor, proveyendo servicios para acceder a la pantalla y los dispositivos de interacción con el ususario, y permitiendo independizar lo que se quiere mostrar (servidor) de la forma de cómo mostrarlo (cliente). Esto permite también que el cliente de ventanas no esté corriendo en la misma computadora que el servidor, siendo posible ejecutar aplicaciones gráficas de forma remota.

La comunicación entre el cliente y el servidor se realiza utilizando un protocolo determinado (Xprotocol). El hecho de tener tanto un estándar como un protocolo bien definidos tiene como consecuencia una gran portabilidad del código que utiliza X11.

Wikipedia, como ya es de cosumbre tiene información más detallada y bastante clara sobre el sistema de ventanas X, están los links en las referencias.

Sistema de ventanas X en Windows

El tener una definición estándar del manejo de ventanas X permite implementar clientes para Windows. Uno de estos clientes es XMing, una alternativa gratis que funciona muy bien junto a clientes SSH como PuTTY.

Para poder utilizarlo debemos descargar, instalarlo y ejecutarlo. Aparecerá un ícono con una X en el tray, como se ve en la imagen:

Luego, al abrir una sesión SSH, debemos activar la opción para poder hacer tunnelling de X11 a través de esa conexión SSH. En PuTTY, esa opcion está en Connection -> SSH -> X11 -> Enable X11 forwarding:

Luego de tener activado el forwarding, siempre que ejecutemos un comando que necesite un ambiente gráfico en esa sesión SSH, se visualizará en nuestro Windows, como si fuera un proceso local.

En mi caso, el X11 forwarding sirvió para poder utilizar el IBM Webshphere MQ Explorer (comando strmqcfg). Estoy seguro que lo voy a utilizar en alguna otra oportunidad, espero que a ustedes también les sirva.

Referencias

X11

• http://es.wikipedia.org/wiki/X_Window_System
• http://en.wikipedia.org/wiki/X_Window_System
• http://es.wikipedia.org/wiki/Protocolos_y_arquitectura_de_X_Window_System
• http://www2.its.strath.ac.uk/courses/x/

XMing

• http://sourceforge.net/projects/xming/
• http://www.straightrunning.com/XmingNotes/
• http://en.wikipedia.org/wiki/Xming

Posts relacionados:

1. UnxUtils: ejecutar comandos Linux/UNIX en Windows
2. Copiar archivo y particiones utilizando dd (Linux/UNIX)
3. 64GB de RAM en un sistema operativo de 32 bits
4. Matar procesos en Windows (taskkill)

dd es de esos comandos de Linux y UNIX “para temer”. Puede ser de mucha utilidad en algunas situaciones, pero también puede ser fatal si se usa mal, especialmente si no tenemos cuidado en los parámetros con los que lo invocamos.

En pocas palabras, dd permite copiar y convertir el contenido de un archivo a otro. El concepto de archivo es bastante amplio, ya que además de copiar archivos comunes, se pueden utilizar como entrada y salida los archivos de /dev, y así copiar una partición, generar archivos vacíos, generar archivos con contenido aleatorio, etc.

Formato

El formato es un poco diferente a los comandos de linux que conocemos, dado que dd se basa en parámetros del tipo opción=valor en lugar de utilizar el formato más común -op valor o –opción valor.

El archivo de entrada estará especificado por la opción if (por input file). Como es de suponer, el archivo de salida está especificado por la opción of (por output file).

Con la opción bs configuramos el tamaño de cada bloque que se leerá/convertirá/escribirá (con las opciones ibs, cbs y obs se configuran los tamaños de los bloques de cada proceso por separado). A éstos parámetros se les puede pasar un valores que sean el resultado de una multiplicación, por ejemplo, 1024x1024x1024 para expresar 1 GB. También se pueden utilizar sufijos como ser c (1 byte), w (2 bytes), b (512 bytes, asociado por defecto del tamaño de un sector de disco), kB (1000 bytes), K (1024 bytes), MB (1000*1000), M (1024*1024), GB (1000*1000*1000), G (1024*1024*1024), y así para T, P, E, Z, Y.

Con el parámetro count configuramos la cantidad de bloques a copiar; por lo tanto, el tamaño de lo transferido será bs*count. Aunque la última porción del archivo no tenga el tamaño de un bloque exacto, ese restante se transfirirá de todas formas.

Podemos utilizar el parámetro conv para hacer ciertas transformaciones además de la lectura y la escritura, y puede tener los siguientes valores:

• lcase: transformar mayúsculas a minúsculas
• ucase: transformar minúsculas a mayúsculas
• swab: intercambiar cada par de bytes de entrada
• excl: fallar si el archivo de salida existe
• noerror: continuar aunque se encuentren errores de lectura
• nocreat: no crea el archivo de salida

Otras opciones que me parecieron menos interesantes fueron: ascii, ebcdic, ibm, block, unblock, notrunc, sync, fdatasync y fsync (consultar las páginas man por más datos).

Ejemplos de uso

(De más está decir que no puedo asegurar que todos los ejemplos van a funcionar como deberían, ya que en algunos casos, ni siquiera puedo afirmar que “en mi máquina anda”. Por favor usar con responsabilidad. Dicho esto, continuamos…)

En los siguientes ejemplos veremos algunos ejemplos de uso del comando dd. En los casos que corresponda este comentario, se generarán archivos de 64MB, en 1000 bloques de a 64KB.

Duplicar una partición

En este ejemplo duplicaremos el contenido de una partición en otra. Creo que lo ideal es que sean las 2 del mismo tamaño, aunque si la partición de salida es más grande, también funcionaría.

dd if=/dev/sda2 of=/dev/sdb2 bs=4096 conv=notrunc,noerror

Duplicar una partición en otro host (ésta me la enseñó MacGyver)

Es la misma idea que el ejemplo anterior, pero en lugar de duplicar la partición en un disco local, se duplica a través de la red, utilizando el comando netcat (también conocido como la navaja suiza de TCP/IP):

En el host de destino:

netcat -l -p 1234 | dd of=/dev/hdc bs=16065b

El el host de origen:

dd if=/dev/sda2 bs=16065b | netcat [IP-destino] 1234

También podemos duplicar una partición a un host remoto a través de SSH:

dd if=/dev/sda2 bs=16065b | ssh user@host "dd of=/dev/hdc bs=16065b"

Generar un archivo con ceros o contenido aleatorio

Los archivos generados con ceros o contenido aleatorio nos pueden servir como material para transferir entre discos o por la red para diagnosticar posibles problemas.

Con ceros:

dd if=/dev/zero of=/tmp/zeros bs=64k count=1000

Con contenido aleatorio:

dd if=/dev/urandom of=/tmp/myrandom bs=64k count=1000

Copiar una partición a un archivo

dd if=/dev/sda2 of=/tmp/part.image bs=4096 conv=notrunc,noerror

Si queremos copiar un CD/DVD a una imagen ISO, podemos ejecutar:

dd if=/dev/cdrom of=/tmp/myCD.iso bs=2048 conv=sync,notrunc

Parecido al ejemplo de duplicar una partición a través de la red, podemos respaldar nuestra partición a un archivo en un host remoto a través de SSH:

dd if=/dev/sda2 | ssh user@host "dd of=/home/user/partition.image"

Escribir basura en una partición

Cuando borramos archivos o utilizamos un formato rápido, la mayoría de los archivos pueden ser recuperados. Este ejemplo puede servir para asegurarnos que no se puedan recuperar los datos de una partición entera:

dd if=/dev/urandom of=/dev/hda

Convertir un archivo a MAYÚSCULAS

dd if=filename of=filename conv=ucase

Referencias

man dd
http://en.wikipedia.org/wiki/Dd_%28Unix%29

Posts relacionados:

1. Copiar archivos utilizando SCP en Linux
2. UnxUtils: ejecutar comandos Linux/UNIX en Windows
3. Ejecutar aplicaciones gráficas de X11 (Linux y Unix) en Windows
4. Descargar archivos de sitios de file-sharing por consola en Linux

En este post veremos cómo aprovechar los megabytes de RAM por arriba de los 3GB utilizando PAE, una característica de la mayoría de los procesadores modernos, sin necesidad de instalar un sistema operativo de 64 bits. Veremos también algunas consideraciones a tener en cuenta a la hora de poner en la balanza desperdiciar la memoria RAM por encima de los 3GB, habilitar PAE en un sistema operativo de 32 bits, o de utilizar un sistema de 64 bits.

PAE

PAE (Physical Address Extension, Extensión de dirección física) es una característica de la mayoría de los procesadores x86 y x86-64, que permite que sistemas de 32 bits puedan utilizar hasta 64GB de RAM. Esto es posible ampliando la cantidad de bits utilizados para direccionar memoria de 32 a 36 bits y por esto, la cantidad de memoria direccionable máxima pasa de 4GB (2^32) a 64GB (2^36).

PAE en Windows

Lo más importante a destacar si de Windows hablamos, es que el uso de PAE para extender el espacio de direccionamiento de memoria no está habilitado en ninguna versión “consumer” de Windows, por lo que hay que recurrir a una versión de servidor (NT, 2003, etc.). En realidad, en Windows XP SP1 se permitió habilitar PAE, pero en SP2 se restringió nuevamente, siendo la principal causa de esta restricción los problemas de compatibilidad e inestabilidad de los drivers de los dispositivos. Estos problemas se daban porque en la programación de dichos drivers se asumen cosas que al direccionar la memoria utilizando PAE dejan de ser ciertas (ver la parte de More information de éste artículo).

En la siguiente tabla se muestran los máximos de memoria RAM física soportados por cada versión de Windows:

Sistema operativo - Memoria máxima soportada con PAE
Windows 2000 Advanced Server – 8 GB de RAM física
Windows 2000 Datacenter Server – 32 GB de RAM física
Windows XP (todas las versiones) – 4 GB de RAM física*
Windows Server 2003 (y SP1), Standard Edition – 4 GB de RAM física*
Windows Server 2003, Enterprise Edition – 32 GB de RAM física
Windows Server 2003, Datacenter Edition – 64 GB de RAM física
Windows Server 2003 SP1, Enterprise Edition – 64 GB de RAM física
Windows Server 2003 SP1, Datacenter Edition – 128 GB de RAM física

* El espacio físico de memoria está limitado a 4 GB en estas versiones de Windows.

PAE en Linux

La historia con Linux es diferente, ya que contando con un kernel 2.6+ que tenga habilitado el soporte para PAE, se abre la posibilidad de usar hasta 64GB de RAM en sistemas de 32 bits. Los kernels 2.4 soportan hasta 4GB de memoria RAM física.

Veamos algunos ejemplos de configuración:

Habilitar PAE en Ubuntu

Para habilitar PAE en Ubuntu basta con instalar algunos paquetes que reemplazan el kernel genérico por uno con soporte para PAE. Estoy en un sistema con 4GB de RAM, con el kernel por defecto, y Ubuntu versión 9.04 para x86 (32 bits). La memoria RAM disponible anda en los 3GB:

jarrarte@nb-jarrarte:~$ free -m
total       used       free     shared    buffers     cached
Mem:          3023        428       2594          0         26        176
-/+ buffers/cache:        225       2797
Swap:         1906          0       1906

Mi kernel:

jarrarte@nb-jarrarte:~$ uname -a
Linux nb-jarrarte 2.6.28-15-generic #49-Ubuntu SMP Tue Aug 18 18:40:08 UTC 2009 i686 GNU/Linux

Para instalar el soporte para PAE (este punto también se puede hacer desde el gestor de paquetes gráfico):

jarrarte@nb-jarrarte:~$ sudo sudo apt-get install linux-headers-server linux-image-server linux-server

Luego de reinciar con el nuevo kernel, vemos que la actualización surgió efecto:

jarrarte@nb-jarrarte:~$ free -m
total       used       free     shared    buffers     cached
Mem:          4021        389       3631          0         26        166
-/+ buffers/cache:        196       3824
Swap:         1906          0       1906

jarrarte@nb-jarrarte:~$ uname -a
Linux nb-jarrarte 2.6.28-15-server #49-Ubuntu SMP Tue Aug 18 19:30:06 UTC 2009 i686 GNU/Linux

Habilitar PAE en Gentoo

Para habilitar el soporte para PAE en Gentoo, debemos recompilar el kernel con la opción de “High memory support” activada. Para ello, ejecutamos

server ~ # cd /usr/src/linux
server linux # make menuconfig

Encontraremos esta configuración bajo Processor type and features —> High Memory Support:

Processor type and features  --->
 High Memory Support  --->
  ( ) off
  ( ) 4GB
  (X) 64GB

La opción de 64GB activa el soporte para PAE. Luego de seleccionada, debemos recompilar el kernel, y reiniciar el sistema utilizando este nuevo kernel.

Habilitar PAE en CentOS, Fedora y similares

En estos sabores de Linux podemos habilitar el soporte para PAE instalando “kernel-PAE” utilizando el comando yum:

# yum install kernel-PAE

Luego de instalado, debemos reiniciar el sistema utilizando este nuevo kernel.

¿PAE o sistema operativo de 64 bits?

Creo que la desición de utilizar un sistema operativo de 32 bits con PAE habilitado o de utilizar uno de 64 bits va un poco más allá de la dificultad o facilidad técnica de utilizar uno u otro; como generalmente pasa, “depende” será la mejor respuesta a la hora de hacernos esa pregunta:

• Como primer punto, dependerá del tipo de aplicaciones que se vayan a correr, teniendo en cuenta especialmente si existen versiones optimizadas para CPUs de 64 bits. Si nos estamos planteando este cambio en un servidor de base de datos o de procesamiento multimedia, es muy posible que veamos incrementos de performance con un sistema operativo de 64 bits, ya sea porque aprovechan los registros más grandes, los registros adicionales, las nuevas instrucciones de 64 bits o los espacios de direccionamiento de memoria para los procesos mucho más grandes (pasan de 4GB a 1TB).
• Por otro lado, también hay que poner en la balanza que una aplicación compilada para 64 bits va a ocupar más espacio en disco y más memoria, por tener que manejar variables y punteros del doble de tamaño. Este incremento en el tamaño repercute en un incremento en el ancho de banda ocupado entre el CPU y la memoria, que a su vez puede repercutir en una degradación de performance si no es bien aprovechado.
• El no tener drivers de 64 bits para los dispositivos de nuestro sistema puede ser una razón de peso bastante importante para no poder pasarnos de arquitectura de 64 bits. También puede pasar que los drivers de 32 bits no funcionen bien con PAE habilitado.
• Si tenemos un sistema Linux de 32 bits corriendo hace tiempo, aplicaciones instaladas, configuraciones personalizadas, etc. hay que ver si vale la pena reinstalar todo de cero para pasarnos a un sistema de 64 bits y aprovechar un poco más de RAM (si tenemos 4GB instalados, pasarmos a ver unos 800MB adicionales, menos el incremento de uso de memoria de las aplicaciones que vimos 2 puntos más arriba). En mi caso, cambiar el kernel de Ubuntu para aprovechar los 4GB completos implicó unos minutos bajando e instalando el paquete, y una reiniciada al sistema. Hasta ahora no he tenido problemas utilizando 32 bits con PAE.
• Como último punto, el no poder pasar a sistemas de 64 bits por política organizacional también puede ser una respuesta válida a la pregunta. Si tenemos licencias de algunas aplicaciones que puedan tener problemas o directamente no corran en un servidor de 64 bits, la desición está tomada antes de plantearla (especialmente si estamos hablando de costos elevados o de aplicaciones críticas para el negocio de la organización).

Referencias

• http://www.microsoft.com/whdc/system/platform/server/PAE/PAEdrv.mspx
• http://www.microsoft.com/whdc/system/platform/server/PAE/pae_os.mspx
• http://es.wikipedia.org/wiki/Extensi%C3%B3n_de_direcci%C3%B3n_f%C3%ADsica
• http://en.wikipedia.org/wiki/PAE
• http://support.microsoft.com/kb/929605/en-us

Posts relacionados:

1. Hotkeys del símbolo de sistema de Windows
2. UnxUtils: ejecutar comandos Linux/UNIX en Windows
3. Ejecutar aplicaciones gráficas de X11 (Linux y Unix) en Windows
4. Monitoreo en Linux: nmon

killall -9 java

logramos parte de nuestro cometido (matar el proceso), pero seguramente nos traiga más problemas que soluciones, ya que matamos TODAS las máquinas virtuales java corriendo al momento de ejecutar el comando.

Podemos hacerlo de forma manual, haciendo un

ps -fea |grep java

para luego seleccionar el PID (process id) correspondiente a nuestro proceso, tomando en cuenta la clase que inicia el proceso, el classpath utilizado o los parámetros de inicio y luego invocando el comando kill -9 PID.

Si vamos a matar un cierto proceso java bastante seguido, podemos crearnos un shell script que se tome el trabajo de buscar el proceso y matar únicamente al que nosotros querramos.

A este script únicamente le debemos configurar la variable MAIN_CLASS, que contendrá el nombre de la clase que contiene el método main (clase que inicia nuestra aplicación). Basándose en éste nombre, el script buscará todos los procesos que contengan ese nombre en la línea de comandos, extraerá el PID de las líneas que filtró, y ejecutará un kill -9 para cada proceso.

El script entonces, es el siguiente:

#!/bin/bash
# Nombre del binario
MAIN_CLASS=com.josearrarte.demo.MainClass

# Cantidad de reintentos para matarlo
CNT_INTENTOS=5

# Funcion para matar el proceso
matar(){
INTENTO=1

while [ `ps -ef --cols=5000 |grep -v "grep"| grep -c ${MAIN_CLASS}` -gt 0 ] && [ ${INTENTO} -le ${CNT_INTENTOS} ]; do
  ps -ef --cols=5000 |grep -v "grep"| grep ${MAIN_CLASS}|awk '{ print $2 }'|xargs -i{} kill -9 {} > /dev/null 2> /dev/null
  INTENTO=$(( ${INTENTO} + 1 ))
done
}

matar

Queda abierta la sección de comentarios para proponer mejores formas de matar procesos java.

Posts relacionados:

1. Matar procesos en Windows (taskkill)
2. Audio y video en Java utilizando ffmpeg, Jffmpeg, y JMF
3. Crear un nuevo proyecto Java con Maven
4. Array de bytes y la clase java.nio.ByteBuffer
5. “Unmappable character for encoding UTF-8″ al compilar proyectos Java con Maven

NMon (por Nigel’s MONitor) es un sistema de monitoreo para Linux y AIX. Nos permite ver en pantalla los diferentes indicadores de nuestro sistema, o hacerlo de forma no interactiva guardando todos los datos a un CVS para luego procesar y graficar los datos recabados.

No lo probé en AIX, pero en Linux corre sobre SLES9, SLES10, RHEL, Knoppix, Debian, Fedora, Ubuntu y hasta Gentoo con la versión anterior a la actual. Tiene soporte para las distribuciones x86, y para algunas distribuciones x86_64 y POWER.

Es gratis, muy simple de instalar (hay ejecutables para las diferentes distribuciones) y si bien no tiene soporte oficial por parte de IBM, está disponible para bajar desde la wiki de AIX de IBM.

Entre otros, tiene soporte para monitorear los siguientes datos de un sistema:

• Uso de CPU
• Uso de memoria
• Estadísticas del kernel y de la cola de ejecución de procesos
• I/O, transferencias, y tasas de lectura/escritura de los discos
• Espacio libre en file systems
• I/O, transferencias, y tasas de lectura/escritura de las interfaces de red
• Paginado de memoria
• Network File System (NFS)

Instalación

No tiene mayores dificultades, debemos bajar un archivo comprimido de aquí, dependiendo de nuestro hardware y versión del sistema operativo. Descomprimimos el archivo, damos permisos de ejecución (chmod +x) al ejecutable que concuerde con nuestra distribución de Linux/AIX y listo.

Uso interactivo

Si usamos NMon de forma interactiva, al ejecutarlo en una terminal veremos una pantalla similar a la siguiente:

+nmon-12a---------------------Hostname=server-vm----Refresh= 2secs ---09:45.39-+
¦                                                                              ¦
¦  ------------------------------       For help type H or ...                 ¦
¦  #    #  #    #   ####   #    #        nmon -?  - hint                       ¦
¦  ##   #  ##  ##  #    #  ##   #        nmon -h  - full                       ¦
¦  # #  #  # ## #  #    #  # #  #                                              ¦
¦  #  # #  #    #  #    #  #  # #       To start the same way every time       ¦
¦  #   ##  #    #  #    #  #   ##        set the NMON ksh variable             ¦
¦  #    #  #    #   ####   #    #                                              ¦
¦  ------------------------------                                              ¦
¦                                                                              ¦
¦  Use these keys to toggle statistics on/off:                                 ¦
¦     c = CPU        l = CPU Long-term   - = Faster screen updates             ¦
¦     m = Memory     j = Filesystems     + = Slower screen updates             ¦
¦     d = Disks      n = Network         V = Virtual Memory                    ¦
¦     r = Resource   N = NFS             v = Verbose hints                     ¦
¦     k = kernel     t = Top-processes   . = only busy disks/procs             ¦
¦     h = more options                   q = Quit                              ¦
¦------------------------------------------------------------------------------¦

En la misma nos muestra las teclas de uso más comunes (con h nos muestra la lista completa):

¦ HELP ------------------------------------------------------------------------¦
¦     key  --- statistics which toggle on/off ---                              ¦
¦     h = This help information                                                ¦
¦     r = RS6000/pSeries CPU/cache/OS/kernel/hostname details + LPAR           ¦
¦     t = Top Process Stats 1=basic 3=CPU                                      ¦
¦         u = shows command arguments (hit twice to refresh)                   ¦
¦     c = CPU by processor             l = longer term CPU averages            ¦
¦     m = Memory and Swap  stats       j = JFS Usage Stats                     ¦
¦     n = Network stats                N = NFS                                 ¦
¦     d = Disk I/O Graphs D=Stats      o = Disks %Busy Map                     ¦
¦     k = Kernel stats & loadavg       V = Virtual Memory                      ¦
¦     g = User Defined Disk Groups [start nmon with -g <filename>]             ¦
¦     v = Verbose Simple Checks - OK/Warnings/Danger                           ¦
¦     b = black & white mode                                                   ¦
¦     --- controls ---                                                         ¦
¦     + and - = double or half the screen refresh time                         ¦
¦     q = quit                     space = refresh screen now                  ¦
¦     . = Minimum Mode =display only busy disks and processes                  ¦
¦     0 = reset peak counts to zero (peak = ">")                               ¦
¦     Developer Nigel Griffiths                                                ¦
¦------------------------------------------------------------------------------¦

A continuación veremos la salida de las opciones que a mi entender resultan más útiles:

Estadísticas del kernel (tecla k)

¦ Kernel Stats ----------------------------------------------------------------¦
¦ RunQueue             -1   Load Average    CPU use since boot time            ¦
¦ ContextSwitch       0.0    1 mins  0.71    Uptime Days=  0 Hours= 6 Mins=57  ¦
¦ Forks               0.0    5 mins  0.34    Idle   Days=  0 Hours= 6 Mins=45  ¦
¦ Interrupts        713.0   15 mins  0.16    Average CPU use=  2.83%           ¦
¦------------------------------------------------------------------------------¦

Uso de CPU (tecla c)

En esta gráfica con forma de barras horizontales, las U representan el tiempo de usuario, las s el tiempo de sistema y las w el wait time. Los > registran los picos de CPU.

¦ CPU Utilisation -------------------------------------------------------------¦
¦                           +-------------------------------------------------+¦
¦CPU  User%  Sys% Wait% Idle|0          |25         |50          |75       100|¦
¦ 1  53.6  31.4   0.0   14.9|UUUUUUUUUUUUUUUUUUUUUUUUUUsssssssssssssss >      |¦
¦ 2  54.0  19.5   0.0   26.5|UUUUUUUUUUUUUUUUUUUUUUUUUUUsssssssss >           |¦
¦                           +-------------------------------------------------+¦
¦Avg 53.8  25.3   0.0   21.0|UUUUUUUUUUUUUUUUUUUUUUUUUUssssssssssss >         |¦
¦                           +-------------------------------------------------+¦
¦------------------------------------------------------------------------------¦

Uso de memoria (tecla m)

¦ Memory Stats ----------------------------------------------------------------¦
¦                RAM     High      Low     Swap                                ¦
¦ Total MB      3012.8     -0.0     -0.0   2055.1                              ¦
¦ Free  MB        19.1     -0.0     -0.0   2055.1                              ¦
¦ Free Percent     0.6%   100.0%   100.0%   100.0%                             ¦
¦             MB                  MB                  MB                       ¦
¦                      Cached=  2301.9     Active=  1717.3                     ¦
¦ Buffers=   141.9 Swapcached=     0.0  Inactive =   962.1                     ¦
¦ Dirty  =     3.6 Writeback =     0.0  Mapped   =  1346.4                     ¦
¦ Slab   =    89.7 Commit_AS =   906.5 PageTables=    19.2                     ¦
¦------------------------------------------------------------------------------¦

Estadísticas de red (tecla n)

¦ Network I/O -----------------------------------------------------------------¦
¦I/F Name Recv=KB/s Trans=KB/s packin packout insize outsize Peak->Recv Trans  ¦
¦    lo     8.6     8.6      37.0     37.0   238.6  238.6     1234.6  1234.6   ¦
¦  eth0    44.3  1420.2     613.9   1140.8    73.8 1274.8       44.3  1420.2   ¦
¦vmnet1     0.0     0.0       0.0      0.0     0.0    0.0        0.0     0.0   ¦
¦vmnet8     0.0     0.0       0.0      0.0     0.0    0.0        0.0     0.0   ¦
¦------------------------------------------------------------------------------¦

Estadísticas de disco (teclas D y d)

Con la tecla d nos presenta la información de forma tabular:

¦ Disk I/O -----(/proc/diskstats)--------all data is Kbytes per second---------¦
¦DiskName Busy    Read    Write       Xfers   Size  Peak%  Peak-RW    InFlight ¦
¦sda        0%      0.0     48.0KB/s    6.5   7.0KB   13%    1883.9KB/s   0   |¦
¦sda1       0%      0.0     48.0KB/s    6.5   7.0KB   12%    1883.9KB/s   0   |¦
¦sdb       39%  14864.6     24.0KB/s  115.9 128.0KB  100%  126938.8KB/s   1   |¦
¦sdb1       0%      0.0      0.0KB/s    0.0   0.0KB    0%       0.0KB/s   0   |¦
¦sdb2      33%  14652.7     24.0KB/s  101.4 144.0KB  100%  124939.1KB/s   1   |¦
¦sdb3       6%    211.9      0.0KB/s   14.5  14.0KB   13%    1999.6KB/s   0   |¦
¦fd0        0%      0.0      0.0KB/s    0.0   0.0KB    0%       0.0KB/s   0   |¦
¦------------------------------------------------------------------------------¦

Con la tecla D nos presenta la información en forma de gráfica de barras horizontal. De forma similar a la gráfica de uso de CPU, las W representan escrituras en disco, las R lecturas en disco y los > registran los picos de transferencia:

¦ Disk I/O -----(/proc/diskstats)--------all data is Kbytes per second---------¦
¦DiskName Busy  Read WriteKB|0          |25         |50          |75       100|¦
¦sda        0%    0.0    4.0|      >                                          |¦
¦sda1       0%    0.0    4.0|     >                                           |¦
¦sdb       43% 1916.5  393.7|WWWWRRRRRRRRRRRRRRRRRRR                          |¦
¦sdb1       0%    0.0    0.0|>                                                |¦
¦sdb2      30% 1688.7  393.7|WWWRRRRRRRRRRRRR                                 |¦
¦sdb3      13%  227.8    0.0|RRRRRR>                                          |¦
¦fd0        0%    0.0    0.0|>                                                |¦
¦------------------------------------------------------------------------------¦

Verbose Simple Checks (tecla d)

+nmon-12a---------------------Hostname=server-vm----Refresh= 2secs ---23:46.50-+
¦ Verbose Mode ----------------------------------------------------------------¦
¦ Code    Resource            Stats   Now        Warn    Danger                ¦
¦     OK -> CPU               %busy   5.2%       >80%    >90%                  ¦
¦     OK -> Top Disk          %busy   0.0%       >40%    >60%                  ¦
¦------------------------------------------------------------------------------¦

Capturar datos para análisis posterior

Si queremos capturar datos para posterior análisis, utilizamos la opción -f. La opción -s configura el período de muestreo, y la opción -c la cantidad de muestreos.

Por ejemplo, para obtener muestras cada 30 segundos durante una hora (120 muestras), ejecutamos:

nmon -f -s 30 -c 120

Esto genera un archivo con nombre hostname_date_time.nmon con formato CSV, que luego puede ser interpretado por el NMon analyser. Por más info, ver la wiki de NMon analyser y la ayuda de NMon.

Referencias

Wiki de NMon
Wiki de NMon analyser
nmon performance: A free tool to analyze AIX and Linux performance
NMon en Wikipedia

Posts relacionados:

1. Monitoreo en linux: top

Sintaxis

La sintaxis del comando, con las opciones más relevantes es las sigiuente:

scp [-p] [-v] [-r] [-C] [-i identity_file] [[username@]host:]file ... [[username@]host:]file_or_dir

Las descripción de las opciones es la siguiente:

• -p: preserva las fechas de modificación, acceso y modo del archivo original.
• -v: verbose mode. Habilita mensajes de debug para diagnosticar problemas de conexión, autenticación o configuración.
• -r: modo recursivo al copiar directorios (copia también los subdirectorios)
• -C: habilita la compresión en la conexión SSH
• -i identity_file: selecciona el archivo desde el cual se lee una clave privada. Esta clave privada se pasa a SSH a la hora de establecer la conexión

Ejemplos de uso

Enviar un archivo a un host remoto

scp archivo.txt usuario@host:/ruta/de/destino/archivoDestino.txt

Envía archivo.txt a host, a la ruta /ruta/de/destino, y lo graba con el nombre archivoDestino.txt. La conexión se establecerá utilizando el nombre de usuario especificado, y el dueño del archivo en el host será el utilizado en la conexión.

scp archivo.txt usuario@host:archivoDestino.txt

Si no se especifica la ruta de destino, se copiará al directorio del usuario especificado (/home/usuario).

scp archivo.txt host:archivoDestino.txt

Si no se especifica un usuario remoto, utilizará el nombre con el que estamos logueados actualmente en el host local.

Copiar un archivo desde un host remoto

scp usuario@host:/ruta/archivoRemoto.txt ./archivo.txt

Copia archivoRemoto.txt del host remoto a mi directorio actual, y lo nombramos archivo.txt.

scp usuario@host:archivoRemoto.txt ./

Copia archivoRemoto.txt ubicado en el home de usuario del host remoto a mi ubicación actual.

Copiar un directorio entero hacia un host remoto

scp -r dirLocal usuario@host:/ruta/de/destino/

Este comando copia el directorio dirLocal a /ruta/de/destino en el host remoto, conectándonos como usuario. El directorio de destino ya debe de existir.

Otra opción es crear un archivo tar o tar comprimido (.tar.gz), copiar ese único archivo y descomprimirlo en el destino.

Copiar un directorio entero desde un host remoto

scp -r usuario@host:/ruta/dirRemoto/ /tmp/

Copia el directorio /ruta/dirRemoto ubicado en el host remoto, y lo copia en el directorio local /tmp

Copiar un archivo entre hosts remotos

Otra de las posiblidades del comando SCP es copiar un archivo (o directorio, similar a los ejemplos antes mostrados) desde un host remoto a otro host remoto.

scp usuario1@host1:/ruta/en/host1/archivoHost1.txt usuario2@host2:/ruta/en/host2/archivoHost2.txt

En este ejemplo, usuario1 es un usuario de host1, mientras que usuario2 es un usuario de host2.

Uso desde Windows

Si necesitamos copiar archivos o directorios desde un ambiente Windows podemos utilizar la excelente aplicación WinSCP, que nos provee una interfaz gráfica para mover, copiar, renombrar, cambiar permisos, etc. Su interfaz es muy intuitiva, y nos permite visualizar el contenido local y remoto con dos paneles al estilo Norton Commander o con otro estilo más parecido al explorador de Windows.

Posts relacionados:

1. Copiar archivo y particiones utilizando dd (Linux/UNIX)
2. Descargar archivos de sitios de file-sharing por consola en Linux
3. UnxUtils: ejecutar comandos Linux/UNIX en Windows
4. Audio y video en Java utilizando ffmpeg, Jffmpeg, y JMF
5. Ejecutar aplicaciones gráficas de X11 (Linux y Unix) en Windows

top - 16:26:10 up  2:53,  1 user,  load average: 0.01, 0.01, 0.00
Tasks:  46 total,   2 running,  44 sleeping,   0 stopped,   0 zombie
Cpu(s):  0.3%us,  0.3%sy,  6.0%ni, 93.0%id,  0.3%wa,  0.0%hi,  0.0%si,  0.0%st
Mem:    252692k total,   248656k used,     4036k free,    19440k buffers
Swap:   506036k total,       44k used,   505992k free,   188384k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND
 3365 p2p       39  19 42560  21m 4716 S  6.3  8.9   3:32.54 mlnet
 4076 root      20   0  2324 1120  888 R  0.3  0.4   0:00.11 top
    1 root      20   0  1656  496  456 S  0.0  0.2   0:00.38 init
    2 root      15  -5     0    0    0 S  0.0  0.0   0:00.00 kthreadd
    3 root      15  -5     0    0    0 S  0.0  0.0   0:00.00 ksoftirqd/0
    4 root      15  -5     0    0    0 S  0.0  0.0   0:00.00 events/0
    5 root      15  -5     0    0    0 S  0.0  0.0   0:00.03 khelper
  163 root      15  -5     0    0    0 S  0.0  0.0   0:00.00 kblockd/0

Resumen del estado del sistema

En la primer línea tenemos la fecha y hora actual, la cantidad de usuarios utilizando el sistema y la carga del sistema del último minuto, de los últimos 5 minutos y de los últimos 15 minutos respectivamente. Cómo se calcula el load average es un tema en sí mismo, pero básicamente es el promedio de la cantidad de procesos corriendo o prontos para correr en cierto período de tiempo.

Lo que tenemos que saber que a mayor load average, mayor uso de procesador. Un load average de 0 indica que el procesador ha sido muy poco utilizado en ese período de tiempo, mientras que si es mayor, significa que hay más procesos corriendo y prontos para correr que lo que el(los) core(s) pueden procesar. Un load average igual a la cantidad de cores indica un uso óptimo del CPU.  Más info acá y acá.

En la segunda línea (Tasks) tenemos la cantidad de procesos y una agregación según el estado de cada uno. Los diferentes estados que muestra son los siguientes:

• Running: procesos corriendo actualmente, o listos para correr en cuanto se les asigne tiempo de CPU.
• Sleeping: el proceso está dormido esperando que ocurra un evento para volver al estado “running”.
• Stopped: La ejecución del proceso está parada; no está corriendo, y no va a volver a correr. Los procesos generalmente entran en este estado cuando reciben señales que no están manejando, y la acción por defecto de las mismas es pasar el proceso a stopped. Esto incluye señales como SIGSTOP, SIGTSTP, SIGTTIN, y SIGTTOU. Una señal de tipo SIGCONT saca al proceso de este estado (ver el comando fg). Con Ctrl+Z mandamos el proceso corriendo en la terminal al background, pasando a estado stopped.
• Zombie: El proceso tampoco está corriendo. Los procesos quedan en este estado cuando su el proceso que los inició murió, ya sea por un error de programación o porque fue matado (ver kill -9).

La tercera línea nos da los porcentajes de uso de procesador, discriminado por “tipo” de uso. Los diferentes tipos significan lo siguiente:

• us: tiempo de procesos de usuario
• sy: tiempo de procesos del sistema (kernel)
• ni: tiempo de procesos del usuario que tienen un “nice” positivo
• wa: tiempo en el cual los procesos están esperando por pedidos de I/O pendientes.
• id: tiempo “idle”, en que no hay procesos requiriendo tiempo de procesador, y tampoco hay pedidos de I/O pendientes.
• st: “steal time”, sólo aplica cuando nuestro Linux corre en una máquina virtual. Es el tiempo que algún proceso de nuestro sistema estaba esperando en la cola de ejecución, pero el hypervisor eligió no darnos tiempo de procesador, y asignarlo a otro procesador virtual.

Si presionamos la tecla ‘1’, top nos muestra las estadísticas de uso discriminado por cada core/procesador:

top - 18:57:22 up 12 days,  5:09,  1 user,  load average: 0.03, 0.03, 0.00
Tasks: 174 total,   1 running, 173 sleeping,   0 stopped,   0 zombie
Cpu0  :  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Cpu1  :  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Cpu2  :  0.0%us,  0.3%sy,  0.0%ni, 99.7%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Cpu3  :  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Cpu4  :  0.0%us,  0.3%sy,  0.0%ni, 99.7%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Cpu5  :  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Cpu6  :  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Cpu7  :  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st

La línea siguiente (Mem) detalla las estadísticas de uso de memoria. En ella vemos la memoria total, la memoria utilizada, la memoria libre y la memoria utilizada por como buffers.

Mem:    252692k total,   248656k used,     4036k free,    19440k buffers

La última de las líneas del resumen (Swap) detalla el uso del espacio de swap. Indica cuánto es el espacio de swap total, cuánto está utilizado, cuánto libre y cuánto está siendo utilizado por páginas cacheadas

Swap:   506036k total,       44k used,   505992k free,   188384k cached

Lista de procesos

Luego del resumen del uso de los recursos del sistema top lista los procesos activos, ordenándolos según el uso de procesador.

Las columnas tienen el siguiente significado:

• PID: Process ID
• USER: usuario que inició el proceso
• PR: prioridad del proceso
• NI: nice value. Un valor negativo significa mayor prioridad (hasta -20), un valor positivo, menor prioridad (hasta 19)
• VIRT: Cantidad de memoria virtual utilizada por el proceso (incluyendo datos, código, shared libraries y swap)
• RES: Cantidad de memoria RAM física que el proceso está utilizando
• SHR: Cantidad de memoria compartida. Refleja la memoria que potencialmente podría ser compartida con otros procesos.
• S: Status del proceso. Los posibles estados son ‘D’ (uninterruptible sleep), ‘R’ (running),  ‘S’ (sleeping), ‘T’ (traced o stopped) o ‘Z’ (zombie).
• %CPU: porcentaje de CPU utilizado desde la última actualización de la pantalla.
• %MEM: porcentaje de memoria física utilizada por el proceso
• TIME+: Tiempo total de CPU que el proceso ha utilizado desde que se inició.
• COMMAND: comando utilizado para iniciar el proceso.

Se pueden agregar, quitar o cambiar el orden de estas columnas con las teclas f y o.

Interacción con top

Podemos utilizar las siguientes teclas para interactuar con top:

• M – Ordenar por uso de memoria
• P – Ordenar por uso de CPU
• T – Ordenar por tiempo de CPU utilizado
• F – seleccionar campo por el cual ordenar la lista de procesos
• i  – mostrar u ocultar procesos idle y zombie
• m, l, t, 1 – muestra u oculta las líneas del resumen (parte de arriba)
• f, o – agregar/quitar columnas, cambiar el orden
• s – cambia el tiempo de actualización de la pantalla (por defecto, 3 segundos)
• z – Colores
• k – Matar un proceso (luego pregunta el PID)
• r – “renice” cambia el nice value de un proceso (luego pregunta el PID)
• q – finalizar
• h – ayuda

Hay algunas más, que se pueden ver en la ayuda del comando o en las man pages.

Referencias

http://www.kernelhardware.org/linux-top-command/

http://www.unix.com/unix-dummies-questions-answers/10157-top-shows-stopped-process.html

http://foros.hackerss.com/lofiversion/index.php/t3914.html

man top

Posts relacionados:

1. Monitoreo en Linux: nmon

Supongamos que queremos implementar un reproductor multimedia en Java. Si a priori no conocemos los codecs de audio o video que debemos soportar, o si simplemente no existe una implementación de ese codec en Java, podemos interactuar con ffmpeg para reproducir multimedia en un montón de formatos diferentes. Para ello podemos utilizar JMF, Jffmpeg del lado del “mundo Java” interactuando con ffmpeg del lado del “mundo nativo”.

ffmpeg es una solución muy completa, open source y multi plataforma para grabar, convertir y reproducir audio y video. El proyecto está licenciado bajo LGPL o GPL (dependiendo de la configuración).

JMF (Java Media Framework) es una API  que permite agregar audio y video a nuestras aplicaciones y applets implementadas sobre tecnología Java. Además de reproducir, JMF nos permite capturar, transcodificar o hacer streaming en varios formatos.

Jffmpeg es el puente entre ffmpeg y JMF. Si bien JMF soporta algunos formatos, eventualmente nos cruzaremos con el mensaje de error “Unable to handle format:…”, especialmente al intentar reproducir los formatos más nuevos. Este plugin de JMF un wrapper Java que utiliza JNI para hacer las llamadas directas al código nativo de ffmpeg.

Instalación en Linux

Vamos a instalar y configurar las diferentes partes de la solución para poder reproducir video en Linux. Quizá el post tienda a compilar todo y configurar “a mano”, es debido a que documenta la necesidad de reproducción de pautas publicitarias en un NLPOS, un flavour de Linux de Novell bastante recortado y orientado a puntos de venta.

1. Instalación de ffmpeg

Como primer punto, compilaremos e instalaremos ffmpeg a partir del código fuente. Tenemos varias opciones: hacer un checkout de SVN, hacer un GIT clone, o bajarnos el código de la última versión estable. Para cualquier opción, contamos con lo que necesitamos aquí.

Es una buena idea instalar codecs externos para luego poder integrarlos con ffmpeg. Entre estos codecs externos tenemos a LAME para MPEG Audio Layer III,  AMR para 3GPP y xvid para los estándares MPEG-4 Simple Profile and Advanced Simple Profile.

La primer parte de este link nos muestra cómo instalar los diferentes tanto los codecs externos como ffmpeg.

Para la instalación más básica, sin codecs externos, basta con hacer un

./configure

en el directorio en donde está ubicado el código de ffmpeg, luego un

make

y finalmente, con permisos de root un

make install

En distribuciones de Linux más “modernas”  seguramente tengamos la opción de instalar ffmpeg desde repositorios de paquetes, sin la necesidad de compilarlo a mano.

2. Instalación de JMF

JMF no tiene mucha ciencia para instalarlo, simplemente bajamos el instalador de aquí y lo corremos en el directorio que queramos instalarlo. Yo lo ejecuté desde /usr/lib para que JMF quede en /usr/lib/JMF-2.1.1e/ (llamaremos ${JMF_HOME} al directorio de instalación), pero no repercute en el funcionamiento. Debemos recordar que ${JMF_HOME}/lib/jmf.jar deberá estar en el classpath de nuestra aplicación.

3. Instalación de Jffmpeg

Jffmpeg tampoco da muchas dificultades para instalarlo. Podemos bajar el JAR y el .so (o .dll) de aquí, y descomprimirlos en el directorio que nos resulte más cómodo. Lo que debemos tener en cuenta después, es que el JAR deberá estar en el classpath de nuestra aplicación, y el .so en LD_LIBRARY_PATH, o configurado en el path de las librerías de Linux.

Llamaremos ${JFFMPEG_HOME} al directorio en donde tenemos el JAR y el .so.

4. Classpath, LD_LIBRARY_PATH, etc.

Tanto las librerías nativas como los JARs de JMF y Jffmpeg deberán estar referenciadas por nuestra aplicación para ser tenidas en cuenta.

Para los JARs basta con agregarlos a una variable de entorno que luego se referenciará en el classpath de nuestra aplicación.

Para las librerías nativas podemos agregar un archivo de extensión conf en /etc/ld.so.conf.d/ que contenga una línea para cada directorio que deba ser considerado al buscar las librerías.

La otra opción es agregar los directorios a la variable de entorno LD_LIBRARY_PATH. Esta variable contiene una lista de directorio separados por coma, la cual es utilizada por el sistema operativo para buscar librerías antes de recurrir al conjunto predeterminado de directorios.

Si no queremos definir este conjunto de variables a mano, podemos editar el archivo ~/.bashrc agregando las siguientes líneas (quizá las rutas no sean las que correspondan):

# cat ~/.bashrc

export JMF_HOME=/usr/lib/JMF-2.1.1e
export JFFMPEG_HOME=/root/jffmpeg
export CLASSPATH=$ JMF_HOME /lib/jmf.jar:$JFFMPEG_HOME/jffmpeg-1.1.0.jar:.:$CLASSPATH
export LD_LIBRARY_PATH=$ JMF_HOME /lib:$JFFMPEG_HOME:${LD_LIBRARY_PATH}
export JAVA_HOME=/usr/java/jdk1.6.0_14

5. Registro de los codecs

Para agregar los codecs de Jffmpeg en JMF utilizaremos la herramienta JMFRegistry que viene con el Java Media Framework. Podemos ejecutarlo por consola tipeando “java JMFRegistry” o desde las preferencias del JMStudio, otra herramienta de JMF que hace de Media Player.

Para cada cambio que listamos a continuación, debemos hacer clickear el botón de commit.

En la pestaña de “Mime types” registramos las siguientes extensiones:

1. video/vob -> vob
2. audio/ogg -> ogg

Bajo la pestaña “Plugins” registramos los siguientes “Demultiplexers”:

1. net.sourceforge.jffmpeg.demux.vob.VobDemux
2. net.sourceforge.jffmpeg.demux.ogg.OggDemux

Y bajo la pestaña “Codec” registramos los siguientes codecs:

1. net.sourceforge.jffmpeg.VideoDecoder
2. net.sourceforge.jffmpeg.AudioDecoder

6. Parámetros de la aplicación

Como último paso, debemos recordar agregar ya sea la variable $CLASSPATH al classpath de nuestra aplicación, o cada JAR por separado (${JMF_HOME}\lib\jmf.jar,   ${JFFMPEG_HOME}\jffmpeg-1.1.0.jar).

Conclusión

Si bien no es “soplar y hacer botellas”, en Java tenemos la posibilidad de agregar contenido multimedia a nuestras aplicaciones o applets utilizando la potencialidad que nos dan los codecs implementados como código nativo al sistema operativo.

En este post vimos un ejemplo en instalación y configuración en Linux; la configuración en Windows no es demasiado diferente.

Referencias

http://jffmpeg.sourceforge.net/download.html

http://downloads.xvid.org/downloads/xvidcore-1.2.2.tar.bz2

http://java.sun.com/javase/technologies/desktop/media/jmf/2.1.1/download.html

http://www.ffmpeg.org/

http://jffmpeg.sourceforge.net/

http://www.hiteshagrawal.com/ffmpeg/installing-ffmpeg-easily-on-linux

http://www.elctech.com/articles/installing-ffmpeg-with-faac-and-x264-encoders-from-source-on-ubuntu

http://www.luniks.net/luniksnet/html/java/jtvd/doc/jmf.html

http://tldp.org/HOWTO/Program-Library-HOWTO/shared-libraries.html

Posts relacionados:

1. Seleccionar y matar un proceso java determinado
2. Generación del manifest de un JAR utilizando Maven
3. Crear un nuevo proyecto Java con Maven