jboss-user
[Arriba] [Todas las Listas]

[jboss-Usuario] [JBoss Herramientas] - Soportando versiones en grande mu

To: User development <jboss-user@xxxxxxxxxxxxxxx>
Subject: [jboss-Usuario] [JBoss Herramientas] - Soportando versiones en grande multi-módulo osgi proyectos
From: Max Rydahl Andersen <do-not-reply@xxxxxxxxx>
Date: Sat, 17 Sep 2011 11:50:58 -0400
Auto-submitted: yes
Delivery-date: Sat, 17 Sep 2011 11:53:03 -0400
Envelope-to: traductor@xxxxxxxxxxx
List-archive: <http://lists.jboss.org/pipermail/jboss-user>
List-help: <mailto:jboss-user-request@lists.jboss.org?subject=help>
List-id: The JBoss User main mailing list <jboss-user.lists.jboss.org>
List-post: <mailto:jboss-user@lists.jboss.org>
List-subscribe: <https://lists.jboss.org/mailman/listinfo/jboss-user>, <mailto:jboss-user-request@lists.jboss.org?subject=subscribe>
List-unsubscribe: <https://lists.jboss.org/mailman/listinfo/jboss-user>, <mailto:jboss-user-request@lists.jboss.org?subject=unsubscribe>
Reply-to: The JBoss User main mailing list <jboss-user@xxxxxxxxxxxxxxx>
Sender: jboss-user-bounces@xxxxxxxxxxxxxxx
Max *Rydahl *Andersen [*http://comunidad.*jboss.*org/Personas/*maxandersen] modificó el *blog correo:

"Soportando versiones en grande *multi-módulo *osgi proyectos"

para ver el *blog correo, visita: *http://comunidad.*jboss.*org/Herramientas/de comunidad/*blog/2011/09/17/soportando-con-versiones-dentro-grande-*multi-módulo-*osgi-proyectos

--------------------------------------------------------------
*h1. Versiones para grande *multi-módulo *osgi proyecta
Recientemente pasé por *JBoss Herramientas base de código de fuente principal y fijado unos cuantos largo estando asuntos que habían hecho lo *cumbersome para dirigir versiones sobre los años. Este *blog intenta explicar lo que cambiamos, por qué y cómo *Tycho ayudó.
*h1. *Tycho Versión *Plugin
*Maven lo tiene’*s versiones propias *plugin pero sólo cuida de referencias de versión en *pom.*xml, no considera *osgi/*p2 referencias relacionadas. *Tycho Por tanto lo tiene’*s versiones propias *plugin.
Desafortunadamente allí *aren’*t *alot de documentación para este *plugin, pero por *poking a *Sonatype, seguir el  *https://*dev.*eclipse.*org/*mailman/*listinfo/*tycho-Usuario *tycho *mailing lista y mirando en  un *https://*docs.*sonatype.*org/Exhibición/*M2*ECLIPSE/Escenificando+y+liberando+nuevo+*M2*Eclipse+liberación pocas pistas allí dirigí conseguir el lo laborable. Aquí es mi intento de hacer el mundo más consciente del *Tycho Versión *plugin.
*h1. Uso
La orden de núcleo para *Tycho Versiones *plugin es ejecutado en vuestro *Maven módulo que representa vuestro *plugin/características. El *Tycho Versión *plugin la orden parece esto:
*mvn *org.*eclipse.*tycho:*tycho-Versiones-*plugin:conjunto-versión -*DnewVersion=<versión>

Aquí <la versión> es la versión te numera quiere para vuestro *plugins, *i.*e. 1.2.3.GA. Si utilizas 1.2.3-*SNAPSHOT el *plugin utilizará 1.2.3.*qualifier En los sitios necesarios (*i.*e. Dentro manifestar.*mf Y característica.*xml).

La belleza de este *plugin es que con una orden sola puedes actualizar vuestro *plugin, características, producto y *updatesite referencias. 

No manual *tweaking requerido, excepto aquello para utilizarlo eficazmente vuestro *pom.*xml’*s Tendría que seguir unos cuantos *maven convenciones.

Aquella última parte es lo que nos mantuvo en *JBoss Herramientas para utilizar esta orden hasta recientemente.

Por qué preguntas ? Bien, leído en…
*h1. *Maven Relaciones/de Niño del padre
La razón nosotros *couldn’*t utilizar el *tycho versión *plugin anteriormente era que tuvimos el siguiendo *layout para cada cual de nuestros módulos:   

 *http://comunidad.*jboss.*org/*servlet/*JiveServlet/*showImage/38-4019-16990/módulos_antes de_*reorg.*png  *http://Comunidad.*jboss.*org/*servlet/*JiveServlet/*downloadImage/38-4019-16990/450-168/módulos_antes de_*reorg.*png 
Cada módulo de nivel superior tiene un conjunto de *submodules: *plugins, pruebas, características y sitio (hay también un *doc módulo pero que es para otro *blog).

Cada cual de estos *submodules puede tener niños, para *plugins que son todo el individual *plugins la característica principal incluirá, las pruebas son el *plugin pruebas y tan adelante.

Aquel padre representa el padre *pom donde la configuración de complexión compartida para *JBoss las Herramientas es almacenada - utilizamos que para evitar repitiendo las instrucciones de complexión en todo 350+ *buildable unidades. 

Pero hay un problema grande con esta estructura.

Primer de cada artefacto tiene un manual sección de versión mantenida, pero  te aviso todo aquel rojo grueso las líneas perfiladas que van al Padre de cada hoja *plugin, característica, *etc. ?

Aquellas líneas rojas ilustra que cada punto de hoja del niño directamente al padre principal *pom que lo hace posible de tener la configuración de complexión en uno el sitio central pero él también significa que *everytime actualizamos el padre *pom versión lo tenemos que cambiar en cada cual y cada nodo (para #prpers que es 605 ubicaciones).

También tiene la consecuencia que incluso aunque tenemos esta división modular guapa de cada +módulo+ a +pruebas+ y +*plugins+ no hay un sitio para almacenar módulo o *submodule específico *settings para nuestras complexiones - que todos tienen que tener lugar en cada hoja *plugin en vez de ser justo declarado en un sitio.

Así para hacer este compartiendo más fácil y para hacerlo más explícito lo que la estructura de hecho está siendo *versioned con el *Tycho módulo Denis *Golovin y yo  unos cuantos *pom *refactorings.

 *http://Comunidad.*jboss.*org/*servlet/*JiveServlet/*showImage/38-4019-16991/módulos_después de_*reorg.*png  *http://Comunidad.*jboss.*org/*servlet/*JiveServlet/*downloadImage/38-4019-16991/450-230/módulos_después de_*reorg.*png 
Aviso la diferencia ?

Cada “*sub-el nodo” ahora utiliza su padre relativo estructural real como el *pom padre (líneas rojas) y sólo el módulo de nivel superior de hecho señala atrás al principal *JBoss módulo de padre de las Herramientas (línea azul).

Esto tiene el siguiendo características positivas:
* puedes estar en la raíz de un módulo y corrido *mvn limpio instalar y construirá el módulo entero
* puedes *override/*customize una complexión localmente para un módulo o *submodule
* *maven *tycho versión *plugin será capaz a fácilmente versión este módulo en su poseer

El último *optimization últimamente era que ahora que tenemos esta +estructura+ natural entre padre y niño *setup podemos sacar los módulos de niño *redundant versión *info del *pom.*xml’*s. Desafortunadamente todavía tenemos que listar la versión llena *info para el padre pero con el *Tycho versiones *plugin esto acontece trivial de mantener.
*h1. Los Detalles Sucios
El *essentials las partes de la estructura es cuando sigue (utilizando *hibernatetools como referencia):
Módulo *pom:
<proyecto ...>
    ...
    <Padre>
            <!-- La *referencia única* para arraigar padre de complexión de un módulo -->
            <*groupId>*org.*jboss.Herramientas</*groupId>
            <*artifactId>*org.*jboss.Herramientas.Padre.*pom</*artifactId>
            <Versión>0.0.2-*SNAPSHOT</versión>
            <*relativePath>../Padre/de complexión/*pom.*xml</*relativePath>
    </Padre>
    <*groupId>*org.*jboss.Herramientas</*groupId>
    <*artifactId>*hibernatetools</*artifactId>
    <nombre>*hibernatetools.Todos</nombran>
    <!-- El sitio único las *necesidades de número de versión* de módulo para ser en un *pom.*xml Para un módulo -->
    <versión>3.4.0-*SNAPSHOT</versión>
    <*packaging>*pom</*packaging>
    <módulo>
            <de características>de módulo</de módulos>
            <módulo>*plugins</módulo>
            <de pruebas>de módulo</de módulo>
            <módulos>de módulo</de sitio>
   </de módulo>
</proyecto>
*Sub-Módulo *pom:
<proyecto ...>
    ...
    <Padre>
            <!-- Esta sección es *mantenida por las versiones *plugin* --!>
            <*groupId>*org.*jboss.Herramientas</*groupId>
            <*artifactId>*hibernatetools</*artifactId>
            <versión>3.4.0-*SNAPSHOT</padre>
    </de versión>
    <*groupId>*org.*jboss.Herramientas.*hibernatetools</*groupId>
    <*artifactId>*plugins</*artifactId>
    <Nombre>*hibernatetools.*plugins</Nombre>
    <*packaging>*pom</*packaging>
    <módulo>
            <de módulos>*org.*hibernate.*eclipse</Módulo>
            <de módulo>*org.*hibernate.*eclipse.Módulo</de consola>
            ...
</Módulos>

 …y finalmente el real *plugin/característica *pom’*s:
<proyecto ... >
<*modelVersion>4.0.0</*modelVersion> 
<padre>
    <*groupId>*org.*jboss.Herramientas.*hibernatetools</*groupId>
    <*artifactId>*plugins</*artifactId>
    <Versión>3.4.0-*SNAPSHOT</padre>
</de versión>
<*groupId>*org.*jboss.Herramientas.*hibernatetools.*plugins</*groupId>
<*artifactId>*org.*hibernate.*eclipse</*artifactId> 
<*packaging>*eclipse-*plugin</*packaging>

Aviso cómo este *setup hace la configuración en el *plugin nivel muy *concise (o al menos cuando *concise como *Maven les deja para ser). Sólo si vuestro *plugin tiene lógica de complexión de la costumbre  necesitan ser diferentes.
*h1. Conclusión
Con esto *setup podemos ahora fácilmente *customize nuestras complexiones en un nivel de módulo y fácilmente chocar nuestro número de versiones *across todo el *osgi/*p2 artefactos dentro del módulo.

Significado si utilizo el *Tycho versiones *plugin para chocar un módulo a 3.5.0, por *default +todo+ en aquel módulo consigue chocado a 3.5.0, ningún asunto si han cambiado o no.

Puristas de *osgi podría afirmar aquello es una práctica mala y tú sólo tendrían que chocar las versiones del *plugins que cambios recibidos de hecho y en principio estoy de acuerdo con ellos, pero…

…*JBoss las Herramientas consiste de sobre 202 *plugins y 100 características cada cual con su característica propia.*xml, MANIFIESTA.MF y cuándo incluimos *Tycho o bastante *Maven en la mezcla ellos también cada cual tiene un *pom.*xml.

Añade en el varios *updatesites, y otros artefactos y justo en el árbol de código de fuente principal de *JBoss Herramientas él todo añade hasta #prpers teniendo en el tiempo actual de escritura *628* *versionable artefactos.

Aquello es *alot de versiones para mantener pista de y asegurar es *uptodate.

Hasta que ahora hemos sido manteniendo las versiones de estos artefactos a mano a mano y tan un *precaution nosotros (cuando muchos otros en *osgi/*p2 tierra)  nuestras complexiones con un .*qualifier Como la última parte del número de versión. Esto asegura el número de versión es siempre más alto que la complexión anterior. Si nosotros *don’*t, entonces *p2 ganado’*t instalar la complexión más nueva. 

Esto de hecho significa que si tú *don’*t realizarlo entonces puedes fácilmente estancia en versión 1.0.0 puesto que vuestro *plugins *forever y nunca - ningún usuario  *complain desde entonces siempre pueden conseguir la la versión actualizada más nueva.

El problema de ser ciego a las versiones naturalmente aparecen cuándo empiezas habiendo ramas múltiples e incluso más así que cuándo intentas construir arriba de API *plugins y te quiere asegurar está utilizando la versión compatible correcta - y aquí confiando en “el aleatorio” *qualifier la cadena acontece *unmanagable.

Con un *handful de *plugins lo’*s “fácil”, pero con 628 artefactos puede acontecer bastante caótico.

Por ello yo’*ll argumentar su mejor de hacerlo en el nivel de módulo que reduce el *versionable artefactos a 42 en nuestro caso - un mucho más *managable número y mucho más sencillo de manejar y entender para ambos *developer e IMO de usuario.

Aviso, que si eres en una situación donde necesitas a a mano la versión específica *plugins entonces tú sencillamente puesto la versión explícitamente para aquellos *plugins/características y *Tycho versiones *plugin no les cambiará si no son igual cuando el módulo *pom.

Aquello es otra cosa me gusta sobre este *setup 

- te deja para hacer la mayoría de *manageble cosa fácilmente, y si necesitas el control lleno puedes hacer aquello para justo las partes lo desea puesto que.

Qué  piensas ? 

Te tiene solucionado este problema *differently/mejor/peor ?
--------------------------------------------------------------

Comentario por ir a Comunidad
[*http://comunidad.*jboss.*org/Herramientas/de comunidad/*blog/2011/09/17/soportando-con-versiones-dentro-grande-*multi-módulo-*osgi-proyectos]

Max Rydahl Andersen [http://community.jboss.org/people/maxandersen] modified the blog post:

"Coping with versions in large multi-module osgi projects"

To view the blog post, visit: http://community.jboss.org/community/tools/blog/2011/09/17/coping-with-versions-in-large-multi-module-osgi-projects

--------------------------------------------------------------
h1. Versions for large multi-module osgi projects
Recently I went through JBoss Tools main source code base and fixed a few long standing issues that had made it cumbersome to manage versions over the years. This blog tries to explain what we changed, why and how Tycho helped.
h1. Tycho Version Plugin
Maven has it’s own versions plugin but it only takes care of version references in pom.xml, it does not consider osgi/p2 related references. Tycho therefore has it’s own versions plugin.
Unfortunately there aren’t alot of documentation for this plugin, but by poking to Sonatype, follow the  https://dev.eclipse.org/mailman/listinfo/tycho-user tycho mailing list and looking at a  https://docs.sonatype.org/display/M2ECLIPSE/Staging+and+releasing+new+M2Eclipse+release few hints out there I managed to get the it working. Here is my attempt to make the world more aware of the Tycho Version plugin.
h1. Usage
The core command for Tycho Versions plugin are executed in your Maven module that represents your plugin/features. The Tycho Version plugin command looks like this:
mvn org.eclipse.tycho:tycho-versions-plugin:set-version -DnewVersion=<version>

Here <version> is the version number you want for your plugins, i.e. 1.2.3.GA. If you use 1.2.3-SNAPSHOT the plugin will use 1.2.3.qualifier in the places necessary (i.e. in manifest.mf and feature.xml).

The beauty of this plugin is that with a single command you can update your plugin, features, product and updatesite references. 

No manual tweaking required, except that to use it effectively your pom.xml’s should follow a few maven conventions.

That last part is what kept us in JBoss Tools to use this command until recently.

Why you ask ? Well, read on…
h1. Maven Parent/Child relationships
The reason we couldn’t use the tycho version plugin previously was that we had the following layout for each of our modules:   

 http://community.jboss.org/servlet/JiveServlet/showImage/38-4019-16990/modules_before_reorg.png  http://community.jboss.org/servlet/JiveServlet/downloadImage/38-4019-16990/450-168/modules_before_reorg.png 
Each top level module has a set of submodules: plugins, tests, features and site (there are also a doc module but that is for another blog).

Each of these submodules can have children, for plugins that are all the individual plugins the main feature will include, tests are the plugin tests and so forth.

That parent represents the parent pom where the shared build configuration for JBoss Tools is stored - we use that to avoid repeating the build instructions in all 350+ buildable units. 

But there is a big problem with this structure.

First of each artifact have a manual maintained version section, but do you notice all those thick red outlined lines going to the Parent from each leaf plugin, feature, etc. ?

Those red lines illustrates that each child leaf point directly to the main parent pom which makes it possible to have the build configuration in one central place but it also means that everytime we update the parent pom version we have to change it in each and every node (for us that is 605 locations).

It also have the consequence that even though we have this nice modular division of each +module+ into +tests+ and +plugins+ there is not a place to store module or submodule specific settings for our builds - that all have to take place in each leaf plugin instead of being just stated in one place.

Thus to make this sharing easier and to make it more explicit what structure is actually being versioned with the Tycho module Denis Golovin and I did a few pom refactorings.

 http://community.jboss.org/servlet/JiveServlet/showImage/38-4019-16991/modules_after_reorg.png  http://community.jboss.org/servlet/JiveServlet/downloadImage/38-4019-16991/450-230/modules_after_reorg.png 
Notice the difference ?

Each “sub-node” now uses their actual structural relative parent as the pom parent (red lines) and only the top level module actually points back to the main JBoss Tools parent module (blue line).

This has the following positive features:
* you can stand in the root of a module and run mvn clean install and it will build the whole module
* you can override/customize a build locally for a module or submodule
* maven tycho version plugin will be able to easily version this module on its own

The last optimization I did lately was that now that we have this +natural+ structure between parent and child setup we can remove the child modules redundant version info from the pom.xml’s. We unfortunately still have to list the full version info for the parent but with the Tycho versions plugin this becomes trivial to maintain.
h1. The Dirty Details
The essentials parts of the structure is as follows (using hibernatetools as reference):
Module pom:
<project ...>
    ...
    <parent>
            <!-- the *only reference* to root build parent from a module -->
            <groupId>org.jboss.tools</groupId>
            <artifactId>org.jboss.tools.parent.pom</artifactId>
            <version>0.0.2-SNAPSHOT</version>
            <relativePath>../build/parent/pom.xml</relativePath>
    </parent>
    <groupId>org.jboss.tools</groupId>
    <artifactId>hibernatetools</artifactId>
    <name>hibernatetools.all</name>
    <!-- the only place the *module version number* needs to be in a pom.xml for a module -->
    <version>3.4.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <modules>
            <module>features</module>
            <module>plugins</module>
            <module>tests</module>
            <module>site</module>
   </modules>
</project>
Sub-Module pom:
<project ...>
    ...
    <parent>
            <!-- this section is *maintained by the versions plugin* --!>
            <groupId>org.jboss.tools</groupId>
            <artifactId>hibernatetools</artifactId>
            <version>3.4.0-SNAPSHOT</version>
    </parent>
    <groupId>org.jboss.tools.hibernatetools</groupId>
    <artifactId>plugins</artifactId>
    <name>hibernatetools.plugins</name>
    <packaging>pom</packaging>
    <modules>
            <module>org.hibernate.eclipse</module>
            <module>org.hibernate.eclipse.console</module>
            ...
</modules>

 …and finally the actual plugin/feature pom’s:
<project ... >
<modelVersion>4.0.0</modelVersion> 
<parent>
    <groupId>org.jboss.tools.hibernatetools</groupId>
    <artifactId>plugins</artifactId>
    <version>3.4.0-SNAPSHOT</version>
</parent>
<groupId>org.jboss.tools.hibernatetools.plugins</groupId>
<artifactId>org.hibernate.eclipse</artifactId> 
<packaging>eclipse-plugin</packaging>

Notice how this setup makes the configuration at the plugin level very concise (or at least as concise as Maven allows them to be). Only if your plugin has custom build logic do they need to be different.
h1. Conclusion
With this setup we can now easily customize our builds at a module level and easily bump our versions number across all the osgi/p2 artifacts within the module.

Meaning if I use the Tycho versions plugin to bump a module to 3.5.0, by default +everything+ in that module gets bumped to 3.5.0, no matter if they have changed or not.

Purists of osgi might claim that is a bad practice and you should only bump the versions of the plugins that actually received changes and in principle I agree with them, but…

…JBoss Tools consists of about 202 plugins and 100 features each with their own feature.xml, MANIFEST.MF and when we included Tycho or rather Maven in the mix they also each have a pom.xml.

Add in the various updatesites, and other artifacts and just in the main source code tree of JBoss Tools it all adds up to us having at the current time of writing *628* versionable artifacts.

That is alot of versions to keep track of and ensure is uptodate.

Until now we have been maintaining the versions of these artifacts manually by hand and just as a precaution we (as many others in osgi/p2 land) do our builds with a .qualifier as the last part of the version number. This ensure the version number is always higher than the previous build. If we don’t, then p2 won’t install the newest build. 

This actually means that if you don’t realize it then you can easily stay on version 1.0.0 for your plugins forever and ever - no users will complain since they can always get the the newest updated version.

The problem of being blind to versions of course show up when you start having multiple branches and even more so when you try to build up API plugins and want to ensure you are using the right compatible version - and here relying on the “random” qualifier string becomes unmanagable.

With a handful of plugins it’s “easy”, but with 628 artifacts it can become rather chaotic.

Thus I’ll argue its better to do it on the module level which reduces the versionable artifacts to 42 in our case - a much more managable number and much simpler to handle and understand for both developer and user IMO.

Notice, that if you are in a situation where you need to manually version specific plugins then you simply set the version explicitly for those plugins/features and Tycho versions plugin will not change them if they are not the same as the module pom.

That is another thing I like about this setup 

- it allows you to do the most manageble thing easily, and if you need the full control you can do that for just the parts you wishes it for.

What do you think ? 

Have you solved this problem differently/better/worse ?
--------------------------------------------------------------

Comment by going to Community
[http://community.jboss.org/community/tools/blog/2011/09/17/coping-with-versions-in-large-multi-module-osgi-projects]

_______________________________________________
*jboss-Usuario *mailing lista
*jboss-user@xxxxxxxxxxxxxxx
*https://listas.*jboss.*org/*mailman/*listinfo/*jboss-Usuario
_______________________________________________
jboss-user mailing list
jboss-user@xxxxxxxxxxxxxxx
https://lists.jboss.org/mailman/listinfo/jboss-user
<Anterior por Tema] Tema Actual [Siguiente por Tema>