Tag Archives: Alfresco

Alfresco, CMIS y Python

Thursday April 25th, 2013

El estandar CMIS (Content Management Interoperability Services) es un estandar para la gestion de contenidos aprobada por OASIS.

http://en.wikipedia.org/wiki/Content_Management_Interoperability_Services

Esto nos permite tener una capa de llamadas estandar para multitud de productos de gestion de contenidos que incluyan CMIS y por tanto también acceder desde multitud de lenguajes y no solo desde Java.

Este es el caso de cmislib de Jeff Potts para Python.

La installación es muy sencilla, necesitamos un interprete Python (versión
2.7) además del módulo cmislib y setuptools para instalar el primero y
Alfresco 4.

Podemos usar la línea de comandos de Python para hacer las siguientes pruebas:

Importamos la librería:

from cmislib.model import CmisClient, Repository

Creamos el cliente configurando el end-point y las credenciales:

client = CmisClient(‘http://localhost:8080/alfresco/s/cmis’, ‘admin’, ‘admin’)

Recuperamos el servicio de repositorio por defecto:

repo = client.getDefaultRepository()
repo.getRepositoryId()

Recuperamos información del repositorio:

info = repo.getRepositoryInfo()
for k,v in info.items():
print “%s:%s” % (k,v)

Deberia devolvernos algo así:

cmisSpecificationTitle:Version 1.0 OASIS Standard
aclCapability:

cmisVersionSupported:1.0
principalAnonymous:guest
principalAnyone:GROUP_EVERYONE
repositoryDescription:None
changesOnType:cmis:document
changesIncomplete:true
productVersion:4.0.0 (4003)
rootFolderId:workspace://SpacesStore/b92b669b-4f2a-42ab-a9d8-1451b1596e80
repositoryId:6891ed19-41e3-4160-8c77-65de35c5a428
repositoryName:Main Repository
vendorName:Alfresco
productName:Alfresco Repository (Community)

Bien, ya lo tenemos, ahora creamos…

… una carpeta:

rootFolder = repo.rootFolder
newFolder = rootFolder.createFolder(‘Carpeta nueva’)
newFolder.id

… un contenido:

f = open(‘Mi fichero’, ‘r’)
newDoc = newFolder.createDocument(‘New Document’, contentFile=f)

… y listamos las propiedades:

for k,v in newDoc.properties.items()
print ‘%s = %s’ % (k,v)

Personalmente me parece una idea muy buena y más con el lenguaje más popular
del momento 😉

Más información en:

https://code.google.com/p/cmislib/
http://chemistry.apache.org/python/cmislib.html
https://pypi.python.org/pypi/setuptools#files
http://www.python.org/
https://www.oasis-open.org/committees/tc_home.php?wg_abbrev=cmis
http://cmis.alfresco.com/

Transformar ficheros RAW en Alfresco

Thursday February 7th, 2013

Como ya sabemos, Alfresco tiene muchas posibilidades de manipulación y transformación de ficheros/documentos. Una de las cosas más flexibles es el uso de transformadores que puden ser de dos tipos básicamente:

Llamadas directas a algún comando o utilidad del sistema
Desarrollar una clase Java que realice la transformación

Aquí vamos a ver la primera para utilizar la transformación de fotografías tomadas en formato RAW (o bruto como generalmente se llama) a TIFF y a JPEG. Actualmente hago fotos con Nikon y Olympus y me interesa pasar el formato NEF (por poner el de Nikon) a TIFF y a JPEG. ImageMagick puede hacerlo pero me ha dado problemas tanto en el resultado (no se pueden ver) como en la propia conversión por lo que voy a usar otra utilidad que existe para Linux, Mac OS X y Windows.

Esta utilidad se llama dcraw y podemos bajarla de http://www.cybercom.net/~dcoffin/dcraw/ para el sistema operativo que tengamos. En este caso voy a utilizar la que hay para Windows compilada con MingW desde la dirección http://www.rawness.es/dcraw/?lang=es

Una vez instalada o descomprimida en el directorio que nos guste obtendremos el programa ejecutable dcraw.exe

Bien, ahora a configurar el transformador…

Toda la configuración se basa en un bean llamado RuntimeExecutableContentTransformer para versiones anteriore a la 3.2 de Alfresco o RuntimeExecutableContentTransformeWorker para las siguientes. A su vez este bean contiene las siguientes propiedades principales:

transformCommand: Define el comando y parámetros usando variables como ${source} y ${target}
checkCommand: Chequea si la sintaxis es correcta y si ocurre un error también se puede definir con errorCodes. Cuando no está disponible el método getReliability devuelve 0:0 este método se usa para utilizar el transformador más eficiente en caso de que haya varios definidos que conviertan de la misma fuente al mismo destino.
explicitTransformations establece el tipo MIME fuente y destino de forma explícita.

Creamos el fichero nef-tiff-jpeg-transform-context.xml:

${dcraw.exe} -i ${dcraw.home}/test.nef

${dcraw.exe} -T ‘${source}’ ‘${target}’

${dcraw.exe} -T “${source}” “${target}”

true

image/x-nikon-nef

image/tiff

<bean id="transformer.complex.Nef.Jpg"

class=”org.alfresco.repo.content.transform.ComplexContentTransformer”

parent=”baseContentTransformer” >

image/tiff

Como vemos hay además otro bean definido de la clase ComplexContentTransformer, este sirve para realizar transformaciones a partir de otras, es decir, si no podemos transformar una imagen del formato NEF al formato JPEG pero si podemos realizar la transformación de NEF a TIFF y de TIFF a JPEG podemos configurarlo a través de este bean en el que hay que poner los transformadores y el mimetype intermedio de la transformación.

Con esto ya podemos transformar imágenes tomadas directamente en RAW (NEF en el caso de Nikon) a TIFF y a si vez y mediante ComplexContentTransformer directamente a JPEG.

Ahora con dcraw.exe…

Esta utilidad de línea de comandos al igual que convert.exe de ImageMagick tiene la siguiente sintaxis:

C:Usersfernando.gonzalezworkspaceCommonMingW-release-orig-x32>dcraw.exe
Raw photo decoder “dcraw” v9.06

by Dave Coffin, dcoffin a cybercom o net

Usage: dcraw.exe [OPTION]… [FILE]…

-v Print verbose messages

-c Write image data to standard output

-e Extract embedded thumbnail image

-i Identify files without decoding them

-i -v Identify files and show metadata

-z Change file dates to camera timestamp

-w Use camera white balance, if possible

-a Average the whole image for white balance

-A Average a grey box for white balance

-r Set custom white balance

+M/-M Use/don’t use an embedded color matrix

-C Correct chromatic aberration

-P Fix the dead pixels listed in this file

-K Subtract dark frame (16-bit raw PGM)

-k Set the darkness level

-S Set the saturation level

-n Set threshold for wavelet denoising

-H [0-9] Highlight mode (0=clip, 1=unclip, 2=blend, 3+=rebuild)

-t [0-7] Flip image (0=none, 3=180, 5=90CCW, 6=90CW)

-o [0-5] Output colorspace (raw,sRGB,Adobe,Wide,ProPhoto,XYZ)

-d Document mode (no color, no interpolation)

-D Document mode without scaling (totally raw)

-j Don’t stretch or rotate raw pixels

-W Don’t automatically brighten the image

-b Adjust brightness (default = 1.0)

-g

Set custom gamma curve (default = 2.222 4.5)

-q [0-3] Set the interpolation quality

-h Half-size color image (twice as fast as “-q 0”)

-f Interpolate RGGB as four colors

-m Apply a 3×3 median filter to R-G and B-G

-s [0..N-1] Select one raw image or “all” from each file

-6 Write 16-bit instead of 8-bit

-4 Linear 16-bit, same as “-6 -W -g 1 1”

-T Write TIFF instead of PPM

Podemos observar tres cosas:

Podemos usar el modificador -i para chequear la utilidad, solo hay que usar una imagen y llamarla por ejemplo test.nef
Debemos usar el modificador -T para pasar las imágenes a TIFF en lugar de PPM que es lo que hace por defecto
Tenemos un problema, el resultado de la transformación es siempre el mismo fichero pero con la extensión cambiada, es decir, no podemos obligar a guardar el resultado en otro fichero (bueno, si, con el modificador -c que saca la salida por consola y capturandola con una redirección “>” pero esto no funciona bien)

Como Alfresco utiliza en la transformación dos variables ${source} y ${target} y ambos son distintos (genera los nombres de estos ficheros distintas) nos encontramos con el problema de que no podemos llamarlo directamente por lo que hay que crear un script que llame correctamente al ejecutable con los modificadores adecuados.

Este script en formato BAT/CMD de Windows y llamado dcraw.cmd es el siguiente:

@ECHO OFF

set path_dcraw=%0

SET opts=%1

SET source=%2

SET target=%3

%path_dcraw:~,-3%exe %opts% %source%

IF “%opts%”==”-i” GOTO END

MOVE %source:~,-4%tiff” %target%

:END

Seguidamente vamos a crear las variables en el fichero de propiedades, en este caso utilizo el mismo alfresco-global.properties:

dcraw.home=C:/Users/fernando.gonzalez/workspace/Common/MingW-release-orig-x32

dcraw.exe=${dcraw.home}/dcraw.cmd

Y por último debemos declarar los tipos MIME (mimetypes) en el fichero mimetypes-extension-map.xml que está en /alfresco/extension/mimetype:

nef

Listo, ya solo nos falta hacer las reglas necesarias para convertir NEF a TIFF o a JPEG directamente en nuesto estudio fotográfico y tener almacenadas y ordenadas todas nuestras fotografías. Además, podemos usar Alfresco de previsualizador de imágenes RAW aunque no tengamos nigún programa para ello como podemos ver en la siguiente imagen:

Para depurar podemos activar las siguientes líneas en Log4J (log4j.properties o custom-log4j.propeties en el extension):

log4j.logger.org.alfresco.repo.content.transform.TransformerDebug=debug

log4j.logger.org.alfresco.util.exec.RuntimeExec=debug

log4j.logger.org.alfresco.repo.content.transform.ContentTransformerRegistry=debug

Enlaces de interés:

http://wiki.alfresco.com/wiki/Content_Transformations

http://docs.alfresco.com/4.1/index.jsp

https://wiki.alfresco.com/wiki/Content_Transformation_and_Metadata_Extraction_with_Apache_Tika

https://wiki.alfresco.com/wiki/Developer_Guide

Cifrado de contenido en Alfresco

Sunday December 16th, 2012

En muchas ocasiones es necesario el cifrado del contenido en Alfresco, en este sentido ya Alfresco en la versión 4.0 puede cifrar propiedades (http://wiki.alfresco.com/wiki/Data_Encryption) y también hay un módulo para utilizar el cifrado (http://addons.alfresco.com/addons/alfresco-encryption-module).

En este caso vamos a realizar dos acciones que cifren y descifren el contenido de un documento (propiedad content) usando el algoritmo de cifrado simétrico AES. Estos sirven para la versión 3.4 de Alfresco y siguientes.

El código también se encuentra en: http://code.google.com/p/alfcrypto

Algunas cosas importantes primero: Este software es una versión alpha o beta o como queráis llamarla pero sobre todo es un código hecho de forma más o menos rápida y por tanto no hay garantía ninguna de funcionamiento, se ha probado solo con algunos documentos MS-Word y PDF. Además, ya he detectado un problema, cuando se descifra el tipo MIME en el que se guarda la copia desencriptada es plain/text (no es que no funcione, si descargais el documento se puede abrir/editar, etc) por lo que hay que incluir en el modelo de datos una propiedad que guarde el valor original y lo restaure posteriormente (ya lo haré cuando consiga algo de tiempo). Se ha realizado solamente con carácter educativo y por lo tanto no lo recomiendo para su uso en sistemas de producción sin realizar antes algunas modificaciones y pruebas.

Otro apunte más, como bien comenta Toni de la Fuente (blyx.com), existen algunas restricciones derivadas del cifrado, la primera es en la previsualización, evidentemente no existe cuando los documentos están cifrados y no tiene sentido descifrar para previsualizar ya que rompería la seguridad. Tampoco es posible la indexación full-text ya que no es posible al igual que en contenidos de imágenes (JPG, GIF, etc.), es más, es una buena idea cambiar el tipo MIME a algún tipo que Alfresco no indexe y cuando sea descifrado reponer el tipo MIME original. El uso de este sistema sería para documentos que son necesariamente obligados a ser cifrados y solo se tenga acceso a ellos por personal especial (Recursos Humanos, I+D+I, datos con carácter especial de protección de datos, etc.) que una vez descifrados (en otra ubicación a la original principalmente) sean descargados y borrados (la copia descifrada) vaciando la papelera e incluso modificando la configuración para que no sean guardados en esta. Además recomendaría que o bien el cifrado, o el descifrado se aloje en otras unidades de disco diferentes usando para ello Content Store Selector (en este último caso solo para las versiones Enterprise).

Con todo esto, comencemos:

Lo primero que hay que hacer es construir la clase de cifrado que en este caso se llamará crypto.java:

/*
* alfcrypto is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* alfcrypto is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see .
*/
package com.fegor.alfresco.security.crypto;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.AlgorithmParameters;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.InvalidParameterSpecException;
import java.security.spec.KeySpec;

import org.apache.log4j.Logger;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.ShortBufferException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;

public class Crypto {
private final Logger logger = Logger.getLogger(Crypto.class);

    String password = null;
    public final static int SALT_LEN = 8;
    byte[] vector_init = null;
    byte[] salt_pos = null;

byte[] input;
byte[] output;

Cipher eCipher = null;
Cipher deCipher = null;

private final int KEYLEN_BITS = 128;
private final int ITERATIONS = 65536;

    /**
    * Constructor
    */
    public Crypto() {
    }

    /**
    * Encryption configuration
    *
    * @throws NoSuchAlgorithmException
    * @throws InvalidKeySpecException
    * @throws NoSuchPaddingException
    * @throws InvalidParameterSpecException
    * @throws IllegalBlockSizeException
    * @throws BadPaddingException
    * @throws UnsupportedEncodingException
    * @throws InvalidKeyException
    */
    public void configEncrypt() throws NoSuchAlgorithmException,
            InvalidKeySpecException, NoSuchPaddingException,
            InvalidParameterSpecException, IllegalBlockSizeException,
            BadPaddingException, UnsupportedEncodingException,
            InvalidKeyException {
        SecretKeyFactory factory = null;
        SecretKey tmp = null;

        salt_pos = new byte[SALT_LEN];
        SecureRandom rnd = new SecureRandom();
        rnd.nextBytes(salt_pos);

        if (logger.isDebugEnabled())
            logger.debug(this.getClass().getName() + “: [salt: “
                    + (new String(Hex.encodeHex(salt_pos))) + “]”);

factory = SecretKeyFactory.getInstance(“PBKDF2WithHmacSHA1”);

        /*
        * http://www.javamex.com/tutorials/cryptography/unrestricted_policy_files
        * .shtml
        */
        KeySpec spec = new PBEKeySpec(password.toCharArray(), salt_pos,
                ITERATIONS, KEYLEN_BITS);
        tmp = factory.generateSecret(spec);
        SecretKey secret = new SecretKeySpec(tmp.getEncoded(), “AES”);

        eCipher = Cipher.getInstance(“AES/CBC/PKCS5Padding”);
        eCipher.init(Cipher.ENCRYPT_MODE, secret);
        AlgorithmParameters params = eCipher.getParameters();

vector_init = params.getParameterSpec(IvParameterSpec.class).getIV();

        if (logger.isDebugEnabled())
            logger.debug(this.getClass().getName() + “: [vector ini: “
                    + (new String(Hex.encodeHex(vector_init))) + “]”);
    }

    /**
    * Decryption configuration
    *
    * @param initvec
    * @param salt
    * @throws NoSuchAlgorithmException
    * @throws InvalidKeySpecException
    * @throws NoSuchPaddingException
    * @throws InvalidKeyException
    * @throws InvalidAlgorithmParameterException
    * @throws DecoderException
    */
    public void configDecrypt(String initvec, String salt)
            throws NoSuchAlgorithmException, InvalidKeySpecException,
            NoSuchPaddingException, InvalidKeyException,
            InvalidAlgorithmParameterException, DecoderException {
        SecretKeyFactory factory = null;
        SecretKey tmp = null;
        SecretKey secret = null;

salt_pos = Hex.decodeHex(salt.toCharArray());

        if (logger.isDebugEnabled())
            logger.debug(this.getClass().getName() + “: [salt: “
                    + (new String(Hex.encodeHex(salt_pos))) + “]”);

        vector_init = Hex.decodeHex(initvec.toCharArray());
        if (logger.isDebugEnabled())
            logger.debug(this.getClass().getName() + “: [vector ini: “
                    + (new String(Hex.encodeHex(vector_init))) + “]”);

        /*
        * http://www.javamex.com/tutorials/cryptography/unrestricted_policy_files
        * .shtml
        */
        factory = SecretKeyFactory.getInstance(“PBKDF2WithHmacSHA1”);
        KeySpec spec = new PBEKeySpec(password.toCharArray(), salt_pos,
                ITERATIONS, KEYLEN_BITS);

tmp = factory.generateSecret(spec);
secret = new SecretKeySpec(tmp.getEncoded(), “AES”);

        deCipher = Cipher.getInstance(“AES/CBC/PKCS5Padding”);
        deCipher.init(Cipher.DECRYPT_MODE, secret, new IvParameterSpec(
                vector_init));
    }

    /**
    * Cipher input
    *
    * @param input
    *            – the cleartext file to be encrypted
    * @param output
    *            – the encrypted data file
    * @throws IOException
    * @throws IllegalBlockSizeException
    * @throws BadPaddingException
    * @throws ShortBufferException
    */
    public void Cipher() throws IOException, IllegalBlockSizeException,
            BadPaddingException, ShortBufferException {
        try {
            this.output = eCipher.doFinal(this.input);
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }
    }

    /**
    * Decipher input
    *
    * @param input
    *            – the cleartext file to be encrypted
    * @param output
    *            – the encrypted data file
    * @throws IOException
    * @throws IllegalBlockSizeException
    * @throws BadPaddingException
    * @throws ShortBufferException
    */
    public void Decipher() throws IOException, IllegalBlockSizeException,
            BadPaddingException, ShortBufferException {
        try {
            this.output = deCipher.doFinal(this.input);
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }
    }

    /*
    * Methods setter and getter
    */
    public void setInput(byte[] input) {
        this.input = input;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getSalt() {
        return (new String(Hex.encodeHex(salt_pos)));
    }

    public String getVectorInit() {
        return (new String(Hex.encodeHex(vector_init)));
    }

    public byte[] getOutput() {
        return this.output;
    }
}

Como se observa es una clase normal con los métodos para configurar el cifrado y descifrado y la llamada para realizar las acciones correspondientes.

Utilizaremos dos aspectos para saber que documentos están cifrados y cuales han sido descifrados, el modelo de datos a utilizar será el siguiente:

    Alfresco Crypto Model
    Fernando González Ruano (twitter://fegorama)
    1.0

        <import uri="http://www.alfresco.org/model/dictionary/1.0"
            prefix=”d” />



        <namespace uri="http://www.fegorsoft.com/model/alfcrypto/1.0"
            prefix=”acr” />



            Ciphered


                    d:text
                    false

                        false
                        false
                        false



                    d:text
                    false

                        false
                        false
                        false





            Deciphered

Para llamar a esta clase se necesitan dos acciones de Alfresco, estas serán CipherContent.java y DecipherContent.java:

Fichero: CipherContent.java
/*
* alfcrypto is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* alfcrypto is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see .
*/
package com.fegor.alfresco.action;

import java.io.IOException;
import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.InvalidParameterSpecException;
import java.util.HashMap;
import java.util.List;

import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.ShortBufferException;

import org.alfresco.model.ContentModel;
import org.alfresco.repo.action.executer.ActionExecuterAbstractBase;
import org.alfresco.service.cmr.action.Action;
import org.alfresco.service.cmr.action.ParameterDefinition;
import org.alfresco.service.cmr.repository.ContentIOException;
import org.alfresco.service.cmr.repository.ContentReader;
import org.alfresco.service.cmr.repository.ContentService;
import org.alfresco.service.cmr.repository.ContentWriter;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.repository.NodeService;
import org.alfresco.service.namespace.QName;
import org.apache.commons.io.IOUtils;
import org.apache.log4j.Logger;

import com.fegor.alfresco.model.AlfCryptoModel;
import com.fegor.alfresco.security.crypto.Crypto;
import com.google.gdata.util.common.util.Base64;

/**
* CryptoRepo Action
*
* @author fegor
*
*/
public class CipherContent extends ActionExecuterAbstractBase {

private final Logger logger = Logger.getLogger(CipherContent.class);

    /*
    * Services
    */
    private ContentService contentService;
    private NodeService nodeService;

    private String password;
    //
    // TODO Poder usar más algoritmos que AES
    //
    // private String algorithm;

private String salt;
private String vector_init;

    /*
    * (non-Javadoc)
    *
    * @see
    * org.alfresco.repo.action.executer.ActionExecuterAbstractBase#executeImpl
    * (org.alfresco.service.cmr.action.Action,
    * org.alfresco.service.cmr.repository.NodeRef)
    */
    @Override
    protected void executeImpl(Action action, NodeRef actionedUponNodeRef) {
        if (!nodeService.hasAspect(actionedUponNodeRef,
                AlfCryptoModel.ASPECT_CIPHERED)) {
            if (logger.isDebugEnabled()) {
                logger.debug(this.getClass().getName() + “: [Action for: “
                        + actionedUponNodeRef + ” is ciphering…]”);
            }
            if (actionedUponNodeRef != null)
                try {
                    this.cryptoFileCipher(actionedUponNodeRef);
                } catch (ContentIOException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }

    /*
    * (non-Javadoc)
    *
    * @see org.alfresco.repo.action.ParameterizedItemAbstractBase#
    * addParameterDefinitions(java.util.List)
    */
    @Override
    protected void addParameterDefinitions(List arg0) {
    }

    /**
    * Crypto file for nodeRef
    *
    * @param nodeRef
    * @throws IOException
    * @throws ContentIOException
    */
    private void cryptoFileCipher(NodeRef nodeRef) throws ContentIOException,
            IOException {
        ContentReader contentReader = this.contentService.getReader(nodeRef,
                ContentModel.PROP_CONTENT);
        ContentWriter contentWriter = this.contentService.getWriter(nodeRef,
                ContentModel.PROP_CONTENT, true);

        if (contentReader != null) {
            Crypto crypto = new Crypto();
            crypto.setPassword(this.password);
            byte[] crb = IOUtils.toByteArray(contentReader
                    .getContentInputStream());

            try {
                crypto.configEncrypt();
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (InvalidKeySpecException e) {
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
            } catch (InvalidParameterSpecException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }

            crypto.setInput(crb);
            try {
                crypto.Cipher();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (ShortBufferException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

contentWriter.putContent(Base64.encode(crypto.getOutput()));

this.salt = crypto.getSalt();
this.vector_init = crypto.getVectorInit();

this.removeAspect(nodeRef);
this.addAspect(nodeRef);

        } else {
            if (logger.isDebugEnabled())
                logger.debug(this.getClass().getName()
                        + “: [contentReader is null]”);
        }
    }

    /**
    * Remove aspect Deciphered
    *
    * @param nodeRef
    */
    private void removeAspect(NodeRef nodeRef) {
        if (nodeService.hasAspect(nodeRef, AlfCryptoModel.ASPECT_DECIPHERED)) {
            nodeService.removeAspect(nodeRef, AlfCryptoModel.ASPECT_DECIPHERED);
        }
    }

    /**
    * Add aspect Ciphered
    *
    * @param nodeRef
    */
    private void addAspect(NodeRef nodeRef) {
        HashMap properties = new HashMap(
                1, 1.0f);
        properties.put(AlfCryptoModel.PROP_SALT, this.salt);
        properties.put(AlfCryptoModel.PROP_VECTOR_INIT, this.vector_init);
        if (!nodeService.hasAspect(nodeRef, AlfCryptoModel.ASPECT_CIPHERED)) {
            nodeService.addAspect(nodeRef, AlfCryptoModel.ASPECT_CIPHERED,
                    properties);
        }
    }

    /**
    * @param contentService
    */
    public void setContentService(ContentService contentService) {
        this.contentService = contentService;
    }

    /**
    * @param nodeService
    */
    public void setNodeService(NodeService nodeService) {
        this.nodeService = nodeService;
    }

    /**
    * @param password
    */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
    * @param algorithm
    */
    //
    // TODO Poder usar más algoritmos que AES
    //
    // public void setAlgorithm(String algorithm) {
    // this.algorithm = algorithm;
    // }
}

Fichero: DecipherContent.java
/*
* alfcrypto is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* alfcrypto is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see .
*/
package com.fegor.alfresco.action;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.util.List;

import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.ShortBufferException;

import org.alfresco.model.ContentModel;
import org.alfresco.repo.action.executer.ActionExecuterAbstractBase;
import org.alfresco.service.cmr.action.Action;
import org.alfresco.service.cmr.action.ParameterDefinition;
import org.alfresco.service.cmr.repository.ContentReader;
import org.alfresco.service.cmr.repository.ContentService;
import org.alfresco.service.cmr.repository.ContentWriter;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.repository.NodeService;
import org.apache.commons.codec.DecoderException;
import org.apache.log4j.Logger;

import com.fegor.alfresco.model.AlfCryptoModel;
import com.fegor.alfresco.security.crypto.Crypto;
import com.google.gdata.util.common.util.Base64;
import com.google.gdata.util.common.util.Base64DecoderException;

/**
* DecryptoRepo Action
*
* @author fegor
*
*/
public class DecipherContent extends ActionExecuterAbstractBase {

private final Logger logger = Logger.getLogger(DecipherContent.class);

    /*
    * Services
    */
    private ContentService contentService;
    private NodeService nodeService;

    private String password;
    //
    // TODO Poder usar más algoritmos que AES
    //
    // private String algorithm;

private String salt;
private String vector_init;

    /*
    * (non-Javadoc)
    *
    * @see
    * org.alfresco.repo.action.executer.ActionExecuterAbstractBase#executeImpl
    * (org.alfresco.service.cmr.action.Action,
    * org.alfresco.service.cmr.repository.NodeRef)
    */
    @Override
    protected void executeImpl(Action action, NodeRef actionedUponNodeRef) {
        if (nodeService.hasAspect(actionedUponNodeRef,
                AlfCryptoModel.ASPECT_CIPHERED)) {
            if (logger.isDebugEnabled()) {
                logger.debug(this.getClass().getName() + “: [Action for: “
                        + actionedUponNodeRef + ” is deciphering…]”);
            }
            if (actionedUponNodeRef != null)
                try {
                    this.cryptoFileDecipher(actionedUponNodeRef);
                } catch (InvalidAlgorithmParameterException e) {
                    e.printStackTrace();
                } catch (DecoderException e) {
                    e.printStackTrace();
                }
        }
    }

    /**
    * Scan file for nodeRef
    *
    * @param nodeRef
    * @throws DecoderException
    * @throws InvalidAlgorithmParameterException
    */
    private void cryptoFileDecipher(NodeRef nodeRef)
            throws InvalidAlgorithmParameterException, DecoderException {
        ContentReader contentReader = this.contentService.getReader(nodeRef,
                ContentModel.PROP_CONTENT);
        ContentWriter contentWriter = this.contentService.getWriter(nodeRef,
                ContentModel.PROP_CONTENT, true);

if (contentReader != null) {

            byte[] crb = contentReader.getContentString().getBytes();
            Crypto crypto = new Crypto();
            crypto.setPassword(this.password);
            this.salt = (String) nodeService.getProperty(nodeRef,
                    AlfCryptoModel.PROP_SALT);
            this.vector_init = (String) nodeService.getProperty(nodeRef,
                    AlfCryptoModel.PROP_VECTOR_INIT);

            try {
                crypto.configDecrypt(this.vector_init, this.salt);
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (InvalidKeySpecException e) {
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
            }

            try {
                crypto.setInput(Base64.decode(crb));
            } catch (Base64DecoderException e1) {
                e1.printStackTrace();
            }

            try {
                crypto.Decipher();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (ShortBufferException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            contentWriter.setMimetype(“text/plain”);
            contentWriter.putContent((InputStream) (new ByteArrayInputStream(
                    crypto.getOutput())));

this.removeAspect(nodeRef);
this.addAspect(nodeRef);

        } else {
            if (logger.isDebugEnabled())
                logger.debug(this.getClass().getName()
                        + “: [contentReader is null]”);
        }
    }

    /**
    * Remove aspect Ciphered
    *
    * @param nodeRef
    */
    private void removeAspect(NodeRef nodeRef) {
        if (nodeService.hasAspect(nodeRef, AlfCryptoModel.ASPECT_CIPHERED)) {
            nodeService.removeAspect(nodeRef, AlfCryptoModel.ASPECT_CIPHERED);
        }
    }

    /**
    * Add aspect Deciphered
    *
    * @param nodeRef
    */
    private void addAspect(NodeRef nodeRef) {
        if (!nodeService.hasAspect(nodeRef, AlfCryptoModel.ASPECT_CIPHERED)) {
            nodeService
                    .addAspect(nodeRef, AlfCryptoModel.ASPECT_CIPHERED, null);
        }
    }

    /**
    * @param contentService
    */
    public void setContentService(ContentService contentService) {
        this.contentService = contentService;
    }

    /**
    * @param nodeService
    */
    public void setNodeService(NodeService nodeService) {
        this.nodeService = nodeService;
    }

    /**
    * @param password
    */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
    * @param algorithm
    */
    //
    // TODO Poder usar más algoritmos que AES
    //
    // public void setAlgorithm(String algorithm) {
    // this.algorithm = algorithm;
    // }
}

El siguiente paso es configurar y registrar las acciones en Alfresco:

Fichero: actions-context.xml

            true



                classpath:alfresco/extension/alfcrypto.properties




    <bean id="alfcrypto.cipher.action" class="com.fegor.alfresco.action.CipherContent"
        parent=”action-executer”>







        <!–

            ${alfviral.algorithm}

         –>

            ${alfviral.password}

    <bean id="alfcrypto.decipher.action" class="com.fegor.alfresco.action.DecipherContent"
        parent=”action-executer”>







        <!–

            ${alfviral.algorithm}

         –>

            ${alfviral.password}

Fichero: model-context.xml

                alfresco/module/alfcrypto/model/alfcryptoModel.xml




Fichero: webclient-context.xml

                alfresco.module.alfcrypto.messages.alfcrypto




   <bean id="alfcrypto.webclient.configBootstrap" class="org.alfresco.web.config.WebClientConfigBootstrap"
        init-method=”init”>


                classpath:alfresco/module/alfcrypto/ui/web-client-config-custom.xml

Fichero: web-client-config-custom.xml

Fichero: alfcrypto.properties (messages)
alfcrypto.cipher.action.title=Cifrar
alfcrypto.cipher.action.description=Cifrado del contenido

alfcrypto.decipher.action.title=Descifrar
alfcrypto.decipher.action.description=Descifrado del contenido

alfcrypto.label.ciphered=Cifrado
alfcrypto.label.deciphered=Descifrado

Y por último construir el fichero de configuración:

Fichero: alfcrypto.properties
# La elección de algoritmo (alfcrypto.algorithm) no está implementado todavía
alfcrypto.algorithm=AES
alfcrypto.password=estoesunaclavesecreta

A partir de aquí podemos utilizar el sistema para cifrar y descifrar, para ello podemos usar reglas para que el contenido en una carpeta sea cifrado, crear un workflow para descifrar el contenido de los documentos cifrados, etc.

Solo cifra el contenido, no las propiedades de los documentos.

Más sobre este tema:
http://es.wikipedia.org/wiki/Advanced_Encryption_Standard
http://en.wikipedia.org/wiki/Advanced_Encryption_Standard
http://wiki.alfresco.com/wiki/Data_Encryption
http://addons.alfresco.com/addons/alfresco-encryption-module

Actualización de Alfviral 1.2.1

Thursday October 25th, 2012

Debido a un “desliz” en mi código con la versión 1.2.0 se me olvidó declarar el servicio NodeService para usarlo en los modos COMMAND y INSTREAM por lo que he arreglado esto y algún que otro retoque más y he subido la versión 1.2.1 que os recomiendo que instaléis en lugar de la versión anterior.

Agradezco a Niccolò Pasquetto su aportación y aviso.

La nueva versión se puede descargar directamente desde:

https://alfviral.googlecode.com/files/fegorsoft-alfviral-1.2.1.zip

Como no sobrecargar form.get.head.ftl en Alfresco

Wednesday September 26th, 2012

En el blog de Michal Wróbel y su magnífico artículo “How to perform form field validation in Alfresco Share?” se explica la forma de usar los eventos para validaciones de campos en formulario de Alfresco Share. Lo hace sobreescribiendo la restricción obligatoria (mandatory constraint).

El problema viene cuando creamos un módulo para Alfresco Share con su fichero JAR correspondiente y lo instalamos en un Alfresco Share donde hay otro fichero form.get.head.ftl ya que el del JAR anulará al anterior con lo que no funcionarán las validaciones.

Para esto he decidido usar otra forma de tener cargado el fichero .js que necesitamos para las validaciones, por ejemplo form_validation_module.js dentro de nuestra instalación. La forma es usando la referencia a ficheros javascript de la configuración de los “forms” de forma que podamos tener y cargar los ficheros por cada módulo que tengamos sin tener que tocar el fichero original.

De esta forma, podremos tener el mismo fichero form_validation_module.js en la misma ubicación tomcat/webapps/share/components/form pero ahora lo referenciamos no en form.get.head.ftl sino dentro de nuestro fichero de configuración de los campos, por ejemplo module-form-config.xml de esta forma:


















                            <constraint type="mandatory"
                                validation-handler=”Alfresco.forms.validation.prueba”/>

Lo único que cambia del anterior método es que aquí no hace falta referenciar la parte ${page.url.context}/res y que hay que añadir “-min” al fichero si lo vamos a “compactar”.

De esta forma tendrémos más seguridad a la hora de desplegar distintos módulos para Alfresco Share donde haya otros ya instalados.

Alfviral versión 1.1.0

Monday September 3rd, 2012

Por fin el 21 de agosto liberé la versión 1.1.0 del módulo para escaneo de documentos mediante antivirus llamado Alfviral (el nombre a lo mejor no es muy apropiado pero fue el que se me ocurrió en ese momento).

Básicamente lo que se ha incluido ha sido una pequeña refactorización del código y la inclusión de la posibilidad de poder escanear los documentos mediante la página www.virustotal.com que a su vez utiliza más de 40 motores de antivirus.

Las características actuales del módulo son:

1. Escanear en base a tres modos distintos:

COMMAND: Permite utilizar un script o directamente el programa ejecutable del antivirus que se quiera siempre y cuando permita al menos un parámetro que sea el fichero a escanear. Este proceso depende del arranque del comando antivirus en si.

INSTREAM: Utilizado para lanzar un flujo de datos del fichero en Alfresco hacia el puerto (3310TCP) utilizado por ClamAV. Esto permite tener un antivirus ClamAV central en un servidor y utilizarlo remotamente desde Alfresco.

VIRUSTOTAL: En este modo se sube el fichero que sube o se actualiza en Alfresco a la web virustotal.com vía HTTP mediante el método POST y se recoge el resultado mediante JSON para su análisis.

2. Si el documento se detecta como infectado se añade el aspecto “infected” así como un aspecto adicional dependiendo del método utilizado para su análisis.

3. Uso de las “policies” de Alfresco usando los métodos onContentUpdate y onContentRead para analizar los documentos que son subidos, modificados y/o leídos.

4. Se puede utilizar el análisis mediante una programación de tiempo indicando a partir de qué espacio se quiere analizar y si se utiliza en profundidad, es decir, a los subespacios.

5. Implemena acciones de usuario tanto en la interface /alfresco como en /share para poder analizar documentos de forma interactiva.

6. Uso de reglas para personalizar los análisis utilizando la acción de escanear.

7. Facilidad de instalación utilizando las Alfresco Module Management Tools para la parte de repositorio y copiando directamente una librería en extension/lib para Share.

8. Configuración flexible y sencilla para establecer el modo de análisis y las formas en las que se quiere realizar el análisis:

– Al subir/modificar un documento
– Al leer un documento
– En una programación horaria y/o de fecha concreta
– Desde una carpeta (espacio de trabajo) en adelante

Un ejemplo de configuración es:

# Command to exec, i.e. clamscan, alfviral.sh, etc.
alfviral.command=C:\Users\fegor\Documents\alfviral.bat
# Config for ClamAV in stream data
alfviral.timeout=30000
alfviral.host=127.0.0.1
alfviral.port=3310
#Config for VIRUSTOTAL
vt.key=246df658bca5e096895683c01ba4bd2eb3a00303b506bda774b71488134bf984
vt.url=https://www.virustotal.com/vtapi/v2/file/scan
# Modes: COMMAND, INSTREAM, VIRUSTOTAL
alfviral.mode=VIRUSTOTAL
# Events
alfviral.on_update=TRUE
alfviral.on_read=FALSE
# Scheduled action
alfviral.scheduled.pathQuery=/app:company_home/st:sites
alfviral.scheduled.cronExpression=* * 3 * * ? 2099

Toda la información tanto en español como en inglés está en la página principal del proyecto: http://code.google.com/p/alfviral/

Como es un proyecto libre y personal las mejoras y nuevas funcionalidades dependen mucho de mi tiempo libre pero más o menos algunas ideas que tengo en mente son:

– Añadir estadísticas sobre los documentos infectados
– Posibilidad de mover los documentos infectados a un espacio de cuarentena
– Recuperación de los documentos infectados a su ubicación original si son desinfectados o se eliminan los aspectos de infección.
– Añadir nuevos protocolos de comunicación con antivirus (Symantec, McAfee,…)
– Poder utilizar distintos modos de análisis al mismo tiempo y para diferentes objetos (espacios y ficheros)

Problemas en la previsualización de documentos PDF en Alfresco

Thursday May 10th, 2012

Primer problema:

En ocasiones los ficheros PDF no pueden ser visualizados por el Share de Alfresco. Esto puede ser debido a que si el PDF tiene activas las restricciones de impresión y/o copia, la librería SWFTools y en concreto la utilidad pdf2swf no es capaz de transformar el fichero.

Para estar seguros de que es este el problema, podemos llamar directamente a la utilidad con el fichero PDF y comprobar el resultado:

pdf2swf prueba.pdf -o prueba.swf

Si el mensaje que devuelve es “FATAL PDF disallows copying” entonces estamos ante este problema.

La forma de solucionarlo es recompilar SWFTools y de esta forma evitamos el aviso y podremos ver los documentos.

Las siguientes instrucciones son para la compilación bajo Linux:

Bajamos el paquete de código fuente de las SWFTools (p.e. la versión 0.9.2 está probada en la versión 3.4.8 de Alfresco funcionando perfectamente), lo descomprimimos y entramos en el directorio creado.

En lib/pdf/pdf.cc comentamos las dos líneas siguientes:

if(!pi->config_print && pi->nocopy) {msg(” PDF disallows copying”);exit(0);}
if(pi->config_print && pi->noprint) {msg(” PDF disallows printing”);exit(0);}}

Configuramos de forma estática para que podamos llevarlo a otras distribuciones de Linux (yo la he probado en Ubuntu 11.10):

CC=/usr/bin/gcc-4.6 CXX=/usr/bin/g++-4.6 LDFLAGS=”-static” ./configure

Seguramente tengamos que instalar los paquetes para desarrollo como es el g++ y el gcc.

Luego:

make

Y por último:

make install

O bien, simplemente sustituimos la utilidad pdf2swf que es la que se utiliza. Ya podremos ver los PDF bloqueados normalmente.

Segundo problema:

Otro problema que encontramos es que en la versión 3.4.x y 4.x los PDF se ven borrosos en la previsualización, esto es debido a los modificadores establecidos para realizar la conversión a SWF que pone Alfresco.

Para solucionarla tendremos que modificar el fichero webapps/alfresco/WEB-INF/classes/alfresco/subsystems/thirdparty/default/swf-transform.properties que generalmente tiene la siguiente línea:

swf.encoder.params=-s zoom=72 -s ppmsubpixels=1 -s poly2bitmap=1 -s bitmapfonts=1

Por esta otra (por ejemplo):

swf.encoder.params=-s zoom=100 -s ppmsubpixels=1 -s poly2bitmap=1 -s bitmapfonts=1

De esta forma se verán correctamente, eso si, el tiempo de conversión será mayor.

ACTUALIZACIÓN (12/07/2012): Aunque para compilar SWFTools se puede usar la información de los enlaces que doy al final, para Ubuntu 11 (y probado en la 12) tanto para amd64 como i386 se pueden seguir la siguiente secuencia de comandos de forma rápida:

sudo apt-get install build-essential checkinstall
sudo chown $USER /usr/local/src
sudo chmod u+rwx /usr/local/src
sudo apt-get install libgif-dev xpdf libfreetype6 libfreetype6-dev libjpeg62 libjpeg8 libjpeg8-dev
sudo wget http://www.swftools.org/swftools-0.9.1.tar.gz
cd lib/pdf
sudo wget http://gd.tuwien.ac.at/publishing/xpdf/xpdf-3.02.tar.gz
./configure make
 sudo checkinstall

Fuentes:
http://monkiki.wordpress.com/2010/04/19/compilar-pdf2swf-con-soporte-para-pdf-protegidos/
http://loftux.com/2012/01/08/replace-alfresco-standard-flash-viewer-with-pdf-js/
http://www.vservu.com/_blog/MegaZine3_-_tips,_tricks_and_hints/post/pdf2swf-switches/
http://www.swftools.org/
https://designbye.wordpress.com/2010/02/23/installing-swftools-and-pdf2swf-on-ubuntu-linux/
http://ubuntuforums.org/showthread.php?t=1821521

Enviar documentos a Alfresco de forma desantendida

Tuesday April 17th, 2012

En ocasiones necesitamos enviar a Alfresco documentos que han sido escaneados o generados por otras aplicaciones de forma automatizada.

La forma más común de “inyectar” documentos a Alfresco es mediante el uso del protocolo CIFS, de forma que podemos usar una unidad de red o recurso compartido (según el sistema operativo utilizado) para guardar el documento directamente en el entorno de Alfresco.

En ocasiones, bien porque el producto está limitado a usar unidades de red, o bien, porque necesitamos que los ficheros generados se envíen de alguna forma u orden y a una hora o espacio de tiempo determinado, hay que usar sistemas de copia o de movimiento de ficheros de forma desatendida.

En este caso, se ha utilizado un sistema utilizando el producto DigiDocFlow (http://www.digidocflow.com/) que en lugar de guardar el documento escaneado y el correspondiente fichero XML con los valores de los metadatos en el recurso de red del servidor donde está instalado Alfresco, se ha utilizado un directorio local de la máquina donde está instalado el producto (en Windows XP) y mediante un proceso batch se copian cada minuto a una unidad compartida de red que hace referencia a una carpeta de Alfresco llamada FROMSCAN.

Los pasos han sido:

1. Crear una carpeta en Company Home de Alfresco llamada FROMSCAN. Esta llevará las reglas necesarias para mover los documentos que entran.

2. Crear una carpeta local en Windows XP donde está instalado DigiDocFlow llamada también FROMSCAN.

3. Escribir el siguiente fichero batch:

@ECHO OFF

SET CARPETAWIN=C:FROMSCAN

SET CARPETAALF=Y:FROMSCAN

COPY /Y “%CARPETAWIN%*.pdf” “%CARPETAALF%”

COPY /Y “%CARPETAWIN%*.xml” “%CARPETAALF%”

IF ERRORLEVEL 1 GOTO SALIR

DEL /F /Q “%CARPETAWIN%*.*”

:SALIR

4. Crear la tarea (ejecutar en intérprete de comandos en Windows XP llamado CMD.EXE) para que se realice (ejecute) el batch cada hora:

SCHTASKS /CREATE /TN FROMSCAN /TR “CMD /C “C:FROMSCAN.BAT”” /SC HOURLY

Hay que tener en cuenta “escapar” las comillas con para que no se produzcan errores, no en este caso, pero si, si en el directorio o nombre de fichero batch se contienen caracteres en blanco.

De esta forma podemos tener incluso un directorio local donde van a parar ficheros que provienen de un ERP, un CRM o un sistema de escaneo como Kofax o DigiDocFlow sin tener que usar ningún tipo de conector y personalizando tanto el tiempo de envío de los ficheros como el orden.

Webinar de Alfresco en una hora

Friday January 27th, 2012

Hace unos meses hice un webinar conjunto con Toni de la Fuente (Alfresco) y la empresa para la que actualmente trabajo Ricoh España. Finalmente se ha publicado como vídeo y aquí está:

El enlace es: http://vimeo.com/35619313

[vimeo http://www.vimeo.com/35619313 w=400&h=267]
Alfresco en una hora con Ricoh from Alfresco Spain Portugal on Vimeo.

Instalar WQS y AWE en WebSphere 7

Monday October 10th, 2011

Pasos para incluir en el fichero .ear de Alfresco 3.4.x Enterprise el módulo Web Quick Start y Alfresco Web Editor para su instalación en WebSphere Application Server.

1. Bajar Web Quick Start (zip bundle)

alfresco-enterprise-wcmqs-3.4.4.zip

2. Desempaquetar el fichero EAR

mkdir alfresco-enterprise-3.4.3.3-WQS

cd alfresco-enterprise-3.4.3.3-WQS

jar -xvf ../alfresco-enterprise-3.4.3.3.ear

3. Desempaquetar el fichero que contiene WQS

jar -xvf ../alfresco-enterprise-wcmqs-3.4.3.zip

4. Desempaquetar el fichero que contiene el Alfresco Web Editor

jar -xvf ../alfresco-enterprise-webeditor-3.4.3.zip

5. Instalar paquetes AMP en Alfresco y Share

java -jar ../alfresco-mmt-3.3.5.jar install alfresco-enterprise-wcmqs-3.4.3.amp alfresco.war -verbose

java -jar ../alfresco-mmt-3.3.5.jar install alfresco-enterprise-wcmqs-share-3.4.3.amp share.war -verbose

6. Editar application.xml de META-INF y añadir los nuevos WAR

Alfresco

alfresco.war

/alfresco

share.war

/share

wcmqs.war

/wcmqs

awe.war

/awe

customer.war

/customer

7. Empaquetar como EAR todos los ficheros WAR

jar cvf alfresco-enterprise-3.4.3.3-WQS.ear *.war

8. Mover los ficheros jar a una ubicación para compartirla en WAS

mkdir -p /opt/IBM/WebSphere/AppServer/lib/awe

mv *.jar /opt/IBM/WebSphere/AppServer/lib/awe

9. Mover los ficheros xml al “extension” de configuración y añadir lo siguiente para la conexión.
mv awe-config-custom.xml /opt/alf343WAS7_shared_cluster/web-extension
vi /opt/alf343WAS7_shared_cluster/web-extension/awe-config-custom.xml
(incluir lo siguiente):

            alfresco
            Alfresco – user access
            Access to Alfresco Repository WebScripts that require user authentication
            alfresco
            http://localhost:9080/alfresco/s

            user



…

10. En WebSphere, crear una biblioteca compartida para los ficheros y asignarla a la aplicación AWE.

11. Actualizar aplicación desde el Manager de WAS 7 usando el fichero ear creado e iniciar Alfresco ECM.

12. Copiar el fichero de propiedades de wcmqs al extension y modificarlo si es necesario.
cp ../installedApps/alfpru1Cell01/Alfresco.ear/wcmqs.war/WEB-INF/classes/alfresco/extension/wqsapi-custom.properties /opt/alf343WAS7_shared_cluster/extension/

vi /opt/alf343WAS7_shared_cluster/extension/wqsapi-custom.properties

(contenido del fichero)

wcmqs.api.alfresco=http://localhost:9080/alfresco
wcmqs.api.user=admin
wcmqs.api.password=admin

Datos sobre la instalación:
Alfresco 3.4.3 en clúster sobre WebSphere 7
Directorio de instalación: /opt/IBM/WebSphere
Directorio de configuración (vía NFS): /opt/alf343WAS7_share_cluster
Directorio del repositorio (vía NFS): /opt/alf343WAS7_repo_cluster
Directorio de índices: /opt/alf343WAS7_index_cluster

Para más información, ir a la documentación oficial de Alfresco (http://docs.alfresco.com) y a la wiki (http://wiki.alfresco.com).

Quiero agradecer la ayuda y consejos de Mikel Asla, experto en sistemas, Alfresco y WebSphere.

Fegor’s blog

A very humanistic computer scientist