Hacia portales OpenCms en integración continua

20/07/2010

Hace ya muchísimo tiempo que no escribo nada en el blog. La verdad que no ha sido por falta de ganas, si no como suele ocurrir por falta de tiempo. En todo este tiempo he seguido trabajando en el módulo OpenCms Free Balance pero, desde que los amigos de OpenCms Hispano me invitaran como ponente a la 2ª tarde tecnológica de OpenCms, he estado trabajando en algo que por aquellos días solo conseguí esbozar y que la verdad sea dicha me ha costado mucho más de lo que en un principio pensaba, pero creo que los resultado han merecido la pena: un plugin de maven que permite a los desarrolladores, tras compilar el módulo, desplegarlo en OpenCms automáticamente

En un principio esa fue realmente la idea original, para la versión beta, ya que después, dándole una vuelta de turca más en base a mi experiencia en el desarrollo de portales haciendo uso de tecnología OpenCms, se me ocurrió que sería mucho más interesante que el plugin, además permitira el despliegue del módulo en un servidor remoto de forma que hiciera factible la integración continua.

Aunque crear un nuevo plugin en Maven es realmente fácil, los mayores problemas han sido:

  1. Gestionar todas las dependencias necesarias para la obtención de un objeto CmsObject fuera del contexto de OpenCms.
  2. Obtención del propio objeto CmsObject, en función de la versión de OpenCms que se use el modo de obtención de dicho CmsObject será distinto.
  3. Importación y publicación del módulo dentro del contexto de OpenCms.

Solucionar el problema fue fácil aunque muy tedioso ya que el proceso consistió en compilar el módulo ejecutar el plugin y cuando fallaba se busca y declara la dependencia, el resultado final ha sido:

<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>servlet-api</artifactId>
<version>6.0.26</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.16</version>
</dependency>
<dependency>
<groupId>oro</groupId>
<artifactId>oro</artifactId>
<version>2.0.8</version>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>20040616</version>
</dependency>
<dependency>
<groupId>org.safehaus.uuid</groupId>
<artifactId>uuid</artifactId>
<version>2.0.0</version>
</dependency>
<dependency>
<groupId>org.dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>org.apache.commons.digester</groupId>
<artifactId>digester</artifactId>
<version>1.8</version>
</dependency>
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>20030211.134440</version>
</dependency>
<dependency>
<groupId>quartz</groupId>
<artifactId>quartz</artifactId>
<version>1.5.2</version>
</dependency>
<dependency>
<groupId>org.htmlparser</groupId>
<artifactId>htmlparser</artifactId>
<version>1.6</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>jsp-api</artifactId>
<version>6.0.26</version>
</dependency>
<dependency>
<groupId>org.apache.lucene</groupId>
<artifactId>lucene-analyzers</artifactId>
<version>2.4.1</version>
</dependency>
<dependency>
<groupId>org.apache.lucene</groupId>
<artifactId>lucene-core</artifactId>
<version>2.4.1</version>
</dependency>
<dependency>
<groupId>org.apache.lucene</groupId>
<artifactId>lucene-highlighter</artifactId>
<version>2.4.1</version>
</dependency>
<dependency>
<groupId>org.apache.lucene</groupId>
<artifactId>lucene-queries</artifactId>
<version>2.4.1</version>
</dependency>
<dependency>
<groupId>org.apache.lucene</groupId>
<artifactId>lucene-snowball</artifactId>
<version>2.4.1</version>
</dependency>
<dependency>
<groupId>commons-email</groupId>
<artifactId>commons-email</artifactId>
<version>1.1</version>
</dependency>
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.2.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.0.7</version>
</dependency>
<dependency>
<groupId>com.alkacon</groupId>
<artifactId>simapi</artifactId>
<version>0.9.8</version>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.3</version>
</dependency>
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.1.1</version>
</dependency>

El siguiente problema a que tuve que solucionar fue, como he comentado antes, la obtención de un objeto CmsObject, para ello tuve que apoyarme en el código fuente de varios plugins de eclipse que permiten sincronizar los ficheros físicos con los ficheros de OpenCms, a continuación os dejo algunas de las referencias que me han sido de utilidad:

  1. OpenCms Mod Dev
  2. OpenCms VFS

