Instalación de PNP4Nagios en Debian Wheezy

Complementando mi anterior artículo, en el que explicaba cómo instalar Nagios en Debian, ahora es el momento de instalar PNP4Nagios, un addon para Nagios que sirve para analizar los datos de rendimiento proporcionados por los plugins y almacenarlos en bases de datos RRD (Round Robin Databases).

Debian ya incluye PNP4Nagios en sus repositorios oficiales, así que lo instalaremos usando apt:

# aptitude install pnp4nagios

Lo siguiente será leer el archivo /usr/share/doc/pnp4nagios/README.Debian del paquete pnp4nagios, donde nos recomiendan usar bulk mode y será el que yo utilice. Para configurar este modo bulk seguimos los siguientes pasos:

  1. Habilitar NPCD: Editar el archivo /etc/default/npcd y establecer RUN=”yes”
  2. Habilitar “process_performance_data”: Editar el archivo /etc/nagios3/nagios.cfg y establacer process_performance_data=1
  3. Registrar “broker_module”: Editar el archivo /etc/nagios3/nagios.cfg y establecer broker_module=/usr/lib/pnp4nagios/npcdmod.o config_file=/etc/pnp4nagios/npcd.cfg
  4. Ejecutar NPCD: /etc/init.d/npcd start (si éste no ha sido iniciado ya)
  5. Recargar Nagios: /etc/init.d/nagios reload

Para ver las gráficas generadas, entramos en la siguiente URL: http://localhost/pnp4nagios/

Si queremos crear enlaces a PNP4Nagios en la interfaz de Nagios para cada uno de nuestros hosts y services configurados, tenemos que configurar la propiedad action_url de estos hosts y services. Para no configurarlos uno a uno, se puede optar por configurar las plantillas (templates).

Para los hosts, editamos la definición de plantilla para generic-host (/etc/nagios3/conf.d/generic-host_nagios2.cfg o el que corresponda) y agregamos la siguiente línea: action_url  /pnp4nagios/graph?host=$HOSTNAME$

Para los services, editamos la definición de plantilla para generic-service (/etc/nagios3/conf.d/generic-service_nagios2.cfg o el que corresponda) y agregamos la siguiente línea: action_url  /pnp4nagios/graph?host=$HOSTNAME$&srv=$SERVICEDESC$

Con estos cambios, ahora veremos un nuevo icono que nos enlaza a las gráficas del correspondiente HOST o SERVICE, tal como podemos ver en las siguientes capturas:

PNP4Nagios01 PNP4Nagios02

Instalación de Nagios 3.4.1 en Debian Wheezy

Vamos a ver cómo instalar Nagios en Debian. He utilizado la última versión estable de Debian actualmente: Debian Wheezy.

Podemos instalar Nagios usando los repositorios oficiales de Debian o hacerlo descargando las fuentes desde la web de descargas de Nagios. En mi caso he optado por lo más sencillo, usar los repositorios de Debian, así que lo único que debemos hacer es instalar el paquete nagios3 usando apt o aptitude.

# aptitude install nagios3

En total se instalan 156 paquetes por las dependencias, entre las que se incluyen apache2, exim4 y nagios-plugins.

La instalación es muy sencilla. Lo único que nos pide es la contraseña del usuario nagiosadmin, que necesitaremos para acceder a la interfaz web una vez terminada la instalación.

http://localhost/nagios3/

Configurar escáner Genius ColorPage-Vivid 1200XE en Ubuntu 12.04

Hoy he necesitado escanear un par de documentos y he comprobado que Ubuntu tiene una aplicación llamada Simple Scan que es muy sencillita. He probado con el comando lsusb para comprobar que lo detectaba:

$ lsusb
Bus 007 Device 004: ID 0458:201f KYE Systems Corp. (Mouse Systems) ColorPage-Vivid 1200 XE

Lo detecta perfectamente.

Luego he probado a ejecutar la herramienta scanimage y me da el siguiente error:

