Category Archives: Blog

Article de blog

03Juil/18

Intégrer CMIS avec Ruby

Installation

Pour jouer cette même requête avec ruby, et l’intégrer par exemple dans un développement basé sur RoR, il faut installer une  librairie cmis, par exemple :

  • https://github.com/UP-nxt/cmis-ruby.git

Configuration

Après installation, il faut saisir les informations correspondantes à votre GED, en l’occurrence Alfresco, dans spec/config.yml :

server:
  service_url: http://localhost:8080/alfresco/api/-default-/public/cmis/versions/1.1/browser
  username: admin
  password: admin
repository: -default-

Lancez alors les tests avec la commande suivante :

rake

Récupération d’une liste de documents

Pour vous aider à faire vos premiers pas avec cette librairie, vous pouvez tester le script suivant adapté depuis le readme du projet :

[code language=”ruby”] $LOAD_PATH.unshift ‘lib’
require ‘cmis’

# get the repository object
server = CMIS::Server.new(service_url: ‘http://localhost:8080/alfresco/api/-default-/public/cmis/versions/1.1/browser’,
username: ‘admin’, password: ‘admin’)
repository = server.repository(‘-default-‘)

# query for first 50 documents where the property ‘cmis:name’ is ‘%DAT%’
# and stored in sites/test directory
cmisq = <<eos
select * from cmis:document
where cmis:name like ‘%DAT%’
and contains (‘PATH:\”//app:company_home/st:sites/cm:test//*\”‘)
eos

#query = repository.query(“select * from cmis:document where cmis:name like ‘GED%'”)
query = repository.query(cmisq)

query.each_result(limit: 50) { |document|
puts “-New item ——————————”
puts “Name: ” + document.name
puts “CMIS ObjectId: ” + document.cmis_object_id
puts “Mime-Type: ” + document.content_stream_mime_type
puts “Last Modification Date: ” + document.last_modification_date.to_s
}
[/code]

En exécutant ce code, on obtient la sortie suivante :

Conclusion

Pour étudier les autres possibilités de la librairie, je vous invite à consulter les fichiers de tests dans le répertoire spec/cmis-ruby, et plus particulièrement :

  • document_spec.rb : pour la création/lecture/mise à jour/suppression de document
  • folder_spec.rb : pour la création/lecture/mise à jour/suppression de dossier
01Juil/18

Introduction à CMIS

CMIS est le langage de choix pour requêter une gestion documentaire. En effet, ce langage, proche de SQL, utilise les concepts proches des bases de données. CMIS est un standard mais, bien sûr, chacun a développé un sous-ensemble de fonctions supplémentaires en dehors du standard. Cependant, c’est mieux que rien…

Ainsi, pour récupérer la liste des documents dont le nom contient la chaine DAT et qui sont stockés dans la sous arborescence “sites/test”, il faudra taper la requête suivante :

select * from cmis:document
where cmis:name like '%DAT%'
  and contains ('PATH:"//app:company_home/st:sites/cm:test//*"')

Navigateur de noeuds

Les habitués d’Alfresco auront remarqué que le chemin fait référence à un répertoire stocké dans un site…

Dans mon cas, en tapant la requête dans le navigateur de noeuds d’Alfresco j’obtiens le résultat suivant :

CMIS Workbench

Afin de découvrir Alfresco d’un point de vue CMIS (nom des propriétés notamment), je vous invite à télécharger CMIS Workbench. Il vous permettra de mieux comprendre le fonctionnement de CMIS :

  • Navigation dans le repository et découverte des propriétés CMIS
  • Exécution d’une requête CMIS depuis une fenêtre de console

CMIS Workbench est disponible à l’adresse suivante :

Navigation dans le repository et découverte des propriétés

Exécution d’une requête CMIS

Conclusion

Un standard riche, simple à utiliser de par sa proximité avec le SQL, une fois qu’on a, comme d’habitude, intégré quelques subtilités (notamment les D: et P: pour spécifier les types et aspects… 😉

Bon tests !

18Mai/18

Ouvrez simplement votre entrepôt Alfresco au grand public

Module de consultation externe simplifié par profil

Blue Search

Introduction

BlueSearch est une application de consultation simplifiée qui permet d’effectuer des recherches « à la google » sur un repository Alfresco. Les recherches effectuées sans authentification sont limitées à des documents « publics » et ne ramènent que des documents accessibles par l’utilisateur « public ».

Les recherches peuvent également être réalisées avec authentification ; elles sont alors réalisées sur l’ensemble des documents accessibles par l’utilisateur authentifié.

Suite à la recherche, les résultats peuvent être affinés grâce la sélection de facettes. Les documents peuvent être prévisualisés, téléchargés, étudiés dans le détail et partagés via un lien par mail ou sur les réseaux sociaux quels qu’ils soient (twitter, pinterest, facebook…).

Les principaux écrans de cette application peuvent être facilement personnalisés via des fichiers css directement accessibles par l’administrateur de l’application ou par un prestataire d’une agence de communication.

Application de consultation

Spécifications fonctionnelles

Cas d’utilisation

@TODO

Rôles

L’application est composée de 2 modules :

  1. l’application de consultation simplifiée ;
  2. l’application de configuration.

Elle peut être accédée par 3 rôles :

  • un rôle public : une authentification automatique et transparente est réalisée par l’application. Les utilisateurs n’ont généralement que des droits de lecture, de consultation et de téléchargement ;
  • un rôle authentifié : l’utilisateur s’authentifie à l’aide de son identifiant et de son mot de passe. Il a les droits correspondant à son degré d’habilitation quelle que soit l’application utilisée ; il accède généralement à l’application de consultation simplifiée mais il peut également accéder à l’application Alfresco Share native s’il a besoin de l’ensemble des fonctionnalités disponibles ;
  • un rôle d’administrateur fonctionnel : l’utilisateur s’authentifie à l’aide de son identifiant et de son mot de passe. Il a les droits correspondants à son degré d’habilitation. Il accède à l’application uniquement via Alfreco Share natif.

Plateformes de consultation

Les plateformes de consultation se divisent en :

  • Ordinateurs de bureau ;
  • Tablettes ;
  • Smartphones.

Cette application de consultation a été développée pour les ordinateurs de bureau. Elle peut être consultée sur une tablette et un smartphone mais son ergonomie n’a clairement pas été pensée pour ces derniers.

Il serait intéressant de développer un module pour tablette et smartphone.

Architecture

Diagramme d’architeture

L’architecture de la solution est la suivante :

@TODO

Fonctionnalités techniques

Les fonctionnalités suivantes sont implémentées :

  • Interface d’administration de l’application
  • Authentification automatique
  • Pages personnalisables
    • Pages html statiques
    • Fichiers css statiques
    • Personnalisation des informations à afficher

Interface d’administration de l’application

Une IHM spécifique est disponible. Elle correspond à l’application Alfresco Share native. Elle permet de :

  • créer le compte public
  • modifier les pages personnalisables

Authentification automatique

L’accès à quelque page que ce soit au niveau de l’application Alfresco nécessite obligatoirement une authentification. BlueSearch authentifie automatiquement l’utilisateur sans saisie d’aucun mot de passe. Les documents qui peuvent être recherchés ou accédés sont limités par les droits de l’utilisateur choisi pour l’authentification automatique.

Ce mécanisme pourrait être étendu très simplement afin de s’authentifer avec diffférents utilisateurs selon divers critères (son adresse IP – interne/externe, l’heure, le temps qu’il fait… :-).

Pages personnalisables

L’application peut être personnalisée au niveau des pages html statiques suivantes :

  • formulaire de recherche : construction totale de la page ;
  • mentions légales : construction totale de la page ;
  • contact : construction totale de la page.

L’application peut également être personnalisée au niveau des fichiers css statiques qui permettent d’adapter la présentation des pages dynamiques :

  • home.css : pour personnaliser la présentation globale des pages statiques ;
  • delib.css : pour personnaliser la présentation de la page détail.

Fonctionnalités

L’application est constituée des pages suivantes :

  • Page de recherche à la google
  • Page de liste de résultats
  • Page de recherche avancée
  • Page de détails

Page de recherche à la google

Cette page permet de rechercher le repository à partir d’un ensemble de mots-clés comme sur Google, Bing, Yahoo…

Page de liste de résultats

Cette page s’affiche suite à une recherche « à la google » ou suite à une recherche avancée.

Par défaut, seuls 20 documents sont affichés. Il est possible de « scroller » en bas de page pour afficher 20 nouveaux résultats… Dans la pratique, l’utilisateur sélectionne souvent une facette afin d’affiner sa recherche.

Téléchargement d’un ou plusieurs documents

L’utilisateur peut télécharger un document avec les actions suivantes :

  • Cliquer sur Actions ;
  • Cliquer sur Télécharger.

L’utilisateur peut aussi télécharger un ou plusieurs documents :

  • Sélectionner plusieurs documents ;
  • Cliquer sur Documents sélectionnés ;
  • Cliquer sur Télécharger un .zip.

Navigation par facettes

Sélection de facettes métier

En cliquant sur une facette métier, la liste des résultats s’affine et se met à jour. Il est possible de sélectionner une autre facette ou de désélectionner une facette.

Prévisualisation du document

En cliquant sur l’icône de « document », la page suivante s’affiche :

Page de recherche avancée

Une page de recherche avancée est disponible. Elle permet de sélectionner plusieurs critères en même temps sur un ou plusieurs champs. Elle renvoie sur la liste de résultats ci-dessus.

Page de détails du document

Partage d’un document

Des actions de partage par mail sont disponibles. Elles créent un message en mode édition dans votre outil de messagerie que l’utilisateur peut personnaliser :

Visualisation des métadonnées

Les métadonnées sont présentées à l’utilisateur sur la page de détails. Ces détails peuvent être cachés/affichés via le fichier css personnalisable delib.css.

Conclusion

BlueSearch permet de valoriser très simplement le contenu public d’un repository Alfresco et d’augmenter très simple votre retour sur investissement.

Pour voir le système en production, je vous invite à consulter le site public suivant :

11Mai/18

Découverte de l’interface ADF pour ECM Alfresco

Etude de faisabilité ADF pour outils Alfresco

Qu’est ce qu’ADF ?

ADF ou Application Development Framework est le nouvel outil d’interface mis à disposition par Alfresco. Il vise, à terme, à remplacer la solution d’interface “Share” qui est actuellement utilisée. Le projet est open-source et profite déjà d’une communauté assez active sur internet.

ADF se base sur le framework Angular 5, ce qui lui apporte beaucoup de flexibilité au niveau des fonctionnalités ainsi qu’une bonne adaptabilité par rapport au support de visualisation (PC, tablette ou téléphone).

La force d’ADF réside également dans son côté customisable : la plupart des fonctionnalités de “Share” peuvent être déployées dans ADF, c’est l’utilisateur qui décide ou non de les faire incorporer par le développeur. On se retrouve donc avec un outil unique, s’adaptant au mieux aux besoins spécifiques de chacun.

L’interface ADF s’adapte aussi bien à la gestion de fichiers avec l’ECM d’Alfresco, qu’à la gestion de processus avec l’outil de BPM Activiti.

ADF pour la gestion de contenu numérique

Comme pour l’interface “Share” classique, l’accès aux fonctionnalités de l’application n’est possible qu’après la connexion de l’utilisateur.

La page de connexion

Une fois connecté l’utilisateur est automatiquement redirigé vers l’explorateur de fichiers. La gestion des droits étant prise en compte, il n’aura accès qu’aux répertoires auxquels il est autorisé. Depuis cette interface il pourra également créer un nouveau répertoire ou ajouter un fichier (via un bouton ou en drag’n’drop). Une fonctionnalité de recherche est également présente pour retrouver plus rapidement un document particulier.

L’explorateur de fichiers

Quand l’utilisateur arrive sur le document qui l’intéresse, un volet d’options lui offre l’accès à plusieurs actions : copier le document, le télécharger, le déplacer, le supprimer ou encore voir les différentes versions de ce document. Cette liste n’est pas exhaustive, d’autres actions sont à disposition mais n’ont pas été mise en place dans notre monture de test (le partage du document vers l’extérieur notamment).

L’onglet détails permet d’afficher toutes les actions relatives au document : la visualisation, l’affichage et l’édition des métadonnées ainsi que les différentes versions de ce document.

Les options disponibles pour un fichier

 

La visionneuse de documents

 

Options d’édition des métadonnées

 

Encore une fois les fonctionnalités présentées ici ne représentent pas la totalité des possibilités offertes par ADF.

Le versioning est pris en charge par ADF

 

 

 

Ressentis

L’application ADF offre vraiment énormément de possibilités que ce soit pour Alfresco ou Activiti. Les modules node mis à disposition pour les équipes de développeur Alfresco sont très complets et des documentations détaillées sont accessibles sur le GitHub du projet. La création de sa propre application avec les modules qui nous sont utiles est assez simple, même si des connaissances de base en Angular sont les bienvenues.

 

Cela conclu le premier billet de blog dédié à ADF, traitant de l’aspect ECM. Un autre article arrive prochainement, qui exposera les possibilités qu’offre ADF pour l’outil de BPM Activiti.

24Avr/18

Hot Reloading en Alfresco avec HotswapAgent

Pour développer en Java sur Alfresco, il faut absolument mettre en place une solution de hot reloading, car le temps de redémarrage du serveur de la plateforme est bien trop long pour pouvoir tester facilement les changements au code. Cela concerne aussi le développement de scripts serveur en JavaScript qui sont exécutés par le moteur Rhino : il n’est pas normal pour un dev JavaScript de devoir attendre quelques minutes avant de tester une petite modification du code.

Alfresco propose deux solutions : JRebel (payante) et HotswapAgent (open source). Pour l’instant j’ai choisi de ne pas investir dans JRebel et de bien tester son concurrent gratuit pour voir s’il suffit. Alfresco nous donne un tutoriel officiel pour l’utiliser, mais il manque quelque passage (notamment l’utilisation dans Eclipse qu’on ne trouve que pour JRebel), donc je vais refaire le tour pour arriver a un petit projet basé sur l’archétype Maven et le code démo qu’il contient.

La liste de courses

Nous allons utiliser un correctif pour la machine virtuelle Java (ne paniquez pas, il s’installe à côté, sans modifier la VM originale). Téléchargez donc la version pour Java 8 de DCEVM (version 8u152 à l’heure).

Bien évidemment, il faut avoir exactement la même version de Java, donc si vous utilisez une version différente, allez fouiller dans l’archive Oracle pour trouver la bonne.

Enfin, le vrai HotswapAgent. Inutile de télécharger la version la plus récente : pour Alfresco il faut utiliser la 1.0.

Voici un résumé des fichiers que j’ai utilisés dans Linux :

L’installation

Après avoir installé le JDK (pas besoin de l’installer en tant que administrateur), appliquez le correctif en utilisant cette commande :

$ java -jar DCEVM-8u152-installer.jar

En Windows on peut aussi taper deux fois sur DCEVM-8u152-installer.

Il s’agit d’un installateur qui vous donne une interface utilisateur assez simple :

Ajoutez la VM que vous venez d’installer et après tapez sur Install DCEVM as altjvm :

Quant au JAR du HotswapAgent, il faut tout simplement le mettre quelque part et se souvenir de son parcours.

Creation d’un projet

Créez un projet Maven comme indiqué dans la documentation Alfresco :

mvn archetype:generate -Dfilter=org.alfresco:

Choisissez l’archétype « All-in-One » et configurez les paramètres comme vous voulez.

Configuration d’Eclipse

Après avoir rajouté le JDK installé à la liste des JREs disponibles dans Eclipse (Window > Preferences > Java > Installed JREs), importez le projet (la documentation officielle explique comment faire et vous l’avez déjà fait plusieurs fois, donc je vous évite les détails).

Exécution du projet en mode hot reloading

Enfin, vous êtes prêts à créer une configuration pour exécuter le code. Dans les configurations de debug, créez-en une nouvelle de type Maven. Les paramètres à définir sont :

  • Base directory ${project_loc}
  • Goals clean install alfresco:run
  • Dans l’onglet JRE, sélectionnez le JRE avec le correctif DCEVM
  • VM arguments -Xms256m -Xmx2G -javaagent:/<parcours du HotswapAgent>/hotswap-agent-1.0.jar -XXaltjvm=dcevm

(Je vous conseille aussi de sélectionner Skip Tests, parce que la VM Hotswap est plus lente, donc c’est mieux de vérifier les tests séparément.)

Cette configuration peut être exécuté en mode DEBUG. Il faudra attendre un peu plus que d’habitude avant de pouvoir se connecter à Alfresco, mais il vaut le coup.

Cela donne quoi ?

Nous allons faire le test proposé par Alfresco dans le tutoriel JRebel : en se connectant à http://localhost:8080/alfresco/s/sample/helloworld, ou ici ;  le résultat sera Message: ‘Hello from JS!’ ‘HelloFromJava’

Sans arrêter le processus de debug, nous allons modifier ce message qui est généré par trois fichiers du projet platform-jar (on peut les ouvrir en tapant Ctrl+R et helloworld) : helloworld.get.js, helloworld.get.html.ftl et HelloWorldWebScript.java. Habituellement, un changement à chacun de ces fichiers entraine un redémarrage du projet.

Allons donc changer les messages :

  • dans helloworld.get.js remplacez model["fromJS"] = "Hello from JS!"; avec model["fromJS"] = "Bonjour de JS !";
  • dans helloworld.get.html.ftl remplacez Message: '${fromJS}' '${fromJava}' avec Messages : '${fromJS}' et '${fromJava}'
  • dans HelloWorldWebScript.java remplacez model.put("fromJava", "HelloFromJava"); avec model.put("fromJava", "Bonjour de Java");

À noter que chaque fois que vous tapez Ctrl+S, les changements sont pris en charge à l’instant et le log vous en donne confirmation. Un coup de F5 dans Firefox vous donne le nouveau message qui arrive des trois fichiers modifiés : pour l’instant rien à envier à JRebel.

Conclusion

Je trouve encore plus intéressante de pouvoir exécuter mes tests d’intégration en mode debug hot reloading, ce qui donne la possibilité de redémarrer à la volée une méthode qu’on vient de changer. Cela sera peut-être le sujet d’une autre article si cela vous intéresse.

02Mar/18

Conteneur Docker Alfresco avec SSL

Ceci est une petite note concernant la génération de conteneur Docker Alfresco. Pour d’autres logiciels, possédant par exemple des ports particuliers il conviendra d’adapter ces informations.
Afin d’utiliser un conteneur Alfresco en HTTPS, voici la configuration à passer à la commande “docker run” :

#!/bin/sh
docker run -it -d -v /data/mvico:/opt/alfresco/alf_data \
-e VIRTUAL_PROTO=https \
-e VIRTUAL_PORT=8443 \
-e VIRTUAL_HOST=mvico.docker.bluexml.com \
-e INITIAL_PASS=mvicoforever \
-e ALF_1=smart.folders.enabled.EQ.true \
-e ALF_2=alfresco.host.EQ.mvico.docker.bluexml.com \
-e ALF_3=alfresco.port.EQ.443 \
-e ALF_4=alfresco.protocol.EQ.https \
-e ALF_5=share.host.EQ.mvico.docker.bluexml.com \
-e ALF_6=share.port.EQ.443 \
-e ALF_7=share.protocol.EQ.https \
–name mvico-522 mvico-522:$BUILD_NUMBER

Note 1 : Les variables VIRTUAL_XXX servent à la configuration du vhost générée automatiquement par le proxy NGINX lors de chaque nouveau “run” de conteneur.
Voir conteneur NGINX proxy utilisé ici
Note 2 : Les variables ALF_XXX servent à la configuration du fichier “alfresco-global.properties” en accord avec le travail de Philippe Dubois (d’où le travail sur le changement de numéro de port)
Note 3 :  “.EQ.” signifie “=“. La substitution est effectuée pas NGINX lors de la génération du vhost.

Attention, dans Jenkins, onglet build du projet en question, par défaut il est nécessaire de mettre toute la commande sur un ligne; je vous l’accorde ce n’est pas hyper pratique ni lisible. L’éditeur ne gérant pas les sauts de ligne dans la commande. Il y a possibilité de scinder la commande en ajoutant “#!/bin/sh” au début du script et en ajoutant ” \” à chaque fin de ligne où la commande se poursuit. Ceci force l’outil d’intégration continue à exécuter la commande comme dans un script shell.

J’ajouterais enfin que pour l’édition en ligne, ne pas oublier d’ajouter la propriété aos.baseUrlOverwrite (pour cet exemple) (et en remplaçant le “=” par “.EQ.” bien sûr 😉 ). Sans cela Alfresco insérera le port 8443 dans l’URL AOS et le document ne sera pas ouvert par Office.

Je terminerais en précisant s’il est nécessaire que dans cette installation, et vous l’aurez sans doute compris, nous avons plusieurs conteneurs Docker qui interagissent : celui d’Alfresco et ceux d’NGINX.

Hope this helps.

16Fév/18

Génération d’un paquet SIP conforme au format SEDA 2.0

Introduction

Le projet VITAM propose des outils pour générer des SIP conformes au format SEDA 2.0 à partir d’une arborescence de fichiers.

Si cette fonctionnalité est disponible sur Windows et Linux, il est nécessaire de faire quelques adaptations pour MacOSX.

Adaptations

Installation de siegfried

Le générateur SEDA de VITAM utilise l’application siegfried pour détecter les formats des fichiers à intégrer. Pour cela, il suffit d’installer cette application à l’aide de brew :

brew install siegfried

Modification de run_generate.sh

Vous tentez alors de générer le paquet SIP :

sh run_generate.sh monrepertoire

Il est possible que vous obteniez le message d’erreur suivant :

jck$ > sh run_generator.sh conf
 run_generator.sh: line 4: realpath: command not found
 The given path must be a directory (not a single file):

Pour résoudre ce problème, vous devez installer coreutils :

brew install coreutils

Les outils ainsi fournis sont stockés, pour mon installation, dans le répertoire /usr/local/opt/coreutils/libexec/gnubin. Du coup, il faut modifier run_generator.sh pour lui donner cette information (ligne 4) :

#!/bin/sh
SCRIPT_DIR=$(dirname $0)
if [ "x$1" != "x" ];then
 TARGET_DIR=$(/usr/local/opt/coreutils/libexec/gnubin/realpath "$1")
fi
java -classpath "$SCRIPT_DIR/conf:$SCRIPT_DIR/lib/*" -Dvitam.config.folder=/tmp -Dvitam.tmp.folder=/tmp -Dvitam.data.folder=/tmp -Dvitam.log.folder=/tmp fr.gouv.vitam.generator.scanner.main.SedaGenerator "$SCRIPT_DIR" "$TARGET_DIR"

Utilisation

Il suffit alors de relancer le script run_generator.sh sur le répertoire de votre choix. Et ça marche !

jck$ > sh run_generator.sh monrepertoire
2018-02-16 16:01:25,987 [main] INFO f.g.v.g.scanner.main.SedaGenerator : Generateur SEDA : Beginning of scan of directory /Users/bxml/Documents/opt/local/new-workspaces/vitam/seda/generateur-seda_0.16.0/monrepertoire 
2018-02-16 16:01:26,951 [main] INFO f.g.v.generator.scanner.core.ScanFS : Managing BinaryDataObjects : 455 ms for 3 BinaryDataObjects (time per BDO : 151 ms) 
2018-02-16 16:01:27,085 [main] INFO f.g.v.generator.scanner.core.ScanFS : Writing ArchiveUnits : 127 ms for 5 ArchiveUnits (time per AU : 25 ms) 
2018-02-16 16:01:27,366 [main] INFO f.g.v.g.scanner.main.SedaGenerator : Generateur SEDA : End of scan of directory /Users/bxml/Documents/opt/local/new-workspaces/vitam/seda/generateur-seda_0.16.0/monrepertoire in 1380 ms

Conclusion

Merci Vitam 🙂

18Jan/18
Blog

Présentation de l’outil Alfresco Bulk Export

Alfresco Bulk Export Tool.

Vijay Prince a présenté l’outil Alfresco Bulk Export Tool à la Devcon Alfresco et comment l’utiliser et gérer les exports de données pendant les migrations.
Plusieurs fonctionnalités ont été ajoutées à l’outil afin de rendre son usage plus simple :
[list style=”list12″ color:”#6699ff”]

  • Une interface utilisateur pour superviser l’export et utiliser l’outil
  • Vous pouvez à présent démarrer, stopper et redémarrer l’export via l’interface
  • Vous pouvez choisir une période d’export
  • Vous pouvez ajouter des aspects et des propriétés aux données exportées
  • Vous pouvez mettre à jour les types, les aspects et les propriétés
  • Vous pouvez mettre à jour le préfix du modèle
[/list] L’interface n’est pas très belle mais efficace :

Si vous souhaitez plus d’informations sur ce projet

01Déc/17
Flowable

Installation de Flowable

Introduction

Ce tutoriel décrit comment installer et configurer l’application de BPM Flowable pour stocker les informations de manière permanente, l’installation de base par défaut étant temporaire, vos travaux sont purement et simplement supprimés à chaque arrêt/redémarrage de votre serveur BPM.

Pré-requis

Flowable est une application Java qui stocke les nombreuses informations qu’elle gère dans une base de données relationnelles. Elle a donc besoin d’un moteur de base de données relationnelles, par exemple postgresql ou mysql ainsi que d’un moteur d’exécution tel que Tomcat.

Vous pouvez trouver des informations sur l’installation de ces logiciels sur les sites correspondants.

Installation

Dans un premier temps, téléchargez la dernière version de Flowable. :

  • Double-cliquez sur l’archive flowable que vous avez récupérée. Récupérez les fichiers contenus dans le répertoire « wars » et déposez-les dans le répertoire webapps de tomcat
  • Lancez tomcat en double-cliquant sur ./bin/startup.bat

Vous pouvez alors vous connecter sur l’application flowable :

  • http://localhost:8080/flowable-idm/

Flowable est installé mais cette installation est temporaire : rien de ce que vous ferez ne sera sauvegardé. Il faut donc configurer flowable pour utiliser une base de données et persister les informations.

Configuration et initialisation

Afin de rendre les processus persistants, tout comme les données de configuration telles que les utilisateurs, il est nécessaire de configurer Flowable pour qu’il utilise la base de données que vous avez installée :

datasource.driver=org.postgresql.Driver

datasource.url=jdbc:postgresql://localhost:5432/flowable

Bien sûr, n’oubliez pas de créer la base de données correspondante:-)

Arrêtez et redémarrez Tomcat.

Initialisation

Avant de pouvoir faire quoique ce soit, il vous faut d’abord créer quelques utilisateurs et leur donner les droits nécessaires et suffisants pour pouvoir :

  • administrer flowable ;
  • créer des utilisateurs ;
  • modéliser des applications ;
  • gérer les tâches.

Création des utilisateurs

L’utilisateur par défaut est admin :

  • utilisateur : admin
  • mot de passe : test

Connectez-vous à l’adresse suivante :

Vous arrivez alors sur l’écran suivant :

  • Cliquez sur Créer un utilisateur
  • Saisissez les informations attendues

Dans le cadre de notre tutoriel, je vous invite à créer les utilisateurs suivants, en mettant le même mot de passe que le nom d’utilisateur, et ajoutant @test.org à chaque nom d’utilisateur (pas besoin que l’adresse soit opérationnelle ou même réelle) :

  • Jean-Christophe ELPADRE : directeur / identifiant : jcelpadre
  • Théo LEPREM : directeur commercial / identifiant : tleprem
  • Max LESEC : directeur RH / identifiant : mlesec
  • Lou LADER : directrice SI / identifiant : llader

Création des groupes

Cliquez ensuite sur l’onglet Groupes et créez les groupes suivants :

  • Nom : Administrateurs Alfresco / Identifiant : ADMIN_ALFRESCO
  • Nom : Administrateurs Flowable / Identifiant : ADMIN_FLOWABLE
  • Nom : Direction / Identifiant : DIR_GEN
  • Nom : Direction Commerciale / Identifiant : DIR_CALE
  • Nom : Direction des Ressources Humaines / Identifiant : DIR_RH
  • Nom : Direction du Service Informatique / Identifiant : DIR_SI

Ajoutez ensuite les utilisateurs créés précédemment dans les groupes ci-dessus.

Configuration des privilèges

Pour finir, cliquez sur l’onglet Privilèges :

Et donnez les privilèges suivants :

  • Accéder à l’application de gestion des identités : ADMIN_FLOWABLE
  • Accéder à l’application d’administration : ADMIN_FLOWABLE
  • Accéder à l’application de modélisation : DIR_TRANSVERSE_METIER
  • Accéder à l’application de workflow : DIR_CALE, DIR_GEN, DIR_RH, DIR_SI

Test

Connectez-vous sur l’application http://localhost:8080/flowable-modeler/ avec l’utilisateur jcelpadre et vérifiez que vous avez accès aux fonctions de modélisation :

31Juil/17

Mise en place d’un RedMine actif sur Docker

Lorsque l’on développe une application, celle-ci est testée sur une machine de développement. Mais il peut être intéressant de préserver le comportement de l’application indépendamment de la machine utilisée. Pour cela, il est possible d’utiliser un Docker, qui permet la mise en place d’un environnement virtuel qui ne varie pas selon la machine sur laquelle il est déployé.

Cet article va se diviser en 2 parties :

  1. Mise en place d’un container Docker sur une machine Ubuntu.
  2. Mise en place d’une image de l’environnement de développement d’un RedMine existant.

1 . Technologies Utilisées

  • Linux Ubuntu 16.04
  • RedMine 3.3.3
  • Docker 17.03.1

2 . Déroulement du développement

2.1   Mettre à jour Linux :

Source(s) utilisée(s) : https://angristan.fr/mettre-a-jour-ubuntu-16-04-lts/

Dans un premier temps, afin d’être bien sûr de mon environnement, j’ai effectué une ‘bête’ mise à jour de Linux … sans imaginer tous les problèmes que cela allait engendrer …

Problème(s) rencontré(s) :

  1. Crash au redémarrage de la machine sur la page de chargement. Ubuntu ne se lance pas, seul le chargement des packages avec [OK] sont inscrits à l’écran.
  2. Connexion au réseau Wi-Fi, mais aucune connexion Internet.
  3. Message d’erreur rencontré lors de l’utilisation d’apt.

N: « 50unattended-upgrades.ucf-old » dans le répertoire « /etc./apt/apt.conf.d/ » a été ignoré car il utilise une extension non valable

Solution(s) apportée(s) :

  1. Suppression d’un package en passant par l’invite de commande (ctrl+alt+1).

apt-get remove insserv

  1. Suppression d’une 2ème route par défaut sur le mauvais port (eth0 au lieu de wlan0).
  2. Suppression du fichier “50unattended-upgrades.ucf-dist”

Source(s) solution(s) :

  1. https://help.directadmin.com/item.php?id=379
  2. Collègue Brice PAJOT
  3. https://forum.ubuntu-fr.org/viewtopic.php?id=1999366

2.2  Installation de Docker CE (Community Edition) pour Linux :

Source(s) utilisée(s) : https://docs.docker.com/engine/installation/linux/ubuntu/

Installation de Docker Community Edition sur la machine.

Problème(s) rencontré(s) : Aucun

Solution(s) apportée(s) : Aucune

Source(s) solution(s) : Aucune

2.3  Lancement d’un environnement RedMine sur Docker :

2.3.1  RedMine simple :

Source(s) utilisée(s) : https://hub.docker.com/_/redmine/

Dans un premier temps, j’ai mis en place un RedMine simple (qui ne s’appuie sur aucune base existante).

$ docker run -d --name some-redmine redmine

$ docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' some-redmine

>172.17.0.2

Aller dans le navigateur et entrer l’adresse retournée dans l’invite de commande + port 3000 : 172.17.0.2:3000

Voilà, un RedMine neuf est lancé, cependant ce n’est pas réellement ce qui nous intéressait initialement.

Problème(s) rencontré(s) : Aucun

Solution(s) apportée(s) : Aucune

Source(s) solution(s) : Aucune

2.3.2  RedMine personnalisé :

Source(s) utilisée(s) : http://www.outofpluto.com/blog/how-to-dockerize-your-outdated-redmine/

https://github.com/abgotsunami/simple-docker-redmine

Dans l’optique d’installer un RedMine personnalisé (Avec une base de donnée, des plugins, des thèmes) nous allons suivre le Tutoriel du site OutOfPluto :

Tout d’abord, récupérer les sources du GitHub pour la suite du développement, puis se placer dans le dosser ‘simple-docker-RedMine’ du git cloné.

Résumé du Tutoriel GitHub/OutOfPluto :

Création d’une boite qui contiendra la base de données de notre RedMine

docker pull busybox

docker create –name redminedata busybox

    docker pull mysql

    docker run -d –volumes-from redminedbdata -e MYSQL_ROOT_PASSWORD=<root_psswd> -e MYSQL_DATABASE=redmine -e MYSQL_USER=redmine -e MYSQL_PASSWORD=<redmine_psswd> --name tmpdb mysql

NOTE : Penser à remplacer <root_psswd> par ‘ root ’ et <redmine_psswd> par ‘ RedMine ’ dans lignes de commandes et le fichier docker-compose.yml

docker exec -ti tmpdb /bin/bash

mysql

CREATE USER ‘lwa’@’%’ IDENTIFIED BY ‘=<redmine_psswd>’;

CREATE DATABASE ‘redmine’;

GRANT ALL PRIVILEGES ON redmine.* TO ‘redmine’@’%’;

exit

exit

NOTE : Erreur dans le GitHub, écrire ‘ tmpdb ‘ à la place de ‘ db ‘.

NOTE : Une erreur peu intervenir à l’exécution de mysql, se référer aux erreurs ci-dessous (problèmes rencontrés).

docker stop tmpdb

docker rm tmpdb

(Inutile d’installer / configurer nginx dans notre situation)

Dans le fichier docker-compose.yml :

Supprimer la partie nginx

Remplacer <mydomain> par ‘ localhost ‘ à la ligne     – MAILNAME=localhost

Rajouter :

ports:

– 3000:3000

Juste en dessous de    – smtp:smtp

Changer les versions dans le fichier Dockerfile par les plus récentes :

  • ruby:2.4-slim
  • GOSU_VERSION 1.10
  • TINI_VERSION v0.14.0
  • REDMINE_VERSION 3.3.3

NOTE : Changer ruby:2.4-slim  par   ruby:2.2-slim  peut éviter quelques erreurs directement (voir liste des erreurs ci-dessous)

docker-compose build

docker-compose up

Problème(s) rencontré(s) :

  1. Erreur à l’étape 4 du github, pas les permissions pour root@localhost lors de l’exécution de mysql.
  2. Erreur lors du docker-compile build
ERROR: Service 'redmine' failed to build: The command '/bin/sh -c set -x     && curl -fSL -o /usr/local/bin/gosu "https://github.com/tianon/gosu/releases/download/$GOSU_VERSION/gosu-$(dpkg --print-architecture)"     && […] && gosu nobody true' returned a non-zero code: 127
  1. Erreur lors du docker-compile build
ERROR: Service 'redmine' failed to build: The command '/bin/sh -c curl -fSL "http://www.redmine.org/releases/redmine-${REDMINE_VERSION}.tar.gz" -o redmine.tar.gz     && […] && chown -R redmine:redmine ./' returned a non-zero code: 1
  1. simpledockerredmine_redmine_1 exited with code 2 lors de   docker-compile up
  2. simpledockerredmine_redmine_1 exited with code 1 lors de docker-compile up En remontant plus haut on aperçoit également :
 /usr/local/lib/ruby/gems/2.4.0/gems/activesupport-4.2.7.1/lib/active_support/core_ext/numeric/conversions.rb:121: warning: constant ::Fixnum is deprecated

/usr/local/lib/ruby/gems/2.4.0/gems/activesupport-4.2.7.1/lib/active_support/core_ext/numeric/conversions.rb:121: warning: constant ::Bignum is deprecated

rake aborted!

Solution(s) apportée(s) :

  1. mysql -u root -p  à la place de      mysql
  2. Ajout de RUN apt-get update && apt-get install -y apt-transport-https && apt-get install -y curl   dans le fichier Dockerfile avant la ligne :

#grab gosu for easy step-down from root

(Ecrire ligne 5)

  1. la ligne && echo “$REDMINE_DOWNLOAD_MD5 redmine.tar.gz” | md5sum -c – \  dans le fichier docker-compose.yml pose soucis, car la vérification de la variable  $REDMINE_DOWNLOAD_MD5  n’est pas connue en brut pour la version de RedMine 3.3.3, j’ai simplement retiré cette ligne. (On peut éventuellement la commenter ou chercher la valeur en ligne).
  2. Exécuter :

docker logs simpledockerredmine_redmine_1

On s’aperçoit qu’il y a un ‘ ” ‘ manquant dans le fichier docker-entrypoint.sh ligne 54

  1. RedMine 3.3.3 ne supporte pas Ruby 2.4 et 2.3, changer ruby:2.4-slim  par   ruby:2.2-slim dans le fichier Dockerfile

Source(s) solution(s) :

  1. http://askubuntu.com/questions/401449/error-104528000-access-denied-for-user-rootlocalhost-using-password-no
  2. http://www.redmine.org/issues/25109

2.4  Intégration de la base de données d’un RedMine existant :

Source(s) utilisée(s) : http://www.outofpluto.com/blog/how-to-dockerize-your-outdated-redmine/

Tout d’abord, faire une sauvegarde de la base de données du RedMine actuel, créer un fichier recover.sh contenant :

#!/bin/bash

/usr/bin/mysqldump -u redmine -pmy_password redmine |gzip > ./redmine_db`date +%y_%m_%d`.gz

Exécuter. recover.sh

Le .gz contient un fichier, extraire ce fichier, le renommer en .sql

(Pendant que le docker RedMine est lancé)

(Pour lancer un docker sans avoir besoin d'une console active, utiliser l'argument -d après docker-compose up)

 docker cp backup_db/redmine_db17_04_13.sql simpledockerredmine_db_1:/

 docker exec -ti simpledockerredmine_db_1 /bin/bash



 mysql -u RedMine -predmine -D RedMine < /redmine_db17_04_13.sql

 rm redmine-db17_04_13.sql

 exit

NOTE : Remplacer 17_04_13 par la date du fichier .sql (date actuelle)

Enfin, associer maintenant les fichiers présents sur notre RedMine actuel avec le RedMine du Docker.

docker inspect --format "{{ .Mounts }}" simpledockerredmine_redmine_1

 [{bind  /var/lib/docker/volumes/24d85b9a6996844d7c1260a19b200e49a1001a7b40962377b5d40ef4c323694f/_data /usr/src/redmine/files  rw true }]

 sudo cp -r <REDMINE_PATH>/files/* /var/lib/docker/volumes/24d85b9a6996844d7c1260a19b200e49a1001a7b40962377b5d40ef4c323694f/_data

NOTE : <REDMINE_PATH> est le chemin vers le RedMine (éventuellement. si on se place à la racine du RedMine)

NOTE : La partie longue (/var/lib/docker/volumes/24…/_data) est propre au résultat obtenu par la commande précédente

Voilà, le RedMine du Docker possède maintenant la même base de données (utilisateurs, fichiers, etc. …) que le RedMine précédent.

Problème(s) rencontré(s) : Aucun

Solution(s) apportée(s) : Aucune

Source(s) solution(s) : Aucune

2.5  Ajout de Plugins et Thèmes :

Source(s) utilisée(s) : http://www.outofpluto.com/blog/how-to-dockerize-your-outdated-redmine/

2.5.1  Ajouter un plugin custom ou existant sur la machine :

Pour ajouter un plugin déjà présent sur le pc, créer un .tar.gz de celui-ci puis le mettre dans le répertoire RedMine/plugins de notre répertoire Docker.

Dans le fichier Dockerfile, sous la catégorie #install some plugins, écrire :

COPY RedMine/monplugin.tar.gz /usr/src/RedMine/plugins/

RUN tar xzf /usr/src/RedMine/plugins/monplugin.tar.gz -C /usr/src/RedMine/plugins/ \

    && rm /usr/src/RedMine/plugins/monplugin.tar.gz

Puis dans l’invite de commande :

docker-compose stop

docker-compose build

docker-compose up -d
2.5.2  Ajouter un plugin depuis un github :

Dans le cas d’un plugin qui provient directement d’un GitHub, il est possible de l’intégrer par lien. Dans le fichier Dockerfile, sous la catégorie #install some plugins, écrire :

RUN git clone <adresse_github>.git <nom_repertoire_plugin> && mv <nom_repertoire_plugin> /usr/src/RedMine/plugins/

<adresse_github> est l’adresse à laquelle se trouve le plugin à télécharger ex : https://github.com/onozaty/redmine-parent-issue-filter

<nom_repertoire_plugin> est le nom que doit porter le répertoire du plugin ex : parent_issue_filter

le nom du répertoire peut être connu en regardant dans le fichier init.rb du plugin : RedMine::Plugin.register :parent_issue_filter do

Exemple final :

RUN git clone https://github.com/onozaty/redmine-parent-issue-filter.git parent_issue_filter && mv parent_issue_filter /usr/src/redmine/plugins/
2.5.3  Ajouter un thème :

Pour ajouter un thème, il suffit d’appliquer exactement la même méthode que pour l’ajout d’un plugin. Dans le fichier Dockerfile, sous la catégorie #install theme, écrire :

RUN git clone <adresse_github>.git && mv <nom_repertoire_theme> /usr/src/redmine/public/themes/<nom_theme>

COPY redmine/themes/<nom_theme>/stylesheets/ /usr/src/redmine/public/themes/<nom_theme>/stylesheets/

Ici le répertoire n’a pas besoin d’être renommé (il peut l’être, de la même manière que pour le plugin si le nom ne convient pas).

<nom_theme> est le nom que vous choisirez de donner au thème.

Problème(s) rencontré(s) : Aucun

Solution(s) apportée(s) : Aucune

Source(s) solution(s) : Aucune

3. Durée de développement

Le développement de ce module a duré 2 jours du 04/12 au 04/13.

4. Commentaires supplémentaires

Une partie du développement a été consacrée à la lecture de la documentation Docker (et à la résolution des problèmes engendrés par la mise à jour de Linux).

 

Auteur : Alexandre BOUDINE