Y el último problema que tuve que solucionar fue la importación del módulo, importación que para nada es trivial y para solucionarlo una vez más tuve que adentrarme en el código fuente de OpenCms para finalmente encontrar la solución:

String importpath = OpenCms.getSystemInfo().getPackagesRfsPath();

importpath = OpenCms.getSystemInfo().getAbsoluteRfsPathRelativeToWebInf(
importpath + “modules/” + config.getModuleName());

// Se obtiene el módulo
module = CmsModuleImportExportHandler.readModuleFromImport(importpath);

// check the module dependencies
List dependencies = OpenCms.getModuleManager().checkDependencies(module,
CmsModuleManager.DEPENDENCY_MODE_IMPORT);
if (dependencies.size() > 0) {
// some dependencies not fulfilled
StringBuffer missingModules = new StringBuffer();
Iterator it = dependencies.iterator();
while (it.hasNext()) {
CmsModuleDependency dependency = (CmsModuleDependency) it.next();
missingModules.append(”  “).append(dependency.getName()).append(“, Version “).append(
dependency.getVersion()).append(“\r\n”);
}
System.out.println(“[ERROR] ” + module.getName() + “, Version ” + module.getVersion() + missingModules);
}

// check the imported resource types for name / id conflicts
List checkedTypes = new ArrayList();
Iterator i = module.getResourceTypes().iterator();
while (i.hasNext()) {
I_CmsResourceType type = (I_CmsResourceType) i.next();
// first check against the already configured resource types
int externalConflictIndex = OpenCms.getResourceManager().getResourceTypes().indexOf(type);
if (externalConflictIndex >= 0) {
I_CmsResourceType conflictingType = (I_CmsResourceType) OpenCms.getResourceManager()
.getResourceTypes().get(externalConflictIndex);
if (!type.isIdentical(conflictingType)) {
// if name and id are identical, we assume this is a module replace operation
throw new CmsConfigurationException(org.opencms.loader.Messages.get().container(
org.opencms.loader.Messages.ERR_CONFLICTING_MODULE_RESOURCE_TYPES_5,
new Object[] {type.getTypeName(), new Integer(type.getTypeId()), module.getName(),
conflictingType.getTypeName(), new Integer(conflictingType.getTypeId())}));
}
}
// now check against the other resource types of the imported module
int internalConflictIndex = checkedTypes.indexOf(type);
if (internalConflictIndex >= 0) {
I_CmsResourceType conflictingType = (I_CmsResourceType) checkedTypes.get(internalConflictIndex);
throw new CmsConfigurationException(org.opencms.loader.Messages.get().container(
org.opencms.loader.Messages.ERR_CONFLICTING_RESTYPES_IN_MODULE_5,
new Object[] {module.getName(), type.getTypeName(), new Integer(type.getTypeId()),
conflictingType.getTypeName(), new Integer(conflictingType.getTypeId())}));
}
// add the resource type for the next check
checkedTypes.add(type);
}

// Se comprueba si el módulo esta instalado
if(!OpenCms.getModuleManager().hasModule(module.getName())){
OpenCms.getModuleManager().addModule(cmsObject, module);
} else {
OpenCms.getModuleManager().updateModule(cmsObject, module);
}

// reinitialize the resource manager with additional module resource types if necessary
if (module.getResourceTypes() != Collections.EMPTY_LIST) {
OpenCms.getResourceManager().initialize(cmsObject);
}
// reinitialize the workplace manager with additional module explorer types if necessary
if (module.getExplorerTypes() != Collections.EMPTY_LIST) {
OpenCms.getWorkplaceManager().addExplorerTypeSettings(module);
}

// import the module resources
CmsImport cmsImport = new CmsImport(cmsObject,
new CmsShellReport(cmsObject.getRequestContext().getLocale()));
CmsImportParameters parameters = new CmsImportParameters(importpath, “/”, true);
cmsImport.importData(parameters);

cmsObject.publishResource(“/”);

Para la primera versión del módulo, una vez que compruebe el correcto funcionamiento en distintas plataformas el objetivo de esta primera versión estará cumplido, el siguiente paso será que el plugin permita el despliegue remoto de módulos de forma que se permita la integración continua.