$ scanimage
[gt68xx] Couldn’t open firmware file (`/usr/share/sane/gt68xx/CCD569.fw’): Permission denied
scanimage: open of device gt68xx:libusb:007:004 failed: Invalid argument

Buscando… veo que hay que copiar el archivo CCD569.fw a ese directorio. Pero, ¿de dónde saco ese archivo? Aprovechando que lo tenía instalado en Windows 7, lo encuentro en C:\Program Files\ScannerU\CCD569.fw. Lo copio en el directorio anterior y a escanear!

$ sudo mkdir -p /usr/share/sane/gt68xx
$ sudo cp /media/windows/Program\ Files/ScannerU/CCD569.fw /usr/share/sane/gt68xx
$ sudo chmod 666 /usr/share/sane/gt68xx/CCD569.fw
$ scanimage
scanimage: output is not a file, exiting

Ahora el mensaje que da es informativo, pero no de error, así que ejecutamos de nuevo la aplicación Simple Scan y ya podemos escanear nuestros documentos.

 

NOTA: Os pongo aquí el enlace al archivo CCD569.fw por si os hiciera falta. Por limitaciones de WordPress, lo he subido con extensión PDF, así que renombradlo a CCD569.fw.

Instalar Firefox 3.6 en Ubuntu 9.10

Acaba de publicarse la última versión de Firefox 3.6. Ésta aún no está en los repositorios oficiales de Ubuntu. Así que para los impacientes como yo, hay dos alternativas para instalarla:

La primera alternativa es descargarlo desde los servidores de Mozilla, descomprimirlo en el directorio /opt/ y crear un enlace simbólico en el directorio /usr/local/bin/:

cd ~
wget http://download.mozilla.org/?product=firefox-3.6&os=linux&lang=es-ES
sudo tar -C /opt/ -xf ~/firefox-3.6.tar.bz2
sudo ln -s /opt/firefox/firefox /usr/local/bin/firefox

Tras esto, bastará que cerremos y volvamos a iniciar nuestro navegador para que se ejecute esta nueva versión.

La segunda alternativa sería añadir mozillateam/firefox-stable a nuestros repositorios e instalarlo con aptitude:


sudo add-apt-repository ppa:mozillateam/firefox-stable
sudo aptitude update
sudo aptitude full-upgrade

Luego, os recomiendo que vayáis a esta web si queréis instalar el xpi con vuestro idioma, ya que por defecto se instala en inglés.

Por cierto, podéis ver las novedades de esta nueva versión, entre las que destaca el nuevo motor Gecko 1.9.2, mejora de rendimiento en JavaScript y soporte para nuevos atributos CSS y nuevas especificaciones DOM y HTML5.

Funciones opendir, readdir y closedir en C

La función opendir se usa para abrir un directorio. Su prototipo es:

DIR *opendir(const char *nombre);

El único parámetro que recibe es el nombre del directorio que se quiere abrir. Devuelve un puntero al flujo de directorio (DIR) o NULL en caso de error. Este puntero se colocará en la primera entrada del directorio.

La función readdir sirve para leer las entradas del directorio abierto con opendir. Su prototipo es:

struct dirent *readdir(DIR *dir);

Recibe como parámetro el puntero al flujo de directorio (DIR) que se obtuvo con opendir y devuelve un puntero a una estructura dirent o NULL en caso de error o fin del directorio. Esta estructura dirent representa la siguiente entrada de directorio al que apunte dir.

La función closedir cierra el flujo de directorio que se obtuvo con opendir. Su prototipo es:

int closedir(DIR *dir);

Recibe como parámetro el puntero al flujo de directorio (DIR) y devuelve 0 en caso de éxito y -1 en caso de error.

Y nada mejor que un ejemplo para entenderlo:

#include <sys/types.h>
#include <dirent.h>
#include <stdlib.h>
#include <stdio.h>

int main (int argc, char *argv[]){

 /* Variables */
 DIR *dirp;
 struct dirent *direntp;

 /* Comprobamos los argumentos */
 if (argc != 2){
 printf("Uso: %s directorio\n", argv[0]);
 exit(1);
 }

 /* Abrimos el directorio */
 dirp = opendir(argv[1]);
 if (dirp == NULL){
 printf("Error: No se puede abrir el directorio\n");
 exit(2);
 }

 /* Leemos las entradas del directorio */
 printf("i-nodo\toffset\t\tlong\tnombre\n");
 while ((direntp = readdir(dirp)) != NULL) {
 printf("%d\t%d\t%d\t%s\n", direntp->d_ino, direntp->d_off, direntp->d_reclen, direntp->d_name);
 }

 /* Cerramos el directorio */
 closedir(dirp);
}

Funciones open/close y read/write en C

Las funciones open y close se usan para abrir abrir y cerrar ficheros, respectivamente. Sus prototipos son los siguientes:

int open(const char *camino, int flags);
int open(const char *camino, int flags, mode_t modo);
int close(int fd);

La función open devuelve un número entero que identifica a un descriptor de fichero o -1 en caso de error, y tiene como parámetros un puntero a la ruta del fichero que queramos abrir y unas banderas (flags) que indican la forma de apertura: sólo lectura (O_RDONLY), sólo escritura (O_WRONLY), lectura/escritura (O_RDWR) u otros (O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC, O_APPEND, O_NONBLOCK u O_NDELAY, O_SYNC, O_NOFOLLOW, O_DIRECTORY, O_DIRECT, O_ASYNC y O_LARGEFILE). Se puede leer más información sobre las banderas en el manual de open.

En la función open podemos especificar un tercer parámentro, el modo, que se usa para especificar los permisos en caso de que se esté creando el archivo. Dichos permisos o modos pueden ser S_IRWXU (el usuario puede leer, escribir y ejecutar (rwx)), S_IRUSR (el usuario puede leer (r)), S_IWUSR (el usuario puede escribir (w)), S_IXUSR (el usuario puede ejecutar (x)), S_IRWXG, S_IRGRP, S_IWGRP, S_IXGRP, S_IRWXO, S_IROTH, S_IWOTH y S_IXOTH.

La función close cierra el descriptor de fichero que le pasemos como parámetro. Devuelve 0 en caso de éxito y -1 en caso de error.

Las funciones read y write se usan para leer y escribir en un descriptor de fichero que previamente hayamos abierto. Sus prototipos son los siguientes:

ssize_t read(int fd, void *buf, size_t nbytes);
ssize_t write(int fd, const void *buf, size_t num);

Como véis, ambas funciones son iguales y los parámetros que reciben son el descriptor de fichero que devolvía la función open, un puntero a un buffer de memoria y un tamaño que indica el número de bytes del buffer que queramos leer o escribir. Ambas funciones devuelven el número de bytes leídos o escritos, o -1 en caso de error.

Aquí os muestro un ejemplo de cómo se pueden usar estas cuatro funciones para copiar un fichero en otro. Este programa recibe dos parámetros que son el archivo origen y el archivo destino. El archivo origen lo abre en modo sólo lectura (O_RDONLY), mientras que el archivo destino lo abre en modo sólo escritura, creándose en caso de que no exista y truncándolo (O_WRONLY|O_CREAT|O_TRUNC). Luego se usa un bucle para leer del descriptor fd1 (origen), guardarlos en un buffer de memoria y escribirlos en el descriptor fd2 (destino). Finalmente cerrará ambos archivos.

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>

int main(int argc, char *argv[]){

  /* Variables */
  int fd1,fd2;
  char buffer[1024];
  int numbytes;

  /* Comprobamos que se pasan dos argumentos */
  if (argc != 3){
    printf("Uso: %s origen destino\n", argv[0]);
    exit(1);
  }

  /* Abrimos los dos archivos */
  fd1 = open(argv[1], O_RDONLY);
  fd2 = open(argv[2], O_WRONLY|O_CREAT|O_TRUNC, 0700);

  /* Bucle de lectura/escritura */
  while ((numbytes = read(fd1, &buffer, sizeof(char))) > 0){
    write(fd2, &buffer, numbytes);
  }

  /* Cierre de archivos */
  close(fd1);
  close(fd2);
}