Metalklesk's space

Netbeans Platform LifecycleManager

2010-06-06T15:53:00.006-04:00

Una de las cosas que necesitamos cuando desarrollamos una aplicación es el control cuando cerramos la aplicación. Que debería hacer nuestra aplicación si presionamos el botón salir ? debemos guardar nuestro trabajo ? deberíamos confirmar la salida ? o simplemente debemos cerrar la aplicación y perder todo ?
Si han comenzado a utilizar la Netbeans Platform es posible que se hayan encontrado con este dilema, la solución es MUY simple.

Lo primero que debemos hacer es crear la carpeta META-INF/services en la raíz de la carpeta src de nuestro proyecto Netbeans. Dentro de esa carpeta creamos el archivo "org.openide.LifecycleManager", el cual es un simple archivo de texto (sin extensión txt ni nada), luego abrimos el archivio desde Netbeans y agregamos las siguientes líneas:

org.metalklesk.nbservices.impl.MyLifecycleManager
#position=1
org.netbeans.core.NbTopManager$NbLifecycleManager
#position=2

Con eso estamos indicando que reemplazaremos la implementación por default de Netbeans por la nuestra, así es como se ve:

luego simplemente debemos crear nuestra clase, la cual tiene el siguiente contenido:

public class MyLifecycleManager extends LifecycleManager {

@Override
public void saveAll() {
}

@Override
public void exit() {
//close all the topcomponent tabs
Set<TopComponent> tcs = TopComponent.getRegistry().getOpened();
Iterator<TopComponent> it = tcs.iterator();
while(it.hasNext()) {
TopComponent tc = it.next();
if(tc instanceof DepartmentEditorTopComponent)
tc.close();
}

Collection c = Lookup.getDefault().lookup (
new Lookup.Template (LifecycleManager.class)).allInstances();

for (Iterator i=c.iterator(); i.hasNext();) {
LifecycleManager lm = (LifecycleManager) i.next();
if (lm != this) {
lm.exit();
}
}
}

}

y así es como se ve:

Al extender de la clase LifecycleManager debemos implementar el método exit y es en esa implementación donde ingresamos nuestro código. En este caso me preocupo de cerrar unos TopComponent que yo construí.
El pedazo de código siguiente debe ir para poder cerrar la aplicación:

Collection c = Lookup.getDefault().lookup (
new Lookup.Template (LifecycleManager.class)).allInstances();

for (Iterator i=c.iterator(); i.hasNext();) {
LifecycleManager lm = (LifecycleManager) i.next();
if (lm != this) {
lm.exit();
}
}

Con eso ya tienen su propia implementación de la clase LifecycleManager y se pueden preocupar de realizar lo que sea necesario antes de cerrar la aplicación.

Saludos !!!

Netbeans Platform Notifications

2010-06-01T22:35:00.006-04:00

He estado trabajando en un software para domótica (Home Automation) y para ello estoy utilizando la plataforma Netbeans y su excelente API.

Una de las cosas que me ha gustado es el manejo de las notificaciones.
Si han usado el IDE Netbeans, se habrán dado cuenta que cuando cargas algo, aparece un texto en el área de estado que está abajo a la izquierda (Status Area).

Para utilizar esa área para notificaciones desde tu aplicación simplemente basta con la siguiente linea de código:
StatusDisplayer.getDefault().setStatusText("Hola mundo");
así de simple.

También existe un globo, el cual muchos ya habrán visto cuando Netbeans encuentra actualizaciones. Ese globo también está disponible para tu aplicación!!!

Cómo se usa ? simple ... en el siguiente blog aparecen unas clases que amablemente su autor dispuso para todos en la red, las cuales yo estoy usando en mi aplicación con unas pequeñas modificaciones.

Las clases con mis modificaciones son las siguientes:

Con estas 3 clases en tu aplicación basada en Netbeans Platform, puedes usar el globo de la siguiente manera:

NotifyUtil.warn("titulo", "mensaje de advertencia", false);

NotifyUtil.show("titulo", "mensaje informativo", false);

NotifyUtil.show("titulo", "mensaje informativo", new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
//hago algo
}
};, false);

NotifyUtil.error("titulo", "mensaje de error, false);

NotifyUtil.error("titulo", "mensaje de error", exception, false);

El último muestra la excepción en un dialogo informativo.

Y por último si queremos mostrar una notificación en un diálogo informativo, en vez de usar un JOptionPane, podemos usar lo siguiente:

MessageUtil.showException("mensaje", exception);

MessageUtil.error("mensaje", exceptionInstance);

MessageUtil.error("mensaje");

MessageUtil.info("mensaje");

MessageUtil.question("mensaje");

MessageUtil.plain("mensaje");

Y con eso ya tenemos cubierto el tema de las notificaciones en la plataforma Netbeans.

Saludos !!!

NetBeans 6.8 y Visual Library API, ejemplo completo

2009-12-13T17:54:00.013-03:00

Hace unos días me vi enfrentado en la necesidad de desarrollar una aplicación que permitiera crear diagramas arrastrando iconos desde una paleta. Para esto existen varias bibliotecas de la API de NetBeans que son muy útiles, las cuales permiten desarrollar una aplicación del tipo "Editor visual", como Microsoft Visio o Dia, con el cual podemos generar diagramas y agregar acciones.

Muchos pequeños ejemplos para trabajar con la Visual Library API se pueden encontrar en http://netbeans.sourcearchive.com/documentation/6.0.1/files.html.

También existe este ejemplo en http://java.dzone.com/news/how-create-visual-applications el cual nos indica como agregar un poco de funcionalidad a un widget y este otro ejemplo en http://java.dzone.com/news/how-add-resize-functionality-v que nos dice como agregar la funcionalidad de "Resize" de un widget, el cual modifiqué un poco.

Otro ejemplo muy bueno es éste de acá, que nos muestra como añadir la Common Palette a nuestra aplicación, funcionalidad que se utilizó en este ejemplo.

Primero que todo quiero agradecer la buena voluntad de Geertjan Wielenga y David Kaspar, quienes muy amablemente me ayudaron a entender como funcionan algunas API de NetBeans y con lo cual pude desarrollar un ejemplo que quiero compartir con ustedes.

Lo primero es aclarar que el ejemplo hace uso de la plataforma NetBeans, tanto para su desarrollo como para su ejecución. NetBeans trae la opción de crear una aplicación utilizando un esqueleto llamado NetBeans Platform Application

al cual, en este ejemplo se le dio el nombre de Visual Editor.

Sobre este esqueleto se agregan módulos.

y los módulos se pueden crear como aplicaciones standalone (para cargar en NetBeans IDE) o como módulos para una aplicación del tipo NetBeans Platform Application, el cual es nuestro caso.

La gracia de crear módulos en NetBeans es que pueden ser exportados como archivos nbm, los cuales pueden ser cargados dentro de NetBeans o nuestras aplicaciones del tipo NetBeans Platform Application.

Al crear una aplicación del tipo NetBeans Platform Application, le podemos cargar todos los módulos que queramos lo cual nos permite crear una aplicación extensible y además nos permite exportar la aplicación con binarios listos para su ejecución (script en linux, exe en windows).

Dejo aquí el enlace de descarga del código fuente del ejemplo, el cual iremos comentando a continuación y acá están los binarios.

Para crear una aplicación del tipo editor de diagramas, debemos crear una escena. Una escena es un componente que permite agregar widgets en él y se encarga de manejarlos por nosotros.

En el caso de este ejemplo, creamos una clase llamada MyScene que hereda de la clase GraphScene.

public class MyScene extends GraphScene<MyNode, MyEdge> {

En una escena tenemos Nodos y Edges. Ambos son widgets pero la diferencia es que los Nodos los utilizamos para los iconos representativos que agregamos a la escena y los Edges los utilizamos para crear conexiones entre los nodos, es por eso que creamos las clases MyNode y MyEdge.

Cuando agregamos un nodo a una escena, utilizamos el método addNode al cual le pasamos como argumento un objeto de tipo MyNode (ver método accept de la clase MyScene).

Widget w = MyScene.this.addNode(new MyNode(idGenerator.getNextId(), image, "Object " + (nodeCounter++), point));

cuando se llama el método addNode inmediatamente se dispara una llamada a la implementación del método attachNodeWidget que es donde recién se agrega el Widget a la escena

protected Widget attachNodeWidget(MyNode node) { MyWidget widget = new MyWidget(this, mainLayer, interactionLayer, connectionLayer, node); mainLayer.addChild(widget); setFocusedWidget (widget); validate(); return widget; }

La gracia de usar un objeto MyNode es que podemos almacenar y obtener los datos propios del Widget, los cuales podemos utilizar luego para almacenarlos en un archivo xml, con lo cual le agregamos la función de importar y exportar la escena.

En la clase MyWidget agregamos la opción de crear conexiones con otros widgets creando una acción en particular en el constructor:

getActions().addAction(ActionFactory.createExtendedConnectAction(connectionLayer, new MyConnectionProvider(scene)));

Esto utiliza un objeto del tipo MyConnectionProvider el cual se encarga de generar un objeto MyEdge y lo agrega utilizando el método addEdge de la escena. Al llamar al método addEdge se dispara una llamada a la implementación del método attachEdgeWidget de la escena, el cual se encarga de agregar un widget de conexión.

En el caso de este ejemplo se creó una clase para el widget con la imagen (MyWidget) y otra para la conexión (MyConnectionWidget).
Ambos tienen la capacidad de modificar un texto en la escena ya que se les agrego la acción de edición usando createInplaceEditorAction.

Es interesante el poder agregar un menú a un Widget, lo cual nos da la posibilidad de añadir funcionalidad a los widgets. Para esto se utiliza un PopupMenuProvider el cual retorna un JPopupMenu el que a su vez puede contener JMenuItems con la funcionalidad que queramos en cada uno, ver la clase MyWidget.

popupMenuProvider = new PopupMenuProvider() { public JPopupMenu getPopupMenu (final Widget widget, final Point location) { return popupMenu; } };

Nuestro buen amigo Geertjan Wielenga nos dió un tip muy útil para agregar la funcionalidad de Resize de nuestros Widgets, tip que apliqué en este ejemplo y que podemos ver acá. El único problema es que es que para que ese tip funcione, se debe modificar la clase ImageWidget del API de la Visual Library, lo cual no es muy cómodo. Lo que hice fue crear una clase llamada MyImageWidget a la cual le apliqué el tip de Geertjan. También generé una clase llamada MyIconNodeWidget, la cual hace uso de la clase MyImageWidget (en vez de la clase ImageWidget). La clase MyWidget extiende de MyIconNodeWidget en vez de IconNodeWidget por lo que de esa forma se tiene la funcionalidad de Resize sin necesidad de cargar el código fuente de la API de la Visual Library.

También se agregó la funcionalidad de poder eliminar un widget (MyWidget o MyConnectionWidget) desde la escena presionando la tecla DELETE, para lo cual se creó la clase KeyEventLoggerAction, en donde el código para eliminar el widget es el siguiente:

public State keyReleased(Widget widget, WidgetKeyEvent event) { if (event.getKeyCode() == KeyEvent.VK_DELETE) { GraphScene s = (GraphScene)widget.getScene(); if(widget instanceof MyWidget) { s.removeNode(s.findObject(widget)); return State.CONSUMED; } else if(widget instanceof MyConnectionWidget){ widget.removeFromParent(); return State.CONSUMED; } } return State.REJECTED; }

Lo importante acá es que para eliminar un objeto MyWidget se debe utilizar el método removeNode y en el caso de un objeto MyConnectionWidget se debe utilizar removeFromParent.

La acción de eliminar se agrega en las clases MyWidget y MyConnectionWidget.

Una opción muy útil, y que no he visto en Internet, es la capacidad de guardar la escena para que la podamos cargar en otro momento (importar/exportar). Para esto creé el método saveWidgetsToXML en la clase MyScene y lo que hace es tomar cada uno de los objetos MyWidget, toma la clase MyNode de cada uno y lo pasa a un XML, almacenando sus atributos como texto (incluyendo la imagen, usando Base64). También toma los objetos MyConnectionWidget, de cada uno toma el objeto MyEdge y los almacena en el mismo XML, guardando la relación entre Widgets.

public void saveWidgetsToXML() { JFileChooser chooser = new JFileChooser (); chooser.setDialogTitle ("Save Scene As XML"); chooser.setDialogType (JFileChooser.SAVE_DIALOG); chooser.setMultiSelectionEnabled (false); chooser.setFileSelectionMode (JFileChooser.FILES_ONLY); chooser.setFileFilter (new FileFilter() { public boolean accept (File file) { if (file.isDirectory ()) return true; return file.getName ().toLowerCase ().endsWith (".xml"); // NOI18N } public String getDescription () { return "Extensible Markup Language (.xml)"; // NOI18N } }); if (chooser.showSaveDialog (new JFrame()) != JFileChooser.APPROVE_OPTION) return; File file = chooser.getSelectedFile (); if (! file.getName ().toLowerCase ().endsWith (".xml")) // NOI18N file = new File (file.getParentFile (), file.getName () + ".xml"); // NOI18N if (file.exists ()) { DialogDescriptor descriptor = new DialogDescriptor ( "File (" + file.getAbsolutePath () + ") already exists. Do you want to overwrite it?", "File Exists", true, DialogDescriptor.YES_NO_OPTION, DialogDescriptor.NO_OPTION, null); DialogDisplayer.getDefault ().createDialog (descriptor).setVisible (true); if (descriptor.getValue () != DialogDescriptor.YES_OPTION) return; } WidgetsXML wxml = new WidgetsXML(file); wxml.prepareToSave(); List<Widget> list = mainLayer.getChildren(); for(int i=0; i<list.size(); i++) { MyWidget w = (MyWidget)list.get(i); MyNode n = w.getNode(); n.setLocation(w.getLocation()); wxml.addMyNode(n); } List<Widget> listConn = connectionLayer.getChildren(); for(int i=0; i<listConn.size(); i++) { MyConnectionWidget w = (MyConnectionWidget)listConn.get(i); MyEdge e = w.getMyEdge(); wxml.addMyEdge(e); } wxml.save(); }

El archivo XML tiene la forma

<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?> <raiz> <my-nodes></my-nodes> <my-edges></my-edges> </raiz>

También se agregó la opción de cargar el XML y reconstruir la escena, para lo que se creó el método loadWidgetsFromXML

public void loadWidgetsFromXML() { JFileChooser chooser = new JFileChooser (); chooser.setDialogTitle ("Load Scene From XML"); chooser.setDialogType (JFileChooser.OPEN_DIALOG); chooser.setMultiSelectionEnabled (false); chooser.setFileSelectionMode (JFileChooser.FILES_ONLY); chooser.setFileFilter (new FileFilter() { public boolean accept (File file) { if (file.isDirectory ()) return true; return file.getName ().toLowerCase ().endsWith (".xml"); // NOI18N } public String getDescription () { return "Extensible Markup Language (.xml)"; // NOI18N } }); if (chooser.showSaveDialog (new JFrame()) != JFileChooser.APPROVE_OPTION) return; File file = chooser.getSelectedFile (); WidgetsXML wxml = new WidgetsXML(file); wxml.prepareToLoad(); ArrayList<MyNode> myNodes = wxml.getMyNodes(); for(int i=0; i<myNodes.size(); i++) { MyNode node = myNodes.get(i); Widget w = MyScene.this.addNode(node); getSceneAnimator().animatePreferredLocation(w, w.convertLocalToScene(node.getLocation())); } ArrayList<MyEdge> myEdges = wxml.getMyEdges(); MyNode source = null; MyNode target = null; for(int i=0; i<myEdges.size(); i++) { MyEdge edge = myEdges.get(i); for(int j=0; j<myNodes.size(); j++) { MyNode n = myNodes.get(j); if(n.getId().equals(edge.getSource())) source = n; if(n.getId().equals(edge.getTarget())) target = n; } addEdge(edge); setEdgeSource(edge, source); setEdgeTarget(edge, target); } }

El detalle de la funcionalidad de los Widgets lo pueden ver leyendo el código fuente de este ejemplo. El código es muy limpio y simple, por lo que no creo que tengan problemas en entenderlo. Si hay dudas, comenten en el blog.

Dejo unas capturas de pantalla para que vean como luce la aplicación.

Saludos !!!

Mandriva 2010 liberado, actualízate !!!

2009-11-04T21:27:00.000-03:00

Mandriva Linux 2010

Mandriva, el editor europeo líder en soluciones Linux, anuncio el 3 de Noviembre de 2009 el lanzamiento de Mandriva Linux 2010. Más rápida, fácil y segura que nunca, Mandriva Linux ofrece nuevas funcionalidades que revolucionarán el entorno de escritorio. Mandriva Linux 2010 es el sistema operativo Linux más avanzado hasta la fecha, una genuina concentración de tecnologías e innovaciones. Incluye soporte para un amplio número de configuraciones de hardware, lo que lo convierte en base sólida y estable para los usuarios.

Mandriva Linux 2010 combina simplicidad y cordialidad en un entorno intuitivo y de alto rendimiento. Es la distribución ideal para toda clase de usuarios, desde los más nuevos hasta los avanzados. Diseñada para satisfacer las necesidades reales de los usuarios, en cuanto a seguridad, rendimiento y ergonomía, Mandriva Linux 2010 es todo lo que Usted siempre ha esperado de un sistema operativo.

"En la búsqueda incesante para ofrecer la mejor experiencia de uso posible, nunca dejamos de lado nuestro objetivo: diseñar uno de los más avanzados sistemas del mundo"

Explica Anne Nicolas-Velu, Directora de Ingeniería de Mandriva.

Mandriva Linux 2010 ofrece un sistema operativo Linux que no solo es el más avanzado y fácil de usar del mercado, sino también que integra la lista de los softwares más completos. El corazón de las innovaciones de Mandriva 2010 es el "Escritorio inteligente", una tecnología única que ofrece acceso dinámico a todos los archivos mediante su etiquetado; clasificación de fotos, documentos, correos electrónicos y videos salvaguardando los datos personales a través de un
enfoque personalizado.

En pocas palabras, Mandriva Linux 2010 ofrece un sistema completo, de rápida y fácil instalación; y que incluye:

Todos los controladores necesarios Compatibilidad con las nuevas plataformas (así cómo con las más antiguas), incluídos los netbooks.

Una amplia gama aplicaciones que abarcan ofimática, software educativo, multimedia, juegos

Moblin: El entorno para plataformas móviles

Herramientas que permiten mantener su sistema seguro de manera fácil

Las últimas versiones de las principales aplicaciones de Código Abierto:
- KDE 4.3.2
- GNOME 2.28
- Firefox 3.5.3
- Xorg Server 1.6.5
Un amplio rango de aplicaciones complementarias en la versión Powerpack: Códecs de video y audio, virtualización a través de VMware, aplicaciones de Adobe. Etc.

Mandriva Linux es un sistema operativo de uso diario que se adapta a su ordenador y dispositivos. Satisfará todas sus necesidades y le permitirá compartir la experiencia con sus amigos. Mandriva Linux 2010 está disponible en tres ediciones:

Powerpack (la edición comercial, que incluye software exclusivo, soporte y servicios)

One (un Cd en vivo que puede ser también instalado permanentemente en el equipo) y

Free (una edición que únicamente incluye Software Libre y de Código Abierto).

Dual Arch (edición para arquitecturas i586 / 32 bits y x86 / 64 bits es la instalacion minima, perfecta para sistemas antiguos).

Versiones libres y gratuitas

Mandriva Linux, Free, ONE y Dual Arch pueden ser descargadas desde sin cargo alguno:

http://www.mandriva.com/es/descargas

http://torrent.mandriva.com/public/2010.0/

Las versiones FREE y DUAL ARCH solo contienen Software Libre la version ONE trae consigo algunos programas cuya licencia no es libre.

Version de pago: Precios y disponibilidad

Todas las ediciones de Mandriva Linux 2010 estarán disponibles para su descarga desde el 3 de Noviembre de 2009. Puede obtener la edición de descarga de Mandriva Linux 2010 Powerpack desde Mandriva Store:

http://store.mandriva.com/

o puede comprar una suscripción Powerpack y descargar Mandriva Linux 2010 Powerpack hoy. Mandriva Linux 2010 Free y One pueden descargarse desde el sitio de Mandriva:

http://www.mandriva.com/

La edición en caja de Mandriva Linux 2010 Powerpack esta disponible por 69 euros, o US$79. La edición "Slim" (liviana) (solo contiene el DVD sin documentación) está disponible por 64 euros, o US$74. La suscripción Powerpack le permite obtener la edición de descarga de Powerpack durante doce meses (por lo que cubre 2 versiones Mandriva Linux), disponible por 69 euros, o US$79.

¿Necesitas ayuda con Mandriva linux?

Visita la Comunidad y Foro Oficiales de los Usuarios Hispanohablantes de Mandriva Linux:
blogdrake.net

Traduccion realizada por el equipo de Traductores de BlogDRAKE "MDK Trans"

Copia esta noticia en tu sitio web: Colabora con Mandriva Linux

Zenoss - Monitoreo de infraestructura TI

2009-09-04T10:51:00.029-04:00

Zenoss es un software opensource que permite realizar monitoreo remoto de equipos como servidores, routers, ups, etc.

El monitoreo permite saber si un equipo está andando (up) o no (down), permite saber los filesystem que tiene (discos duros, unidades externas, opticos, RAM, memoria caché, etc.) y la utilización (total, usado, libre), permite saber qué procesos y servicios están corriendo y además saber que aplicaciones están instaladas en el equipo.

Y para que quiero saber esto de forma remota ? simple e importante, hoy en día toda infraestructura TI es crítica para el negocio ya que sin ésta es muy dificil que el negocio funcione, la infraestructura TI es la base de los negocios de hoy y el mañana y es importante tener un control respecto a los equipos y los servicios que corren y que soportan a nuestro equipo de trabajo y el de nuestros clientes.

El monitoreo permite adelantarse a los problemas y generar directivas preventivas y correctivas de manera tal de asegurar la prestación y calidad de nuestros servicios.

Zenoss es una solución entre varias como Nagios u openNMS e incluso otras propietarias como BMC Performance Manager Portal y BMC Proactive Net.

La gracia de Zenoss es que es simple de usar y configurar, es mas escalable que Nagios y puede utilizar plugines de éste último. A modo personal puedo decir que se parece a BMC Performance Manager Portal y BMC Proactive Net en su forma de funcionar y los servicios y opciones que provee.

Zenoss permite manejar eventos provenientes de los equipos monitoreados y generar notificaciones de alertas según lo configure el administrador, por ejemplo, si el servicio SSH se cae o no se ha levantado, es un error crítico desde el punto de vista del servicio como tal, pero tal vez no impacte mi infraestructura de forma grave por lo que se puede configurar una notificación con una criticidad baja.

Zenoss permite monitorear utilizando SNMP, SSH, WMI. Actualmente SSH es el más débil de los 3 ya que su implementación aún no está completa, sin embargo ya existen packs que permiten obtener bastante información útil desde máquinas con Ubuntu, Fedora y openSUSE. Hay que mantenerse informado y actualizado ya que las posibilidades mediante SSH son muchas porque se pueden ejecutar comandos que nos pueden traer cualquier métrica que necesitemos.

Mediante WMI podemos obtener información útil de máquinas Windows como los servicios que están corriendo y el software instalado.

La información que viene desde SNMP es bastante y por lo general suficiente para saber que procesos corren o el % de utización de los recursos físicos.

Zenoss muestra, además, gráficas representativas de la utilización de recursos de CPU y memoria.

Al ser un software opensource, existe una comunidad que aporta con packs de monitoreo, llamados ZenPacks, que extienden la aplicación agregando soporte para más dispositivos, características nuevas o mejoras en performance a dispositivos ya soportados.

El negocio de Zenoss está en el soporte, como todo negocio basado en modelo opensource. Mantienen dos versiones del software, Zenoss Core y Zenoss Enterprise. La primera es la versión libre y gratis que se puede descargar y utilizar, la segunda es la versión pagada con soporte profesional. Ambas son capaces de lo mismo, solo que a la primera se le deben integrar los ZenPacks necesarios (viene listo para SNMP y SSH básico, se debe instalar el soporte para monitoreo WMI, lo cual es muy fácil de hacer).

Una característica realmente interesante es la funcionalidad de Thresholds predictivos que lo acerca a su rival BMC Proactive Net, funcionalidad que permite manejar umbrales dinámicos.

Un umbral dinámico permite manejar valores distintos de acuerdo a la realidad de nuestra organización, por ejemplo para un banco el día 30 sus servidores reciben una mayor carga pero eso es un comportamiento normal por lo que no es necesario alertar, pero si el mismo comportamiento ocurre un día 10 entonces si estamos frente a un problema. Esto no lo permite hacer BMC Performance Manager Portal ni Nagios, punto a favor a Zenoss.

Otra característica importante es el soporte para monitoreo de infraestructura de servidores virtuales VMware ESX 4 (vSphere) ya que está acreditado por VMware.

También tiene integración con Remedy mediante el cual se pueden generar tickets de soporte.

La comunidad alrededor de Zenoss es muy amable, tuve la oportunidad de hacer preguntas y comentarios a los desarrolladores de Zenoss mediante el IRC y no tuvieron ningún problema en responder y aclarar mis dudas. Zenoss tiene a nuestra disposición un blog, foros, noticias y el IRC para hacer preguntas en vivo.

La instalación es muy simple de realizar, solo requiere que esté instalado MySQL.

Primero hay que descargar el instalador de acá, está para 32 y 64 bits (solo para linux).

Luego le damos permisos al ejecutable

chmod +x instalador

y lo ejecutamos desde consola

Presionamos next

Seleccionamos el lugar de instalación

Ingresamos el nombre la contraseña del usuario administrador de MySQL

Presionamos next

Esperamos unos minutos

Y ya tenemos Zenoss listo

Con eso ya la instalación está completa.

Para ingresar simplemente abrimos un navegador web e ingresamos la siguiente URL:

http://localhost:8080

y se abrirá la pantalla inicial de configuración de Zenoss

Pinchamos Step 1 y veremos la siguiente pantalla en donde debemos ingresar la contraseña del usuario "admin" e ingresamos un nuevo usuario de monitoreo

Ahora podemos agregar máquinas para monitorear

Seleccionamos la opcion Manually find devices e ingresamos el IP de la máquina que queremos, en este caso un Linux por SNMP y luego pinchamos submit

Si pinchamos Devices (al lado derecho en la pestaña Classes) podemos ver que en Server aparece un dispositivo agregado con color azul (que significa que se encontró el dispositivo)

Si pinchamos la elipse azul podemos ver el detalle del evento

Si pinchamos el nombre del dispositivo podemos ir a la página de monitoreo del mismo

Como ven, instalar y agregar un elemento al monitoreo es muy simple de realizar y solo se requiere que el servicio SNMP esté activo en el dispositivo a monitorear (Windows, Linux, *NIX, etc.).

Los invito a darle una oportunidad y probar Zenoss, realmente es muy muy muy bueno, una excelente alternativa para monitorear infraestructura que no tiene nada que envidiarle a sus rivales directos. Mas adelante iré agregando tips para usar este super software de monitoreo.

Saludos !!!

JKiltro reproductor de audio 1.0.1

2009-08-23T21:21:00.010-04:00

Hoy he subido la versión 1.0.1 de JKiltro Reproductor de Audio, el cual es un pequeño software desarrollado en Java con el IDE NetBeans 6.7.1.

Este reproductor de audio se basa en varios proyectos open source para reproducir sonido, los cuales son:

Mediante el uso de los proyectos antes mencionados, JKiltro Reproductor de Audio puede reproducir archivos en los formatos aiff, ape, au, mp3, ogg, flac y wav, además permite editar la metadata de los archivos ape, mp3, ogg y flac.

JKiltro Reproductor de Audio mantiene una lista única de reproducción y contiene los controles básicos de reproducción:

reproducir, detener, pausa, anterior, siguiente, volumen, panning, saltar posición, agregar a la lista, eliminar de la lista, vaciar lista

además permite saltarse la reproducción a cualquier pista de la lista simplemente presionando doble click o la tecla espacio sobre la canción que se quiere escuchar.

También tiene la opción de repetir la reproducción desde el inicio con solo marcar un cuadro con un ticket.

Otra característica que lo hace interesante es que contiene un pequeño previsualizador al momento de elegir la carpeta o archivos justo antes de seleccionarlos y agregarlos a la lista de reproducción, de manera que se puede escuchar y así estar seguros de agregarlos o no a la lista.

Lo mejor de todo este proyecto es que puede ser utilizado en sus propias aplicaciones ya que pueden agregar el panel principal a su propio contenedor (JFrame, JPanel) con solo crear una instancia:

PanelPrincipalReproductorAudio reproductor = new PanelPrincipalReproductorAudio();

y ya tienen un reproductor de audio (y editor de metadata) empotrado.

Si no les gusta la interfaz gráfica entonces pueden crearse una propia sin preocuparse por la lógica que maneja la reproducción y edición de los archivos de audio gracias al diseño MVC, simplemente utilizan una instancia del controlador del panel principal en su propio panel con la GUI.

ControladorPanelPrincipalReproductorAudio controlador = new ControladorPanelPrincipalReproductorAudio();

Una buena forma de entender el código fuente es partir mirando la clase PanelPrincipalReproductorAudio.java, leer y tracear los métodos asociados a los eventos de cada botón, lo cual es muy útil al crearse una interfaz gráfica propia y hacer uso del controlador (que ya es capaz de encargarse de toda la lógica importante de la reproducción y edición).

El proyecto substance lo usé para permitir elegir un theme para la aplicación pero eso no tiene nada que ver con la reproducción de audio, sin embargo es un proyecto muy interesante que le da belleza a las aplicaciones java.

Aún quedan cosas por hacer, por ejemplo agregar un equalizador, JLGui trae uno pero falta integrarlo a mi proyecto.

Lo he probado en Mandriva Spring 2009 y Windows XP SP3 y funciona bien.
En el caso de Linux, si se quiere compartir el recurso de audio con otras aplicaciones se debe usar pulse audio y OpenJDK, de otra forma la aplicación les tomará el recurso de audio y no permitirá a otras aplicaciones utilizarlo.

A continuación les dejo algunas capturas de pantalla:

Desde aća pueden descargar el código fuente (proyecto NetBeans 6.7.1) y desde acá pueden descargar los binarios para usar la aplicación y probarla.

Espero les sea de utilidad.

Saludos !!!

Me titulé de Ingeniero Civil en Computación e Informática !!!

2009-06-29T14:48:00.004-04:00

Estimados lectores de mi blog,

Hace tiempo que no levantaba una entrada en mi blog ya que me he visto muy ocupado con varios temas (trabajo, universidad, familia, etc), pero me comprometo a seguir manteniendo el blog con mas entradas y aportes.

Hoy quiero compartir mi alegría con ustedes y contarles que he obtenido mi título de Ingeniero Civil en Computación e Informática, después de 6 años de sacrificio tanto propio como de mi familia y amigos que estuvieron acompañandome por este camino que elegí.

Quiero decirle a quienes están estudiando que sigan adelante, que se puede lograr, se puede llegar a la meta !!!, sigan estudiando, aprendiendo, aplicando y compartiendo conocimiento, que gracias a estos principios es que cada día crecemos mas como personas y profesionales.

Un saludo a todos.

Exposición Web Service con NetBeans 6.5.1 y Glassfish 2.1

2009-05-24T00:11:00.012-04:00

Tiempo atrás hice un tutorial bastante detallado sobre como crear y consumir web services usando NetBeans y Glassfish. Hoy traigo lo mismo pero con un ejemplo mucho mas sencillo y fácil de entender y digerir.

Esta entrada trata sobre la exposición de un Web Service, en otra entrada explicaré cómo consumirlo.

El ejemplo expone dos métodos a través de Web Service para validar la existencia de un usuario (getUsuario) y para modificar sus datos (setUsuario).

Los datos del usuario están en un archivo XML para mantener el ejemplo sencillo y simple. La estructura del XML es la siguiente:

<?xml version="1.0" encoding="UTF-8"?>
<raiz>
<usuario id="1" user="metalklesk" passwd="metalklesk" activo="true" />
<usuario id="2" user="klesk" passwd="klesk" activo="false" />
</raiz>

como se puede ver a continuación:

El archivo se llama usuarios.xml y debe crearse (o copiarse) en el directorio home del usuario (en el caso de Windows creo que es el directorio del usuario dentro de Mis Documentos, corríjanme si me equivoco y en el caso de Linux es /home/usuario).

Una vez listo ya podemos crear el Web Service. Para esta tarea utilizaremos un contenedor EJB.

Abrimos NetBeans 6.5.1 -> New project -> Java EE -> EJB module

como nombre ingresamos EJBModuleWebService y seleccionamos Glassfish como servidor de aplicaciones.

Una vez listo creamos una clase java a la cual llamaremos Usuario y la agregamos al package org.modelo (como no existe, se creará al ingresarlo en la misma pantalla de creación de la clase). La clase Usuario tendrá el siguiente código:

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package org.modelo;

/**
*
* @author metalklesk
*/
public class Usuario {

private int id;
private String user;
private String passwd;
private boolean activo;

public boolean isActivo() {
return activo;
}

public void setActivo(boolean activo) {
this.activo = activo;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getPasswd() {
return passwd;
}

public void setPasswd(String passwd) {
this.passwd = passwd;
}

public String getUser() {
return user;
}

public void setUser(String user) {
this.user = user;
}
}

Ahora crearemos la clase AccesoDatos en el mismo package. Esta clase tendrá el siguiente código:

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package org.modelo;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
*
* @author metalklesk
*/
public class AccesoDatos {

private Document documento = null;
private String archivo = System.getProperty("user.home") + "/usuarios.xml";
private static AccesoDatos datos = new AccesoDatos();

private AccesoDatos() {
try {
documento = (Document) (((DocumentBuilderFactory.newInstance()).newDocumentBuilder()).parse(new File(archivo)));
} catch (SAXException ex) {
Logger.getLogger(AccesoDatos.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
Logger.getLogger(AccesoDatos.class.getName()).log(Level.SEVERE, null, ex);
} catch (ParserConfigurationException ex) {
Logger.getLogger(AccesoDatos.class.getName()).log(Level.SEVERE, null, ex);
}
}

public static AccesoDatos getInstance() {
return datos;
}

public Usuario getUsuario(String user, String passwd) {
Element raiz = (Element) documento.getDocumentElement();
NodeList hijos = raiz.getElementsByTagName("usuario");
Usuario usuario = null;

for(int i=0; i<hijos.getLength(); i++) {
Element elemento = (Element) hijos.item(i);
String x = elemento.getAttribute("user");
String y = elemento.getAttribute("passwd");

if(x.equalsIgnoreCase(user) && y.equalsIgnoreCase(passwd)) {
usuario = new Usuario();
usuario.setId(Integer.parseInt(elemento.getAttribute("id")));
usuario.setUser(x);
usuario.setPasswd(y);
usuario.setActivo(Boolean.parseBoolean(elemento.getAttribute("activo")));

break;
}
}

return usuario;
}

public boolean setUsuario(Usuario usuario) {
Element raiz = (Element) documento.getDocumentElement();
NodeList hijos = raiz.getElementsByTagName("usuario");
boolean respuesta = false;

for(int i=0; i<hijos.getLength(); i++) {
Element elemento = (Element) hijos.item(i);
int id = Integer.parseInt(elemento.getAttribute("id"));

if(id == usuario.getId()) {
elemento.setAttribute("id", String.valueOf(id));
elemento.setAttribute("user", usuario.getUser());
elemento.setAttribute("passwd", usuario.getPasswd());
elemento.setAttribute("activo", String.valueOf(usuario.isActivo()));

respuesta = actualizarUsuarios();
break;
}
}

return respuesta;
}

private boolean actualizarUsuarios() {
documento.getDocumentElement().normalize();

try {
DOMSource source = new DOMSource(documento);
StreamResult result = new StreamResult(new FileOutputStream(archivo));

TransformerFactory transFactory = TransformerFactory.newInstance();
Transformer transformer = transFactory.newTransformer();
transformer.transform(source, result);

return true;
} catch (TransformerException ex) {
Logger.getLogger(AccesoDatos.class.getName()).log(Level.SEVERE, null, ex);
return false;
} catch (FileNotFoundException ex) {
Logger.getLogger(AccesoDatos.class.getName()).log(Level.SEVERE, null, ex);
return false;
}
}
}

Una vez listo ya podemos crear el Web Service, para eso hacemos click derecho en el proyecto -> New -> Web service

Ingresamos como nombre UsuarioWebService y lo agregamos al package org.modelo.

Una vez listo, ingresamos el siguiente código con los métodos a exponer en el Web Service:

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package org.modelo;

import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
import javax.ejb.Stateless;

/**
*
* @author metalklesk
*/
@WebService()
@Stateless()
public class UsuarioWebService {

/**
* Web service getUsuario
* @param user
* @param passwd
* @return
*/
@WebMethod(operationName = "getUsuario")
public Usuario getUsuario(@WebParam(name = "user")
String user, @WebParam(name = "passwd")
String passwd) {
AccesoDatos datos = AccesoDatos.getInstance();

return datos.getUsuario(user, passwd);
}

/**
* Web service getUsuario
* @param usuario
* @return
*/
@WebMethod(operationName = "setUsuario")
public Boolean setUsuario(@WebParam(name = "usuario")
Usuario usuario) {
AccesoDatos datos = AccesoDatos.getInstance();

return datos.setUsuario(usuario);
}

}

Ya con eso estamos listos con la exposición del Web Service, ahora para probarlo podemos ejecutar la aplicación haciendo click derecho -> Run y luego expandimos la carpeta Web Services, damos click derecho el web service UsuarioWebService y pinchamos la opción Test Web service, lo cual abrirá una ventana del navegador web predeterminado en NetBeans.

Espero les sea de utilidad y como siempre me pueden dejar un comentario con su dirección de correo y les reboto el proyecto NetBeans comprimido.

Saludos !!!

Gráficos JMaki-Dojo, Servlets y Java Beans

2009-05-22T23:49:00.015-04:00

Hace unos días estuve "jugando" con Java y JMaki para crear gráficos (charts). Buscando en la red encontré el proyecto jmaki-charting, el cual permite generar gráficos Dojo de tipo Area, Linea, Barra y Torta.

Desgraciadamente, los ejemplos de gráficos Dojo están malos, si entran en la página de ejemplos y pinchan un enlace de gráficos Dojo verán lo siguiente:

Asi es que me propuse crear un ejemplo que si funcione y de eso se trata esta entrada.

La gracia del ejemplo que explicaré a continuación es que se hace uso de clases java para la creación de los gráficos. De ésta manera se pueden crear gráficos a partir de datos obtenidos dinámicamente de una base de datos o cualquier fuente que se quiera. Si bien el ejemplo usa datos "duros" fácilmente se podrían modificar las clases y traer los datos de una base de datos.

También se muestra en el ejemplo la carga de los gráficos sin la necesidad de cargar una página jsp nueva, simplemente se refresca el área correspondiente y lo demás sigue igual lo que impacta positivamente en la velocidad de carga y experiencia del usuario.

Manos a la obra. Lo primero que necesitamos es NetBeans 6.5.1 con el JDK 1.6 update 13 (con ésta versión realicé el ejemplo). Una vez instalado hay que descargar los módulos de JMaki, para eso ir a Tools -> Plugins y seleccionar los dos plugines de JMaki.

Una vez reiniciado NetBeans hay que descargar el módulo jmaki-charting, abrir NetBeans e ir a Tools -> Palette -> Add jmaki library y seleccionar el módulo previamente descargado. Una vez listo ya se pueden utilizar los gráficos Dojo en NetBeans a través de la paleta.

La aplicación es web y explicaré la lógica que hay detrás de todo. Lo primero es entender como funciona la aplicación.

Básicamente se tiene un menú donde puedes elegir el tipo de gráfico. Éste menú es un combobox Dojo, el cual se arrastra desde la paleta al index.jsp. Cuando se arrastra un combobox dojo se genera con valores por default, pero eso no es muy útil, lo mejor es cargar los datos desde un Java Bean. El java Bean utilizado es el siguiente:

package org.beans;

import org.modelo.Parametros;

/**
*
* @author metalklesk
*/
public class BeanListaCharts {

public String getValues() {
StringBuffer buffer = new StringBuffer();

buffer.append("[");
buffer.append("{label:'Area', value:'" + Parametros.AREA + "'},");
buffer.append("{label:'Barra', value:'" + Parametros.BAR + "'},");
buffer.append("{label:'Linea', value:'" + Parametros.LINE + "'},");
buffer.append("{label:'Torta', value:'" + Parametros.PIE + "'}");
buffer.append("]");

return buffer.toString();
}
}

Luego hay que ingresar la siguiente línea en el jsp para hacer uso del Bean:

<jsp:useBean id="BeanListaCharts" class="org.beans.BeanListaCharts"/>

Y luego hay que pasar del siguiente código (que viene por default al arrastrar un combobox Dojo)

<a:widget name="dojo.combobox"
value="[
{label : 'Alabama', value : 'AL'},
{label : 'California', value : 'CA'},
{label : 'New York', value : 'NY', selected : true},
{label : 'Texas', value : 'TX'}
]" />

a la siguiente forma:

<a:widget name="dojo.combobox" value="${BeanListaCharts.values}" publish="/miCombo" />

Si se fijan, el value lo rellenamos con el método getValues del Java Bean. Eventualmente esos datos podrían provenir de una base de datos.

El publish es para publicar un evento asociado al combobox. Lo que sigue es programar el evento a nuestro gusto. Esto se hace en el archivo glue.js utilizando un subscribe, en ese archivo agregamos lo siguiente (al final):

jmaki.subscribe("/miCombo/onSelect", function(args) {
/*
*Se debe cargar el grafico desde una pagina (o servlet) externa pero dentro del dominio
*e insertarla mediante el injector.
**/
var url_ = jmaki.webRoot + '/ServletGeneradorCharts?tipoChart=' + args.value;
var injector = new jmaki.Injector();
injector.inject({url:url_, injectionPoint:"chart"});
});

Aquí utilizamos un Injector para agregar código html dinámico en una parte específica de la página, sin tener que recargar todo de nuevo en una página nueva. El Injector recibe como parámetros la dirección de la página a cargar y el lugar de la página actual en la cual será insertada.

En este caso llamamos a un servlet al cual le pasamos como parámetro el valor recogido de la selección en el combobox.

El método processRequest del servlet luce de la siguiente manera:

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();

String contexto = request.getContextPath();

String seleccion = request.getParameter("tipoChart");
String chart = "No existe ese tipo de gráfico.";

if(seleccion.equalsIgnoreCase(Parametros.PIE)) {
PieChartDojoJMaki pie = new PieChartDojoJMaki();
//si no le pasamos los parámetros requeridos, se genera un pie de ejemplo
//con valores predeterminados.
chart = pie.getValor();

out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/resources/base.js"></script>");
out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/resources/plotkit/excanvas.js"></script>");
out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/resources/plotkit/PlotKit_Packed.js"></script>");
out.println("<link rel="stylesheet" type="text/css" href="" + contexto + "/resources/jmaki/charting/resources/jmaki-charting.css" />");
out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/pie/component.js"></script>");
out.println("<script type="text/javascript">jmaki.addWidget({widgetDir:'" + contexto + "/resources/jmaki/charting/pie',name:'jmaki.charting.pie',value:" + chart + ",uuid:'jmaki_charting_pie'});</script>");
out.println("<div id="jmaki_charting_pie" class="jmCPie">");
out.println("<canvas id="jmaki_charting_pie_chart" class="jmCPie"></canvas>");
out.println("</div>");
out.close();
} else if(seleccion.equalsIgnoreCase(Parametros.AREA)) {
AreaChartDojoJMaki area = new AreaChartDojoJMaki();
//si no le pasamos los parámetros requeridos, se genera un pie de ejemplo
//con valores predeterminados.
chart = area.getValor();

out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/resources/base.js"></script>");
out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/resources/plotkit/excanvas.js"></script>");
out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/resources/plotkit/PlotKit_Packed.js"></script>");
out.println("<link rel="stylesheet" type="text/css" href="" + contexto + "/resources/jmaki/charting/resources/jmaki-charting.css" />");
out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/area/component.js"></script>");
out.println("<script type="text/javascript">jmaki.addWidget({widgetDir:'" + contexto + "/resources/jmaki/charting/area',name:'jmaki.charting.area',value:" + chart + ",uuid:'jmaki_charting_area2'});</script>");
out.println("<div id="jmaki_charting_area2" class="jmCPie">");
out.println("<canvas id="jmaki_charting_area2_chart" class="jmCPie"></canvas>");
out.println("</div>");
out.close();
} else if(seleccion.equalsIgnoreCase(Parametros.BAR)) {
BarChartDojoJMaki bar = new BarChartDojoJMaki();
//si no le pasamos los parámetros requeridos, se genera un pie de ejemplo
//con valores predeterminados.
chart = bar.getValor();

out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/resources/base.js"></script>");
out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/resources/plotkit/excanvas.js"></script>");
out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/resources/plotkit/PlotKit_Packed.js"></script>");
out.println("<link rel="stylesheet" type="text/css" href="" + contexto + "/resources/jmaki/charting/resources/jmaki-charting.css" />");
out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/bar/component.js"></script>");
out.println("<script type="text/javascript">jmaki.addWidget({widgetDir:'" + contexto + "/resources/jmaki/charting/bar',name:'jmaki.charting.bar',value:" + chart + ",uuid:'jmaki_charting_bar'});</script>");
out.println("<div id="jmaki_charting_bar" class="jmCPie">");
out.println("<canvas id="jmaki_charting_bar_chart" class="jmCPie"></canvas>");
out.println("</div>");
out.close();
} else if(seleccion.equalsIgnoreCase(Parametros.LINE)) {
LineChartDojoJMaki line = new LineChartDojoJMaki();
//si no le pasamos los parámetros requeridos, se genera un pie de ejemplo
//con valores predeterminados.
chart = line.getValor();

out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/resources/base.js"></script>");
out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/resources/plotkit/excanvas.js"></script>");
out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/resources/plotkit/PlotKit_Packed.js"></script>");
out.println("<link rel="stylesheet" type="text/css" href="" + contexto + "/resources/jmaki/charting/resources/jmaki-charting.css" />");
out.println("<script type="text/javascript" src="" + contexto + "/resources/jmaki/charting/line/component.js"></script>");
out.println("<script type="text/javascript">jmaki.addWidget({widgetDir:'" + contexto + "/resources/jmaki/charting/line',name:'jmaki.charting.line',value:" + chart + ",uuid:'jmaki_charting_line'});</script>");
out.println("<div id="jmaki_charting_line" class="jmCPie">");
out.println("<canvas id="jmaki_charting_line_chart" class="jmCPie"></canvas>");
out.println("</div>");
out.close();
} else {
//si el tipo de gráfico no corresponde, notifico al usuario.
out.println("<font color="#f00">" + chart + "</font>");
out.close();
}
}