Anuncios

Integrando Hibernate y Maven en un módulo de OpenCms

28/04/2010

Una de las tareas que forman parte de la release-beta del módulo opencms-free-balance es llevar a cabo la integración de este módulo con Hibernate para facilitar su interacción con la base de datos, para ejecutar esta tarea he seguido con el enfoque que en GMV seguimos (y que recomiendo encarecidamente) a la hora de trabajar con este gestor de contenidos y sus módulos, utilizar Maven como herramienta de construcción de dichos módulos.

La utilización de Maven como herramienta de construcción en el proceso de desarrollo de los módulos facilita enormemente tareas habituales como: la gestión de  dependecias, generación del desplegable en OpenCms, generación de reportes, ejecución de tests, etc.

Bueno, pues manos a la obra. El primer paso para integrar Hibernate en un módulo de OpenCms es declarar las dependecias necesarias en el pom.xml del módulo, a continuación se deberán declarar en el fichero manifest.xml para que sean incluidas en el directorios WEB-INF/lib de OpenCms. También se tendrá que configurar el fichero hibernate.cfg.xml con los datos de conexión con la base de datos, anotar convenientemente las entidades que interacutarán con la base de datos y por último se tendrá que implementar la interfaz DAO que se haya definido (si es que se ha definido). Adjunto el módulo para que os sirva como ejemplo/punto de partida (es el proyecto eclipse completo, para generar el instalable, como siempre, ejecutar “mvn clean install”).

Esta posible solución es válida en aquellos módulos, como es el caso del módulo opencms-free-balance, que deben ser lo más autocontenidos, fáciles de instalar e independientes. En otros escenarios, en los que se está llevando a cabo un desarrollo a medida, con varios módulos accediendo a la base de datos, es mejor otro tipo de aproximaciones como la propuesta por Saga con su módulo de integración (de propósito general) entre OpenCms e Hibernate.

Lo maravilloso de aprender es que nadie puede arrebatárnoslo.


Sincronización de instancias de OpenCms

08/02/2010

Uno de los temas sobre los que más se habló en la tarde tecnológica de OpenCms fue sobre los problemas que existían a la hora de poner OpenCms en clúster sin contar con el módulo de pago OCEE, pues bien, desde hace algún tiempo vengo trabajando, en mis ratos libres, en un módulo para este CMS que permita disponer de varias instancias del gestor de contenidos, consumiendo los datos de una base de datos común, de forma que los cambios que realice en una instancia se propaguen a las demás. Por defecto, OpenCms dispone de una serie de funcionalidades de caché que no permiten el comportamiento anterior, dificultando de esta forma la posibilidad de disponer de un clúster de instancias de OpenCms.

Para paliar este problema he desarrollado el módulo “org.opencms.free.balance” cuya base de funcionamiento es sencilla, cada vez que se realice una modificación de los contenidos, desde cualquiera de las instancias de OpenCms, todas las demás se actualizan, a través de un servicios web, de forma que el contenido está disponible y listo para ser servido por cualquiera de los nodos.

La anatomía del módulo es la siguiente:

  1. admin: Componente encargado de llevar a cabo la administración de los nodos, en esta primera versión alpha sólo CRUD de los nodos del cluster.
  2. action: Componente encargado de interceptar las acciones que se realizan sobre OpenCms y en función de dicha acción creación, modificiación, etc le pedirá a los demás nodos del clúster que se actualicen para que puedan disponer de los cambios realizados.
  3. client: Componente que se encarga de realizar la llamada de sincronización del servicio web.
  4. webservice: Componente que se encarga de atender las peticiones de los clientes y de sincronizar, borrando la caché de OpenCms del servidor que se encuentra alojado.

Para llevar a cabo su instalación es necesario, además de desplegar el módulo, instalar un servicio web en el contexto de OpenCms.

He creado un proyecto en Google Code donde os podréis descargar el módulo, por supuesto, cualquiera que se anime a colaborar será bienvenido 😉


Tarde Tecnológica OpenCms

14/01/2010

Esta tarde he tenido la oportunidad de poder asistir a un evento organizado por OpenCms Hispano e Ingenia titulado “Tarde Tecnológica OpenCms“.

