Netbeans Platform LifecycleManager

domingo, 6 de junio de 2010
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

martes, 1 de junio de 2010
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

domingo, 13 de diciembre de 2009
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 !!!

miércoles, 4 de noviembre de 2009
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:


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

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

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

  4. 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

viernes, 4 de septiembre de 2009
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 !!!