El servlet recibe el parámetro seleccionado por el usuario a través del request.getParameter y dependiendo del valor construye un gráfico. Para obtener los valores del widget se hace uso de las clases

AreaChartDojoJMaki
BarChartDojoJMaki
LineChartDojoJMaki
PieChartDojoJMaki

Cada una de éstas clases se especializa en construir un gráfico en particular, utilizando la notación definida por JMaki (Dojo en este caso). En el ejemplo se utilizan datos duros, pero al igual que el caso del combobox, fácilmente se pueden adaptar para hacer uso de una base de datos.

A continuación se puede ver el código de la clase que define un gráfico de area:

package org.modelo;

import java.util.ArrayList;

/**
*
* @author metalklesk
*/
public class AreaChartDojoJMaki {

private ArrayList<String> xEtiquetas;
private ArrayList<String> yEtiquetas;
private ArrayList<String> datos;

/**
* Constructor sin parámetros. Inicia valores predeterminados para construir un
* gráfico de ejemplo.
*/
public AreaChartDojoJMaki() {
xEtiquetas = new ArrayList<String>();
xEtiquetas.add("{label : 'Enero'}, ");
xEtiquetas.add("{label : 'Febrero'}, ");
xEtiquetas.add("{label : 'Marzo'}, ");
xEtiquetas.add("{label : 'Abril'}, ");
xEtiquetas.add("{label : 'Mayo'}, ");
xEtiquetas.add("{label : 'Junio'}, ");
xEtiquetas.add("{label : 'Julio'}, ");
xEtiquetas.add("{label : 'Agosto'}, ");
xEtiquetas.add("{label : 'Septiembre'}, ");
xEtiquetas.add("{label : 'Octubre'}, ");
xEtiquetas.add("{label : 'Noviembre'}, ");
xEtiquetas.add("{label : 'Diciembre'}");

yEtiquetas = new ArrayList<String>();
yEtiquetas.add("{ label : '0', value : 0}");
yEtiquetas.add("{ label : '10s', value : 10}");
yEtiquetas.add("{ label : '20s', value : 20}");
yEtiquetas.add("{ label : '30s', value : 30}");
yEtiquetas.add("{ label : '40s', value : 40}");
yEtiquetas.add("{ label : '50s', value : 50}");

datos = new ArrayList<String>();
datos.add("{id : 'marcador', label : 'Dataset 1', values : [25, 45, 25, 45, 50, 25, 35, 25, 25, 20, 35, 45] }");
datos.add("{label : 'Dataset 2', values : [20, 40, 30, 35, 45, 20, 25, 15, 20, 25, 30, 40] }");
datos.add("{label : 'Dataset 3', values : [15, 35, 15, 40, 30, 15, 20, 10, 15, 20, 30, 35] }");
datos.add("{label : 'Dataset 4', values : [10, 25, 10, 5, 20, 5, 15, 5, 10, 15, 25, 30] }");
}

/**
* Recibe los datos que construyen el gráfico. Se pueden ingresar varios conjuntos de datos (datasets) y la forma
* en que se ingresa cada uno es de la siguiente manera:
* "{label : '$titulo_dataset', values : [$valor1, $valor2, ..., $valorN]}", sin las comillas.
* @param datos
*/
public void setDatos(ArrayList<String> datos) {
this.datos = datos;
}

/**
* Recibe las etiquetas para la coordenada X. El formato de cada etiqueta debe ser de la siguiente forma:
* "{label: '$valor'},", sin las comillas.
* @param xEtiquetas
*/
public void setXEtiquetas(ArrayList<String> xEtiquetas) {
this.xEtiquetas = xEtiquetas;
}

/**
* Recine las etiquetas para la coordenada Y. El formato de cada etiqueta debe ser de la siguiente forma:
* "{label : '$titulo', value : $valor}"
* @param yEtiquetas
*/
public void setYEtiquetas(ArrayList<String> yEtiquetas) {
this.yEtiquetas = yEtiquetas;
}

/**
* Retorna el contenido de la etiqueta value del componente jmaki.charting.area.
* @return
*/
public String getValor() {
StringBuffer buffer = new StringBuffer();

buffer.append("{");
//valores de la coordenada x
buffer.append("xAxis : { labels : [ ");
for(int i=0; i< xEtiquetas.size(); i++) {
buffer.append(xEtiquetas.get(i));
}
buffer.append("]},");
//valores de la coordenada y
buffer.append("yAxis : { labels : [");
for(int i=0; i< yEtiquetas.size(); i++) {
buffer.append(yEtiquetas.get(i) + ", ");
}
buffer.append("]},");
//aqui agrego marcadores en algunos puntos.
buffer.append("markers : [{ targetId : 'marcador', label : '{value}', " +
"index : 5}, { targetId : 'marcador', label : '{value}', index : 6}, " +
"{ targetId : 'marcador', label : '{value}', index : 8}],");
//datos que construyen el grafico
buffer.append("data : [ ");
for(int i=0; i<datos.size(); i++) {
buffer.append(datos.get(i) + ", ");
}
buffer.append("]");

buffer.append("}");

return buffer.toString();
}
}

Como se pude ver, no es necesario utilizar objetos JSON, un simple String con la estructura adecuada basta para generar un chart o widget JMaki en general.

A continuación se pueden ver imágenes del ejemplo funcionando.