Respecto al evento y a todo lo que él se ha hablado y tratado sólo puedo tener palabras de alabanza. Ha sido una reunión en la que muchos profesionales del sector que nos dedicamos al desarrollo web basado en OpenCms hemos expuesto nuestras experiencias e impresiones y en la que se han puesto de manifiesto una serie de ideas que pueden dar como resultado, con el esfuerzo de todos, un cambio en la dirección en la que se mueve actualmente la comunidad de OpenCms.

A todos los asistentes muchas gracias y en especial a los organizadores del evento, Sergio Raposo y Alejandro Alves, sólo espero que pronto podamos volver a vernos todos y continuar tratando temas tan interesantes y útiles como los que hemos tratado hoy.

Personalmente me ha encantado la idea que Sergio a propuesto de reunirnos para hacer un sprint.

A todos muchas gracias.


Software libre, de verdad

03/08/2009

Hace algún tiempo comenzamos con el desarrollo de un proyecto utilizando tecnología OpenCms, como fruto de este trabajo hemos liberado cinco nuevos módulos que esperamos sea de utilidad para la comunidad (los módulos están modelados con maven y documentados con docbook):

RestrictedVFSWidget

Este módulo es una evolución del wdiget de exploración de OpenCms, con él se modelará el comportamiento de un árbol de exploración del directorio virtual de OpenCms en el que tan sólo se mostrarán los directorios y aquellos tipos de contenidos que se hayan configurado en la declaración del tipo de contenido que lo use.

SurveyModule

Con este módulo se amplía el funcionamiento del módulo Alkacon OAMP Survey Module, de manera que se ofrece la posibilidad de generar las gráficas de los informes en flash mediante Open Flash Chart.

Modulo Alfresco

El objetivo de este módulo es proporcionarle a los usuarios de OpenCms una herramienta con la que asignar recursos de un gestor documental Alfresco para ser utilizados en el portal. De esta forma se consigue separar la capa de gestión de contenidos de la capa de gestión documental, pudiendo aprovechar todas las funcionalidades que un gestor documental como Alfresco proporciona.

Georeference

Este módulo permite llevar a cabo la geolocalización de puntos a través de Google Maps, estableciendo las localizaciones directamente sobre un mapa que se muestra en el formulario de alta/edición de contenidos de OpenCms.

Thesaurus

El objetivo de este módulo es proporcionarle a los usuarios de OpenCms una herramienta con la que etiquetar los contenidos (noticias, eventos, etc) que se utilicen en el portal.

El software es como el sexo, es mejor cuando es libre. Linus Torvalds


Puntos de administración en OpenCms 7.0.5

25/05/2009

Hace ya algo menos de un año que comencé a trabajar con el gestor de contenidos OpenCms 7.0.5, durante este tiempo he desarrollado nuevos tipos de contenidos, widgets personalizados y puntos de administración, para el desarrollo de estas tareas me he servido de muchos recursos online pero sobre todo me ha sido de gran utilidad el foro de la comunidad de OpenCmsHispano, es por ello que he decidido realizar este tutorial cuando el otro día me encontré con este mensaje, manos a la obra.

Un punto de administración en OpenCms es una entrada en la vista de administración del gestor de contenidos con la que podremos realizar ciertas operaciones, OpenCms trae en su distribución básica una serie de entradas de administración con la que se podrán llevar a cabo tareas de administracion de usuarios, módulos, caché, etc, así como los mecanismos necesarios para extender con nuevas entradas estas funcionalidades de administración

Vista de administración del workplace

Vista de administración del workplace

Para crear un nuevo punto de administración en OpenCms deberemos crear la correspondiente estructura de directorios en /system/workplace/admin es en este directorio donde se definen los puntos de administración a través de la creación y edición de propiedades de los directorios.

Correspondencia con la zona de administración

Correspondencia con la zona de administración

