Conectamos el guru plug a la red cableada usando la interfaz eth0.

Accedemos a la consola del plug ya sea uniéndonos a la red inalámbrica que de manera predeterminada el guru plus levanta (cuyo nombre es Plug2-uap-#### en dónde los 4 últimos números son los últimos números de la dirección mac) y usando luego ssh o usamos el jtag para accederlo a través de minicom.

Una vez adentro revisamos que la configuración de las interfaces de red (el archivo con la ruta /etc/network/interfaces) contenga las siguientes líneas:

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet dhcp

Le indicamos al kernel que vamos a hacer uso del ip forwarding, para ello editamos el archivo /proc/sys/net/ipv4/ip_forward, lo único que debe haber en dicho archivo es un 1

Configuramos que el tamaño del MTU sea de 1500 (este es un requisito para mi ISP, para que el cambio sea permanente agregar la línea /sbin/ifconfig eth1 mtu 1500 up al final del archivo /etc/rc.local):

/sbin/ifconfig  eth0 mtu 1500

Para cambiar el nombre de la red sustituimos en el archivo /root/init_setup.sh la línea que dice

SSID=Plug2-uAP-`ifconfig eth0 | awk -F ":" '/HWaddr/ {print $6$7}'`

por la línea:

SSID=nombre_red

Ahora vamos a habilitar la seguridad inálambrica con WPA2, para ello agregamos al archivo /root/init_setup.sh las siguientes líneas justo antes de la instrucción /usr/bin/uaputl bss_start

/usr/bin/uaputl sys_cfg_protocol 32
/usr/bin/uaputl sys_cfg_wpa_passphrase "miPass"
/usr/bin/uaputl sys_cfg_cipher 8 8

Nos unimos a la red inálambrica creada por el guru plug.

Notas

• Tuve que actualizar el archivo /etc/apt/sources.list para cambiar la línea:

  deb http://www.backports.org/debian lenny-backports main contrib non-free
  

  por:

  deb http://backports.debian.org/debian-backports lenny-backports main contrib non-free

  Y ejecutar el comando:

  apt-get install debian-archive-keyring

También desactivé los servicios que no voy a usar:

update-rc.d -f mysql remove
update-rc.d -f lighttpd remove
update-rc.d -f exim4 remove

Listo listo.

Enjoy!

Algunas consideraciones a tomar en cuenta:

• La unidad usb usada en este ejemplo tiene un tamaño de 7.35G.
• Dentro de dicha unidad se crean dos particiones, la primera es una unidad fat32 para poder ser vista desde cualquier sistema (por ejemplo windows) , la segunda partición es de tipo ext3 (puede usarse ext4 si se desea) y es booteable, es allí dónde residirá el systemRescueCd.
• El tamaño de las particiones que se le pasan al comando sfdisk están en cilindros, esto debe ajustarse manualmente para su caso particular.


#!/bin/bash
#Copyright (c) 2010 Victor Castro Mattei
#All rights reserved.

# Se asegura que el dispositivo no está montado
echo "Desmontando el dispositivo $DEVNUM_USB"
fuser -ck $DEVNUM_USB
umount -f $DEVNUM_USB


# Llenar la unidad usb de ceros
# MUY lento
echo "Borrando el dispositivo $DEVNUM_USB"
tr '00' '\377'< /dev/zero | dd bs=4096 | pv -s 8G |dd bs=4096 of=$DEVNUM_USB

# Crear una nueva tabla de particiones
# con dos particiones, la primera de tamaño cercano a los 7G (6.84G)
# y la segunda con un tamaño de unos 670M
# MUY lento
echo "Creando una nueva tabla de particiones"
sfdisk --no-reread $DEVNUM_USB -uC << EOF
0,929,77
929,,69,*
;
EOF


# Crear los sistemas de archivos
echo "Creando las particiones"
echo "Creando el sistema vfat en $DEVNUM_PART1"
mkfs.vfat -n $LABEL1 $DEVNUM_PART1

# Copiar archivos del cd de systemRescueCd a la unidad usb
umount /media/cdrom
mount -t $FS_TYPE $DEVNUM_PART2 $MOUNT_POINT
mount -o loop,exec ./systemrescuecd-x86-1.6.1.iso /media/cdrom
cp -a /media/cdrom/* $MOUNT_POINT
umount /media/cdrom


# Crear la carpeta para el grub en $MOUNT_POINT
echo "Copiando el grub"
mkdir -p $MOUNT_POINT/boot/grub

exit 0


La última parte del script que es la que se instala el gestor de arranque GRUB en la unidad usb está comentada porque no me funcionó de esa manera, lo que hice fue instalar el GRUB 1 (actualmente se usa GRUB 2) en la unidad usb desde un lenny virtualizado con qemu, para ello levanto el lenny con soporte para dispositivos usb y luego realizo las siguientes operaciones en consola:


grub
grub> find /boot/grub/menu.lst (verifica la ubicación correcta)
grub> root (hd0,1) (especificar adónde reside la partición)
grub> setup (hd0,1) (instalar el GRUB en la memoria usb)
grub> quit


Listo listo

Enjoy!

Referencias:

• Guía de instalación usb del System Rescue Cd
• El blog de Darkphader

Preparación de los archivos

• Con la unidad usb desmontada se crea una partición fat16 en el dispositivo. En mi caso utilizo cfdisk y el volumen de mi dispositivo usb es el /dev/sdb:

  # cfdisk /dev/sdb

  Algo importante a anotar es que las particiones de tipo fat16 no pueden tener un tamaño mayor a los 2GB, dado esto se creó la partición con un tamaño seguro de 1024MB (1GB), además debemos marcar la partición como booteable, es decir agregamos el flag boot a la partición, el volumen de unidad resultante es el /dev/sdb1

• Si no está instalado el paquete dosfstools lo instalamos:

  # aptitude install dosfstools

  luego ejecutamos el comando:

  # mkdosfs /dev/sdb1

• Si no están instalados los paquetes syslinux y mtools se instalan:

  # aptitude install syslinux mtools

  después instalamos el gestor de arranque (syslinux) en la unidad usb:

  # syslinux /dev/sdb1

• De la imagen de instalación hd-media de squeeze que es la utilizada para dispositivos usb, obtenemos los archivos initrd.gz y vmlinuz:

  $ wget http://ftp.es.debian.org/debian/dists/squeeze/main/installer-amd64/current/images/hd-media/initrd.gz
  $ wget http://ftp.es.debian.org/debian/dists/squeeze/main/installer-amd64/current/images/hd-media/vmlinuz

  Nota: para ver otras imágenes de instalación o si ha cambiado el enlace anterior ver: debian.org/releases/.

• Creamos el directorio initrd y descomprimimos dentro el archivo initrd.gz recién descargado (se supone estamos en el directorio que contiene el archivo initrd.gz):

  $ mkdir initrd
  $ cd initrd
  $ zcat ../initrd.gz | cpio -i -d

• Dentro del directorio initrd creado en el paso anterior, creamos el archivo preseed.cfg que es utilizado para que el instalador de Debian obtenga las respuestas a las preguntas de la instalación (es decir una instalación desatendida):

  $ nano preseed.cfg

• Ahora se debe agregar el contenido al archivo preseed.cfg, a continuación se detalla dicho contenido junto con su explicación en los comentarios:

  # Seleccionar lenguaje y país: en mi caso Costa Rica:
  d-i debian-installer/locale string es_CR
  
  # Seleccionar el mapa del teclado: español
  d-i console-keymaps-at/keymap select es
  
  # NO quiero configurar la red porque estoy conectado
  # inálambricamente y agregaré el driver manualmente después.
  # Aunque en teoría existen respuestas de preseed para del
  # todo no configurar la red, esto no funcionó en la práctica
  # y por ello permito que se detecte la red con DHCP para
  # posteriormente indicar que no se va a configurar la red
  
  # Si hay más de una interfaz de red (eth0, eth1)
  # seleccionar automáticamente una
  d-i netcfg/choose_interface select auto
  
  # Cuando falla la detección por red indicar que no se va a
  # configurar la red
  d-i netcfg/dhcp_failed note
  d-i netcfg/dhcp_options select Do not configure the network at this time
  
  # Establecer el nombre de la computadora (hostname)
  d-i netcfg/get_hostname string mad-clown 
  
  # Seleccionar la lista de repositorios
  # Costa Rica en mi caso
  d-i mirror/country string manual
  d-i mirror/http/hostname string ftp://mirrors.ucr.ac.cr
  d-i mirror/http/directory string /debian
  d-i mirror/http/proxy string
  
  # Utilizar el reloj con utc
  d-i clock-setup/utc boolean true
  
  # Establecer la zona horaria
  d-i time/zone string America/Costa_Rica
  
  # Indicar al partman (creador de particiones) el volumen del disco a
  # utilizar para crear las particiones
  d-i partman-auto/disk string /dev/sda
  
  # Indicar al partman que vamos a particionar de manera regular
  # otras opciones son lvm y crypto (para particionar encriptado)
  d-i partman-auto/method string regular
  
  # Dar al partman la receta para crear las particiones
  # en este caso se crearán tres particiones:
  # una partición de unos 200GB para el /home
  # una partición de unos 80GB para /
  # una partición de intercambio (swap) de 2GB
  # puede encontrar información sobre la receta
  # más adelante en este documento
  d-i partman-auto/expert_recipe string                         \
        boot-root ::                                            \
                215040 200000 1000000000 ext3                                  \
                        $primary{ } $bootable{ }                \
                        method{ format } format{ }              \
                        use_filesystem{ } filesystem{ ext3 }    \
                        mountpoint{ /home }                     \
                .                                               \
                88181 10000 88181 ext3                       \
                        method{ format } format{ }              \
                        use_filesystem{ } filesystem{ ext3 }    \
                        mountpoint{ / }                         \
                .                                               \
                2048 2048 200% linux-swap                          \
                        method{ swap } format{ }                \
                .
  
  # Indicamos al partman que no nos pregunte más nada
  d-i partman/confirm_write_new_label boolean true
  d-i partman/choose_partition select finish
  d-i partman/confirm boolean true
  
  # Permitimos que se instale el grub como gestor de arranque
  # como yo sólo uso debian se lo indico al instalador
  # si tuviera otro sistema operativo (window$ por ejemplo) tendría
  # que cambiar la instrucción
  d-i grub-installer/only_debian boolean true
  
  # Saltarse el mensaje de: "instalación finalizada"
  d-i finish-install/reboot_in_progress note
  
  # Poner la prioridad del
  # debconf (que es la herramienta para crear configuraciones)
  # que use el nivel crítico para que
  # no haga preguntas innecesarias
  d-i debconf/priority select critical
  debconf debconf/priority select critical
  
  # Crear la contraseña del usuario root
  passwd passwd/root-password password t7_7d.4RyTr5g98.
  passwd passwd/root-password-again password t7_7d.4RyTr5g98.
  
  # Crear un usuario con su contraseña
  # en este ejemplo el usuario con username "pedrito"
  # y contraseña "aguacatico"
  passwd passwd/user-fullname string Pedro
  passwd passwd/username string pedrito
  # And their password, but use caution!
  passwd passwd/user-password password aguacatico
  passwd passwd/user-password-again password aguacatico
  

  Guardamos el archivo.

• Recomprimimos de nuevo el archivo initrd.gz para incluir el archivo preseed.cfg:

  $ cd initrd
  $ find . | cpio -o -H newc | gzip -9 > ../initrd.gz

• Montamos la unidad usb y le copiamos el archivo initrd.gz modificado y el vmlinuz anteriormente descargado.

• En la unidad usb creamos el archivo syslinux.cfg con el siguiente contenido:

  default vmlinuz
  append initrd=initrd.gz
  

• Obtenemos una imagen iso netinstall de Debian squeeze y la copiamos a la unidad usb: squeeze netinstall.

• Iniciamos la computadora desde el dispositivo usb y listo listo podemos ir a tomar café. }:)

Sobre la receta del partman

Esta es la guía de recetas de partman. A continuación una breve explicación sobre su formato:

• Cada partición tiene 3 números asociados, el primero es el tamaño mínimo en MB que puede tener la partición, el segundo es el nivel de prioridad y el tercero es el tamaño máximo que puede tener la partición.

• El nivel de prioridad debe ser un número entre el tamaño mínimo de la partición y el tamaño máximo de la misma.

• Al menos una de las particiones creadas debe tener como tamaño máximo el número 1000000000 para que tome el espacio vacío sobrante si es que hay alguno, de no utilizarse ese número el partman da errores.

• El tercer número para la partición linux-swap está en porcentaje, esto indica que dicha partición puede crecer hasta un tamaño de máximo el 200% de la memoria RAM del sistema.

• Los tamaños de las particiones son redeondeados a cilindros automáticamente de ser necesario.

• No deben haber espacios entre el texto y el operador {.

Existe un script escrito en python para probar recetas del partman: http://wiki.debian.org/DebianInstaller/PartmanPrc, para utilizarlo:

• Descargamos el script desde http://wiki.debian.org/DebianInstaller/PartmanPrc y lo guardamos con el nombre partmanprc.py

• Creamos un archivo con extensión .rec con contenido similar a este:

  boot-root ::
  215040 200000 215040 ext3 $primary{ } $bootable{ } method{ format } format{ } use_filesystem{ } filesystem{ ext3 } mountpoint{ /home } .
  88181 10000 88181 ext3 method{ format } format{ } use_filesystem{ } filesystem{ ext3 } mountpoint{ / } .
  2048 2048 200% linux-swap method{ swap } format{ }
  .

• Llamamos al script dándole como parámetros de entrada el archivo .rec, el tamaño del disco duro a utilizar (305245 MB) y la cantidad de memoria RAM (2048 MB) del sistema:

  # ./partam_ghost.py zen.rec 305245:2048

Este script generará una imagen con un gráfico circular de la distribución de las particiones y una página html con información adicional:

Enjoy!

Deshabilitar la campana de la terminal

En un Debian ejecutándose en modo texto la campana de la terminal viene preconfigurada para que suene, algo que puede resultarle molesto a algunas personas (como a mí). Para deshabilitarla editamos el archivo /etc/inputrc (en mí caso uso el editor vi):

sudo vi /etc/inputrc

Luego buscamos una sección de texto como esta:

# set bell-style none
# set bell-style visible

Y lo modificamos para eliminar el comentario de la primera línea:

set bell-style none
# set bell-style visible

Luego reiniciamos el sistema y listo listo, no más pitidos molestos

Deshabilitar la campana de vi

Como uso vim (vi) como editor de texto, entonces voy a deshabilitarle la campana también, para ello creo si no existe el archivo .vimrc en el directorio home de mí usuario:

vi .vimrc

Luego le añado la opción para deshabilitar la molesta campana:

set vb t_vb=

De una vez aprovecho y le agrego unas cuantas configuraciones más:

set tabstop=4
set ai
set magic
set nu

Enjoy!

Una alternativa para resolver este problema es usar el Dropbox que es un servicio en línea, sin embargo en mi caso para el manejo de información sensitiva prefiero que mi información me pertenezca a mí.

Lo que vamos a hacer es utilizar el GNU usbsync que es una herramienta por consola para sincronizar directorios, para ello:

1. Descargamos el GNU usbsync de aquí, en el caso de Ubuntu descargamos el paquete: usbsync_0.2-1_i386.deb
2. Instalamos el programa, en consola:

   sudo dpkg -i usbsync_0.2-1_i386.deb

3. Ahora vamos a nuestra unidad usb externa (pendrive) y en la raíz creamos el archivo .usbsync (el nombre de archivo con punto al inicio)
4. Abrimos el archivo creado en el paso anterior con un editor de texto.
5. Suponiendo que estoy autenticado en Ubuntu como nombre_usuario y que mi host (computadora) se llama nombre_host y que existe la carpeta /home/nombre_usuario/mi_directorio y además quiero que se sincronize con la carpeta llamada mi_directorio_usb que se encuentra en la raíz del pendrive, agrego la siguiente línea al archivo .usbsync:

   #Esto es un comentario:
   mi_directorio_usb
   nombre_usuario@nombre_host:~/mi_directorio
   

6. Desde la consola accedemos a la unidad usb:

   cd /media/nombre_unidad_usb

7. Y ejecutamos el usbsync diciéndole que deseamos sincronizar todo lo que esté en la unidad usb (esto con el uso del . en el comando):

   usbsync .

   Deberíamos ver mensajes indicando que las transferencias se están llevando a cabo.

Listo listo

Enjoy!

1. Vamos a /usr/share/tomcat6/lib y creamos el archivo log4j.properties y le añadimos lo siguiente:

   log4j.rootLogger=debug, R
   log4j.appender.R=org.apache.log4j.RollingFileAppender
   log4j.appender.R.File=${catalina.home}/logs/tomcat.log
   log4j.appender.R.MaxFileSize=10MB
   log4j.appender.R.MaxBackupIndex=10
   log4j.appender.R.layout=org.apache.log4j.PatternLayout
   log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n
   log4j.logger.org.apache.catalina=DEBUG, R
   

2. Descargue el archivo log4j-[version] desde aquí.
3. Descomprima el archivo descargado.
4. De la carpeta creada en el paso 3, copie el archivo log4-[version].jar a /usr/share/tomcat6/lib
5. Ir a la página de descargas del Tomcat
6. Adónde dice Quick Navigation le damos click a Browse y en la página que se abre vamos a la carpeta bin > extras y descargamos los archivos: catalina-ws.jar, tomcat-juli-adapters.jar y tomcat-juli.jar .
7. Creamos la carpeta /usr/share/tomcat6/lib/output/extras
8. Copiamos los archivos catalina-ws.jar, tomcat-juli-adapters.jar y tomcat-juli.jar a la carpeta creada en el paso anterior.
9. Vamos a la carpeta /usr/share/tomcat6/bin y borrarmos el archivo tomcat-juli.jar
10. Creamos un enlace simbólico (acceso directo) al archivo tomcat-juli.jar que habíamos descargado, en consola:

    sudo ln -s /usr/share/tomcat6/lib/output/extras/tomcat-juli.jar /usr/share/tomcat6/bin/tomcat-juli.jar

Reiniciamos tomcat y listo listo ya se puede hacer:

sudo tail -f /var/log/tomcat6/catalina.[fecha].log

Enjo

A partir de la versión 2.5 del framework spring, es posible utilizar anotaciones java para configurar las aplicaciones y de esta manera reducir la cantidad de XML utilizado (es decir, lo que antes había que escribir como configuración xml pasa a ser configuración expresada a través de anotaciones escritas directamente en las clases Java, cool trick ah?).

Vamos a crear una aplicación sencilla (Un Portlet) con Spring (usando modelo-vista-controlador de Spring), que conste de una vista y un controlador, partiendo del supuesto que no hemos instalado ninguno de los componentes necesarios para lograrlo: el IDE netbeans, los plugins de netbeans para el desarrollo web, las librerías spring y el servidor de aplicaciones apache-tomcat.

Sí se asume que tenemos el jdk de java instalado (versión 6 al momento de escribir este documento).

1. Primero descargamos el netbeans (versión 6.7.1 al momento de escribir este documento), accedemos al sitio de descargas de Netbeans y escogemos la tercera opción que incluye soporte para aplicaciones web en Java y que incluye servidores de aplicaciones.

2. Abrimos una consola y navegamos hasta la carpeta dónde se descargó el archivo, por ejemplo si se descargó en /home/usuario/descargas:

   cd /home/usuario/descargas

3. Ahora vamos a darle permisos de ejecución al archivo, para ello digitamos en consola:

   chmod a+rwx netbeans-[número versión]-ml-java-linux.sh

   y ejecutamos el instalador:

   ./netbeans-[número versión]-ml-java-linux.sh

   esto iniciará un instalador gráfico:
   

4. Damos click en el botón personalizar (customize) y a continuación seleccionamos sólamente las opciones que nos interesan, estas son: Base IDE, Java SE, JavaScript Debugger, Java Web and EE, Features on Demand y el Apache Tomcat (versión 6 al momento de escribir):
   
   Damos click en ok y luego en next, aceptamos el contrato de licencia y escogemos el lugar dónde se instalará el netbeans y el servidor apache tomcat, por último damos click en Install.

5. Seguidamente, necesitamos agregar al Netbeans los plugins para el desarrollo de Servlets y Portlets con el uso del framework Spring, para ello descargamos el netbeans portal pack de aquí, actualmente de aquí.
   Elegimos la tercera opción (el paquete all).
   Una vez descargado, lo descomprimimos.

6. Abrimos el netbeans y vamos al menú Tools > Plugins, esto abre una ventana, de ella seleccionamos la pestaña que dice Downloaded (descargados), damos click al botón Add Plugins… y navegamos hasta la carpeta que se creó en el paso anterior:
   
   
   Seleccionamos todos los plugins (archivos con extension .nbm, damos click en Aceptar y luego en Install (si nos dice que algún plugin no está firmado, simplemente elegimos Continuar).
   Ya están instalados los plugins necesarios.

7. Creamos desde Netbeans un proyecto nuevo y lo elegimos como Java Web > Web Application, le ponemos un nombre y elegimos el lugar dónde se va a guardar, seleccionamos el servidor web como Apache Tomcat y marcamos las opciones Portlet Support y Spring Web MVC 2.5:
   
   damos click en Finish.

8. Aunque el netbeans agregó automáticamente las librerías del Spring al proyecto recién creado, algunas de ellas dan problemas a la hora de realizar un deploy al servidor, vamos a reemplazar las que den problema, primero descargamos las librerías del Spring desde: la página del spring, debemos descargar la versión que trae dependecias. Una vez descargadas, las descomprimimos.

9. Las librerías que generan problemas son:

   • Portlet 2.0(JSR 286) Library – portlet-api-2.0.jar
   • Spring Framework 2.5 – spring-2.5.jar
   • Spring Web MVC 2.5 – spring-webmvc-2.5.jar

   Debemos reemplazarlas por las siguientes librerías que se encuentran en la carpeta generada en el paso anterior (con las rutas relativas a la carpeta):

   • portlet-api-2.0.jar : /spring-framework-2.5.6.SEC01/lib/portlet
   • spring.jar : /spring-framework-2.5.6.SEC01/dist
   • spring-webmvc.jar : /spring-framework-2.5.6.SEC01/dist/modules

   Además debemos de agregar la librería:
   spring-webmvc-portlet.jar : /spring-framework-2.5.6.SEC01/dist/modules
   
   

10. Ahora agregamos el controlador, para ello agregamos el paquete mipaquete.web y dentro de él creamos la clase MiController:
    

    La clase MiController contendrá lo siguiente (copiar-pegar):

    
package mipaquete.web;

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.ModelMap;
    import org.springframework.web.bind.annotation.RequestMapping;

    @Controller
    @RequestMapping("VIEW")
    public class MiController {

    @Autowired
    public MiController() {
    }

    @RequestMapping // acción por omisión, renderizado (action=mostrarFormulario)
public String mostrarFormulario(ModelMap model) {
return "miIndex";
}
}

11. Abrimos el archivo dispatcher-servlet.xml y sustituimos su contenido por lo siguiente (copiar-pegar):

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:p="http://www.springframework.org/schema/p"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    
        <bean class="org.springframework.web.portlet.mvc.annotation.DefaultAnnotationHandlerMapping">
            <property name="interceptors">
                <!-- Este interceptor envía el parámetro del request desde un ActionRequest para ser usado como un parámetro del renderizado. -->
                <bean class="org.springframework.web.portlet.handler.ParameterMappingInterceptor" />
            </property>
        </bean>
    
        <bean id="indexController" class="mipaquete.web.MiController"/>
    
        <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
            <property name="mappings">
                <props>
                    <prop key="index.htm">indexController</prop>
                </props>
            </property>
        </bean>
    
        <bean id="viewResolver"
              class="org.springframework.web.servlet.view.InternalResourceViewResolver"
              p:prefix="/WEB-INF/jsp/"
              p:suffix=".jsp" />
    
    </beans>
    

12. Agregamos en la carpeta que contiene los Jsps del proyecto (/WEB-INF/jsp) un jsp nuevo al que llamamos miIndex(que es el nombre de vista que se devuelve desde el controlador). Netbeans lo agregará con un Hello World de contenido.

    Para probar damos click en el nombre del proyecto y elegimos la opción Run (ejecutar), debe verse una página html con el Hello World.

Por último, si se coloca un breakpoint en el código y debbugeamos la aplicación, esta se va a detener al llegar a él, es decir, es posible debuggear.

Listo listo

Enjoy!

Tener respaldos de una base de datos siempre es importante, y estos respaldos deberían ser almacenados en un lugar remoto, como otro servidor por ejemplo.

Para llevar a cabo esta tarea nos valeremos del comando scp de Linux para copiar archivos de manera segura y remota y del administrador de tareas Cron de Unix (disponible en Linux).

Lo primero que necesitamos es que el scp nos deje conectarnos desde el cliente al servidor  sin solicitarnos contraseña ya que en caso contrario no podemos automatizar la copia de archivos en un script.

Lo que vamos a hacer es sustituir el uso de una contraseña por el método de criptografía asimétrica en el que se utilizan un par de llaves: una pública y una privada.

Para llevar a cabo lo anterior se deben seguir estos pasos:

• Desde la Máquina Cliente (que es dónde se va a generar el respaldo de la base) verificamos que el archivo /etc/ssh/sshd_config tenga las siguientes líneas (que de manera predeterminada ya están):

  RSAAuthentication yes
  PubkeyAuthentication yes
  

• Luego escribimos en consola el siguiente comando para generar las llaves:

  # sudo ssh-keygen -t rsa
  

  Se mostrará el siguiente texto preguntando adónde se quiere guardar el archivo que contiene las llaves, de manera predeterminada en /root/.ssh/id_rsa:

  Generating public/private rsa key pair.
  Enter file in which to save the key (/root/.ssh/id_rsa):
  

  Damos enter y ahora se preguntara por una clave, en este caso la dejamos en blanco por lo que damos enter dos veces, se mostrará información referente a los lugares dónde se almacenaron las claves públicas y privadas.

• Ahora debemos transferir la clave pública recién generada al servidor remoto, para ello utilizamos el comando ssh-copy-id:

  ssh-copy-id -i /root/.ssh/id_rsa.pub usuario@ip_servidor

  Se nos pedirá la contraseña, la escribimos y damos enter, a partir de este momento ya no se nos solicitará contraseña al conectarnos a esta computadora, por lo tanto el comando scp ahora puede utilizarse libremente en un script que copie archivos.

  Lo siguiente es un apunte, probablemente no necesite realizar lo siguiente: el servidor al que me conecto vía ssh utiliza otro puerto que no es el predeterminado 22 por lo tanto el procedimiento anterior debe hacerse de la siguiente manera, desde consola:

  sudo vim /root/.ssh/config

  Y añadimos:

  Host miServidor
  Hostname ip.del.servidor.deseado
  User usuario
  Port puerto
  

  Luego:

  sudo ssh-copy-id -i /root/.ssh/id_rsa.pub miServidor

• Ahora creamos un script para bash que haga un dump de la base de datos a respaldar, la comprima y la transfiera a otra máquina, para ello creamos un nuevo archivo y agregamos lo siguiente:

  #!/bin/bash
  fecha=$(date +%Y%m%d)
  mysqldump -u[usuario] -p[contraseña] [nombre_base] > /home/usuario/bd_$fecha.sql
  bzip2 /home/usuario/bd_$fecha.sql
  scp /home/vas/bd_$fecha.sql.bz2 [miUsuario]@[ip_servidor]:/home/usuario

  Se deben sustituir los campos [usuario] y [contraseña] por el nombre de usuario y contraseña utilizados para conectarse al gestor de base de datos mysql y el campo [nombre_base] por el nombre de la base de datos a respaldar, así mismo [miUsuario] y [ip_servidor] por el nombre de usuario e ip del servidor utilizados anteriormente en el comando sh-copy-id e ignorando los [ ].

  Guardamos el archivo con el nombre backup_bases.sh en la ruta /home/usuario/Documentos

• Ahora vamos a agregar el script como una rutina del sistema con el cron, para ello digitamos en consola:

  sudo crontab -e

  Y añadimos lo siguiente para que los respaldos se hagan martes a las 10 am:

  # m h  dom mon dow   command
    0 10 * *  2        /home/usuario/Documentos/backup_bases.sh
  

Listo listo

Enjoy!

Una versión, revisión o edición de un producto de software, es el estado en el que éste se encuentra en un momento dado en su desarrollo o modificación. Se llama control de versiones a la gestión de los diversos cambios que se realizan sobre los elementos de algún producto o una configuración del mismo. [fuente: wikipedia].

Subversion es un Sistema de Control de Versiones, muy útil en ambientes de desarrollo en equipos en dónde los archivos fuente son modificados por distintas personas en períodos de tiempo variables.

De manera simple, puede decirse que el Subversión se utiliza para proteger el código fuente, que es muy valioso para los programadores y para la empresa.

Subversion es de código abierto y soporta los métodos de bloqueo por candados, y de copia de archivos (algo un poco parecido a los googleDocs).

Subversion

Lo primero es instalar Subversion, para ello desde una consola digitamos:

sudo aptitude install subversion

Ahora vamos a crear un repositorio, que es un directorio en el cuál residirán los archivos de una aplicación particular que estarán sujetos al control de versiones, para ello desde consola digitamos:

svnadmin create /home/usuario/miRepositorio

(debe cambiar la ruta por una que sea válida en su computador)

Lo anterior creará la carpeta si no existe, un detalle es que el Subversion es silencioso, es decir, ningún mensaje significa que tuvo éxito.

RapidSVN

Ya creamos la raíz del repositorio pero no se ha agregado ningún archivo, supondremos que localmente poseemos archivos que queremos subir al servidor, para ello nos valdremos de un cliente gráfico, el RapidSVN, para ello desde consola digitamos:

sudo aptitude install rapidsvn

Iniciamos la aplicación desde el submenú Programación > RapidSVN, se mostrará la siguiente pantalla:

Creando una aplicación nueva bajo control de Subversion

Ahora vamos a tomar un directorio en nuestro disco duro y lo vamos a copiar (importar) al repositorio, esta es una manera de agregar un proyecto nuevo para ser controlado por el Subversion (otra manera de hacer esto y que requiere acceso físico al servidor dónde se ejecuta Subversion, es ir al directorio que contiene los repositorios y crear a mano las carpetas y archivos iniciales).

A manera de ejemplo supongo que tengo el directorio miDir en la ruta /home/usuario/miDir y que dentro de dicho directorio existe el archivo con nombre miArchivo.

Para importar miDir al repositorio recién creado nos valemos del cliente RapidSVN, para ello damos click en el menú Repository > Import, aparece la pantalla siguiente:

En el campo Repository URL y ya que los estamos probando localmente escribimos la ruta al repositorio usando el protocolo file:/// que denota el uso de archivos locales. De esta manera la ruta sería: file:///home/usuario/miRepositorio/miProyecto donde miProyecto es cualquier nombre que se le quiera poner a la nueva aplicación, y el resto de la dirección es la ruta al repositorio que creamos al inicio.

En el campo Path se encuentra la ruta al directorio miDir mencionado.

Por último, en el campo Enter log message se especifica un mensaje para la bitácora de cambios (No es obligatorio pero debería serlo).

Damos click en Aceptar y saldrá un mensaje como:

Execute: Import
Added: /home/usuario/miDir/miArchivo
Updating...
Ready

Listo ya creamos una aplicación que está bajo control de versiones.

Obteniendo archivos desde el repositorio

Ahora vamos a agregar los archivos que están en el servidor (local) a una nueva carpeta, dicha carpeta se llama miResultado y una vez que los descarguemos, contendrá los archivos que se importaron anteriormente (tal vez parezca un poco tonto si ya existe la carpeta miDir con estos archivos, pero esto tendría más sentido si fuera en un ambiente de red y la aplicación miRepositorio/miProyecto hubiera sido creada por alguien más).

Ahora usando el RapidSVN damos click en el menú Repository > Checkout, se abrirá la siguiente pantalla:

En el campo URL debe ir la ruta a la aplicación (en este caso miProyecto) que reside en el repositorio.

En el campo Destination Directory puede ser cualquier ruta dónde tengamos permisos de escritura, en mi caso en /home/usuario/miResultado

Damos click en Aceptar y se mostrará un mensaje como:

Execute: Checkout
Added: /home/usuario/miResultado/miArchivo
Updated: /home/usuario/miResultado
Updating...
Ready

Si no existe la carpeta miResultado, esta se creará junto con los directorios y archivos que contenga, ya podemos ver desde el RapidSVN los archivos recién descargados.

Para añadir archivos o directorios basta con añadirlos dentro de la carpeta miResultado y luego ir al RapidSVN y dar click derecho sobre el archivo > add y luego click derecho de nuevo > commit.

Para borrar un archivo es similar, desde el RapidSVN click derecho sobre el archivo > delete, click derecho sobre el archivo > commit

svnserve

Ahora vamos a ejecutar un servidor para que los archivos no sólo sean legibles de manera local a través del protocolo file:///, sino que vamos a usar el svnserve que es un servidor que trae el Subversion, el svnserve es adecuado para equipos de trabajo pequeños y en ambientes de LAN, más tarde usaremos Apache.

Para ejecutar svnserve desde consola digitamos:

svnserve -d

El comando anterior, ejecuta el subversion como un demonio (que es la manera más sencilla de ejecutarlo), también puede ejecutarse con inetd, sobre un túnel ssh y como un servicio de Windows (para mayor información ver el manual).

Configurar svnserve

Ahora vamos a probar el svnserve, para ello vamos a autorizar la lectura de archivos por parte de cualquier persona (acceso anónimo), para ello vamos al archivo de configuración del svnserve, el svnserve.conf que de manera predeterminada se encuentra en la ruta: /var/www/rep/conf/svnserve.conf

Desde consola digitamos:

sudo vim /var/www/rep/conf/svnserve.conf

Habilitamos el acceso anónimo como sólo lectura, para ello descomentamos la siguiente línea:

anon-access = read

Ahora vamos a descargar los datos del repositorio a través del protocolo svn://

Igual que antes vamos a menú Repository > Checkout pero esta vez en el campo URL, cambiamos el protocolo de file:/// a svn:// para indicar que vamos a acceder a través del svnserve, y en el campo Destination Directory digitamos la ruta /home/usuario/miResultado_svnserve, damos aceptar y listo.

Si ahora añadimos un archivo a la carpeta miResultado_svnserve y le damos commit desde el RapidSVN no nos va a dejar ya que no tenemos permiso, para ello modificamos de nuevo el svnserve.conf, descomentamos las siguientes líneas que indican el derecho de escritura para usuario autenticados y el archivo en que se encuentra la lista de usuarios y contraseñas para el svnserve:

auth-access = write

password-db = passwd

Ahora editamos el archivo passwd que se encuentra en /var/www/rep/conf (justo al lado del svnserve.conf) y creamos el usuario guest con contraseña guest (de ejemplo ya vienen dos: Harry y Sally):

Apache

El svnserve es adecuado para equipos de desarrollo pequeños y que accesan desde una LAN o un VPN, si se necesita acceso desde Internet y/o se quiere más seguridad y flexibilidad, es mejor usar Apache para acceder a los repositorios del Subversion.

Apache utiliza el protocolo web-dav que es una extensión del http y permite usar el puerto 80 para acceder.

Primero instalamos apache, desde consola digitamos:

sudo aptitude install apache2

Seguidamente vamos a configurarlo, es necesario tener instalado el módulo mod_dav del apache (que por lo general viene incluido en el apache), podemos verificar que lo tenemos, usamos el siguiente comando:

locate mod_dav.so

También necesitamos el backend del módulo anterior, el mod_dav_svn,para ello instalamos el paquete libapache2-svn:

sudo aptitude install libapache2-svn

Pensando en que la estructura del repositorio que se usará es una carpeta padre dónde residen carpetas hijas, dónde cada una de ellas contendrá (ó representa) el repositorio de una aplicación, creamos dicha carpeta padre, en mi caso en /var/svn

sudo mkdir /var/svn

Ahora vamos a configurar el apache, para ello editamos el archivo de configuración httpd.conf:

sudo vim /etc/apache2/httpd.conf

Agregamos lo siguiente:

<Location /svn>
DAV svn
SVNParentPath /var/svn
</Location>

Con lo anterior estamos diciéndolo al Apache que las peticiones a una dirección como http://ip_servidor/svn/miRepositorio1 ó http://ip_servidor/svn/miRepositorio2 son repositorios bajo el control de versiones.

Ahora vamos a agregar autenticación, existen varias maneras de hacerlo, vamos a usar el modo básico que consiste en un archivo con nombre de usuarios y contraseña, primero modificamos lo agregado anteriormente al httpd.conf para indicar que vamos a usar autenticación básica, indicar la dirección del archivo de usuarios y contraseñas, en este caso es la ruta /etc/svn-auth-file, y solicitar un usuario válido, de manera que quedaría así:

<Location /svn>
DAV svn
SVNParentPath /var/svn
AuthType Basic
AuthName "Repositorios de Subversion"
AuthUserFile /etc/svn-auth-file
Require valid-user
</Location>

Ahora vamos a crear el archivo de usuarios y contraseñas conteniendo un usuario inicial, en este caso harry para ello en consola digitamos:

htpasswd -cm /etc/svn-auth-file harry

A continuación se nos solicitará la contraseña de harry (dos veces por la verificación).

Para agregar un nuevo usuario digitamos: (ojo que es sin la opción -c usuada anteriormente)

htpasswd -m /etc/svn-auth-file nuevo_usuario

Ahora reiniciamos el apache y listo listo, ya podemos acceder el server usando direcciones como http://ip_servidor/svn/miRepositorio, claro siempre hay que usar el comando svnadmin create para crear repositorios dentro de la carpeta /var/svn

Un detalle es que la carpeta debe tener permisos de escritura sino no podremos escribir archivos en el repositorio.

Enjoy!

Cuando tenemos un servidor de aplicaciones Java como Tomcat, por omisión las urls de las peticiones hacia él deben contener el puerto 8080 o 8180 como parte de la misma, por ejemplo: http://localhost:8080/miAplicacion

Una solución sencilla a lo anterior es tener únicamente Tomcat como servidor web (sin usar Apache) y configurarlo (en el archivo server.xml) para que el conector escuche en el puerto 80 en vez del 8080 o del 8081, esto no es adecuado ya que Tomcat no es tan robusto como Apache (en particular para páginas estáticas) y en mi caso, necesito el Apache para ejecutar la aplicación web phpmyadmin para administrar bases de datos mysql.

Lo que se hará es configurar el Apache para que delegue peticiones a aplicaciones particulares hacia el Tomcat (y que van dirigidas a este).

Es necesario tener instalado los siguientes requisitos:

• El JDK de java (en mi caso el paquete sun-java6-jdk)
• apache2
• El módulo a2enmod de apache (que por lo general viene incluido con la instalación)
• El módulo mod_jk de apache (el paquete: libapache2-mod-jk)

Primero y si no existe creamos el archivo /etc/apache2/mods-available/jk.load, este debe contener la siguiente línea:

LoadModule jk_module /usr/lib/apache2/modules/mod_jk.so

Ahora creamos el archivo /etc/apache2/mods-available/jk.conf que contiene la siguiente información:

<IfModule mod_jk.c>
  JkWorkersFile       "/etc/apache2/workers.properties"
  JkLogFile           "/var/log/apache2/mod_jk.log"
  JkLogLevel          info
  JkLogStampFormat    "[%a %b %d %H:%M:%S %Y] "
  JkOptions           +ForwardKeySize +ForwardURICompat -ForwardDirectories
  JkRequestLogFormat  "%w %V %T"
</IfModule>

Desde consola vamos a habilitar el módulo mod_jk, nos dará un error que dice que no se encuentra el archivo workers.properties, pronto arreglaremos eso:

sudo a2enmod jk
sudo /etc/init.d/apache2 force-reload

Ahora vamos a editar el archivo /etc/apache2/sites-available/default y añadimos dentro de las etiquetas <VirtualHost *:80> <VirtualHost> lo siguiente:

ServerAdmin webmaster@localhost
ServerName localhost

JkMount /* miAplicacion

Ahora le decimos al Apache en qué puerto está escuchando el Tomcat, para ello creamos el archivo /etc/apache2/workers.properties y le añadimos lo siguiente:

worker.list=miAplicacion

# Set properties for miAplicacion
worker.miAplicacion.type=ajp13
worker.miAplicacion.host=localhost
worker.miAplicacion.port=8009

Ahora verificamos que en el archivo /usr/share/tomcat6/server.xml se
encuentre descomentada la siguiente línea:

    <!-- Define an AJP 1.3 Connector on port 8009 -->
    <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />

Ahora reiniciamos Tomcat y Apache y listo listo }:) (podemos probarlo con http://localhost/miAplicacion)

Enjoy!