Como siempre pueden dejar un comentario con su dirección de correo y les envío el ejemplo completo (proyecto en NetBeans 6.5.1 comprimido) para que lo corran y vean en sus equipos.

Saludos !!!

Convertir datos de latin1 a utf8 en MySQL 5.1

2009-05-17T17:00:00.005-04:00

Hace poco tuve que migrar el sitio web de la empresa en la cual trabajo a otro servidor para lo cual fue necesario pedir, al proveedor del servicio de hosting, el respaldo del sitio junto a la base de datos.

El problema apareció cuando los datos de la base de datos perdieron la codificación utf8, los acentos (tíldes), las ñ's y otros caracteres fueron reemplazados por caracteres extraños, por ejemplo ConsultorÃa en vez de Consultoría.

Cuando cargué la base de datos (utilizando PhpMyAdmin) me dí cuenta que las tablas quedaron con el charset latin1 en vez de utf8. Averiguando por Internet supe que el problema está en la instalación inicial de MySQL, la cual deja todo el sistema con latin1_swedish_ci y por lo tanto al exportar la base de datos, se pierden los caracteres especiales.

En Internet abundan pequeñas guías que solo solucionan parcialmente el problema pero no del todo. En la mayoría de las páginas encontré que se debía cambiar el charset de la base de datos, tablas y campos (varchar y text), pero eso solo sirve para los datos nuevos, pero que pasa con los que ya están ingresados y que presentan el problema ?

La receta para solucionar el problema completo es seguir los siguientes pasos (en orden):

Convertir los datos de latin1 a binario y de binario a utf8 para cada campo de tipo varchar y text de cada tabla de la base de datos.
Cambiar el charset del campo de latin1 a utf8.
Cambiar el charset de las tablas de latin1 a utf8.
Cambiar el charset y el collation de la base de datos de latin1 a utf8.

Para convertir los datos de un charset a otro se utiliza la función convert de MySQL, la cual se usa de la siguiente manera:

update tabla set campo = convert( convert(campo using binary) using utf8);

Para cambiar el charset de la tabla se hace de la siguiente manera:

alter table tabla charset = utf8;

Para cambiar el charset de la base de datos se hace de la siguiente manera:

alter database basedatos charset = utf8;

Y con eso se soluciona el problema.

Para evitar que vuelva a suceder el problema en el futuro, recomiendo que sean precavidos al crear una base de datos y siempre seleccionen el charset y collation a utf8 (_unicode_ci).

Espero les sirva como a mi.

Saludos !!!

KDE 4.2 Final disponible para openSUSE 11.1

2009-01-27T13:20:00.003-03:00

Hoy 27 de enero sale la versión final oficial de KDE 4.2, un escritorio de lujo, y ya está disponible para los opensuseros !!!!

Simplemente se deben agregar los repositorios e instalar. Si ya lo tienes instalado, entonces un

sudo zypper up

hará la actualización correspondiente.

Aquí pueden ver KDE 4.2 RC 1 actualizandose por zypper:

y aquí pueden ver que uso Amarok 2.0.1 en KDE 4.2.0 (versión final estable):

A disfrutar !!!

Saludos !!!

Cursos HTML, XHTML y PHP online

2009-01-17T00:10:00.005-03:00

Mi buen amigo Eduardo "Jam" Aguila de Tecnologías Libres está haciendo unos cursos online libres para aprender a programar páginas web en HTML y XHTML. Si te interesa aprender sobre estas tecnologías, visita el siguiente enlace Curso para aprender HTML / XHTML. Además te invito a complementar lo anterior aprendiendo PHP con Loreto "Loretoo" Parra, para ello visita el siguiente enlace.

Si tienes dudas y quieres preguntarles directamente a ellos entonces que esperas, hazlo desde irc.

Feliz aprendizaje !!!

Saludos !!!

Opensuse 11.1 disponible para descarga

2008-12-14T16:08:00.003-03:00

Hace unos días atrás comenzó la cruzada por encontrar mirrors desprotegidos para descargar la versión final de opensuse 11.1. Algunos logramos descargar una o mas isos antes de que los sitios fueran protegidos y por ende nadie mas pudiera descargar (otros con menos suerte llegaron a descargar el 90% y nada mas).

Gracias a que algunos que lo bajaron subieron el torrent, ahora está disponible nuevamente para la descarga, un servicio no oficial pero que permite la descarga de la versión final oficial.

Desde ya doy las gracias a la comunidad de foro suse quienes se han encargado de la búsqueda de mirrors y a todos aquellos involucrados en la provisión de los torrents e isos.

Opensuse 11.1 x86 (32 bits) DVD
Opensuse 11.1 x86 (32 bits) Live CD KDE 4.1.3
Opensuse 11.1 x86_64 (64 bits) DVD

Yo ya la estoy disfrutando desde hace dos días, que esperan !!!

Durante estos dos dias de uso como sistema principal y único en mi equipo me he encontrado con un bug bastante desagradable. Cada vez que abria en un programa un diálogo de descarga o de guardado de algun archivo a alguna parte del disco duro (firefox y ktorrent, no probé otros), el home se "desmontaba" y no quedaba otra que reiniciar el equipo. Al volver a hacer lo mismo volvia a "desmontarse" y el home queda inutilizable desde interfaz gráfica (desde consola no hay problema), sin embargo los sub directorios no tienen problemas.

A continuación algunas screenshots del error:

Aquí se ve el home antes de abrir el diálogo de descarga (de firefox)

Aquí se ve el home después de abrir el diálogo de descarga (de firefox)

Aquí se ve un sub directorio después de abrir el diálogo de descarga (de firefox)

Haciendo pruebas por aquí por allá llegué a la conclusión de que el culpable es jexec, entonces simplemente se desactiva ese demonio desde YaST -> Sistema -> Servicios del sistema, se reinicia el equipo y ya está.

Saludos !!!

J-Kiltro 4.0 Beta 5 Liberado

2008-12-14T03:43:00.005-03:00

Hoy he liberado la versión 4.0 Beta 5 de mi software de conversión de archivos de audio multi formato J-Kiltro.
Si bien es beta, funciona a full. Aún me falta revisarlo a detalle y agregarle algunas características mas, por eso está en esta etapa.

Para quienes no saben de qué hablo, J-Kiltro es un software que sirve para convertir un archivo de audio de un formato a otro, por ejemplo mp3 a ogg, wma a mpc. Soporta 14 formatos de entrada y 12 de salida.

Los formatos de entrada son:

aac,aiff,ape,au,flac,m4a,m4b,mp3,mp4,mpc,ogg,ra,wav y wma

y los formatos de salida son:

aac,aiff,ape,au,flac,m4a,m4b,mp3,mp4,mpc,ogg y wav

Esta aplicación está desarrollada 100% en java utilizando el IDE NetBeans 6.5.

Dentro de las características de ésta versión se encuentran:

Interfaz muy simple y amigable.
Soporta 14 formatos de entrada y 12 de salida.
Extracción de pistas de audio desde CD (son selección de pistas).
Tiene previsualizador de audio con un reproductor interno (mp3, ogg, flac, wav, aiff y au).
Reproductor de audio interno.
Obtiene metadata desde archivos de audio automáticamente.
Permite editar la metadata de los archivos de audio.
Detección automática de dependencias.
Permite el ingreso de archivos de distintos formatos a la lista y automáticamente sabe como tratarlos para llevarlos al formato de destino.
Soporta distintos look and feel.
etc.

Ésta aplicación solo funciona en distribuciones Linux ya que requiere de algunas aplicaciones de linea de comandos para hacer las conversiones. Las dependencias son:

Lame
Vorbis-tools
Mppdec y Mppenc
Sox
Mac
Flac
Faac y Faad
Mplayer
CD Paranoia
JRE 1.6 update 10 o superior (openjdk 6 también sirve)

Todas las dependencias (o la mayoría) están disponibles en los repositorios de las distribuciones Linux, por ejemplo todas están disponibles en openSUSE 11.0, por lo que antes de pensar en compilarlas tu mismo, mejor descárgalas usando el gestor de paquetes de tu distro (YaST, apt-get, yum, etc.), es más simple.

La razón de que no corre en Windows es simple, no le he dado soporte. Si bien está desarrollado en Java, la detección de dependencias es solo para distribuciones Linux y los comandos de conversión no son los mismos en una distro Linux y en Windows. De todas formas estos dos aspectos son simples de modificar para portar la aplicación a Windows.

Si alguien está interesado en dar el soporte para que esta aplicación corra en otros SO bienvenido sea, el código está bajo la licencia GPL 3.

Esta versión (beta 5) se diferencia de la beta 4 en varias cosas pequeñas pero importantes.

Se han corregido algunos errores en la reproducción de sonido en el previsualizador interno y se le han agregado algunos detalles como mostrar el % de sonido reproducido (en el avance), el nombre del archivo que se esta leyendo y su duración en minutos y segundos.

Se ha agregado una lista de reproduccion con opcion de agregar y quitar archivos así como editar su metadata (mp3, ogg y flac por el momento) directamente sin necesidad de hacer una conversión.

También se ha agregado la opción de agregar los archivos convertidos a la lista de reproducción de audio principal de la aplicación.

A continuación dejo algunas screenshots extras para que se puedan familiarizar con la aplicación.

El problema que tiene es inherente a java y es que la reproducción de audio no se puede hacer a menos que no exista ningún otro programa reproduciendo audio (firefox en youtube, amarok corriento, etc.) ya que java toma control absoluto y directo de la tarjeta de sonido. Aún no conozco alguna solución a esto pero seguiré buscando.

Cualquier comentario constructivo será bienvenido.

Saludos !!!

Canal #softwarelibre en IRC

2008-12-08T02:16:00.003-03:00

Hace unos días nuestro amigo Eduardo Aguila alias jam de Tecnologías Libres y Foros de Software Libre nos avisó de la apertura de un canal en IRC en donde podemos juntarnos quienes queremos compartir conocimiento y hacernos de amistades mas allá de las fronteras inmediatas.

El servidor IRC es

irc.cl

y el canal es

#softwarelibre

NO se requiere de ninguna contraseña, solo ingresan un nombre de usuario y listo.

Para entrar pueden usar cualquier cliente IRC como XChat, Konversation, Pidgin o mIRC (por nombrar algunos). Un cliente que me recomendó nuestro amigo bloguero Gonzalo Díaz Cruz alias Sir Gon es mibbit, un cliente IRC hecho en ajax y funciona sobre un navegador web, ideal para conectarse desde redes restrictivas como en las Universidades. Un link directo para entrar a este canal es éste.

La verdad, desde que se abrió este canal me conecto bastante, es una buena vía de comunicación y difusión de información.

La invitación es abierta a todos, los esperamos !

Saludos !!!

Chat escalable en Java usando NetBeans 6.5

2008-11-30T23:40:00.010-03:00

Introducción
Hace tiempo creé una pequeña aplicación para chat, un cliente y un servidor.

Si bien ese chat funciona bien, no es escalable. Cada vez que se conecta un cliente, el servidor crea un hilo para gestionarlo. Si se conectan mil personas, se crean mil hilos. Como ya se darán cuenta, mediante esa forma de trabajar el consumo de CPU y memoria RAM se elevan mucho a medida que se conectan mas y mas personas.

Los hilos sirven, permiten hacer varias cosas a la vez sin que se bloquee al usuario, pero la verdad, para una aplicación chat no es recomendable.

Mirando la API de java NIO (New Input Output) mas algunos foros, blogs y tutoriales se puede ver que ésta permite hacer aplicaciones escalables con flujos de datos (Sockets, archivos, etc.). Esta API tiene una clase llamada Selector, la cual se encarga de manejar Sockets no bloqueantes que no son mas que canales para transmisión de flujos de datos.

NIO es una solución para aplicaciones escalables en java, no es necesario crear hilos para cada cliente y literalmente puede manejar miles de clientes con un bajo consumo de recursos.

El problema con NIO es que es de muy bajo nivel, lo único que puede viajar por la red son objetos de tipo ByteBuffer, pero que pasa cuando los datos que se quieren transmitir son de diferentes largos ? que pasa si me paso en el tamaño establecido por el buffer ? o si me sobra ? al ser de bajo nivel hay que gestionar demasiados casos, demasiados parámetros, como mencionaba es de bajo nivel. Y justamente este problema lo tuve al desarrollar un nuevo chat usando NIO. Cuando enviaba muchos emoticones el mensaje se perdía por el tema del buffer.

Los ejemplos en Internet abundan, pero los ejemplos decentes .... no encontré ni uno solo, solo se encuentran cosas como para enviar un par de palabras, nada que permita a un usuario hacer algo mas grande o mas normal como enviar texto mezclado con imágenes o url's.

Buscando algo que encapsulara y subiera de nivel a NIO llegué a un proyecto open source muy muy muy bueno, se llama XSocket. Esta es una API que encapsula a NIO encargándose de todo lo que es de bajo nivel permitiendo al desarrollador preocuparse por la implementación de lo que es importante (la lógica de la comunidad java) y no de los detalles (importantes) de bajo nivel.

Migré mi código inicial de NIO a XSocket y todo funcionó a la perfección.

Características
La aplicación que desarrollé soporta:

Emoticones
Color del texto cambiable
Estados
Mensaje personal
Avatares
URL's
Chat global o general
Chat privados
Pestañas
Multi usuario

Lo que no soporta este chat es envío de archivos, tal vez alguno de ustedes lo puede hacer y compartir con los demás, así hacemos un chat mas poderoso.

Mensajes
Los mensajes que se transmiten son texto con estructura XML, un mensaje podría tener la siguiente estructura:

<?xml version="1.0" encoding="UTF-8" standalone="no"?> <raiz> <tipo></tipo> <remitente>metalklesk</remitente> <avatar></avatar> <color></color> <mensaje> <texto>Este es un ejemplo de texto junto a un emoticon</texto> <emoticon></emoticon> <texto>y al lado hay un link</texto> <url>http://metalklesk.blogspot.com</url> <texto>que se puede pinchar para abrirlo en un navegador web.</texto> </mensaje> <destinatario> <usuario></usuario> <usuario></usuario> <usuario></usuario> <usuario></usuario> </destinatario> </raiz>

Protocolo de mensajería
El protocolo de mensajería se basa en etiquetas o tags que definen ciertas características.
El tag tipo establece el tipo de mensaje que se transmite. Estos tipos tienen un valor entero y cada valor tiene su significado particular. A continuación se pueden ver los tipos y su significado:

-2: conexión aceptada desde el servidor
-1: conexión rechazada desde el servidor, nickname ya está en uso
1 : aviso/petición de conexión
2 : mensaje broadcast (para todos)
3 : cliente ha cambiado de estado
4 : cliente ha cambiado de avatar
5 : cliente ha cambiado su mensaje personal
6 : mensaje unicast (solo para uno)

Mediante el establecimiento de tipos de mensajes, la gestión de los mismos se torna muy fácil, simplemente se lee el tipo de mensaje y se gestiona según corresponda.

El uso de una estructura XML permite crear un mensaje ordenado, donde cada parte esta bien definida y además se pueden agregar más sin cambiar o modificar lo ya hecho.

Mediante este esquema se pueden enviar mensajes con texto, emoticones y URL's, en cualquier orden y todo lo que se quiera. Se pueden enviar mensajes broadcast o unicast (multicast no está implementado pero el protocolo lo permite), se pueden usar nicknames, estados, mensajes personales, etc.

Funcionamiento interno
Formateando el mensaje
Para el funcionamiento interno se debe construir un mensaje con estructura XML a partir del texto que el usuario escriba en el chat. Para esto escribí una clase que se llama FiltroMensajeFormatoXML, el cual hace un parseo de la linea de texto y separa en texto, emoticones y URL's retornando un ArrayList con el contenido del mensaje pre-formateado. Los emoticones son imágenes, éstas imágenes son transformadas a texto codificándolas en Base64.

El texto a formatear puede ser el siguiente:

Hola mundo! [emo]ohaha[/emo], visita mi blog [url]http://metalklesk.blogspot.com[/url]

Y la salida pre formateada sería la siguiente

[texto]Hola mundo!
[emoticon](emoticon en texto)
[texto], visita mi blog
[url]http://metalklesk.blogspot.com

Una ves pre-formateado se crea un objeto de la clase MensajeFormatoXML, al cual se le pasa el contenido del mensaje, el tipo de mensaje y todos los datos que correspondan según el tipo de mensaje. Ésta clase tiene un método que crea un documento XML con toda la información ingresada al objeto y retorna un String con el mensaje construido y formateado.
El mensaje quedaria de ésta forma:

<?xml version="1.0" encoding="UTF-8" standalone="no"?> <raiz> <tipo>2</tipo> <remitente>metalklesk</remitente> <avatar>imagen codificada en base 64</avatar> <color>representacion del color como entero</color> <mensaje> <texto>Hola mundo! </texto> <emoticon>imagen codificada en base 64</emoticon> <texto>, visita mi blog</texto> <url>http://metalklesk.blogspot.com</url> </mensaje> <destinatario> </destinatario> </raiz>

Una vez listo el mensaje está listo para ser enviado.

Conexión al servidor
Para conectarse al servidor del chat se crea una instancia de la clase NonBlockingConnection del API XSocket. Esta clase recibe el ip o hostname del servidor, el puerto y un manejador de la entrada de datos (una instancia de la clase IDataHandler).

Envío y recepción del mensaje
Para enviar un mensaje simplemente se utiliza la linea:

nbc.write(mensaje.getMensajeXML() + "\n", "UTF-8");

y el mensaje en formato de texto XML es enviado al servidor.

Cuando el servidor envía una respuesta, ésta es capturada en el objeto IDataHandler mediante el método onData, y se utiliza la siguiente línea para obtener el texto:

String res = nbc.readStringByDelimiter("\n", "UTF-8");

Luego se crea una instancia de la clase ParserMensajeXML que se encarga de crear un documento XML en memoria con el texto y luego se obtiene un objeto MensajeFormatoXML con el mensaje listo para ser leído utilizando los métodos GET definidos.