En este tutorial vamos a crear un nuevo punto de administración en OpenCms denominado “Personas” que nos permitirá hacer CRUD de entidades de tipo persona, para ello he desarrollado un nuevo módulo que he denominado “PersonManagement”. Como veréis cuando instaléis el módulo (y reincieis el servidor de aplicaciones) el módulo genera un nuevo directorio /system/workplace/admin, si accedemos a las propiedades de este directorio veremos que se encuentran editadas las siguientes propiedades:

  • Description: Establece el texto que se mostrará en la caja “Ayuda” de la zona de administración.
  • NavImage: Establece la imagen que se mostrará en la zona de administración.
  • NavInfo: Establece el nombre del grupo al que pertenecerá el nuevo punto de administración.
  • NavPos: Establece con un número real (float) la posición que ocupará el icono del nuevo punto de administración.
  • NavText: Establece el texto que aparecerá bajo el icono del punto de administración.
  • Title: Establece el título del directorio aunque no es de utilidad dentro de la zona de administración.
  • admintoolhandler-class: Establece la clase que se ejecutará para hacer la gestión de los permisos de acceso al punto de administración.
  • default-file: Establece la página jsp que se ejecutará cuando accedamos a ese directorio.
Propiedades del directorio

Propiedades del directorio

Si accedemos a este directorio veremos que podemos encontrar tres páginas jsp person_list.jsp (genera el listado de los elementos), person_edit.jsp (genera el formulario de edición de los elementos de tipo persona) y person_new.jsp (genera el formulario de creación de elementos de tipo persona), si accedemos a cada una de estas páginas veremos cómo podemos encontrar un fragmento de código que sigue el siguiente patrón:

<%@page import=”paquete.de.la.clase.*”%>
<%
NmbreClase admin = new NmbreClase(pageContext, request, response);
admin.displayDialog();
%>

Como podemos observar para generar el formulario solo necesitamos una clase, que extenderá las correspondientes clase de OpenCms, y que se encargará de generar todo el código html necesario para
generar un listado o un formulario de edición o de alta.

En estas páginas jsp también es necesario editar las propiedades para que el contenido de dichas páginas se muetren correctamente.

También me gustaría haceros un par de recomendaciones para el desarrollo de funcionalidades con OpenCms:

Código del módulo

La información compartida progresa y mejora, de manera que su valor sólo puede aumentar. El conocimiento acaparado simplemente se detiene. Paul Jones, director de ibiblio.


Openfire y OpenCms se conocen

28/04/2009

En el proyecto en el que actualmente estoy trabajando tiene la necesidad de incorporar un servicio de mensajería instantánea (IM), como punto de partida mi compañero Manu me recomendó que empezara estudiando la tecnología que había desarrollada alrededor del protocolo Jabber (protocolo libre IM basado en XML).

Alrededor de este protocolo hay toda una comunidad de software libre que se dedica al desarrollo tanto de servidores como de clientes XMPP. Entre todos los servidores que estuve evaluando me decanté por uno que por su extensibilidad, tecnología y comunidad me convenció, Openfire. Se trata de un servidor de código abierto basado en Java, extensible a través de plugins y desarrollado por la comunidad bajo licencia GPL.

Como comentaba antes en el proyecto existía la necesidad de integrar un servidor de mensajería instantánea, la integración de Openfire con Opencms, el CMS que estamos utilizando, consistía en la autenticación de los usuarios. Para conseguirlo hemos tenido que hacer dos cosas, una del lado de OpenCms y otra de Openfire.

OpenCms

Hemos desarrollado un módulo de OpenCms que ofrece un servicio web con dos operaciones para realizar la autenticación de usuario, a este servicio web solo hay que pasarle el usuario y la contraseña encriptada, él se encargará de comprobar que el usuario y la contraseña son correctos así como de chequear toda la lógica de negocio, devolviendo un objeto en el que se indica si el proceso ha sido correcto.

Openfire

En este caso hemos desarrollado un plugin que cuenta con un cliente para el servicio web y que es el encargado de hacer la petición. Para que Openfire realice la autenticación utilizando la clase que hemos desarrollado, y que ha de implementar la interfaz (AuthProvider), en el método de inicialización del plugin hemos de cambiar la propiedad provider.auth.className para indicarle que utilice nuestra clase, es sumamente importante que previo a este paso hayamos registrado en el classpath del plugin dicha clase.

Una vez hecho esto, OpenCms y Openfire ya se conocen ;-p

No hay lugares remotos. En virtud de los medios de comunicación actuales, todo es ahora. Herbert Marshall Mcluhan