public boolean onData(INonBlockingConnection nbc) throws IOException, BufferUnderflowException,MaxReadSizeExceededException { //aqui recibo el mensaje entrante String res = nbc.readStringByDelimiter("\n", "UTF-8"); //aqui parseo el mensaje ParserMensajeXML xml = new ParserMensajeXML(res); //aqui obtengo el mensaje MensajeFormatoXML mensaje = xml.getMensaje(); //aqui lo envio a todos los que están a la escucha del mensaje entrante. RepetidorMensajeEntrante.getInstance().enviarMensaje(mensaje); return true; }

Lo demás del chat cliente es solo el manejo de la presentación del mensaje, eventos y algunas cosas entretenidas que no tienen nada que ver con la transmisión de datos por la red.

Utilización
Para utilizar el chat primero se debe ejecutar el servidor. Para esto simplemente se debe ejecutar en consola en cualquier Sistema Operativo que soporte Java:

java -jar ServidorNIO.jar

o ejecutar en Linux

./run.sh

o en Windows (se debe renombrar el archivo run.bat.txt a run.bat)

./run.bat

No olvidar que se debe tener instalada la máquina virtual de java, recomiendo la última versión a la fecha.

Capturas de pantalla
Aquí dejo algunas capturas de pantalla mostrando la ejecución de la aplicación

Descarga !!!
Todo el código está muy bien comentado, así es que lo pueden leer, entender, aprender y modificar.
Esta aplicación, cliente y servidor, está bajo la licencia GPL V3.
Para ver el código y modificarlo deben usar NetBeans 6.5.
Aquí está el cliente y aquí está el servidor.

UPDATE 19-12-2008
He subido la versión 2.1 con los siguientes cambios:

Se corrige un error que unos amigos lectores avisaron mediante sus comentarios. El error se refiere a la creación (escritura) y lectura del archivo de configuración config.xml en la clase Configuracion.java. El error ocurre porque cuando se crea el archivo XML, la máquina virtual de java lo crea utilizando la codificación de caracteres por default del sistema operativo en el cual se ejecuta y al leer el archivo XML le especifiqué que el archivo estaba en UTF-8, lo cual no es cierto en el caso de Windows (en Linux ningún problema). La solución fue simplemente forzar la escritura del archivo en UTF-8.
También agregué soporte para los temas (UI, User Interface) del proyecto substance.
Actualicé XSocket a la versión 2.3.
Agregué el soporte para enviar zumbidos en los mensajes privados (la ventana tiembla !!!).
Eliminé código innecesario en el servidor y en el cliente (ahora son menos lineas de código).

Aquí está el cliente y aquí está el servidor.

Para descargar de los links anteriores se debe dar un click donde dice Request Download Ticket y luego Download (o Descargar).

UPDATE 26-04-2009
Hasta que consiga un repositorio que no me de problemas para compartir archivos, por favor dejarme sus correos en un comentario y les reboto el cliente y el servidor por esa vía. Blogger me avisa cuando me hacen comentarios y mi correo lo estoy viendo todo el día, por lo que no me demoraré mucho en responderles (probablemente dentro del mismo día les conteste).

UPDATE 18-08-2009
He creado un proyecto en Google Code así es que ahora pueden descargar el chat desde ahí sin tener que pedírmelo por correo o por el blog. Aún así agradeceré los comentarios que me puedan dejar en el blog.
El enlace es el siguiente: http://code.google.com/p/jtricahuenio/.

He realizado unos pequeños cambios desde la versión 2.1,la versión para descargar desde el enlace anterior es la 2.1.1:

Actualicé xSocket a la versión 2.5.4.
Agregué el proyecto Base64 para reemplazar la implementación de Sun para la codificación y decodificación de las imágenes (avatares y emoticones) en el chat, ahora funciona impecable con OpenJDK.
Actualicé substance a la versión 5.2 agregando 3 nuevos themes (Dust, Dust Coffe y Twilight).
El código fuente viene en un proyecto para NetBeans 6.7.1.

Saludos !!!

Instalación de Openbravo 2.40 en Windows XP (SP3)

2008-11-26T01:56:00.010-03:00

Me han pedido una guía de instalación sobre Windows XP de Openbravo 2.40. Y aunque no uso ese sistema operativo, lo instalé en una máquina virtual solo para hacer esta entrada.

Lo primero es lo primero, algunos se preguntarán qué es Openbravo, Openbravo es un ERP (Enterprise Resource Planning) opensource diseñado para las MIPyME (micro, pequeña y mediana empresa).
Con esta herramienta de gestión los empresarios pueden controlar los diferentes aspectos de su negocio a través de los módulos que provee.

Esta herramienta de gestión empresarial está disponible para la descarga gratuita desde el sitio web oficial de Openbravo y NO se requiere el pago de licencias para su uso en ambiente personal ni comercial.

Openbravo no es un software que se descargue e instale en un par de clicks ... bueno en realidad si pero requiere de algunas dependencias previas y una pequeña configuración del sistema para su instalación y ejecución.

Requerimientos:

Bien, para la realización de esta guía se utilizaron la última versión de Openbravo (2.40), Ant (1.7.1), Tomcat (6.0.18) y JDK (1.6.0_10). La versión de PostgreSQL que utilizé es la 8.3.5. Hay que tener en cuenta que Openbravo funciona con PostgreSQL desde la versión 8.1.4 en adelante.

Instalación de dependencias:

PostgreSQL.
Para descargar PostgreSQL vamos acá. Ahí verán dos opciones, la One click installer y pgInstaller.

La primera parece ser la mejor opción, pero no lo es. Al final de la instalación sale un error que no permite iniciar la base de datos así es que recomiendo descargar la segunda opción (pgInstaller).
Luego seleccionamos la version 8.3.5 para win32 y seleccionamos el archivo que se llama postgresql-8.3.5-1.zip y lo descargamos. Una vez descargado se descomprime, entramos a la carpeta y ejecutamos el instalador (postgresql-8.3.exe).

Aparecerá el wizard de instalación, seleccionamos el idioma (English)

seleccionamos las opciones de instalación por default

luego ingresamos la contraseña de la cuenta de servicio, luego seleccionamos la localización y DEBEMOS seleccionar UTF8 para el encoding del servidor y el cliente, luego ingresamos la contraseña de administrador del usuario postgres (debe ser distinta a la contraseña de la cuenta servicio)

y luego hacemos click siguiente siguiente siguiente para terminar con la configuración y la instalación comenzará. Al final desmarcamos la opción de instalar el Stack Builder y finalizamos.

Tomcat.
Ahora vamos a descargar la última versión de apache tomcat. Acá descargamos la versión 6.0.18. Una vez descargado lo descomprimimos y movemos la carpeta a C:\.

Ant.
Ahora vamos a descargar la última versión de apache ant. Acá descargamos la versión 1.7.1. Una vez descargado lo descomprimimos y movemos a C:\.

JDK.
Ahora vamos a descargar la última versión del JDK. Acá descargamos la versión Java SE Development Kit (JDK) 6 Update 10. Una vez descargado ejecutamos e instalamos.

Configuración del sistema:
Una vez todo instalado debemos configurar las variables de entorno. Si no las configuramos no podremos instalar Openbravo.

Mi PC -> Propiedades -> Opciones Avanzadas -> Variables de Entorno

en Variables de usuario o sistema, click en Nueva:
Nombre de la variable: ANT_HOME Valor de variable: la dirección completa de donde se encuentra la carpeta del Ant (C:\apache-ant-1.7.1)

en Variables de usuario o sistema, click en Nueva:
Nombre de la variable: CATALINA_HOME
Valor de variable: la dirección completa de donde se encuentra la carpeta del tomcat (C:\apache-tomcat-6.0.18)

en Variables de usuario o sistema, click en Nueva:
Nombre de la variable: JAVA_HOME
Valor de variable: la dirección completa de donde se encuentra la carpeta del JDK (C:\Archivos de programa\Java\jdk1.6.0_10)

en Variables de usuario o sistema, click en Nueva:
Nombre de la variable: JRE_HOME
Valor de variable: la dirección completa de donde se encuentra la carpeta del JRE (C:\Archivos de programa\Java\jdk1.6.0_10\jre)

en Variables de usuario o sistema, click en Nueva:
Nombre de la variable: JDK_HOME
Valor de variable: la dirección completa de donde se encuentra la carpeta del JDK (C:\Archivos de programa\Java\jdk1.6.0_10)

Luego debemos modificar la variable PATH e incluir al final del valor lo siguiente:
;%ANT_HOME%\bin;%CATALINA_HOME%\bin;%JAVA_HOME%\bin;%JRE_HOME%\bin;%JDK_HOME%\bin

Guardamos y reiniciamos.
Ahora las variables están correctamente configuradas y ya podemos instalar Openbravo.

Instalación de Openbravo:

Lo primero es descargarlo, para esto nos dirigimos acá y seguimos el wizard. Una vez descargado lo ejecutamos.

Aceptamos la licencia, seleccionamos el directorio de instalación

seleccionamos el directorio de los attachments

seleccionamos la instalación completa

luego la instalación estándar

luego seleccionamos el directorio con los ejecutables de java

ant

y tomcat.

Como configuramos las variables aparecerán automáticamente. Luego seleccionamos la base de datos PostgreSQL

luego aparecerá automáticamente el directorio de los ejecutables de PostgreSQL (al instalarlo se configuraron las variables de entorno de PostgreSQL).

Luego ingresamos el host y el puerto de la base de datos

luego ingresamos la contraseña del usuario postgres

luego ingresamos el nombre de la base de datos, el usuario y su contraseña

Luego ingresamos el nombre del contexto de la aplicación

luego seleccionamos el formato de la fecha que queremos usar en el sistema

luego seleccionamos si queremos que se llene la base de datos con datos ficticios (la empresa Big Bazar).

Una vez listo comienza la instalación.

La instalación demora mas o menos una hora, dependiendo del equipo y sus recursos.
Una vez finalizado estamos listos.

Ahora para iniciar openbravo debemos tener iniciado PostgreSQL y Tomcat.
Para iniciar postgreSQL vamos a Menú inicio -> Todos los programas -> Postgresql 8.3 -> start service
Para iniciar Tomcat vamos a C:\apache-tomcat-6.0.18\bin y ejecutamos el archivo startup.bat

Luego abrimos en nuestro navegador favorito la siguiente URL: http://localhost:8080/openbravo

Ingresamos el nombre de usuario Openbravo y la contraseña openbravo

y ya estamos dentro del sistema.

No hay nada mejor que tener tu propio ERP.

Espero les haya servido esta humilde guía de instalción.

saludos !!!

No Cache, No Store, Internet Explorer en problemas !!!

2008-11-19T01:34:00.006-03:00

Hace meses estoy desarrollando un sistema de administración de prácticas profesionales para la Escuela de Ingeniería Civil de la Universidad Andrés Bello (en Chile).

Resulta que lo estoy desarrollando en Java utilizando el IDE NetBeans 6.5 (partí usando el 6.0, luego el 6.1), uso JSP, Servlets, AJAX (con JMAKI), CSS2, una biblioteca para PDF llamada iText, para el almacenamiento de datos utilizo MySQL (5.0.67) y el servidor de aplicaciones es, por supuesto, Glassfish V2 UR2.

El sistema funciona correctamente corriendo en Windows o Linux. Yo utilizo Firefox y firebug no me ha encontrado ningún error en ninguna parte del sistema. El problema lo tuve al querer acceder al sistema utilizando el "navegador web" Internet Explorer (6.0, 7.0, 8.0Beta2, sobre Windows XP SP1, SP2 y SP3). Siempre que quería acceder me salia el siguiente error:

Internet Explorer cannot download index.jsp from localhost
Internet Explorer was not able to open this Internet site. The requested site is either unavailable or cannot be found.
Please try again later.

Aquí una imagen mostrando la pantalla de error en Windows XP SP3:

Esto me ha traido dolores de cabeza por bastante tiempo, busqué y busqué en Internet sin respuestas satisfactorias. De pronto llegué a una página de Microsoft donde sale el problema de "Internet explorer cannot download". Ahí sale que ese error ocurre cuando la URL es segura (HTTPS) (NO es mi caso).

Entre las causas del error sale el uso de las cabeceras "no-cache" y "no-store". Precisamente en mi sistema utilizo esas cabeceras en todos los JSP por seguridad y consistencia. En esa misma página se reconoce que el problema es de los productos Microsoft (para variar ...... ¬¬), en Internet Explorer 6.0 SP1. Aprovecho para comunicar a la gente de Microsoft que aún no solucionan el problema en todas las versiones posteriores a la 6.0 SP1.

Lo mas ridículo de todo lo que sale en esa página de Microsoft es el WORKAROUND:

To work around this problem, make sure that Do Not Save Encrypted Files check box is not checked and that the server does not send the "Cache-Control: No Store" or the "Cache-Control: No Cache" header.

Y en español dice:

Para solucionar este problema, asegúrese que la opción No Guardar Archivos Encriptados no esté marcada y que el servidor no envíe la cabecera "Cache-Control: No Store" o la "Cache-Control: No Cache".

Inteligente la solución ¬¬, si usted es un usuario, como puede hacer que el servidor no envíe esas cabeceras ?? si usted es desarrollador de software y realmente necesita que no se almacenen los datos en el cache del navegador, va a permitir que Microsoft le de una respuesta tan absurda ??

Bueno, ese es el problema. La solución no era tan complicada, tediosa si. Se debe agregar a TODOS los JSP las siguientes líneas (se agregan al principio, fuera de la etiqueta <html>):

response.setHeader("Cache-Control","no-cache");
response.setHeader("Cache-Control","no-store");
response.setHeader("Cache-Control","must-revalidate");
response.setHeader("Pragma","no-cache");
response.setDateHeader ("Expires", 0);

Para que la solución quede mas elegante se puede crear un fragmento de JSP, un archivo JSPF e insertar esas lineas ahí y luego en los JSP agregar un include que apunte al fragmento, así:

<jsp:directive.include file="../WEB-INF/jspf/NoCache.jspf">

Ya con eso el problema está solucionado, ahora el sistema funciona en Firefox e Internet Explorer.

Desgraciadamente aún hay que hacer excepciones para el navegador mas usado, pues no sigue estándares y lo que hace lo hace casi siempre mal, esta es solo una de las cosas que tuve que realizar para que el sistema funcionara con Internet Explorer, también tuve que hacerlo al crear archivos PDF para que el IE los pudiera descargar, entre otras cosas.

Ya saben, si les ocurre este problema ya tienen una solución.

saludos !!!

Agregar regiones de los países en Openbravo 2.40

2008-10-30T01:54:00.009-03:00

Ayer en la tarde visité el foro de Openbravo y me dirigí a Openbravo Chile. Me fijé en un post que decía que al crear una nueva entidad, seleccionar Chile, en el combobox Regiones no aparece ninguna región. Esto me hizo ir a ver de inmediato para corroborar dicha información y efectivamente es así. Averiguando un poco, las regiones ingresadas solo corresponden a Estados Unidos de Norteamérica, España y otros.

Esta situación por supuesto es crítica, las regiones de nuestros países deberían estar en el sistema.
Mirando los archivos XML de traducción (el mismo que yo traduje) encontré que en el archivo C_COUNTRY_TRL_es_CL(ES, AR, etc) existe la lista de países ingresados en el sistema y cada país tiene una identificación asociada (un id). En el caso de Chile corresponde al número 152.

Luego de buscar regiones en los XML me di cuenta que no existe ninguna, entonces fui a ver la base de datos utilizando phpPgAdmin y mirando las tablas encontré una que se llama c_region y ahí encontré las regiones ingresadas en el sistema (EEUU, España, otros).

Entonces la solución mas clara era ingresar las regiones una a una directamente en la base de datos, lo hice, luego fuí a crear una nueva entidad en Openbravo y al seleccionar Chile ahora si aparecen las regiones correctamente.

Entonces ahora les voy a dar la receta mas simple para agregar las regiones de su país en Openbravo.

Requisitos

Openbravo instalado y funcionando.
Traducción al idioma que les corresponda según su país.
Instalar phpPgAdmin

Para instalar phpPgAdmin simplemente abrimos YaST -> Software -> Instalar/Desinstalar software y en el buscador ingresamos "phpPgAdmin" (sin las comillas), le damos click al botón buscar, seleccionamos el paquete y presionamos finalizar. Automáticamente se seleccionaran las dependencias necesarias.

Una vez listo debemos iniciar la base de datos, para esto simplemente ejecutamos en consola el siguiente comando:

service postgresql start

y luego levantamos el servidor web Apache con el siguiente comando:

service apache2 start

Ahora abrimos un navegador web y escribimos la siguiente dirección:

http://localhost/phpPgAdmin

Ingresamos el nombre de usuario y contraseña de administrador de PostgreSQL:

Veremos la base de datos Openbravo:

Pinchamos la base de datos en el arbol de la izquierda -> Esquemas -> Tablas y buscamos c_region

pinchamos la tabla y podremos ver los campos que contiene. Abajo veremos varios botones con acciones sobre la tabla, una de ellas es Insertar fila:

Pinchamos Insertar fila y podrémos ingresar la región. Lo primero que debemos ingresar es el id de la fila (c_region_id). Si no hemos ingresado regiones mas que las que vienen por default entonces podemos comenzar desde el valor 397 en adelante. Luego debemos ingresar el valor 0 en los siguientes campos:

ad_client_id
ad_org_id
createdby
updatedby

Luego en el campo name ingresamos el nombre de la región (es el que se verá al seleccionar una región desde Openbravo), en el campo description ingresamos la descripción, en el campo c_country_id ingresamos el id del país en cuestión (152 en el caso de Chile), luego marcamos como nulo los siguientes dos campos:

c_nation_id
value

Ahora pinchamos Insertar y repite, con eso se insertará la fila y luego podremos insertar otra mas.

Ya con eso las regiones que faltaban estarán disponibles en Openbravo. Al crear una entidad lo podrán corroborar seleccionando el país en cuestión y verán como aparecen las regiones ingresadas en el combobox Regiones automágicamente.

Para quienes son de Chile, o quieren agregar las regiones de Chile, pueden hacer un copy paste de los siguientes comandos SQL directamente en phpPgAdmin (basta haber seleccionado la base de datos, no necesariamente la tabla c_region) presionando el botón SQL que aparece en la parte superior de la pantalla:

INSERT INTO c_region VALUES (397, 0, 0, 'Y', '2008-10-29 16:00:33.481254', 0, '2008-10-29 16:00:33.481254', 0, 'I - Región de Tarapacá', 'Primera región de tarapacá', 152, 'N', NULL, NULL);
INSERT INTO c_region VALUES (398, 0, 0, 'Y', '2008-10-29 16:05:51.213678', 0, '2008-10-29 16:05:51.213678', 0, 'II - Región de Antofagasta', 'Segunda Región de Antofagasta', 152, 'N', NULL, NULL);
INSERT INTO c_region VALUES (399, 0, 0, 'Y', '2008-10-29 16:06:42.300665', 0, '2008-10-29 16:06:42.300665', 0, 'III - Región de Atacama', 'Tercera región de Atacama', 152, 'N', NULL, NULL);
INSERT INTO c_region VALUES (400, 0, 0, 'Y', '2008-10-29 16:07:26.192938', 0, '2008-10-29 16:07:26.192938', 0, 'IV - Región de Coquimbo', 'Cuarta región de Coquimbo', 152, 'N', NULL, NULL);
INSERT INTO c_region VALUES (401, 0, 0, 'Y', '2008-10-29 16:08:26.366667', 0, '2008-10-29 16:08:26.366667', 0, 'V - Región de Valparaiso', 'Quinta región de Valparaiso', 152, 'N', NULL, NULL);
INSERT INTO c_region VALUES (402, 0, 0, 'Y', '2008-10-29 16:09:26.98355', 0, '2008-10-29 16:09:26.98355', 0, 'VI - Región del Libertador Bernardo O''Higgins', 'Sexta región del Libertador Bernardo O''Higgins', 150, 'N', NULL, NULL);
INSERT INTO c_region VALUES (403, 0, 0, 'Y', '2008-10-29 16:10:12.678488', 0, '2008-10-29 16:10:12.678488', 0, 'VII - Región del Maule', 'Séptima región del Maule', 152, 'N', NULL, NULL);
INSERT INTO c_region VALUES (404, 0, 0, 'Y', '2008-10-29 16:11:13.189255', 0, '2008-10-29 16:11:13.189255', 0, 'VIII - Región del Bío Bío', 'Octava región del Bío Bío', 152, 'N', NULL, NULL);
INSERT INTO c_region VALUES (405, 0, 0, 'Y', '2008-10-29 16:11:48.480753', 0, '2008-10-29 16:11:48.480753', 0, 'IX - Región de la Araucanía', 'Novena región de la Araucanía', 152, 'N', NULL, NULL);
INSERT INTO c_region VALUES (406, 0, 0, 'Y', '2008-10-29 16:12:29.5917', 0, '2008-10-29 16:12:29.5917', 0, 'X - Región de los Lagos', 'Décima región de los Lagos', 152, 'N', NULL, NULL);
INSERT INTO c_region VALUES (407, 0, 0, 'Y', '2008-10-29 16:13:51.964043', 0, '2008-10-29 16:13:51.964043', 0, 'XI - Región de Aysén del General Carlos Ibañez del Campo', 'Undécima región de Aysén del General Carlos Ibañez del Campo', 152, 'N', NULL, NULL);
INSERT INTO c_region VALUES (408, 0, 0, 'Y', '2008-10-29 16:15:16.75494', 0, '2008-10-29 16:15:16.75494', 0, 'XII - Región de Magallanes y la Antártica Chilena', 'Duodécima región de Magallanes y la Antártica Chilena', 152, 'N', NULL, NULL);
INSERT INTO c_region VALUES (409, 0, 0, 'Y', '2008-10-29 16:16:20.543819', 0, '2008-10-29 16:16:20.543819', 0, 'Región Metropolitana', 'Región Metropolitana', 152, 'N', NULL, NULL);
INSERT INTO c_region VALUES (410, 0, 0, 'Y', '2008-10-29 16:17:08.731486', 0, '2008-10-29 16:17:08.731486', 0, 'XIV - Región de los Ríos', 'Décimo cuarta región de los Ríos', 152, 'N', NULL, NULL);
INSERT INTO c_region VALUES (411, 0, 0, 'Y', '2008-10-29 16:18:04.28971', 0, '2008-10-29 16:18:04.28971', 0, 'XV - Región de Arica y Parinacota', 'Décimo quinta región de Arica y Parinacota', 152, 'N', NULL, NULL);

O si quieren pueden importar éste script sql.

Espero les sea de utilidad.

Saludos !!!

Traducción de Openbravo 2.40 al español en OpenSUSE 11.0

2008-10-29T01:01:00.012-03:00

Hace unos días comencé la traducción de Openbravo al español de Chile, mi país.
Me basé en la traducción de España, de la cual solo nos diferenciamos en algunas palabras mas que en conceptos. Sin embargo me encontré con un montón de faltas ortográficas y traducciones mal hechas (desde el inglés), así es que por eso me tomó mas tiempo el lograr la versión Chilena.

Es probable que se me hayan pasado algunos errores ortográficos de la versión española, pero me fijé lo mas que pude (son miles y miles de líneas de texto en 27 archivos XML, 8.5 MB de puro texto, si, es bastante texto por revisar).

La lista de palabras traducidas es la siguiente:

Albarán -> Guía de despacho
albarán -> guía de despacho
Albaranes -> Guías de despacho
albaranes -> guías de despacho
Almacén -> Bodega
almacén -> bodega
Almacenes -> Bodegas
almacenes -> bodegas
Solapa -> Pestaña
solapa -> pestaña
Solapas -> Pestañas
solapas -> pestañas
CIF -> RUT
NIF -> RUT
CIF/NIF -> RUT

Tuve que tener especial cuidado en los singulares y plurales, así como el femenino y masculino, por ejemplo:

Los albaranes -> Las guías de despacho
El almacén -> La bodega
los albaranes -> las guías de despacho
etc.

En el sitio de Openbravo, en la wiki, dice que como recomendación era mejor usar solapa en vez de pestaña, pero en Chile no usamos esa palabra, usamos pestaña, es por eso que en la traducción utilicé esta última. Las demás palabras son las mismas que usamos en Chile. Acá pueden descargar la traducción al español de Chile (es_CL) y acá pueden descargar la versión de España (es_ES) y Argentina (es_AR).

Ahora comenzaré con la explicación de los pasos para traducir Openbravo al idioma Español.

Requisitos:

Openbravo instalado y funcionando

Lo primero que debemos hacer es levantar Postgresql, para eso simplemente ejecutamos el siguiente comando en una consola como usuario root:

service postgresql start

Luego iniciamos Apache Tomcat desde la misma consola:

$CATALINA_HOME/bin/startup.sh

Luego abrimos nuestro navegador web y escribimos la dirección:

http://localhost:8080/openbravo

lo cual nos llevará al sistema de ingreso, escribimos el nombre de usuario Openbravo y la contraseña openbravo y ya entramos al sistema.

Una vez dentro fijamos nuestra mirada sobre el menú donde dice Openbravo (donde sale un icono de una persona) y pinchamos ahí (no pinchar la X o cruz que es para cerrar sesión). Se abrirá una ventana con las opciones del usuario Openbravo. Debemos fijarnos de tener seleccionado el rol de System Administrator y como entidad a System, teniendo eso listo pinchamos ok.

Luego fijamos la mirada nuevamente en el menú y pinchamos General Setup -> Application -> Language

y pinchamos la lupa que aparece arribita (ver imagen anterior). Se abrirá una ventana para ingresar un filtro, ahi ingresamos Spanish% y presionamos ok.

Lo anterior nos cambiará la selección de idioma a español Argentina. Pinchamos el icono de una tabla (con varias filas y 2 columnas) que aparece a la derecha del menú e izquierda del panel de selección de idioma. Al pinchar nos aparecerá un panel con varias filas de países con idioma español, seleccionamos Chile.

Luego pinchamos el icono del lápiz (sobre el icono de la tabla) y veremos que ya no aparece Argentina seleccionado, sino Chile, marcamos la opción System language y fijamos la mirada en el icono de un disquete cuyo tip es "Save Record" y lo pinchamos.

Luego pinchamos el botón Verify Languages

y presionamos ok

esperamos un par de segundos y debemos ver lo siguiente:

Si no aparece lo anterior entonces debemos volver a presionar el botón Verify Languages.
Para comprobar que lo anterior fue realizado correctamente, recomiendo comprobar la salida del siguiente comando SQL en la base de datos:

select * from ad_workflow_trl where ad_language = 'es_CL';

El comando anterior lo puedes realizar desde consola o utilizando algún cliente de administración como phpPgAdmin como se ve a continuación:

y la salida debe ser la siguiente:

Luego debemos crear la carpeta es_CL en /opt/OpenbravoERP/AppsOpenbravo/attachments/lang como se ve a continuación:

luego debemos copiar los 27 archivos XML de la traducción a español Chile a esa carpeta y debe quedar la estructura de archivos así:

Una vez copiados vamos al navegador web y seleccionamos en el menú General Setup -> Application -> Import/Export Translations, seleccionamos la entidad System y el idioma Spanish (Chile), luego presionamos import, como se ve a continuación:

Para estar seguros de que todo se ha realizado correctamente ejecutamos el siguiente comando SQL (es el mismo comando SQL ejecutado anteriormente):

select * from ad_workflow_trl where ad_language = 'es_CL'

y ahora veremos que se han traducido los registros en la base de datos al español:

Ahora cerramos el navegador y bajamos el servicio tomcat con el siguiente comando:

$CATALINA_HOME/bin/shutdown.sh

Luego nos movemos a la carpeta /opt/OpenbravoERP/AppsOpenbravo, abrimos una consola y ejecutamos:

ant compile.complete

Este comando recompilará Openbravo con soporte de idioma español Chile (es_CL). El proceso se demora como 40 minutos mas o menos, dependiendo del equipo. Una vez finalizado ejecutamos:

ant war

y luego:

ant deploy

Al final debemos ver 3 BUILD SUCCESSFUL:

Una vez listo debemos borrar la siguiente carpeta: /opt/apache-tomcat-6.0.18/webapps/openbravo

Si no borramos esa carpeta después nos va a aparecer un error 500 en Openbravo.
Una vez listo iniciamos openbravo:

$CATALINA_HOME/bin/startup.sh

Ingresamos al sistema con el usuario Openbravo y contraseña openbravo y pinchamos donde dice Openbravo sobre el menú al lado del icono de la persona.

Ahora seleccionamos el rol System Administrator, la entidad System el idioma Spanish (Chile), marcamos la opción "Set as default" y presionamos ok:

Apenas presionamos ok, Openbravo se traduce automáticamente al español de Chile como podemos ver a continuación:

Son varios pasos los que hay que seguir para tener Openbravo en nuestro idioma, no es difícil pero debemos respetar los pasos sin saltarnos ninguno. Si siguen esta guía paso a paso no pueden equivocarse.

Espero les sea de utilidad.

Saludos !!!

J-Kiltro 4.0 Beta 3 Liberado

2008-10-25T00:32:00.008-03:00

Hoy he liberado la versión 4.0 Beta 3 de mi software de conversión de archivos de audio multi formato J-Kiltro.
Si bien es beta, funciona a full. Aún me falta revisarlo a detalle y agregarle algunas características mas, por eso está en esa fase.

Para quienes no saben de qué hablo, J-Kiltro es un software que sirve para convertir un archivo de audio de un formato a otro, por ejemplo mp3 a ogg, wma a mpc. Soporta 14 formatos de entrada y 12 de salida.

Los formatos de entrada son:

aac,aiff,ape,au,flac,m4a,m4b,mp3,mp4,mpc,ogg,ra,wav y wma

y los formatos de salida son:

aac,aiff,ape,au,flac,m4a,m4b,mp3,mp4,mpc,ogg y wav

Esta aplicación está desarrollada 100% en java utilizando el IDE NetBeans 6.5.

Dentro de las características de ésta versión se encuentran:

Interfaz muy simple y amigable.
Soporta 14 formatos de entrada y 12 de salida.
Extracción de pistas de audio desde CD (son selección de pistas).
Tiene previsualizador de audio con un reproductor interno (mp3, ogg, flac, wav, aiff y au).
Reproductor de audio interno.
Obtiene metadata desde archivos de audio automáticamente.
Permite editar la metadata de los archivos de audio.
Detección automática de dependencias.
Permite el ingreso de archivos de distintos formatos a la lista y automáticamente sabe como tratarlos para llevarlos al formato de destino.
Soporta distintos look and feel.
etc.

Ésta aplicación solo funciona en distribuciones Linux ya que requiere de algunas aplicaciones de linea de comandos para hacer las conversiones. Las dependencias son:

Lame
Vorbis-tools
Mppdec y Mppenc
Sox
Mac
Flac
Faac y Faad
Mplayer
CD Paranoia
JRE 1.6 update 10

Todas las dependencias (o la mayoría) están disponibles en los repositorios de las distribuciones Linux, por ejemplo todas están disponibles en openSUSE 11.0, por lo que antes de pensar en compilarlas tu mismo, mejor descargalas usando el gestor de paquetes de tu distro (YaST, apt-get, yum, etc.), es mucho mas simple.

La razón de que no corre en Windows es simple, no le he dado soporte. Si bien está desarrollado en Java, la detección de dependencias es solo para distribuciones Linux y los comandos de conversión no son los mismos en una distro Linux y en Windows. De todas formas estos dos aspectos son simples de modificar para portar la aplicación a Windows.

Si alguien está interesado en dar el soporte para que esta aplicación corra en otros SO bienvenido sea, el código está bajo la licencia GPL 3.

Esta versión (beta 3) se diferencia de la beta 2 en varias cosas pequeñas pero importantes.

Se han corregido algunos errores en la reproducción de sonido en el previsualizador interno y se le han agregado algunos detalles como mostrar el % de sonido reproducido (en el avance), el nombre del archivo que se esta leyendo y su duración en segundos.

También se ha agregado un reproductor interno principal (distinto pero parecido al previsualizador) el cual puede ser utilizado para reproducir música mientras se convierten archivos.

Y se agregó un botón para enviar la lista de archivos a convertir a la lista de reproducción de audio (solo se pueden reproducir mp3, ogg, wav, au, aiff y flac).

Se cambió la forma de presentación de datos en la consola de la aplicación ya que antes utilizaba muchos recursos pues se escribía en él cada vez que el proceso devolvía texto, ahora se usa la consola como visualizador de log solo al final de cada proceso (se salva un mucho uso de CPU).

Y por último se me habia olvidado mencionar que las pestañas se pueden cambiar de lugar arrastrándolas desde la beta 2

Si alguno de ustedes usa J-Kiltro, les recomiendo pasarse a esta versión que está mejor que la anterior.

saludos !!!

Instalación de Openbravo 2.40 en OpenSUSE 11.0

2008-10-21T19:25:00.017-03:00

Esta vez vengo con una actualización de la guía para instalar Openbravo en Linux. La versión es la última a la fecha, la 2.40. Si siguen la guía al pie de la letra no deberían tener problemas. Yo lo instalé como explicaré mas adelante y no tuve NINGÚN percance. El sistema operativo que utilizé es OpenSUSE 11.0 , pero sirve cualquier distro (distribución GNU/Linux) con linux 2.6.x.

Lo primero es lo primero, algunos se preguntarán qué es Openbravo, Openbravo es un ERP (Enterprise Resource Planning) opensource diseñado para las MIPyME (micro, pequeña y mediana empresa).
Con esta herramienta de gestión los empresarios pueden controlar los diferentes aspectos de su negocio a través de los módulos que provee.

Esta herramienta de gestión empresarial está disponible para la descarga gratuita desde el sitio web oficial de Openbravo y NO se requiere el pago de licencias para su uso en ambiente personal ni comercial.

Openbravo no es un software que se descargue e instale en un par de clicks ... bueno en realidad si pero requiere de algunas dependencias previas y una pequeña configuración del sistema para su instalación y ejecución.

Requerimientos:

Bien, para la realización de esta guía se utilizaron la última versión de Openbravo (2.40), Ant (1.7.1), Tomcat (6.0.18) y JDK (1.6.0_10). La versión de PostgreSQL que utilizé es la 8.3.1.

Los primeros 4 deben descargarlos de la página oficial de cada uno, el último va a depender de que distribución de linux estén usando y si tienen o no configurados los repositorios de Internet.

Para los recién iniciados en linux y sus múltiples distribuciones, un repositorio es un lugar en donde existen paquetes de software disponible para la descarga e instalación, automática o manual. Por ejemplo openSUSE 11.0 trae un apartado con repositorios, que vienen desactivados por default pero que se pueden activar en YaST -> Software -> Community Repositories, en el caso de PCLinuxOS 2008 los repositorios ya vienen listos. En el caso de otra distribución como Ubuntu, Fedora, etc desconozco ya que no los uso, pero google es su amigo en esos casos.

Recomiendo tremendamente que antes de instalar cualquier cosa, tengan sus repositorios configurados y actualizados antes de seguir con la guía, si no lo hacen así acuérdense de mi, tendrán problemas mas adelante (les suena un BUILD FAILED ??).

Para el JDK tienen varias versiones, si su distribución utiliza paquetes RPM entonces descarguen el paquete de nombre jdk-6u10-linux-i586.rpm.bin y en caso contrario descarguen jdk-6u10-linux-i586.bin. Algunas distribuciones traen el JDK en sus repositorios, pueden instalarlo desde ahí también, pero fíjense después en qué directorio quedará instalado, en el caso del RPM queda en /usr/java/jdk1.6.0_10 y además queda un enlace simbólico llamado /usr/java/latest que apunta al directorio anterior.

Instalación de dependencias:

PostgreSQL.
Entonces ya tenemos descargados Openbravo, Ant, Tomcat y JDK. Ahora utilizaremos el gestor de paquetes que corresponda (YAST, Synaptic, Smart, etc), escribiremos PostgreSQL y lo instalamos como se ve a continuación:

JDK.
Una vez instalado seguimos con el JDK. Lo primero es dar permisos de ejecución al instalador, para esto abrimos una consola (en el caso de utilizar el escritorio KDE, menú -> aplicaciones -> sistema -> terminales -> konsole), escribimos su e ingresamos la contraseña de administrador del sistema (al escribirla no se ve nada, no hay problema) y presionamos enter.

Por default la consola queda posicionada en su home, por ejemplo /home/metalklesk (el cual es mi caso), así que para evitar confusiones tengamos todos los archivos descargados en la raíz de nuestro home.

Ahora escribimos:

chmod a+x jdk-6u10-linux-i586.rpm.bin
./jdk-6u10-linux-i586.rpm.bin

con eso nos va a salir un texto explicando la licencia, etc. y si no nos interesa leerlo presionamos q y enter. Ya con eso tenemos el JDK instalado en /usr/java/jdk1.6.0_10. Si no usamos RPM hacemos lo mismo con el otro:

chmod a+x jdk-6u10-linux-i586.bin
./jdk-6u10-linux-i586.bin

pero no quedará en el mismo directorio, si no que quedará en nuestro home, lo podemos mover a cualquier parte donde tengamos permisos de escritura, por ejemplo, como usuario root lo podemos mover a /opt.

mv -f jdk1.6.0_10/ /opt

y listo. Si utilizaron el gestor de paquetes de su distribución para instalar JDK no hay problemas, pero deben saber en que directorio se encuentra, esa información la necesitaremos mas adelante.

Ant.
Para instalar ant simplemente debemos descomprimir el archivo descargado, si usasmos KDE hacemos click derecho sobre el archivo -> extraer -> extraer aquí. Luego movemos la carpeta a /opt.

mv -f apache-ant-1.7/ /opt

y ya lo tenemos instalado.

Tomcat.
Para instalar Tomcat simplemente debemos descomprimir el archivo descargado, si usamos KDE hacemos click derecho sobre el archivo -> extraer -> extraer aquí. Luego movemos la carpeta a /opt.

mv -f apache-tomcat-6.0.18/ /opt

y ya lo tenemos instalado.

Configuración del sistema.
Ahora debemos configurar PostgreSQL y algunas variables del sistema antes de instalar Openbravo.

PostgreSQL.
Lo primero es darle una contraseña al usuario administrador de PostgreSQL, al usuario postgres, para esto simplemente escribimos en consola:

passwd postgres

y escribimos la contraseña.

Ahora debemos iniciar y detener PostgreSQL por primera vez para que se creen los archivos de configuración, para esto simplemente escribimos en consola:

service postgresql start

y luego

service postgresql stop

como se puede ver en la siguiente imagen.

Ahora debemos modificar el archivo /var/lib/pgsql/data/pg_hba.conf, vamos al final y donde dice:

# "local" is for Unix domain socket connections only
local all all ident sameuser
# IPv4 local connections:
host all all 127.0.0.1/32 ident sameuser
# IPv6 local connections:
host all all ::1/128 ident sameuser

cambiamos el "ident sameuser" por un "trust", sin las comillas, y guardamos.

Con eso ya tenemos lista la configuración de PostgreSQL en el sistema.

Variables del sistema.
Ahora vamos a configurar las variables del sistema, para eso debemos abrir el el archivo /etc/profile como usuario root, si usan KDE entonces escriban en la consola, como usuario root:

kwrite /etc/profile

bajen hasta el final y agreguen las siguientes lineas:

export JAVA_HOME=/usr/java/latest/
export JDK_HOME=/usr/java/latest/
export JRE_HOME=/usr/java/latest/jre
export ANT_HOME=/opt/apache-ant-1.7.1
export CATALINA_HOME=/opt/apache-tomcat-6.0.18
export PATH=${JAVA_HOME}/bin:${JDK_HOME}/bin:${JRE_HOME}/bin:${ANT_HOME}/bin:${CATALINA_HOME}/bin:$PATH

como se ve en la siguiente imagen:

guardamos y reiniciamos el equipo.

Una vez que reiniciamos el equipo, las variables estarán presentes. Fíjense bien en las rutas que ahí aparecen en los export, puede que varíe un poco si han colocado algo en otro lugar que no sea lo que se ve en la imagen.

Ahora ya estamos en condiciones de instalar Openbravo.

Instalación Openbravo.
Para instalar Openbravo debemos tener arriba a PostgreSQL y a Tomcat, para esto simplemente hay que ingresar en la consola, como root:

service postgresql start

$CATALINA_HOME/bin/startup.sh

y después ejecutamos el instalador de Openbravo ...

./OpenbravoERP_2.40-linux-installer.bin

luego aceptamos la licencia

luego elegimos el directorio de instalación de Openbravo

luego elegimos la instalación completa (asumiendo que Openbravo estará en el mismo equipo que la base de datos)

luego la instalación estándar

luego hay que colocar la ruta de JAVA_HOME, pero como ya ingresamos la variable al sistema, debería detectar la rutas automáticamente como se ve en la siguiente imagen

lo mismo con ant

y tomcat

luego seleccionamos la base de datos PostgreSQL

e ingresamos el directorio donde se encuentran los ejecutables (/usr/bin)

luego ingresamos los datos de la base de datos (host y puerto)

luego el nombre de usuario y contraseña de administrador de la base de datos

luego los datos de la base de datos de Openbravo

luego el nombre de contexto de la aplicación, con la cual se accederá directamente en el navegador web

luego hay que configurar las opciones de fecha que queremos utilizar en Openbravo

luego podemos seleccionar la opción para llenar la base de datos con datos demo

y con eso ya podemos instalar Openbravo

Una vez instalado reiniciamos el sistema.
Para iniciar Openbravo debemos levantar PostgreSQL y Tomcat. Esto lo podemos hacer desde línea de comandos en una consola:

service postgresql start
$CATALINA_HOME/bin/startup.sh

luego abrimos el navegador web que queramos y escribimos en la dirección

http://localhost/openbravo

y podrán ver la página de ingreso al sistema

Ingresamos el nombre de usuario Openbravo, la contraseña openbravo y presionamos Login.

Espero les sea de utilidad esta guía de instalación. Mas adelante agregaré una entrada con la forma de traducción al español.

saludos !!!

J-Kiltro 4.0 Beta 2 Liberado

2008-10-21T00:15:00.003-03:00

Hoy he liberado la versión 4.0 Beta 2 de mi software de conversión de archivos de audio multi formato J-Kiltro.
Si bien es beta, funciona a full. Aún me falta revisarlo a detalle y agregarle algunas características mas, por eso está en esa fase.

Para quienes no saben de qué hablo, J-Kiltro es un software que sirve para convertir un archivo de audio de un formato a otro, por ejemplo mp3 a ogg, wma a mpc. Soporta 14 formatos de entrada y 12 de salida.

Los formatos de entrada son:

aac,aiff,ape,au,flac,m4a,m4b,mp3,mp4,mpc,ogg,ra,wav y wma

y los formatos de salida son:

aac,aiff,ape,au,flac,m4a,m4b,mp3,mp4,mpc,ogg y wav

Esta aplicación está desarrollada 100% en java utilizando el IDE NetBeans 6.1.

Dentro de las caracteristicas de ésta versión se encuentran:

Interfaz muy simple y amigable.
Soporta 14 formatos de entrada y 12 de salida.
Extracción de pistas de audio desde CD (son selección de pistas).
Tiene previsualizador de audio con un reproductor interno (mp3, ogg, flac, wav, aiff y au).
Obtiene metadata desde archivos de audio automáticamente.
Permite editar la metadata de los archivos de audio.
Detección automática de dependencias.
Permite el ingreso de archivos de distintos formatos a la lista y automáticamente sabe como tratarlos para llevarlos al formato de destino.
Soporta distintos look and feel.
etc.

Ésta aplicación solo funciona en distribuciones Linux ya que requiere de algunas aplicaciones de linea de comandos para hacer las conversiones. Las dependencias son:

Lame
Vorbis-tools
Mppdec y Mppenc
Sox
Mac
Flac
Faac y Faad
Mplayer
CD Paranoia
JRE 1.6 update 10

VPN segura en openSUSE 11.0 y Windows XP con openVPN

2008-07-13T01:00:00.023-04:00

Hoy traigo una guía de instalación y configuración de una VPN segura utilizando el software openVPN sobre un servidor openSUSE 11.0 y clientes openSUSE 11.0 y Windows XP (SP3).

Me tomó un par de días hacerla ya que tuve que solucionar algunos problemas que sucedieron en el camino cuyas soluciones ahora son parte de la guía misma.

Si tienen aportes a la guía con gusto la actualizaré, la idea es que nos sirva a todos.

Agradeceré cualquier comentario constructivo.

Índice de contenido

Resumen
1 Introducción
1.1 Objetivos generales
1.2 Objetivos específicos
1.3 Conceptos generales
2 Requerimientos
3 Instalación
4 Generación de llave y certificado maestro para unidad certificadora
5 Generación de llave y certificado para el servidor
6 Generación de llave y certificado para el cliente
7 Generación de firma HMAC tls-auth
7.1 Servidor
7.2 Cliente
8 Resumen de archivos creados
9 Configuración del servidor y el cliente
9.1 Servidor
9.1.1 Dando acceso a los clientes a la red local del servidor
9.1.2 Subnet a Subnet
9.2 Cliente (openSUSE 11.0)
9.2.1 Sin control del usuario
9.2.2 Con control del usuario
9.3 Cliente (Windows XP)
10 Revocar certificados
11 Conclusiones
12 Anexos

Resumen

Este documento explica paso a paso la instalación y configuración de una VPN segura utilizando el software openVPN.

Una VPN (Virtual Private Network) es una red virtual privada que está compuesta por equipos (computadores, ordenadores) en una red. Se utilizan para crear redes seguras y privadas, mediante las cuales se puede hacer traspaso de información o utilización de recursos como carpetas (directorios) compartidas e impresoras.

En este documento encontrará información detallada útil para montar un servidor sobre el sistema operativo openSUSE 11.0 y clientes openSUSE 11.0 y Windows XP.

Para montar un servidor, múltiples clientes y manejar la seguridad se utilizarán certificados digitales y llaves privadas (tanto para el servidor como para el cliente), para lo cual se creará una unidad certificadora (CA) quien se encargará de emitir y gestionar los certificados digitales y llaves privadas.

También se mostrará cómo agregar seguridad extra gracias a la firma HMAC tls-auth y revocación de certificados.

Este documento es una adaptación de la guía de Jorge Armando Medina de openVPN para Slackware del 2006-05-03 (http://tuxjm.net/docs/openvpn-como4slack/index.html) a openSUSE 11.0 (servidor y cliente) y Windows XP (cliente) al 2008-07-13.

1 Introducción

Como se mencionó en el resumen de el presente documento, una VPN se utiliza para crear redes virtuales privadas, mediante las cuales podemos transferir información por un canal inseguro como es Internet de forma mas segura.

Se utilizan, por ejemplo, para integrar a nuestra red local equipos o redes externas. Una aplicación posible es, por ejemplo, unir sucursales de una empresa de manera que puedan compartir recursos (directorios e impresoras, etc.), o conectar un equipo de nuestro hogar a la red local de la organización para obtener documentos de forma remota y segura (algo que seguramente a un gerente de la organización le gustaría).

En este documento se tratarán las VPN seguras utilizando openVPN.

1.1 Objetivos generales

Con este documento se pretende dar una guía detallada para montar un servidor openVPN sobre el sistema operativo openSUSE 11.0, así como clientes openVPN montados sobre sistemas operativos openSUSE 11.0 y Windows XP.

1.2 Objetivos específicos

Montar un servidor openVPN en el sistema operativo openSUSE 11.0.

Para montar el servidor se mostrarán los pasos para la instalación de openVPN utilizando imágenes como apoyo, junto a la configuración del mismo detallando los comandos a utilizar así como imágenes ilustrativas.

Montar un cliente openVPN en el sistema operativo openSUSE 11.0.

Para montar el cliente se mostrarán los pasos para la instalación de openVPN utilizando imágenes como apoyo, junto a la configuración del mismo detallando los comandos a utilizar así como imágenes ilustrativas del proceso.

Montar un cliente openVPN en el sistema operativo Windows XP.

Para montar el cliente se mostrarán los pasos para la instalación de openVPN utilizando imágenes como apoyo, junto a la configuración del mismo utilizando imágenes ilustrativas del proceso.

1.3 Conceptos generales

Como se mencionó en la introducción, para crear una VPN utilizaremos openVPN. Un punto muy importante es la seguridad de nuestros datos, con openVPN podemos manejar esto utilizando certificados digitales X.509 y llaves privadas, tanto para el servidor como para los clientes.

Para generar los certificados y llaves necesitamos una unidad certificadora, denominada CA (Certificate Authority). Esta CA necesita un certificado y llave maestro para generar los archivos para el servidor y clientes.

En este documento mantendremos la CA y el servidor openVPN en la misma máquina, pero también se pueden tener separados en máquinas distintas.

Para generar las llaves privadas se utiliza el protocolo Diffie Hellman (http://es.wikipedia.org/wiki/Diffie-Hellman), el cual se usa para generar claves simétricas. Mediante éste mecanismo podemos crear una comunicación entre el cliente y el servidor, en donde se hace un intercambio de llave secreta de forma segura ya que utiliza encriptación de datos, de fábrica se utiliza un cifrado de 1024 bits, pero es parametrizable.

Una vez que se tiene la CA configurada se procede a crear un certificado y una llave privada para el servidor y los clientes (cada certificado y llave privada es distinta para cada cliente y servidor).

OpenVPN hace uso de interfaces TUN (http://en.wikipedia.org/wiki/TUN/TAP) para crear una subred en la cual existirá comunicación entre el cliente y el servidor. Una interfaz TUN provee a la máquina cliente de una interfaz virtual de red mediante la cual podrá asignarse una IP de la subred desde el servidor.

Para poder hacer uso de una interfaz virtual sin que entorpezca a la interfaz real (eth0 por ejemplo) se utiliza un bridge. En este bridge o puente es donde se “cuelgan” las interfaces de red “virtuales” y “reales” y hace de puente para la entrada o salida hacia y desde Internet o nuestra red local.

De esta manera podemos tener un IP de red local 192.168.0.3 y una de la VPN como 10.8.0.6 al mismo tiempo, teniendo acceso a Internet sin problemas.

Un bridge es muy útil cuando se utilizan máquinas virtuales ya que mediante interfaces virtuales (TUN/TAP) se les pueden asignar su propio IP estando en la misma máquina y todos pueden acceder a Internet o a la red sin problemas.

OpenVPN crea, de fábrica, una subred en el dominio 10.8.0.0/24.

2 Requerimientos

El sistema operativo utilizado es openSUSE 11.0 (http://www.opensuse.org), otras distribuciones o sistemas operativos también pueden funcionar siempre y cuando openVPN (http://openvpn.net) pueda correr sobre ellos, pero no se da ninguna garantía de que funcione al pie de la letra, es posible que el directorio de instalación, la forma de configurar el cortafuegos, archivos, etc. sea distinto.

Para el servidor (openSUSE 11.0) se requiere instalar:

OpenVPN 2.0.9

Para el cliente (openSUSE 11.0) se requiere instalar:

OpenVPN 2.0.9
KnetworkManager
KnetworkManager-openvpn

Para el cliente (Windows XP) se requiere instalar:

OpenVPN 2.0.9
OpenVPN-gui 1.0.3

En el caso de el cliente y servidor openSUSE 11.0 se recomienda configurar los repositorios de software antes de instalar cualquier cosa, siempre es bueno tener el software actualizado.

Para agregar los repositorios abrimos YaST → Software → Repositorios de software → Añadir → Repositorios de la comunidad y ahí seleccionamos los que consideremos necesarios.

3 Instalación

En el caso de openSUSE, tanto para el servidor como el cliente hay que utilizar YaST → Software → Instalar/Desinstalar software para instalar openVPN, el cual viene en el DVD.

En el caso de Windows XP podemos ir a http://openvpn.se y descargar openVPN 2.0.9 y openVPN-gui 1.03 en el mismo paquete e instalarlo, si lo queremos en español entonces, además del paquete anterior, descargamos openvpn-gui-1.0.3-es y lo copiamos al directorio bin de instalación de openVPN (C:\Archivos de programa\OpenVPN\bin).

4 Generación de llave y certificado para la unidad certificadora

Lo primero es generar los certificados y llaves necesarios para la unidad certificadora (CA). Para tal tarea utilizaremos unos scripts que vienen hechos en openVPN, específicamente la versión 2.0. Estos scripts están en el directorio /usr/share/openvpn/easy-rsa/2.0/

y debemos copiarlos al siguiente directorio /etc/openvpn/easy-rsa-V2.0/ el cual debemos crear previamente, para esto como usuario root escribimos lo siguiente en la consola:

#mkdir /etc/openvpn/easy-rsa-V2.0/

y luego copiamos los scripts al directorio recién creado:

#cp /usr/share/openvpn/easy-rsa/2.0/* /etc/openvpn/easy-rsa-V2.0

luego crearemos el directorio keys dentro del directorio previamente creado:

#mkdir -p /etc/openvpn/easy-rsa-V2.0/keys

y tendremos el directorio listo para configurar como se ve en la siguiente imagen:

De ahora en adelante trabajaremos con los scripts del directorio /etc/openvpn/easy-rsa-V2.0/.

Con el siguiente comando entramos al directorio de trabajo:

#cd /etc/openvpn/easy-rsa-V2.0

El siguiente paso corresponde a la configuración de algunos parámetros en el archivo vars. Para esto abrimos dicho archivo con kwrite u otro editor de texto:

#kwrite vars

y bajamos hasta el bloque final donde se exportan las variables que definen a la CA.

KEY_COUNTRY
KEY_PROVINCE
KEY_CITY
KEY_ORG
KEY_EMAIL

Éstas variables deben ser definidas según los datos que correspondan a la organización.

Además podemos cambiar el tamaño de la llave, que de fábrica viene con el valor de 1024 bits, mientras mas alto sea el valor, mas seguro será el sistema pero la validación se hará mas lenta. 1024 es un valor razonable, pero como dice el archivo de configuración, si somos paranoicos lo subimos a 2048 bits.

Una vez definidas las variables ejecutamos el siguiente comando:

#source ./vars

si todo sale bien deberíamos obtener la siguiente salida:

NOTE: If you run ./clean-all, I will be doing a rm -rf on
/etc/openvpn/easy-rsa-V2.0/keys

Ahora generaremos los parámetros Diffie Hellman para lo cual simplemente ejecutamos el archivo build-dh:

#./build-dh

y si todo sale bien deberíamos ver la siguiente salida:

Generating DH parameters, 1024 bit long safe prime, generator 2
This is going to take a long time
......+.+..............+...................................................................
....+...........................+................................+.........................
...........+.......................................+......................+................
............................+................................................................
..............................................................+..............................
.....................+...........................................+..........................
........................+....................................................................
+........................+..........................................+......................
................................................+....+......................................
..............................................................................................
....................................+........................................................
.................................................+......+...............................+..
..............+........................................+....................................
+........................+..........++*++*++*

tal como se ve en la siguiente imagen:

Ahora crearemos el certificado para la CA, para esto escribimos en consola el siguiente comando:

#./pkitool --initca

con lo cual debemos obtener la siguiente salida:

Using CA Common Name: Metalklesk's enterprise CA
Generating a 1024 bit RSA private key
........................................++++++
......++++++
writing new private key to 'ca.key'
-----

tal como se ve en la siguiente imagen:

5 Generación de llave y certificado para el servidor

Para esta tarea escribimos el siguiente comando en la consola:

#./pkitool --server servidor

con lo cual obtendremos una salida parecida a la siguiente:

Generating a 1024 bit RSA private key
............++++++
...++++++
writing new private key to 'servidor.key'
-----
Using configuration from /etc/openvpn/easy-rsa-V2.0/openssl.cnf
Check that the request matches the signature
Signature ok
The Subject's Distinguished Name is as follows
countryName :PRINTABLE:'CL'
stateOrProvinceName :PRINTABLE:'RM'
localityName :PRINTABLE:'Santiago'
organizationName :PRINTABLE:'Metalklesk's enterprise'
commonName :PRINTABLE:'servidor'
emailAddress :IA5STRING:'damorales@gmail.com'
Certificate is to be certified until Jul 6 01:08:42 2018 GMT (3650 days)

Write out database with 1 new entries
Data Base Updated

tal como se ve en la siguiente imagen:

Con lo anterior tenemos la unidad certificadora CA y el servidor listos (ambos en el mismo equipo).

6 Generación de llave y certificado para el cliente

Para generar el certificado y llave para un cliente escribimos en la consola el siguiente comando:

#./pkitool cliente1

de lo cual obtendremos una salida parecida a la siguiente:

Generating a 1024 bit RSA private key
...............++++++
............................................++++++
writing new private key to 'cliente1.key'
-----
Using configuration from /etc/openvpn/easy-rsa-V2.0/openssl.cnf
Check that the request matches the signature
Signature ok
The Subject's Distinguished Name is as follows
countryName :PRINTABLE:'CL'
stateOrProvinceName :PRINTABLE:'RM'
localityName :PRINTABLE:'Santiago'
organizationName :PRINTABLE:'Metalklesk's enterprise'
commonName :PRINTABLE:'cliente1'
emailAddress :IA5STRING:'damorales@gmail.com'
Certificate is to be certified until Jul 6 01:13:40 2018 GMT (3650 days)

Write out database with 1 new entries
Data Base Updated

tal como se ve en la siguiente imagen:

Cada vez que se quiera agregar un nuevo cliente ejecutamos el comando

#source ./vars

y luego

#./pkitool clienteN

No olvidar que antes de agregar un nuevo cliente se debe ejecutar #source ./vars y luego usar la herramienta pkitool.

7 Generación de firma HMAC tls-auth

La firma HMAC tls-auth provee un nivel de seguridad adicional al SSL/TLS, ya que cualquier paquete que no contenga la firma será bloqueado automáticamente. Este nivel extra de seguridad permite proteger contra:

Ataques DoS (Deny of Service) en el puerto UDP (1194) de openVPN.
Escaneo de puertos para determinar cual es el puerto UDP del servidor que está a la escucha.
Vulnerabilidades de desbordamiento de buffer en la implementación SSL/TLS.
Inicialización de negociaciones SSL/TLS de máquina que no están autorizadas.

Para utilizar este nivel extra de seguridad (lo cual es extremadamente recomendable, pero no obligatorio) se debe crear una llave secreta compartida, la cual utilizarán el servidor y los clientes. Dicha llave debe ser pasada al cliente por un canal seguro como ssh u otro. Se puede guardar en el mismo directorio que los otros archivos (ca.crt, cliente1.crt, cliente1.key).

Para crear la llave utilizamos el siguiente comando en el lado servidor y como usuario root:

#openvpn --genkey --secret ta.key

La llave creada corresponde a ta.key. Una vez creada se deben configurar el servidor y los clientes.

7.1 Servidor

En el archivo server.conf se debe agregar la siguiente linea:

tls-auth ta.key 0

Si el archivo ta.key está en un directorio distinto a donde está el archivo server.conf, entonces se debe dar la ruta completa (por ejemplo /etc/openvpn/directorio/ta.key).

7.2 Cliente

En el archivo client.conf (en el caso de openSUSE 11.0) o client.ovpn (en el caso de Windows XP) se debe agregar la siguiente linea:

tls-auth ta.key 1

8 Resumen archivos creados

Todos los certificados y llaves que vayamos creando quedarán almacenados en el directorio /etc/openvpn/easy-rsa-V2.0/keys. A continuación podemos ver la lista de archivos creados y visto a lo largo de este documento.

Nótese que todas las llaves (.key) son privadas mientras que los certificados (.crt) no lo son.

Ahora es necesario pasar una copia de los archivos ca.crt, cliente1.crt, cliente1.key y ta.key al cliente 1 a través de algún medio seguro como ssh u otro mecanismo que estimemos como seguro y conveniente.

Podemos crear una carpeta e introducir los archivos anteriormente mencionados y luego darles los permisos correspondientes (755) para luego entregárselos al cliente.

#mkdir ~/cliente1
#cd keys/
#cp -v ca.crt cliente1.crt cliente1.key ta.key ~/cliente1
#chmod -R 755 ~/cliente1

9 Configuración del servidor y el cliente

OpenVPN trae archivos de configuración de ejemplo que pueden ser utilizados como base para nuestra propia configuración, los cuales se encuentran en el directorio /usr/share/doc/packages/openvpn/sample-config-files.

De dicho directorio nos interesan los archivos client.conf y server.conf. El archivo server.conf va en la máquina servidor de openVPN, mientras que el archivo client.conf va en la máquina cliente. El archivo server.conf lo copiaremos al directorio /etc/openvpn.

#cd /usr/share/doc/packages/openvpn/sample-config-files
#cp server.conf /etc/openvpn

9.1 Servidor

Ahora debemos configurar el archivo server.conf de manera que se apunte a los archivos creados anteriormente, los cuales están en el directorio /etc/openvpn/easy-rsa-V2.0/keys. Para ésto abrimos el archivo server.conf

#cd /etc/openvpn
#kwrite server.conf

el cual debe quedar así:

ca /etc/openvpn/easy-rsa-V2.0/keys/ca.crt
cert /etc/openvpn/easy-rsa-V2.0/keys/servidor.crt
key /etc/openvpn/easy-rsa-V2.0/keys/servidor.key
dh /etc/openvpn/easy-rsa-V2.0/keys/dh1024.pem

tal como se ve en la siguiente imagen:

Una vez configurado el servidor solo resta iniciarlo, para esto escribimos en consola:

#service openvpn start

o lo iniciamos desde YaST (YaST → Sistema → Servicios del sistema → activar servicio openvpn) para que al iniciar el sistema automáticamente se inicie el servidor openVPN.

Una vez listo solo resta abrir el puerto 1194 en el cortafuegos, para esto utilizamos YaST → Seguridad y usuarios → Cortafuegos → Servicios autorizados → Opciones avanzadas y agregamos el puerto 1194 en la entrada UDP, guardamos y listo.

Si no abrimos el puerto en el cortafuegos los clientes no se podrán conectar al servidor openVPN.

9.1.1 Dando acceso a los clientes a la red local

Hasta ahora tenemos una comunicación punto a punto entre el cliente y el servidor, pero puede darse el caso en que se requiera que el cliente (que está externo a la red) pueda ver a otros equipos en la red del servidor, para esto debemos agregar la siguiente linea en el archivo server.conf:

push “route subred-local mascara-subred-local”

en donde subred-local podría ser 192.168.0.0 y la mascara-subred-local podria ser 255.255.0.0 quedando así:

push “route 192.168.0.0 255.255.0.0”

En el caso de que el servidor openVPN y el gateway estén en máquinas distintas, será necesario configurar la ruta en el gateway de la LAN en el lado servidor para enrutar la subred del cliente VPN (10.8.0.0/24) hacia el servidor openVPN.

9.1.2 Subnet a Subnet

Hasta ahora hemos asumido que la máquina cliente se conecta a la VPN como una sola máquina, pero supongamos que la máquina cliente es un gateway para una LAN local (como la oficina de casa u otra red de una sucursal de nuestra organización), y quisiéramos que cada máquina en la LAN de el cliente sea ruteada a través de la VPN.

Para este ejemplo, asumiremos que la LAN del cliente esta usando la subred 192.168.15.0/24, y que el cliente VPN esta usando un certificado con el common name de cliente1.

Nuestra meta es configurar la VPN de manera que cualquier máquina en la LAN de el cliente se pueda comunicar con cualquier máquina en la LAN de el servidor a través de la VPN.

Antes de configurarlo, hay unos pre requisitos básicos que deben de seguirse:

La LAN de el cliente (192.168.15.0/24 en nuestro ejemplo) no debe de ser exportada a la VPN por el servidor o algún cliente que este usando la misma subred. Cada subred que sea unida a la VPN vía enrutamiento debe de ser única.
El cliente debe de tener un certificado con un Common Name único (cliente1 en nuestro ejemplo), y la directiva duplicate-cn no debe de ser usada en el archivo de configuración de el servidor OpenVPN (server.conf).

Ahora trataremos con los cambios de configuración necesarios en el lado de el servidor. Si el archivo de configuración de el servidor actualmente no hace ninguna referencia a el directorio de configuraciones de clientes, agreguemos una ahora:

client-config-dir ccd

En la directiva de arriba, ccd debe de ser el nombre de un directorio el cual ha sido pre-creado en el directorio predeterminado donde el demonio de el servidor openVPN corre, en este documento estamos usando /etc/openvpn/. Crearemos el directorio ccd con lo cual nos quedaria:

client-config-dir /etc/openvpn/ccd

Cuando un nuevo cliente se conecta al servidor OpenVPN, el demonio revisará este directorio en busca de algún archivo que concuerde con el common name de el certificado de el cliente que se conecta. Si un archivo concuerda, sera leído y procesado para aplicar directivas adicionales a dicho cliente.

El siguiente paso es crear un archivo de texto llamado cliente1 en el directorio ccd (si, sin extensión). Este archivo debe contener la siguiente linea:

iroute 192.168.15.0/24 255.255.255.0

Esto le dirá a el servidor openVPN que la subred 192.168.15.0/24 debe de ser enrutada al cliente1. Después, agregaremos la siguiente linea a el archivo de configuración principal de el servidor (server.conf ):

route 192.168.15.0/24 255.255.255.0

Ahora, si queremos que otros clientes de la VPN puedan tener tráfico de red con el cliente1 (comunicación de cliente a cliente) entonces debemos agregar las siguientes lineas al archivo de configuración del servidor (server.conf):

client-to-client
push “route 192.168.15.0/24 255.255.255.0”

Con lo anterior el servidor openVPN anunciará la subred cliente1 a los otros clientes que se conecten de manera tal que puedan llegar a dicha subred.

9.2 Cliente (openSUSE 11.0)

Existen varias formas de conectar un cliente openSUSE 11.0 a un servidor openVPN. Una es configurando todo a mano y corriéndolo en el background del sistema, sin control del usuario y otra es utilizando alguna aplicación que le de control al usuario.

9.2.1 Sin control del usuario

El archivo client.conf debe ir en la raíz de la carpeta de openVPN (/etc/openvpn en el caso de openSUSE 11.0) en la máquina del cliente y se debe editar de manera tal que se apunte a los archivos recibidos desde el servidor (ca.crt, cliente1.crt y cliente1.key). Estos archivos podemos copiarlos donde queramos, por ejemplo en /etc/openvpn. Una vez ahí configuramos el archivo client.conf como se ve a continuación:

ca /etc/openvpn/ca.crt
cert /etc/openvpn/cliente1.crt
key /etc/openvpn/cliente1.key

Los archivos deben tener los siguientes permisos:

ca.crt → 644
cliente1.crt → 644
cliente1.key → 600

para lo cual basta escribir lo siguiente en consola:

#chmod 644 ca.crt
#chmod 644 cliente1.crt
#chmod 600 cliente1.key

y además se debe modificar la siguiente linea:

remote my-server-1 1194

en donde my-server-1 corresponde al IP o host-name del servidor openVPN seguido del puerto por el cual se esta prestando el servicio (si hemos seguido la guía al pie de la letra, el puerto no se cambia).

Ahora solo resta conectarse al servidor, para esto podemos escribir en la consola lo siguiente:

#service openvpn start

y automáticamente se leerá el archivo de configuración (client.conf) y se realizará la conexión.

Ahora para probar, desde el servidor podemos hacer un ping al IP asignado al cliente y se podrá comprobar que se puede realizar sin problema.

Para saber que IP fue asignado al cliente se puede ejecutar el comando (en la máquina cliente):

#ifconfig

el cual arrojará las interfaces de red, donde tun0 corresponde a la asignada por openVPN, la cual tiene una IP que le corresponde.

9.2.2 Con control del usuario

Para dar control al usuario podemos utilizar herramientas gráficas existentes para conectarnos a la VPN. Existen varias, dos de ellas son KVPNC y KNetworkManager (con el plugin de openVPN).

Para ésta guía utilizaremos el segundo.

Lo primero es instalar KNetworkManager y el plugin KNetworkManager-openVPN, para esto ir a YaST → Software → Instalar/Desinstalar software, escribimos knetworkmanager y marcamos los paquetes correspondientes para luego instalarlos.

Una vez instalados debemos configurar la conexión de red para que use Network Manager en vez del método tradicional ifup (que viene de fábrica). Para esto vamos a YaST → Dispositivos de red → Ajustes de la red, luego vamos a las Opciones globales y seleccionamos el uso de Network Manager, luego finalizamos.

Una vez listo ejecutamos KnetworkManager, nos aparecerá un icono en la bandeja del sistema. Le damos click derecho → Editar conexiones → Nueva conexión → VPN, en gateway ponemos la dirección IP del servidor openVPN, el port corresponde al 1194, luego le pasamos el CA file (ca.crt), el certificado del cliente (cliente1.crt) y la llave del cliente (cliente1.key), luego en la pestaña de información opcional marcamos Use LZO compression. Luego presionamos siguiente y le damos un nombre a la conexión.

Una vez listo guardamos. Ahora para conectarnos hacemos click derecho en el icono de KnetworkManager → Iniciar conexión VPN y pinchamos el nombre de nuestra conexión, nos pedirá una contraseña, puede ser cualquier cosa y aceptamos.

Ahora para comprobar que nos hemos conectado abrimos una consola y escribimos (como usuario root):

#ifconfig

y veremos que se a agregado la interfaz tun0.

Si hacemos desde, el servidor, un ping al IP de esa interfaz del cliente veremos que se realiza sin problemas ya que la VPN se ha establecido correctamente.

9.3 Cliente (Windows XP)

En el caso de Windows XP se debe instalar openVPN y openVPN-GUI (http://openvpn.se). Una vez instalados copiamos los archivos entregados por el servidor (ca.crt, cliente1.crt y cliente1.key) a el directorio que queramos, por ejemplo C:\\keys.

Una vez ahí vamos al directorio C:\Archivos de programa\OpenVPN\sample-config y copiamos el archivo client.ovpn a C:\Archivos de programa\OpenVPN\config.

Una vez ahí lo abrimos con un editor de texto (notepad sirve) y apuntamos la configuración a la dirección en donde pusimos los certificados y la llave privada, de manera que quede así:

ca C:\\keys\\ca.crt
cert C:\\keys\\cliente1.crt
key C:\\keys\\cliente1.key

luego modificamos la linea que dice:

remote my-server-1 1194

donde cambiamos my-server-1 por la dirección IP de servidor y el puerto que corresponda (si hemos seguido esta guía al pie de la letra, el puerto queda igual).

Una vez listo guardamos el archivo y ejecutamos openvpn-gui.exe (se encuentra en la carpeta bin en el directorio de instalación de openVPN).

Al abrirlo veremos un icono de dos computadores rojos en la bandeja del sistema, si hacemos click derecho veremos un menú en donde la primera opción es conectar:

al pinchar conectar aparecerá una consola mostrando algunos datos y al finalizar aparecerá un mensaje avisando que la conexión se ha realizado:

Ahora para probar, desde el servidor podemos hacer un ping al IP asignado al cliente y se podrá comprobar que se puede realizar sin problema.

10 Revocar certificados

Revocar un certificado es invalidar uno previamente firmado para que ya no pueda ser usado para propósitos de autenticación (y en consecuencia, conexión a la VPN).

Las razones típicas para querer remover un certificado incluyen:

La llave privada asociada con el certificado esta comprometida o robada.
El usuario de una llave privada cifrada olvidó la contraseña de la llave.
Se quiere terminar el acceso a la VPN para un usuario.

Como un ejemplo, revocaremos el certificado cliente1 (el mismo que creamos anteriormente). En una consola y como usuario root entramos al directorio easy-rsa-V2.0

#cd /etc/openvpn/easy-rsa-V2.0

luego reiniciamos las variables de openVPN:

#source ./vars

y luego escribimos el siguiente comando:

#./revoke-full cliente1

con lo cual deberíamos obtener una salida como ésta:

Using configuration from /etc/openvpn/easy-rsa-V2.0/openssl.cnf
Revoking Certificate 02.
Data Base Updated
Using configuration from /etc/openvpn/easy-rsa-V2.0/openssl.cnf
cliente1.crt: /C=CL/ST=RM/L=Santiago/O=Metalklesk's enterprise/CN=cliente1/emailAddress=damorales@gmail.com
error 23 at 0 depth lookup:certificate revoked

tal como se puede ver en la siguiente imagen:

Es probable que el último comando anterior no nos resulte y obtengamos la siguiente salida de error:

Using configuration from /etc/openvpn/easy-rsa-V2.0/openssl.cnf
error on line 282 of config file '/etc/openvpn/easy-rsa-V2.0/openssl.cnf'
16431:error:0E065068:configuration file routines:STR_COPY:variable has no value:conf_def.c:629:line 282
Using configuration from /etc/openvpn/easy-rsa-V2.0/openssl.cnf
error on line 282 of config file '/etc/openvpn/easy-rsa-V2.0/openssl.cnf'
16432:error:0E065068:configuration file routines:STR_COPY:variable has no value:conf_def.c:629:line 282
cat: crl.pem: No existe el fichero o el directorio
cliente1.crt: /C=CL/ST=RM/L=Santiago/O=Metalklesk's enterprise/CN=cliente1/emailAddress=damorales@gmail.com
error 3 at 0 depth lookup:unable to get certificate CRL

tal como vemos en la siguiente imagen:

De ser así debemos abrir el archivo /etc/openvpn/easy-rsa-V2.0/openssl.cnf (como usuario root) y comentar la ultima sección como se puede ver a continuación:

#[ pkcs11_section ]
#engine_id = pkcs11
#dynamic_path = /usr/lib/engines/engine_pkcs11.so
#MODULE_PATH = $ENV::PKCS11_MODULE_PATH
#PIN = $ENV::PKCS11_PIN
#init = 0

tal como podemos ver en la siguiente imagen:

Y luego intentar de nuevo.

Al ejecutar el comando revoke-full se ha creado un archivo CRL (Certificate Revocation List) llamado crl.pem en el directorio keys de openVPN.

Este archivo debe ser referenciado en el servidor openVPN en el archivo server.conf:

crl-verify /etc/openvpn/keys/crl.pem

de manera tal que cada vez que un cliente se conecte, la verificación se haga contra ese archivo para saber si se ha revocado o no su certificado de acceso a la VPN.

Algunas notas sobre CRL:

Cuando la opción crl-verify es usada en openVPN, el archivo CRL sera re-leído cada vez que un nuevo cliente se conecta o un cliente existente re negocia la conexión SSL/TLS (de manera predeterminada una vez por hora). Esto significa que podemos actualizar el archivo CRL mientras el demonio de el servidor openVPN este corriendo, y que el nuevo CRL tenga efecto inmediato para los nuevos clientes que se conecten. Si el cliente para el que estamos revocando su certificado esta actualmente conectado, podemos reiniciar el servidor a través de la señal (SIGUSR1 o SIGHUP) y "flushear" todos los clientes, o podemos hacer telnet a el puerto de la interfaz de administración y explícitamente matar la instancia de el cliente en el servidor sin molestar a los otros clientes.
Puesto que la directiva crl-verify puede ser usada en ambos, el servidor openVPN y el cliente, esto es generalmente innecesario para distribuir el archivo CRL a los clientes a menos que el certificado de el servidor ha sido revocado. Los clientes no necesitan saber acerca de los certificados de otros clientes que han sido revocados porque los clientes no deberían de aceptar conexiones directas de otros clientes en primer lugar (a no ser que queramos conexiones del tipo cliente-cliente).
El archivo CRL no es secreto, y debería ser legible por todos para que el demonio openVPN pueda leerlo después de que los privilegios de root han sido tirados.
Si estamos usando la directiva chroot, debemos asegurarnos de poner una copia de el archivo CRL en el directorio chroot, puesto que a diferencia de la mayoría de los archivos que openVPN lee, el archivo CRL sera leído después de que el chroot es ejecutado, no antes.
Una razón común para que un certificado necesite ser revocado es que el usuario cifra su llave privada con una contraseña, y luego la olvida. Al revocar el certificado original, es posible re-generar un nuevo par de llave/certificado con el common name original de el usuario.

11 Conclusiones

Mediante openVPN podemos crear redes virtuales privadas seguras y a muy bajo costo, de hecho, el software usado es gratis y además open source, por lo que no pagamos por concepto de licencias de software, además de ser multi plataforma.

Gracias a la encriptación usada para el traspaso de la información disminuimos bastante el riesgo de captura y decodificación de nuestros datos, ya que utilizamos certificados digitales y llaves de 1024 o 2048 bits, con lo cual aseguramos que solo quienes tengan certificado se puedan conectar a la VPN y que nuestros datos no puedan ser leídos por terceros.

El uso de los mecanismos de seguridad que se proveen permiten estar preparados frente a ataques del tipo DoS o escaneo de puertos en busca de vulnerabilidades, lo cual deja nuestra red bastante mas segura.

Además openVPN nos provee de un mecanismo muy simple tanto para generar pares de llave/certificado para clientes así como la revocación de los mismos, todo con un par de simples comandos, lo cual ayuda bastante a la administración de la VPN.

Con openVPN podemos generar varios tipos de configuraciones que pueden amoldarse según nuestras necesidades, como tener una VPN uno a uno, uno a muchos o muchos a muchos.

El uso de una VPN nos permite compartir recursos de una red con equipos o redes externas, una combinación especialmente útil es openVPN con SAMBA, ya que con openVPN creamos la red y con SAMBA compartimos los recursos.

12 Anexos

http://tuxjm.net/docs/openvpn-como4slack/index.html
http://openvpn.net/

EXTRA !!!

Este documento lo pueden descargar en formato ODT y PDF para que lo puedan leer y modificar a gusto. Este documento está bajo licencia GPL 3.

Espero les sea de utilidad.

Saludos !!!

ComboBox en JMaki con NetBeans 6.1, publish and suscribe

2008-06-05T01:22:00.012-04:00

Ayer un amigo lector de éste blog me envió un correo preguntando como lo podía hacer para obtener el valor de un Widget JMaki ComboBox, ya que él había probado el método que expliqué en ésta entrada pero no servía. En efecto, el método explicado ahí solo retorna el nombre de la etiqueta y no el valor que se requiere.

El método corresponde al siguiente:


var fecha = jmaki.getWidget('fecha').getValue();

pero este retorna el label del combobox y no el value.

Me explico, cuando uno usa un ComboBox, generalmente muestra un nombre al usuario y por debajo quiere manejar un código, entonces el usuario al seleccionar un nombre específico de la lista quiere obtener el código que le corresponde y hacer algo con éste.

El nombre corresponde al label o etiqueta y el código corresponde al value o valor.

Entonces me dispuse a leer varios sitios y en el el sitio oficial de jmaki encontré la respuesta (era lo mas lógico verdad ??).

Es bastante simple la verdad. Debemos crear nuestra página jsp como queramos y agregamos un widget combobox de la biblioteca dojo, hasta aquí es bastante simple ya que solo arrastramos el widget desde el panel de la derecha a la página jsp.

Lo nuevo que haremos será crear un Bean que utilizaremos para cargar los datos en el widget en vez de hacerlo directamente en el jsp. Esto es mas elegante, útil y seguro. Lo mas probable es que los datos provengan de una base de datos, de seguro que ninguno querrá obtener los datos de la base de datos directamente desde el jsp.

El Bean (ComboBoxBean) es bastante sencillo para éste ejemplo, simplemente contendrá un arreglo de Strings con un par de países y un arreglo de Strings con códigos de los países.


protected String[] paises= new String[] { "Chile", "Argentina", "España", "Estados Unidos"};


protected String[] codigoPaises = new String[] { "CL", "AR", "ES", "US" };

Lo que tenemos que tener en cuenta es que para retornar los datos no basta con hacer un simple método get y retornar el arreglo String, debemos transformar los datos a un form JSON. Esto lo hacemos de la siguiente forma:


public String getPaises() throws JSONException {

        JSONArray datosPaises = new JSONArray();

        JSONObject datosPais = new JSONObject();

        for (int loop = 0; loop < paises.length; loop++) {

            datosPais.put("label", paises[loop]);

            datosPais.put("value", codigoPaises[loop]);

            datosPaises.put(datosPais);

            datosPais = new JSONObject();

        }

        return jsonArrayToString(datosPaises, new StringBuffer());

    }

pero debemos definir el método jsonArrayToString


public String jsonArrayToString(JSONArray ja, StringBuffer buff)  throws JSONException {

        if (buff == null)

            buff = new StringBuffer("[");

        else

            buff.append("[");

       

        for (int key=0; (ja != null) && key < ja.length(); key++) {

            String value = null;

            if (ja.optJSONObject(key) != null){

                jsonToObjectLibertal(ja.optJSONObject(key), buff);

            } else if (ja.optJSONArray(key) != null) {

                jsonArrayToString(ja.optJSONArray(key), buff);

            } else if (ja.optLong(key, -1) != -1) {

                value = ja.get(key) + "";

                buff.append(value);

            } else if (ja.optDouble(key, -1) != -1) {

                value = ja.get(key) + "";

                buff.append(value);

            } else if (ja.optBoolean(key)) {

                value = ja.getBoolean(key) + "";

                buff.append(value);

            } else if (ja.opt(key) != null) {

                Object obj = ja.opt(key);

                if (obj instanceof Boolean) {

                    value = ja.getBoolean(key) + "";

                } else {

                    value = "'" + ja.get(key) + "'";

                }

                buff.append(value);

            }

            if (key < ja.length() -1) buff.append(",");

        }

        buff.append("]");

       

        return buff.toString();

    }

y necesitamos el método jsonToObjectLibertal


public String jsonToObjectLibertal(JSONObject jo, StringBuffer buff)  throws JSONException {

        if (buff == null)

            buff = new StringBuffer("{");

        else

            buff.append("{");

       

        JSONArray names = jo.names();

        for (int l=0; (names != null) && l < names.length(); l++) {

            String key = names.getString(l);

            String value = null;

            if (jo.optJSONObject(key) != null){

                value = key + ":";

                buff.append(value);

                jsonToObjectLibertal(jo.optJSONObject(key), buff);

            }else if (jo.optJSONArray(key) != null) {

                value = key + ":";

                buff.append(value);

                jsonArrayToString(jo.optJSONArray(key), buff);

            } else if (jo.optLong(key, -1) != -1) {

                value = key + ":" + jo.get(key) + "";

                buff.append(value);

            } else if (jo.optDouble(key, -1) != -1) {

                value = key + ":" + jo.get(key) + "";

                buff.append(value);

            } else if (jo.opt(key) != null) {

                Object obj = jo.opt(key);

                if (obj instanceof Boolean) {

                    value = key + ":" + jo.getBoolean(key) + "";

                } else {

                    value = key + ":" + "'" + jo.get(key) + "'";

                }

                buff.append(value);

            }

            if (l < names.length() -1) buff.append(",");

        }

        buff.append("}");

       

        return buff.toString();

    }

Estos 3 métodos no los hize yo, solo modifiqué una ínfima parte para adaptarlos al ejemplo, el código lo saqué de uno de los tutoriales de JMaki (apenas lo encuentre pongo la URL).

Ya con eso tenemos listo el Bean que llenará el widget combobox de datos de forma elegante, limpia y sencilla.

Ahora toca ir al jsp en donde tenemos el widget combobox. El tag debería lucir así:


<a:widget name="dojo.combobox" value="${ComboBoxBean.paises}" publish="/micombobox"/>

y al inicio del jsp agregar las siguientes lineas:


<jsp:useBean id="ComboBoxBean" scope="session" class="org.ComboBoxBean"/>

<%@ taglib prefix="a" uri="http://jmaki/v1.0/jsp" %>

en donde deben cambiar el nombre del Bean al que corresponda.

Antes de continuar explicaré de que se trata el publish y el subscribe en JMaki.

El publish se utiliza para definir un nombre específico a un widget específico (com un ID), con el cual se diferenciará de otros al momento de registrar eventos. El publish se define como un argumento en el widget.

El registro de eventos se hace utilizando el subscribe y se define en el archivo glue.js.

Utilizando publish y subscribe se manejan de forma limpia los eventos asociados a widgets. Cada widget puede tener varios eventos asociados y cada evento se le puede asociar a muchos widgets, una relación de muchos a muchos, en donde cada widget define lo que hace independientemente de los demás, a través de la configuración del subscribe correspondiente en el archivo glue.js.

Dicho y explicado lo anterior, agregamos al jsp un div en donde colocaremos el código del país seleccionado de forma dinámica.


<div id="valorSeleccionado"></div>

Una vez listo abrimos el archivo glue.js y agregamos al final lo siguiente:


jmaki.subscribe("/micombobox/onSelect", function(args){

var value = args.value;

var targetDiv = document.getElementById("valorSeleccionado");

if(targetDiv)

          targetDiv.innerHTML = "El codigo de este pais es: " + value;

});

Si se fijan, el subscribe es específico para el widget de publish "micombobox" y el evento "onSelect", pudiendo subscribir el mismo evento a otros widgets u otros eventos al mismo widget (muchos a muchos), donde para cada widget se define un evento de forma personalizada.

Con el código anterior obtenemos el código del país seleccionado y lo agregamos al div correspondiente.

En esta parte podemos hacer lo que queramos con el dato seleccionado, podríamos enviarlo a un servlet utilizando la función jmaki.doAjax y almacenarlo en una sesión o hacer otra cosa.

A continuación pueden ver algunas screenshots mostrando la funcionalidad descrita en esta entrada:

Como ven, utilizando Beans y los métodos publish y subscribe el llenado de datos y obtención de los mismos mediante un ComboBox de JMaki es realmente simple.

Espero les sea de utilidad.

ya saben, si quieren el código me lo piden y se los envío por correo.

saludos !!!

EDITADO!!!

Subí el código a un servidor para que puedan hacer la descarga sin necesidad de enviarme sus correos (así no tienen que esperar a que yo lea el correo para rebotarlo a ustedes), si tienen problemas para la descarga seguimos con el método tradicional del correo electrónico.

Descarga

saludos !!!!

La ética en la empresa

2008-06-04T19:45:00.003-04:00

Una empresa está constituida y existe para crear bienes y/o servicios útiles para la sociedad, y a partir de esta creación o desarrollo (etc.) obtener beneficios de manera tal que la empresa obtenga un lugar en el mercado y surja dentro de éste, haciéndose de un buen nombre que sea reconocido en la mayor cantidad de lugares posibles.

Y basados en la definición principal de empresa, qué significa útil para la sociedad ??. Muchas veces he escuchado frases como "una empresa existe para ganar dinero" o "una empresa debe centrarse en el desarrollo interno, el bien comercial", etc., pero y qué pasa con el cliente ??

Útil para la sociedad significa proveer productos y/o servicios que satisfagan las necesidades de los consumidores (clientes y usuarios) sin desmedro de éstos ni otros directa o indirectamente.

Existe un problema, que muchos conocen, y es que muchas empresas solo se concentran en el beneficio propio y olvidan lo fundamental que es el cliente. Así surgen sitios como www.reclamos.cl en donde pueden ver la inmensa cantidad de reclamos, denuncias y demandas que los usuarios hacen en contra de distintas empresas de diversos mercados, qué esta pasando ??

Centrémonos en el caso de las empresas IT, como los proveedores de servicios de acceso a Internet (ISP).

Durante años, en nuestro país, hemos visto como las empresas hacen fusiones, las cuales sabemos se utilizan para reducir costos y aumentar beneficios. Pero para quién son las mejoras ??, para el cliente definitivamente no.

Estas fusiones, como la de la antigua Metrópolis y VTR solo han ocasionado problemas a sus clientes.

Caso personal: Yo era cliente de Metrópolis y después por fuerza bruta de VTR. El servicio fue pésimo, el trato indigno, y llegué al extremo de perder mi línea telefónica por los problemas que me ocasionaron y los tuve que demandar al sernac

Estas fusiones ocurren sin el conocimiento ni menos la participación del cliente, a cuantos clientes se les consultó sobre si estaban de acuerdo con la fusión de las dos empresas ? a cuantos siquiera se les notificó las repercusiones que éstos hechos tendría ?

Algunos dirán: Bueno, esas son decisiones de empresa, el cliente no trabaja ahí no tiene nada que ver. Y yo les digo: Lean la definición de empresa y entiendan que una empresa existe por y para el cliente.

El tema que surge aquí es la toma de decisiones por parte de la empresa sin consultar ni notificar al cliente. No involucran al cliente en ninguna etapa mas que en el cobro de la cuenta.

Todos sabemos que una toma de decisiones afecta a todos los niveles de una empresa en mayor o menor medida, pero muy pocas veces se habla de las repercusiones al cliente, simplemente se toman y el cliente debe acatar ... por qué ? si como cliente soy el que pago las cuentas ? y si yo soy el que pago por que otros deben tomar las decisiones que me corresponden ? y mi derecho como ciudadano y cliente ?

Actualmente tengo contrato de acceso a Internet con Telefónica Chile, en el contrato está especificado que no hay un bloqueo de puertos para uso de software p2p que al parecer se respeta (personalmente no he tenido problemas con las descargas), pero si tengo un problema con permitir el acceso a otras personas hacia mi equipo. Telefónica se niega a darme la clave del router Zyxel P-660HW-T1 v2 y no puedo configurar los puertos correspondientes a mi equipo.

La respuesta ante este problema fue:

Debe llamar a atención comercial para solicitar desbloqueo de puertos y re direccionamiento remoto de los mismos. Usted no puede hacer eso desde el router, nosotros lo hacemos de forma remota. Es por su seguridad.

A raíz de lo anterior surgen algunas preguntas básicas:

y quién les pidió que se preocupen por mi seguridad ?
y no se supone que no bloquean puertos ? (está en el contrato)
y por qué tengo que solicitar que me abran los puertos de forma remota ?
por qué no lo puedo hacer yo desde el router ?
debo llamar y solicitar permiso cada vez que quiera abrir o cerrar un puerto en mi equipo ?
debo pedirles permiso por utilizar mi equipo ?

Otro problema típico con empresas como Telefónica Chile es no atender al cliente si éste no utiliza un sistema operativo Windows. En una ocasión tuve problemas con mi conexión y llamé a soporte técnico, le expliqué que había un problema de planta y empezó con el típico: vaya inicio, cmd ... etc. Le dije que no usaba Windows y me dijo que no me podía dar soporte y me cortó la llamada.

Como ven algunas empresas toman decisiones por nosotros que nos afectan directamente, haciéndonos perder el tiempo y en algunos casos dinero y recursos (todas las anteriores en mi caso).

Donde está la ética en la empresa moderna ?? se preocupan de reducir costos, aumentar beneficios, mejorar procesos internos, aplicar ingeniería de vanguardia en la cadena de producción, pero y por qué se toman las atribuciones para tomar una decisión tan personal como la configuración de puertos de mi equipo ?? por qué debo pedir permiso al ISP para dar acceso a mis amigos a mi equipo ??

Como mencioné al principio, las empresas están olvidando para quién trabajan, están mordiendo la mano de quien les da de comer y si siguen así se van a ir llenando de demandas (ya demandé a VTR y gané, tal vez sea el turno de Telefónica Chile).

Nosotros como profesionales IT tenemos el deber de velar por la seguridad de nuestros usuarios y clientes, pero jamás tomarnos las atribuciones de tomar una decisión personal de ellos y por ellos.

La ética no le corresponde solo a los médicos y a los abogados (por ejemplo el caso de la confidencialidad de información), nos corresponde a todos y si trabajamos con y para personas no debemos olvidar darles el lugar que les corresponde.

Está mal que las empresas se tomen atribuciones personales de los clientes y si usted lector tiene su propia empresa mas vale que tome este tema en cuenta, ya que la relación que tenga con sus clientes marcará la diferencia entre si obtiene beneficios o se va a pérdida por demandas o por que sus clientes lo abandonan.

Y ustedes estimados lectores, qué opinan sobre la toma de decisiones por ustedes ?? existe la ética en la empresa moderna ?? están de acuerdo en pedir permiso a una empresa para utilizar sus equipos como les plazca ??

saludos !!!

Demo sistema reclamos Ajax + Servlet + JSP en NetBeans 6.1

2008-05-17T02:03:00.026-04:00

Demo sistema de reclamos Ajax – Servlet - JSP

Contenido

1 Introducción
2 Overview
3 Requerimientos
4 Manos a la obra
4.1 index.jsp
4.2 misFunciones.js
4.2.1 Función enviarDatosAjaxServlet
4.2.2 Función procesarRespuesta
4.2.3 Función valorXml
4.2.4 Función cargarContenidoDinamico
4.3 Servlet MiServlet.java
5 resultado.jsp
6 Conclusiones
7 Anexos

1 Introducción

Durante el desarrollo de un sistema web para mi tesis tuve algunos problemas asociados a Ajax y Java.

El problema general era que no sabía como comunicar dos tecnologías distintas, obtener datos con ajax y enviarlos al backend de la aplicación y desde ésta enviar una respuesta a ajax y desplegar lo que corresponda.

En Internet abundan los ejemplos, que hay que utilizar miAjax.responseText, miAjax.responseXML, etc. pero ningún ejemplo concreto y funcional, todo queda en teoría y poco de práctica.

Tampoco se habla mucho del tema de la codificación de datos, una cosa es enviar datos así como Dios los trajo al mundo y otra distinta es enviarlos y recibirlos tal cual, hablo específicamente de los caracteres especiales (ñ, tíldes, etc.), caracteres que son parte de nuestro lenguaje español (y que al parecer los gringos omiten en sus ejemplos, lo cual trae un par de dolores de cabeza a los de habla hispana).

Bueno, la verdad es que después de mucho averiguar, leer, probar y tomar un par de pastillas para el dolor de cabeza he logrado hacerlo y debo decir que es muy fácil, pero hay varios detalles que se deben tener en cuenta.

2 Overview

El ejemplo que veremos se trata de un demo de un sistema de reclamos. La idea es ingresar el nombre de la persona que reclama, el detalle del reclamo y la fecha de ingreso del reclamo.

Los primeros dos datos se harán simplemente utilizando un input y un textarea de html, mientras que para la fecha se utilizará un widget ajax.

Estos datos se enviarán a un servlet que los validará, de estar correctos los almacenará en una sesión y retornará una respuesta a la función ajax.

Una vez que se tenga la respuesta se procederá a realizar la acción correspondiente.

3 Requerimientos

NetBeans 6.1
Jmaki 1.7.3 (plugin de NetBeans 6.1)

NetBeans 6.1 se puede descargar gratis desde el sitio oficial en http://www.netbeans.org para Windows o Linux. Requiere instalado previamente el kit de desarrollo de java JDK, para la realización de este tutorial se utilizó la versión 1.6.0 update 6 y se puede descargar desde http://java.sun.com/javase/downloads/?intcmp=1281

Jmaki se puede descargar desde el administrador de plugines de NetBeans.

También se utilizó el servidor de aplicaciones GlassFish V2 UR2 que viene incluido en NetBeans 6.1.

4 Manos a la obra

Lo primero es crear un proyecto web en NetBeans 6.1, para esto se pincha el botón new project → Web → Web Application, le damos por nombre AjaxServlet u otro, presionamos next y luego cargamos el módulo Jmaki.

Debemos crear los siguientes recursos en el proyecto.

index.jsp (viene por default).
resultado.jsp
MiServlet.java
misFunciones.js

4.1 index.jsp

Una vez listo aparecerá una página index con un par de cosas. Eliminamos todo lo que esta entre los tags y agregamos lo siguiente:

<h1>Ingresar reclamo</h1> <div id="error" style="color: red;"></div> <form onsubmit="enviarDatosAjaxServlet(); return false;" > <table> <tr><td><b>* Nombre:</b></td><td><input id="nombre" name="nombre" size="20" maxlength="20" ><a:widget name="yahoo.tooltip" args="{context:['nombre']}" value="Ingrese su nombre aquí." /></input></td></tr> <tr><td><b>* Comentario:</b></td><td><a:widget name="yahoo.tooltip" args="{context:['comentario']}" value="Ingrese el detalle del reclamo aquí." /><textarea id="comentario" name="comentario" rows="4" cols="25"></textarea></td></tr> <tr><td><b>* Fecha:</b></td><td><a:widget id="fecha" name="dojo.dropdowndatepicker" /></td></tr> <tr><td></td><td><input type="submit" value="Enviar"/></td></tr> <input type="hidden" value="submit" /> </table> </form>

Vamos a ver cada una de las partes:

<div id="error" style="color: red;"></div>

Aquí creamos un DIV de id error para agregar los errores de forma dinámica, esto es para no usar otra página web para desplegar el error. Esto es ideal para mostrar los errores al ingresar datos en un formulario o al querer loguearse a un sistema ya que no es necesario cargar toda una nueva página, es mucho mas rápido y mejora la usabilidad del sistema.

<form onsubmit="enviarDatosAjaxServlet(); return false;" >

Aquí comenzamos el form, donde tenemos el formulario de ingreso de datos. En vez de llamar directamente una página JSP o un Servlet, hacemos el llamado de una función javascript llamada enviarDatosAjaxServlet(), la cual veremos mas adelante.

<a:widget name="yahoo.tooltip" args="{context:['nombre']}" value="Ingrese su nombre aquí.">

Aquí tenemos un input de id nombre en el cual ingresamos el nombre de la persona que reclama. Si se fijan existe un tag extraño:

<a:widget name="yahoo.tooltip" args="{context:['nombre']}" value="Ingrese su nombre aquí.">

Ese tag corresponde a un widget de la bibliteca de Jmaki, específicamente a un tooltip Ajax de yahoo. Este tooltip lo encuentran en la paleta de Jmaki que pueden ver a la derecha del editor de NetBeans 6.1, simplemente lo arrastran y cambian el valor de context por el id del campo de datos, en este caso nombre.

El caso del textarea de comentario es igual al anterior, se arrastra el widget tootltip de yahoo y se cambia el valor de context a comentario.

<b>* Fecha:</b><a:widget id="fecha" name="dojo.dropdowndatepicker">

En el caso de la fecha utilizaremos un widget de Dojo llamado DropDownDatePicker el cual permite seleccionar la fecha desde un widget muy amistoso y bonito. Lo encuentran en la paleta de Jmaki y basta con arrastrar y soltar.

<input value="Enviar" type="submit">

<input value="submit" type="hidden">

Aquí simplemente agregamos el botón enviar y además la posibilidad de enviar los datos con solo presionar un Enter.

4.2 misFunciones.js

Hasta aquí todo va bien y muy fácil.

El tema ahora es obtener los datos del formulario y enviarlos al servidor para ser procesados. Este es el punto que más me costó. Primero fue difícil por que no sabia cómo obtener la fecha desde el DropDownDatePicker y segundo cómo obtener los caractéres especiales (ñs, tíldes, etc.). No den por sentado con que basta obtenerlos y enviarlos, si hacen eso verán que al otro lado los espacios aparecerán como %20 y cosas así.

A continuación veremos el código de la función enviarDatosAjaxServlet (el cual debe estar en el archivo misFunciones.js):

4.2.1 Función enviarDatosAjaxServlet

function enviarDatosAjaxServlet() { //aqui cargo los valores seleccionados en los drop down date picker var fecha = jmaki.getWidget('fecha').getValue(); //aqui obtengo el valor del comentario ingresado var comentario = encodeURIComponent(document.getElementById("comentario").value); //aqui obtengo el valor del nombre ingresado var nombre = encodeURIComponent(document.getElementById("nombre").value); //aqui envio la fecha, el comentario y el nombre al servlet MiServlet //para almacenarlos en una sesion jmaki.doAjax({ url : "MiServlet", method : 'POST', content : { 'nombre' : nombre, 'comentario' : comentario, 'fecha' : fecha }, callback : function(req) { procesarRespuesta(req); } }); }

El obtener la fecha en realidad es bastante simple, se utiliza la función jmaki.getWidget('fecha').getValue(); la cual retorna un String con la fecha seleccionada.

Para obtener los otros dos datos es necesario recurrir a document.getElementById("comentario").value (en el caso de obtener el comentario) y document.getElementById("nombre").value (en el caso de obtener el nombre). Lo segundo que hay que aplicar al resultado de esas “consultas” es la codificación de los caracteres, para esto utilizamos encodeURIComponent. De ésta manera aseguramos que al otro lado (en el servidor) los caracteres especiales lleguen como tales, pero se debe tener en cuenta que se debe hacer el proceso inverso (mas adelante lo veremos).
Para enviar los datos al servlet utilizamos una función de Jmaki llamada doAjax, la cual recibe como parámetros la url a la cual enviamos los datos, en este caso el servlet MiServlet, el tipo de método GET o POST, los datos que enviamos y el callback que se utiliza para obtener la respuesta del servlet.

En el lado del servidor obtendremos los datos a través del objeto request del servlet.

La función en callback llama a otra función llamada procesarRespuesta, la cual recibe como parámetro el request ajax (que viene con la respuesta del servlet).

La respuesta del servlet viene en formato XML, por lo que utilizaremos un responseXML para obtener la respuesta en vez de un responseText.

4.2.2 Función procesarRespuesta

function procesarRespuesta(respuesta) {

//aqui obtengo el archivo XML en una variable que envio el

//servlet como respuesta

var xml = respuesta.responseXML;

//aqui obtengo el valor del tag respuesta que esta en el xml

var res = valorXml(xml,'respuesta', 0);

//si la respuesta es ok significa que no hay errores

if(res == 'ok'){

window.location.href="resultado.jsp";

} else {

//si hay errores entonces muestro un mensaje

cargarContenidoDinamico('error', "Ocurrió un problema al enviar los datos, tal vez omitió el ingreso de alguno. Intente nuevamente.");

}

}

Lo primero es obtener el objeto xml desde el respuesta.responseXML.
Luego debemos obtener el valor de la respuesta que está entre los tag valor del xml y para tal tarea nos apoyamos en otra función llamada valorXML, que recibe como parámetro el objeto xml, el nombre del tag y el índice en el cual se encuentra el valor dentro del tag.

El valor se almacena en una variable llamada res (que corresponde a un String o cadena de caracteres) y se verifica si hay o no errores. Si no hay errores se redirige el navegador a la página resultado.jsp, en caso contrario se carga el error en el DIV “error” sin cambiar de página utilizando la función cargarContenidoDinamico.

4.2.3 Función valorXml

function valorXml(xml, tagName, index) {

//si el tag no existe retorno null, en caso contrario retorno el valor del tag

if(xml.getElementsByTagName(tagName).length == 0)

return null;

return xml.getElementsByTagName(tagName)[index].childNodes[0].nodeValue;

La función valorXml busca el valor correspondiente al indice index en el tag tagName. Si no lo encuentra retorna null, en caso contrario retorna el valor.

4.2.4 Función cargarContenidoDinamico

function cargarContenidoDinamico(contenedor, texto) {

//aqui agrego el texto al div contenedor

document.getElementById(contenedor).innerHTML = texto;

}

La función cargarContenidoDinamico carga el valor obtenido desde el xml en el DIV error para desplegar el mensaje de error sin cambiar de página.

4.3 Servlet MiServlet.java

El servlet, por default viene con tres métodos, doGet, doPost y processRequest. Es en este último donde codificaremos (los otros dos quedan intactos).

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/xml charset=UTF-8");
response.setHeader("Cache-Control", "no-cache");

PrintWriter out = response.getWriter();

HttpSession sesion = request.getSession();
boolean error = false;

String fecha = request.getParameter("fecha");
if(fecha == null){
error = true;
}

String n = request.getParameter("nombre");
String nombre = null;
try{
nombre = URLDecoder.decode(n,"UTF-8");
if (nombre.equals(""))
error = true;
} catch (NullPointerException ex){
error = true;
}

String c = request.getParameter("comentario");
String comentario = null;
try{
comentario = URLDecoder.decode(c,"UTF-8");
if (comentario.equals(""))
error = true;
} catch (NullPointerException ex){
error = true;
}

if(error == false){
sesion.setAttribute("fecha", fecha);
sesion.setAttribute("nombre", nombre);
sesion.setAttribute("comentario", comentario);

out.println("ok");
} else{
out.println("error");
}

out.close();
}

Lo primero es fijarse que el contentType debe ser text/xml para indicar que devolveremos un xml.

En éste método creamos una sesión (que no tiene porque estar ligada a un user y password) para almacenar los datos ingresados previamente.

Como se dijo anteriormente, a través del request obtenemos los datos y los almacenamos en variables de tipo String.

El punto importante aquí es decodificar los datos codificados anteriormente para recuperar los caracteres especiales. Para ésto utilizamos el método estático URLDecoder.decode(n,"UTF-8"); el cual recibe como parámetro el String obtenido del request y el tipo de codificación. Será necesario importar la siguiente biblioteca: import java.net.URLDecoder;

La razón de almacenar los datos en una sesión es que ésta la utilizaremos en la página respuesta.jsp para desplegarlos en pantalla.

En el caso que no se tengan errores al obtener los datos, éstos se almacenan en la sesión y se envía la respuesta en xml simplemente agregando la linea out.println("ok");, y en caso contrario agregando out.println("error");.

De ésta forma enviamos la respuesta al callback de la función doAjax de Jmaki.

5 resultado.jsp

<%@ page contentType="text/html; charset=UTF-8"%>

<%@ page pageEncoding="UTF-8"%>

<%@ page language="java" session="true"%>

<%

response.setHeader("Cache-Control","no-store");

response.setHeader("Pragma","no-cache");

response.setDateHeader("Expires",0);

HttpSession sesion = request.getSession();

String comentario = (String) sesion.getAttribute("comentario");

String nombre = (String) sesion.getAttribute("nombre");

String fecha = (String) sesion.getAttribute("fecha");

sesion.invalidate();

%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Resultado</title>

</head>

<body>

<h1>Resultado</h1>

<table>

<tr><td><b>El nombre ingresado es:</b></td><td><%=nombre%></td></tr>

<tr><td><b>El comentario ingresado es:</b></td><td><%=comentario%></td></tr>

<tr><td><b>La fecha de ingreso del comentario es:</b></td><td><%=fecha%></td></tr>

</table>

</body>

</html>

Lo primero que hacemos aquí es definir la utilización de la sesión agregando el tag

<%@page language=”java” session=”true”%>

Luego obtenemos la sesión desde el request y obtenemos los datos, después invalidamos la sesión eliminando los datos de ésta.

Después simplemente mostramos los datos agregandolos con el tag <%=valor%>.

6 Conclusiones

Con ajax podemos crear una presentación mas decente de los datos y a la vez mas eficiente si nos preocupamos de que las funciones que carguemos sean livianas y de poco texto.

Gracias a las funciones expuestas en este simple demo, podemos cargar datos de forma dinámica para la muestra de errores sin necesidad de cargar una nueva página, lo que es mas rápido y eficiente.

También vimos que gracias a las funciones de la biblioteca de Jmaki podemos agregar widgets bonitos y que mejoran la usabilidad del sistema.

Y por último aprendimos a comunicar tecnologías distintas como son java con javascript (Ajax), manejando caracteres especiales, etc.

7 Anexos

Espero les sea de utilidad.

El código me lo piden dejando su correo en el blog y se los enviaré a la brevedad.
También tengo esta entrada del blog en un documento ODT y PDF (no me pidan formato DOC), se los reboto junto al código.

saludos !!!

EDITADO!!!

Subí el código a un servidor para que puedan hacer la descarga sin necesidad de enviarme sus correos (así no tienen que esperar a que yo lea el correo para rebotarlo a ustedes), si tienen problemas para la descarga seguimos con el método tradicional del correo electrónico.

Descarga

saludos !!!!

Instalación Openbravo 2.35 MP1 en Linux

2008-03-11T22:20:00.033-03:00

Esta vez vengo con una actualización de la guía para instalar Openbravo en Linux. La versión es la última a la fecha, la 2.35 MP1. Si siguen la guía al pie de la letra no deberían tener problemas. Yo lo instalé como explicaré mas adelante y no tuve NINGUN percance. El sistema operativo que utilizé es PCLinuxOS 2008, pero sirve cualquier distro (distribución GNU/Linux) con linux 2.6.x.

Bien, para la realización de esta guía se utilizaron la última version de Openbravo (2.35 MP1), Ant (1.7), Tomcat (6.0.14) y JDK (1.6.0_05). La versión de PostgreSQL que utilizé es la 8.1.11. En uno de los comentarios que se hicieron en la guía de la versión 2.33 se dijo que Openbravo NO funcionaba con la version 8.3 de PostgreSQL, asi es que por si acaso mejor que no la usen, a no ser que el comentario esté errado, si quieren lo prueban y despues nos cuentan, pero yo no doy garantías de que si funcione. Además hay que tener en cuenta que Openbravo funciona con PostgreSQL desde la versión 8.1.4 en adelante.

Los primeros 4 deben descargarlos de la página oficial de cada uno, el último va a depender de que distribución de linux estén usando y si tienen o no configurados los repositorios de Internet.

Para los recién iniciados en linux y sus múltiples distribuciones, un repositorio es un lugar en donde existen paquetes de software disponible para la descarga e instalación, automática o manual. Por ejemplo openSUSE 10.3 trae un apartado con repositorios, que vienen desactivados por default pero que se pueden activar en yast -> software -> community repositories, en el caso de PCLinuxOS 2008 los repositorios ya vienen listos. En el caso de otra distribución como ubuntu, fedora, etc desconozco ya que no los uso, pero google es su amigo en esos casos.

Recomiendo tremendamente que antes de instalar cualquier cosa, tengan sus repositorios configurados y actualizados antes de seguir con la guía, si no lo hacen así acuerdense de mi, tendrán problemas mas adelante (les suena un BUILD FAILED ??).

Para el JDK tienen varias versiones, si su distribución utiliza paquetes RPM entonces descarguen el paquete de nombre jdk-6u5-linux-i586.rpm.bin y en caso contrario descarguen jdk-6u2-linux-i586.bin. Algunas distribuciones traen el JDK en sus repositorios, pueden instalarlo desde ahí tambien, pero fijense después en qué directorio quedará instalado, en el caso del RPM queda en /usr/java/jdk1.6.0_05.

Instalación de dependencias:

PostgreSQL.
Entonces ya tenemos descargados Openbravo, Ant, Tomcat y JDK. Ahora utilizaremos el gestor de paquetes que corresponda (YAST, Synaptic, Smart, etc) y escribiremos PostgreSQL y lo instalamos como se ve a continuación:

JDK.
Una vez instalado seguimos con el JDK. Lo primero es dar permisos de ejecución al instalador, para esto abrimos una consola (en el caso de utilizar el escritorio KDE, menú -> aplicaciones -> sistema -> terminales -> konsole), escribimos su e ingresamos la contraseña de administrador del sistema (al escribirla no se ve nada, no hay problema) y presionamos enter.

Por default la consola queda posicionada en su home, por ejemplo /home/metalklesk (el cual es mi caso), asi que para evitar confusiones tengamos todos los archivos descargados en la raíz de nuestro home.

Ahora escribimos:

chmod a+x jdk-6u5-linux-i586.rpm.bin
./jdk-6u5-linux-i586.rpm.bin

con eso nos va a salir un texto explicando la licencia, etc. y si no nos interesa leerlo presionamos q y enter. Ya con eso tenemos el JDK instalado en /usr/java/jdk1.6.0_05. Si no usamos RPM hacemos lo mismo con el otro:

chmod a+x jdk-6u5-linux-i586.bin
./jdk-6u5-linux-i586.bin

mv -f jdk1.6.0_05/ /opt

mv -f apache-ant-1.7/ /opt

y ya lo tenemos instalado.

Si mal no recuerdo, los archivos de ejecución de ant no traen permiso de ejecución, para dárselos simplemente aplicamos como root lo siguiente:

chmod +x /opt/apache-ant-1.7/bin/*

Tomcat.
Para instalar Tomcat simplemente debemos descomprimir el archivo descargado, si usamos KDE hacemos click derecho sobre el archivo -> extraer -> extraer aquí. Luego movemos la carpeta a /opt.

mv -f apache-tomcat-6.0.14/ /opt

y ya lo tenemos instalado.

Si mal no recuerdo, los archivos de ejecución de tomcat no traen permiso de ejecución, para dárselos simplemente aplicamos como root lo siguiente:

chmod +x /opt/apache-tomcat-6.0.14/bin/*

Configuración del sistema.
Ahora debemos configurar PostgreSQL y algunas variables del sistema antes de instalar Openbravo.

PostgreSQL.
Lo primero es darle una contraseña al usuario administrador de PostgreSQL, al usuario postgres, para esto simplemente escribimos en consola:

passwd postgres

y escribimos la contraseña. Ahora debemos iniciar y detener PostgreSQL por primera vez, para que se creen los archivos de configuración, para esto simplemente escribimos en consola:

service postgresql start

y luego

service postgresql stop

como se puede ver en la siguiente imagen.

Ahora debemos modificar el archivo /var/lib/pgsql/data/pg_hba.conf, vamos al final y donde dice:

# "local" is for Unix domain socket connections only
local all all ident sameuser
# IPv4 local connections:
host all all 127.0.0.1/32 ident sameuser
# IPv6 local connections:
host all all ::1/128 ident sameuser

cambiamos el "ident sameuser" por un "trust", sin las comillas, y guardamos.

kwrite /etc/profile

bajen hasta el final y agreguen las siguientes lineas:

export JAVA_HOME=/usr/java/latest/
export JDK_HOME=/usr/java/latest/
export JRE_HOME=/usr/java/latest/jre
export ANT_HOME=/opt/apache-ant-1.7.0
export CATALINA_HOME=/opt/apache-tomcat-6.0.14
export PATH=${JAVA_HOME}/bin:${JDK_HOME}/bin:${JRE_HOME}/bin:${ANT_HOME}/bin:${CATALINA_HOME}/bin:$PATH

como se ve en la siguiente imagen:

guardamos y reiniciamos el equipo.

Una vez que reiniciamos el equipo las variables estarán presentes. Fijense bien en las rutas que ahí aparecen en los export, puede que varie un poco si han colocado algo en otro lugar que no sea lo que se ve en la imagen.

Ahora ya estamos en condiciones de instalar Openbravo.

Instalación Openbravo.
Para instalar Openbravo debemos tener arriba a PostgreSQL y a Tomcat, para esto simplemente hay que ingresar en la consola, como root:

service postgresql start

$CATALINA_HOME/bin/startup.sh

y despues ejecutamos el instalador de Openbravo ...

./OpenbravoERP-2.35-MP1-linux-installer.bin

luego aceptamos la licencia

luego escojemos instalación full

después escojemos como base de datos a PostgreSQL

luego hay que colocar la ruta de JAVA_HOME, pero como ya ingresamos la variable al sistema, debería detectar la rutas automáticamente como se ve en la siguiente imagen

lo mismo con Ant

y con Tomcat.

Ahora debemos ingresar los datos de configuración de Tomcat como se ve en la siguiente imagen, si no han cambiado nada en la configuración de Tomcat, no deberiamos cambiar nada en este punto, dejarlo tal como está, si tienen tomcat corriendo en otro puerto distinto del 8080, es acá donde deben especificar eso

luego deben ingresar el directorio en el cual se encuentran los archivos ejecutables de PostgreSQL, en el caso de PCLinuxOS 2008 y openSUSE 10.2/10.3 corresponde a /usr/bin, si usan otra distro deben saber cual directorio corresponde

luego les saldrá un mensaje sobre la versión de PostgreSQL, nada de que preocuparse a menos que estén utilizando la versión 8.3 (según uno de los usuarios que hizo un comentario al respecto, aun no he probado) o una menor a la 8.1.4

luego debemos ingresar los parámetros de la base de datos, como el puerto, el nombre de la base de datos, etc. Si no hemos cambiado nada (como el puerto por default, o la ubicación de la base de datos) entonces dejamos todo tal cual está.

luego se ingresa la contraseña del usuario postgres (administrador de PostgreSQL)

después se crea un usuario y contraseña para la base de datos de openbravo

y luego estamos listos para instalar

luego solo debemos esperar a que termine de compilar e instalar, lo cual demora un poco mas de una hora, dependiendo del equipo que tengamos (puede ser menos tiempo).

Una vez listo abrimos nuestro navegador favorito (firefox :p) y escribimos http://localhost:8080/openbravo

el nombre de usuario es Openbravo y la contraseña es openbravo. Ya tenemos nuestro flamante ERP instalado en nuestro sistema, pero por default está en inglés

en el panel de la izquierda en la parte de arriba dice Openbravo (junto a un ícono de una persona), si pinchamos ahí se abrirá la siguiente ventana

ahí en la sección Language cambiamos English por Spanish y guardamos presionando Ok y ya tenemos Openbravo en español.

Espero les sirva esta guía, la hice con un poco mas de detalle que la anterior para ayudar a los recién iniciados en linux. Mas adelante haré la misma guía de instalación pero sobre Windows XP.

saludos !!!

Creación de LiveUSB con PCLinuxOS

2008-03-08T20:21:00.007-03:00

Hola, como algunos sabían yo usaba openSUSE 10.3 como sistema operativo, pero casi todos los dias pasaba en la Universidad y usaba mi live cd de PCLinuxOS, al final resultó que me acostumbré mas a ésta distro linux por lo que decidí eliminar de mi máquina a openSUSE y dejar a PCLinuxOS.

Además resulta que estoy desarrollando un software para mi tesis y en la misma Universidad prácticamente no se puede trabajar ya que por una parte tienen instalado Windows XP sp2 en TODOS los computadores y por otra están TODOS infectados, por lo que no arriesgaría desarrollar mi tesis en esos computadores, aunque tengan antivirus, no sirve de nada, un problema que todos los usuarios de Windows, por muy maestros que sean, conocen.

Lo que se puede hacer y lo que vengo haciendo desde hace 2 años es usar un live cd, que es una distribución de linux que bootea desde el cd o dvd y no toca el disco duro, a no ser que queramos claro. Esta solución sirve, pero resulta muy lento, es mas rápido que trabajar en los Windows instalados, por el estado en el que están, pero aun asi es lento. Entonces busqué la opcion de instalar linux en un pendrive y encontré que si se puede.

Para instalar linux en un pendrive hay varias formas (google es tu amigo), pero definitivamente la mas fácil es usando PCLinuxOS.

Requerimientos:

PCLinuxOS minime 2008.
Pendrive de 1gb o mas (yo uso uno de 4 gb).
Conexion a Internet.

La iso de PCLinuxOS minime 2008 pesa solo 296 mb y trae el escritorio KDE 3.5.8 con drivers para tarjetas de red y lo mas básico. La idea de esa versión es que un usuario la pueda remasterizar, es decir, personalizar a gusto y crear su propia versión con el software que hay disponible, con sus propias configuraciones de escritorio, etc.

Una vez descargada hay que grabarla a un cd o dvd y ya puedes bootear el pc desde el cdrom o dvdrom. Luego de iniciar el sistema puedes instalarlo (en el escritorio encontraras un icono y solo debes seguir las instrucciones.). Si no quieren instalarlo en el computador de base, pueden usar una máquina virtual como virtualbox.

Una vez instalado ya es cosa de instalar/desinstalar/configurar/personalizar la distro a gusto, para eso necesitarán una conexion a internet para poder descargar los programas que quieran instalar a través de synaptic (o a mano si quieren).

Para conectarse a Internet pueden utilizar el panel de control de pclinuxos, el cual lo encuentran en menú -> aplicaciones -> sistema -> configuracion -> configure your system. Especificamente para internet entran a la opción que dice redes e internet y luego configurar una nueva interfaz de red y siguen las instrucciones.

Una vez listo lo que hay que hacer es abrir una consola (menú -> aplicaciones -> sistema -> terminales), loguearse como usuario root (escribir su y presionar enter, ingresar la contraseña y presionar enter) y escribir "remasterme" sin las comillas, eso creará una iso de nombre livecd.iso, la cual si gustan la pueden grabar a un cd/dvd y ya tienen un livecd/dvd personalizado.

Una vez que ya tienen la iso personalizada a gusto, en la misma consola, como usuario root escriben "liveusb". Al escribir eso aparecerá un wizard muy sencillo que tienen que seguir. Basicamente les sale un mensaje que les advierte que deben ingresar el pendrive, que debe estar en formato fat16, etc. Luego les pedirá que seleccionen el pendrive y que le pasen la iso creada anteriormente. Una vez pasada la iso comenzará el proceso de creación del liveusb. Al finalizar ya esta listo, pueden reiniciar el computador y ya están listos para bootear desde el pendrive, que es bastante mas rápido que desde un cd o dvd.

Espero les sirva, por lo menos a mi si me ha servido para trabjar tranquilamente en mi tesis.

Saludos !!!

OpenVPN y Samba sobre openSUSE 10.3

2007-12-31T02:31:00.000-03:00

Este fin de semana estuve "jugando" con unos softwares bien potentes, OpenVPN y Samba. OpenVPN sirve para crear redes virtuales privadas entre equipos que fisicamente estan separados (no estan en la misma red ni en el mismo dominio). De esta manera se pueden conectar equipos o redes enteras unas con otras, por ejemplo para unir sucursales de una misma organización y compartir información por un canal seguro, o comunicar empresas con proveedores, etc.

OpenVPN utiliza OpenSSL para agregar la capa de seguridad al sistema a través de la encriptación, haciendo uso de llaves simétricas o a través de emisión de certificados digitales y llaves asimétricas (el segundo método es lejos mejor).

A través de OpenVPN podemos conectar equipos con distintos sistemas operativos, ya que tiene versiones para varios (linux, windows, etc.) y corre tanto en modo servidor como en modo cliente (se pueden ejecutar los dos modos al mismo tiempo en el mismo equipo en procesos distintos).

Samba es un software que sirve para compartir recursos en una red, autenticar usuarios, controlar acceso a recursos, tiene compatibilidad con active directory y un laaaargo etc. Mediante Samba podemos compartir recursos en equipos que corren distintos sistemas operativos, por ejemplo podemos compartir una carpeta en linux y desde windows lo podriamos ver sin problemas, o al revés, desde windows podríamos compartir una carpeta (a traves de samba o de windows) y desde linux lo podríamos ver también.

La unión de estos dos sistemas lo encuentro especialmente poderoso, por un lado creamos una red con equipos distantes y por otro lado aprovechamos los recursos compartiendo y manejando, de forma transparente, la seguridad de los datos en la red.

OpenSUSE 10.3 y Mandriva 2008 (los que probé en estos dias) traen todo lo necesario para armar un servidor/cliente OpenVPN y Samba.

En internet se pueden encontrar varias guías para ayudar a configurar OpenVPN y Samba, en mi caso particular me gustó mucho ésta guía para OpenVPN que seguí paso a paso, solo cambie cosas muy particulares para que funcionara en openSUSE 10.3. Debo recalcar que es muy buena y no tiene caso volver a redactar algo como lo que sale ahí en mi blog, está para seguir paso a paso y es casi imposible equivocarse.

Sobre Samba, leí muchas guías en Internet, ninguna me sirvió. Lo fácil es levantar el servidor usando YAST, pues en YAST -> Servicios de red -> Servidor Samba le damos siguiente siguiente a todo y ya está.
Incluso te da la opción de abrir el puerto en el cortafuegos (genial, todo automático y a puros clicks).

El problema que tuve fue al tratar de compartir recursos, YAST te da la opción, pero cuando quería acceder a las carpetas compartidas no podía, ingresaba smb:/ en konqueror y la red aparecía, las carpetas también pero al acceder salen errores como "el recurso o carpeta no existe", siendo que tenía definido que la carpeta estaba para compartir con todos sin pedir password ni nada. Probé desde el módulo de Samba en KDE, lo mismo, los mismos errores. Perdí muchas horas tratando, conclusión, las herramientas que vienen con openSUSE no lo hacen del todo bien o a mi me faltó marcar/desmarcar alguna opción.

Al final lo solucioné a mano (como en la vieja escuela). Samba lee un archivo de configuración que se llama smb.conf que está en /etc/samba. Este archivo define una configuración global a base de directivas del tipo variable = valor. La parte global YAST la maneja a la perfección, pero por experiencia propia recomiendo agregar los recursos de red a compartir a mano.

En este caso particular de OpenVPN y Samba, hay una cosa que hay que tener en cuenta, si configuran Samba (suponiendo que los recursos estan disponibles en la red, todo correcto) y OpenVPN, desde el cliente OpenVPN NO tendrán acceso a los recursos Samba.

Lo anterior es porque OpenVPN crea una sub red definida en 10.8.0.0/24 desde la cual asigna una ip a cada máquina dentro de ese rango y Samba solo permite compartir recursos en la sub red del servidor (en mi caso 192.168.0.0/24), por lo tanto aunque las máquinas estén en red, no podrán acceder a los recursos.

Para solucionar esto solo hay que agregar una linea de texto a la configuración global de samba (smb.conf):

hosts allow = 192.168.0.0/24 10.8.0.0/24 127.0.0.1

y en el caso de que el servidor Samba y el servidor OpenVPN estén corriendo en la misma máquina se agrega la siguiente linea:

interfaces = 192.168.0.0/24 10.8.0.0/24

Luego se reinicia el servidor Samba (#service smb restart) y los clientes de la VPN podrán acceder a los recursos sin problema.

Ahora, cómo agregamos recursos a Samba ? pues la verdad es muy simple y les mostraré 3 ejemplos, en los cuales compartiremos 3 carpetas pero usando distintas directivas para definir permisos, control de acceso ,etc.

[compartido]
comment = Directorio de acceso general
path = /home/metalklesk/Documents/Compartido/General
read only = No
guest ok = yes
browseable = yes

Con esa configuración, el recurso está disponible para cualquiera y tiene permisos de escritura y lectura.

La primera linea define el nombre del recurso, con éste nombre se identifica en la red.
Lo segundo es solo un comentario y puede ser omitido.
El path define el directorio del recurso que se quiere compartir.
Read only = no significa que estamos dando permisos de lectura y escritura al recurso.
guest ok = yes significa que permitimos que cualqueira entre y vea el recurso.
browseable = yes significa que el recurso se puede ver por cualquiera y está disponible.

[restringido]
comment = Directorio de acceso restringido
path = /home/metalklesk/Documents/Compartido/Restringido
read only = No
browseable = yes
security = shared
valid users = klesk metalklesk

Con esta configuración el recurso solo estará disponible para los usuarios klesk y metalklesk, para cualquier otro usuario el acceso al recurso será denegado. Esto se define a través de la directiva valid users = klesk metalklesk.

[restringido2]
comment = Directorio de acceso restringido
path = /home/metalklesk/Documents/Compartido/Restringido2
read only = No
browseable = yes
security = shared
invalid users = metalklesk

Esta configuración permite el acceso al recurso a todos los usuarios de la red excepto al usuario metalklesk mediante la directiva invalid users = metalklesk.

Bueno, pero y como se agregan usuarios a Samba ? pues muy fácil, se utiliza el comando:

smbpasswd -a usuario

y se le ingresa una contraseña y listo.

Ya con esto podrán compartir carpetas o recursos especificando algunas reglas para cada uno de ellos. Existem muchas mas combinaciones y mas directivas, se pueden remitir al manual de Samba para conocerlas todas y lo recomiendo.

A continuación les dejo mi archivo smb.conf completo por si les sirve.

# smb.conf is the main Samba configuration file. You find a full commented
# version at /usr/share/doc/packages/samba/examples/smb.conf.SUSE if the
# samba-doc package is installed.
# Date: 2007-09-22
[global]
printing = cups
printcap name = cups
cups options = raw
map to guest = Bad User
include = /etc/samba/dhcp.conf
logon path = \\%L\profiles\.msprofile
logon home = \\%L\%U\.9xprofile
logon drive = P:
usershare allow guests = Yes
usershare max shares = 100
security = share
restrict anonymous = no
domain master = no
preferred master = no
max protocol = NT
acl compatibility = win2k
ldap ssl = No
server signing = Auto
SO_RCVBUF=8192 SO_SNDBUF=8192
socket options = TCP_NODELAY
hosts allow = 192.168.0.0/24 10.8.0.0/24 127.0.0.1
interfaces = 192.168.0.0/24 10.8.0.0/24

[homes]
comment = Home Directories
valid users = %S, %D%w%S
browseable = No
read only = No
inherit acls = Yes

[users]
comment = All users
path = /home
read only = No
inherit acls = Yes
veto files = /aquota.user/groups/shares/
browseable = yes
public = yes

[groups]
comment = All groups
path = /home/groups
read only = No
inherit acls = Yes

[printers]
comment = All Printers
path = /var/tmp
printable = Yes
create mask = 0600
browseable = No

[print$]
comment = Printer Drivers
path = /var/lib/samba/drivers
write list = @ntadmin root
force group = ntadmin
create mask = 0664
directory mask = 0775

[compartido]
comment = Directorio de acceso general
path = /home/metalklesk/Documents/Compartido/General
read only = No
guest ok = yes
browseable = yes

[restringido]
comment = Directorio de acceso restringido
path = /home/metalklesk/Documents/Compartido/Restringido
read only = No
browseable = yes
security = shared
valid users = klesk metalklesk

[restringido2]
comment = Directorio de acceso restringido
path = /home/metalklesk/Documents/Compartido/Restringido2
read only = No
browseable = yes
security = shared
invalid users = metalklesk

Es muy probable que les suceda que no puedan acceder a los recursos desde un cliente (windows o linux), deben fijarse en los permisos de usuario de las carpetas o directorios que estén compartiendo. Por ejemplo la carpeta Documents en openSUSE no puede ser accedida por otro usuario que no sea el dueño y el root, por lo tanto aunque configuren todo bien en Samba, no podrá ser accesado por un cliente. O modifican los permisos de la carpeta o escojen otra.

Y como siempre unas capturas de pantalla. La primera muestra a openSUSE 10.3 corriendo un servidor Samba y OpenVPN y mandriva como cliente de ambos.

La siguiente muestra el diálogo de autenticación que sale al intentar entrar a la carpeta restringida

La siguiente muestra que efectivamente las máquinas están conectadas en red, mediante un simple ping a la ip del cliente (ip asignada por el servidor OpenVPN)

La siguiente muestra un cliente Windows conectado a la VPN

La siguiente muestra como Windows puede ver los recursos compartidos en openSUSE 10.3 mediante samba

En las imágenes anteriores se ve que las pruebas fueron realizadas con máquinas virtuales, esto no es ninguna trampa, efectivamente están en red a través de OpenVPN. Además probé con el equipo de un amigo y también funcionó.

Espero les sirva.

saludos !!!

Pebble, un blog desarrollado en java sobre Glassfish V2 en openSUSE 10.3

2007-12-29T02:41:00.000-03:00

Pebble es un sistema blog liviano que soporta multi usuarios, muti blogs, cada uno puede tener uno o mas blogs. Maneja roles de usuario como administrador, dueño de un blog, etc.

Trae varias caracteristicas bien interesantes, como por ejemplo:

Permite subir archivos de cualquier tipo para compartir con los lectores.
Tiene un editor de texto increible, es sumamente configurable.
Trae soporte para varios idiomas.
Puedes cambiar el theme por usuario.
No requiere de una base de datos.
etc.

Pueden ver todas sus características en el sitio web oficial.

Existen muchos sistemas de blog públicos como Blogger o Wordpress, entonces para que interesarse en otro mas ? que puede aportar pebble a nuestra vida personal y/o profesional ?

Pues puede aportar mucho, es open source asi es que de licencias no hay que preocuparse, se puede adecuar a nuestras necesidades pues se tiene el código fuente.

Es muy útil para crear blogs al interior de una organización (empresa, universidades, colegios, cooperativas, etc.) como apoyo al desarrollo de proyectos y/o tareas o actividades, por ejemplo:

Compartir información útil.
Dar avisos importantes de eventos al interior de la organización.
Apoyar el desarrollo de memorias de título ya que se pueden ir subiendo los informes de avances, etc., pudiendo comentar y aportar positivamente.
etc.

Pebble es muy liviano y viene listo para su uso, no es necesario recompilar para configurarlo. Funciona sobre cualquier servidor de aplicaciones que soporte JSP 2.0/Servlet 2.4, como por ejemplo Tomcat 5.5.x o Glassfish, entre otros.

Lo primero que hay que hacer es descargarlo, yo descargo siempre la última versión mas actual para ir probando, quizas ustedes prefieran la última versión estable.

Una vez descargado simplemente hay que descomprimir el zip como se ve en la imagen a continuación:

Dentro de la carpeta de Pebble se puede encontrar el código fuente y un archivo llamado pebble.war, el cual no es mas que un archivo zip con el proyecto precompilado. Si no quieren cambiar nada pueden dejarlo tal cual, en mi caso quize cambiar la configuración de pebble para que soporte multi blogs, para eso sacamos una copia del archivo pebble.war y lo renombramos a pebble.zip, luego descomprimimos el zip y entramos a la carpeta WEB-INF y abrimos con un editor de texto el archivo llamado pebble.properties.

Dentro de ese archivo se pueden configurar un par de cosas, como por ejemplo el tamaño máximo para archivos que se quieran subir para compartir con los lectores del blog o dar/quitar soporte multi blog.
En este caso interesa modificar lo segundo (criterio mio, si quieren cambiar algo mas pueden hacerlo). Si se fijan, hay una variable que se llama multiblog y está con valor false, hay que cambiarlo a true.

Una vez listo guardamos y cerramos. Ahora hay que reconstruir el archivo war, para esto simplemente seleccionamos todo y creamos un archivo zip como ven a continuacion:

y renombramos el zip a war.

Ya tenemos Pebble listo, ahora hay que moverlo a un servidor de aplicaciones. En este caso utilizaremos Glassfish.

Si aún no tienes Glassfish instalado y/o configurado entonces date una vuelta por ésta entrada donde explico paso a paso como tener Glassfish correctamente configurado.

Hay que mover el archivo pebble.war a la carpeta /domains/domain1/autodeploy y levantamos el servicio (si estaba arriba entonces no hay que hacer nada mas), al tener el servicio levantado, Glassfish creará un archivo que se llamará pebble.war_deployed.

Una vez copiado el archivo war al servidor de aplicaciones podemos comenzar a utilizarlo, en un navegador escriban

http://localhost:8080/pebble/

y podrán utilizarlo.

Lo primero que deben hacer es entrar como administrador, por default el nombre de usuario es username y la contraseña es password (se puede cambiar).

Una vez logueado como administrador ya pueden crear usuarios, asignar roles, crear blogs y asignárselos a usuarios.

Espero les sea de utilidad como a mi.

saludos !!!

Instalación de Glassfish V2 en openSUSE 10.3

2007-12-28T18:03:00.000-03:00

En mi blog, varias veces he hablado de Glassfish, lo he utilizado en uno de los ejemplos, pero siempre bajo NetBeans 6.0. En un ambiente de producción no tiene sentido utilizar un IDE de desarrollo, de hecho el servidor no deberia tener mas que el SO, un par de programas, un entorno grafico simple (incluso algunos prefieren que el servidor NO tenga entorno gráfico, por seguridad), etc., lo minimo posible.

Instalar glassfish es bastante sencillo, lo primero es descargarlo acá, (necesitan tener java instalado y configurado previamente) luego ejecutar en consola (no es necesario ser ROOT para esto) lo siguiente:

java -Xmx256M -jar glassfish-installer-v2-b58g-ml.jar

les aparecerá una ventana con la licencia, presionan accept y con eso comenzará la instalación la cual finalizará dejando una carpeta llamada glassfish/ en el directorio en el cual ejecutaron el comando anterior.

Luego hay que dar permisos de ejecución al ant que viene embedido en glassfish, para esto ejecutamos en consola lo siguiente (ojo con el directorio en el que tengan glassfish):

chmod -R +x bin/glassfish/lib/ant/bin/

luego entren al directorio de glassfish (a la raiz de éste):

cd bin/glassfish

y escriben lo siguiente:

./lib/ant/bin/ant -f setup.xml

Con el comando anterior se va a configurar el servidor de aplicaciones. Dentro de setup.xml están los puertos que se utilizarán (ademas de otras cosas como el nombre de usuario del administrador y su contraseña), por ejemplo el 4848 que es para entrar a la consola del administrador, 8080 para las aplicaciones web, 8181 para las aplicaciones web seguras, etc. Si quieren cambiar la configuracion que viene por default pueden editar ese archivo.

Una vez ejecutado el comando anterior ya estamos listos para levantar el servidor de aplicaciones.

Para levantar el servidor de aplicaciones glassfish crearemos un simple script, cuyo contenido será el siguiente:

#!/bin/bash

#ingrese el directorio donde se encuentra el servidor de aplicaciones glassfish
GLASSFISH_HOME=/home/metalklesk/bin/glassfish

#ingrese el nombre de usuario del administrador del servidor de aplicaciones glassfish
AS_ADMIN_USER=admin

export AS_ADMIN_USER
export PATH=${GLASSFISH_HOME}/bin:$PATH

asadmin start-domain domain1

Deben modificar el valor de la variable GLASSFISH_HOME al que corresponda, deben colocar el directorio donde se encuentra glassfish en su equipo y lo mismo con la variable AS_ADMIN_USER, si modificaron el nombre de usuario del administrador en el archivo setup.xml, debe reflejarse en el script.

Al script pueden darle el nombre que quieran, y al final permisos de ejecución:

chmod +x iniciar-glassfish.sh

Para levantar el servidor de aplicaciones simplemente ejecutamos el script previamente creado y listo.

./iniciar-glassfish.sh

Ahora para comprobar que el servidor esta corriendo, abrimos un navegador y colocamos en el buscador:

http://localhost:4848

y con eso se abrirá la consola del administrador, ingresamos el nombre de usuario y contraseña y ya está.

Glassfish trae un ejemplo para probar el funcionamiento del servidor de aplicaciones, se encuentra en el directorio /samples/quickstart y el archivo se llama hello.war, ese hay que copiarlo en el directorio /domains/domain1/autodeploy y listo, con eso la aplicación se va a auto configurar, pueden ver en la consola de administrador que esa aplicación (hello.war) ya esta corriendo.

Como ven la instalación y configuración de glassfish es muy facil de hacer. Una caracteristica que me gusta es que puedes hacer hot deploy, es decir, mientras el servidor de aplicaciones está corriendo puedes hacer deploy sin necesidad de bajarlo antes, no afecta en nada a las otras aplicaciones que puedan estar corriendo sobre glassfish.

Espero les sirva esta simple guía.

saludos !!!