COMO INSERTAR VARIOS DOCUMENTOS CON MULTITHREAD(SOLUCIONADO)

[fertuki]

BUENAS, ESTOY CREANDO UNA SERIE DE CLASES QUE ME PERMITAN REALIZAR VARIOS TRABAJOS EN ALFRESCO.
UNA DE ESTAS ES LA DE SUBIDA DE DOCUMENTOS A ALFRESCO.
LA CUESTION QUE PLANTEO ES SI SE PUEDE EJECUTAR UNA SUBIDA MASIVA DE DOCUMENTOS VIA WEBSERVICES.
ESTE ES UN PROBLEMA AL QUE DE MOMENTO NO HE ENCONTRADO SOLUCIÓN.

EN PRINCIPIO EL METODO QUE SE EJECUTA PARA SUBIR EL DOCUMENTO HACE LO SIGUIENTE:

1.- SE COMPRUEBA LA EXISTENCIA DEL DOCUMENTO REALIZANDO UNA BUSQUEDA. SI EXISTE SE PARA LA EJECUCION, SI NO SE PASA AL PASO 2,
2.- SE EJECUTA LA SUBIDA DEL FICHERO MEDIANTE WEBDAV,
3.- SE CREA UNA REFERENCIA AL DOCUMENTO Y SE EJECUTA UNA ACCIÓN QUE CAMBIA ELTIPO DE DOCUMENTO POR UNO ESPECIFICO PASADO POR PARAMETROS, Y
4.- SE ACUTALIZAN LOS METADATOS DEL DOCUMENTO AÑADIENDO UN ASPECTO DETERMINADO SEGÚN EL TIPO DE DOCUMENTO QUE SE HA ASIGNADO AL DOCUMENTO.

LA IDEA ES SIMPLE, EN REALIDAD TODO VA BIEN CUANDO SUBO DE UNO EN UNO. EL PROBLEMA ES QUE SI QUIERO LLAMAR ASINCRONAMENTE AL METODO PARA QUE SUBA MAS DE UN FICHERO A LA VEZ ME DA ERRORES DE TICKET Y CALLBACKS.

SI ALGUIEN TIENE ALGUNA IDEA AGRADECERIA LA COLABORACIÓN.

GRACIAS DE ANTEMANO, UN SALUDO

[venzia]

Habria que echarle un vistazo a dichas clases .. me da que de alguna forma pierdes el contexto o la sesion en mitad del proceso.
A ver si nos puedes facilitar mas informacion.
Saludos,

[fertuki]

Buenas, ante todo gracias por el interes que muestras tan rápidamente.
Te pongo los codigos, son un poco extensos, pero espero que te sirvan:

1.- SUBIDA DE DOCUMENTOS:

public class SubirDocServiceSkeleton {
    public Store storeRef;
    public String puntoCodigo;
    AuthenticationUtils atu;
    private AuthenticationDetails autDet;
    private String[] usupass;
    private alfrescoHelper alfhelp;
    private String alfEnp;
    private String alfEnpDavUp;
    private String app;
    private String procedimiento;
    private String campana;
    private String mes;
    private String exp;
    private String doc;
    private String nombreFicDav;
    private String prefix;
    private String tipo;
    private String modelo;

    public synchronized juntadeandalucia.cap.alfws.alfrescotype._1._0.PeticionSubidaReturnType procesarSubida(
            juntadeandalucia.cap.alfws.alfrescotype._1._0.PeticionSubidaType peticionSubidaType) {
        app = peticionSubidaType.getApp();
        tipo = peticionSubidaType.getTipo();
        modelo = peticionSubidaType.getModelo();
        prefix = peticionSubidaType.getPrefix();
        procedimiento = peticionSubidaType.getProcedimiento();
        campana = peticionSubidaType.getCampana();
        mes = peticionSubidaType.getMes();
        exp = peticionSubidaType.getExp();
        doc = peticionSubidaType.getDoc();
        nombreFicDav = peticionSubidaType.getNombreFicDav();
        PeticionSubidaReturnType respuesta = new PeticionSubidaReturnType();
        this.alfhelp = new alfrescoHelper();        
        String respHelp = this.alfhelp.conectarAlfresco(app);
        this.storeRef = this.alfhelp.getStoreRef();
        this.usupass = this.alfhelp.getUsuPassAlf();

        //Se comprueba el usuario tiene permisos para gestionar en alfresco.
        puntoCodigo = "método procesaSubida. Comprobación aplicación usuaria";
        if (respHelp.equals("OK")){
            puntoCodigo = "método procesaSubida. Comprobación aplicación usuaria correcta";
            //0.-
            /******************************************************************************************
            // Se comprueba la existencia del documento que se quiere subir.
             * Si existe se mandara un mensaje al usuario advirtiendolo y se parara la ejecución.
             * Se comprueba si existe la estructura de espacios que se necesita para
             * guardar el documento a subir.
             * Si no existe la estructura, se creará.
             */

            // 0.1.- Primero comprobamos la existencia del documento
            puntoCodigo = "metodo procesarSubida. Apartado 0.1";
            PeticionListaType plt = new PeticionListaType();
            plt.setApp(app);
            plt.setModelo(modelo);
            plt.setPrefix(prefix);
            plt.setTipoDoc(tipo);
            plt.setProcedimiento(procedimiento);
            plt.setCampana(campana);
            plt.setMes(mes);
            plt.setExpediente(exp);
            plt.setDocumento(doc);
            plt.setParametros(peticionSubidaType.getParametros());
            Documento[] docs = new ListaDocsServiceSkeleton().ejecutaBusqueda(plt, false,this.alfhelp).getDocArray();
            if (!Arrays.equals(docs, null)) {
                for (int i = 0; i < docs.length; i++) {
                    String ret;
                    ret = "El documento que intenta insertar ya existe en el repositorio: \n";
                    ret = ret + "   ID del nodo donde esta el Documento " + (i + 1) + " \n" + "      " + docs[i].getIdAlfresco() + " \n";
                    ret = ret + "   Ruta fisica del nodo donde está el documento " + (i + 1) + " \n" + "      " + docs[i].getRuta() + " \n";
                    ret = ret + "   Nombre del documento " + (i + 1) + " \n" + "      " + docs[i].getNombre();
                    respuesta.setRespuestaSubida(ret);
                    this.alfhelp.desconectarAlfresco();
                    return respuesta;
                }
            }

            // 0.2.- Si el procedimiento insertado pertenece a la aplicacion usuaria
            puntoCodigo = "metodo procesarSubida. Apartado 0.2";
            if (this.alfhelp.checkProced(app, procedimiento)) {
                puntoCodigo = "metodo procesarSubida. Apartado 0.2. El procedimiento " + procedimiento + "  pertenece a la sistema " + app;
            } else {
                puntoCodigo = "metodo procesarSubida. Apartado 0.2. El procedimiento " + procedimiento + "  NO pertenece a la sistema " + app;
                try {
                    throw new Exception("El procedimiento " + procedimiento + " no corresponde al sistema " + app);             
                } catch (Exception ex) {
                    Logger.getLogger(SubirDocServiceSkeleton.class.getName()).log(Level.SEVERE, null, puntoCodigo + "\n" + ex);
                    respuesta.setRespuestaSubida(puntoCodigo + "\n" + ex.getMessage());
                    return respuesta;
                }finally{
                    this.alfhelp.desconectarAlfresco();
                }
            }

            // 0.3.- Si el documento no existe en el repositorio empezamos a comprobar los espacios
            puntoCodigo = "metodo procesarSubida. Apartado 0.3";
            String nodoDav = this.alfhelp.getOrgSisApp(app) + "/P_" + procedimiento + "/C_" + campana + "/M_" + mes + "/EXP_" + exp + "/" + doc;
            String rutaNodo = nodoDav.replaceAll("/", "/cm:");
            rutaNodo = "/app:company_home/cm:" + rutaNodo;
            String resultadoComprobacion = creacionEspacios(nodoDav,rutaNodo);
            if (resultadoComprobacion.equals("")){
            }else{
                respuesta.setRespuestaSubida(resultadoComprobacion);
                this.alfhelp.desconectarAlfresco();
                return respuesta;
            }
            // fin de la comprobacion de existencia de espacios
            /******************************************************************************************/
            try {
                String nombreDoc = nombreFicDav;
                nombreDoc = nombreDoc.replaceAll(" ", "_");
                
                
                
                //1.0.-PROPIEDADES ########################################################################
                /******************************************************************************************
                // Comprobamos que las propiedades pasadas por parametros coinciden con las necesarias para
                // el tipo de documento que queremos subir a Alfresco
                */
                puntoCodigo = "metodo procesarSubida. Apartado 1.0. Comprobación de las propiedades pasadas por parámetros";
                ListaPropDocServiceSkeleton lista = new ListaPropDocServiceSkeleton();
                PeticionPropType ppt = new PeticionPropType();
                ppt.setApp(app);
                ppt.setModelo(modelo);
                ppt.setPrefix(prefix);
                ppt.setTipo(tipo);
                lista.listaPropDoc(ppt,false,this.alfhelp);
                DescPropTipoDoc[] propiedadesTipoDoc = null;
                propiedadesTipoDoc = lista.getPropiedadesTipoDoc();
                Datos[] metad = peticionSubidaType.getParametros().getDatArray();
                boolean estaProp = false;
                boolean hayProp = false;
                if (metad.length > 0) {
                    hayProp = true;
                }
                for (int i = 0; i < metad.length; i++) {
                    String propiedadPasada = Constants.createQNameString(modelo, metad[i].getPropiedad());
                    estaProp = false;
                    for (int j = 0; j < propiedadesTipoDoc.length; j++) {
                        String propiedadModelo = propiedadesTipoDoc[j].getNombreProp();
                        if (propiedadModelo.equals(propiedadPasada)) {
                            estaProp = true;
                            break;
                        }
                    }
                    if (!estaProp) {
                        throw new Exception("La propiedad " + propiedadPasada + " no esta disponible para el tipo de documento " + tipo);
                    }
                }
                // fin de la comprobacion




                /******************************************************************************************/
                //2.0.- SUBIDA DEL DOCUMENTO ################################################################
                /******************************************************************************************/
                puntoCodigo = "metodo procesarSubida. Apartado 2.0. Llamada a ejecutaSubidaDav";
                /* Ejecutamos la subida del fichero */
                ejecutaSubidaDav(this.usupass[0], this.usupass[1], peticionSubidaType.getFichero(), nodoDav, nombreDoc, this.alfhelp.getEndpointAlfDav());
                /* Fin de la ejecución de la subida */

                //Creamos una referencia al documento que hemos subido
                Reference ref = new Reference(this.storeRef, null,/*refDoc*/ rutaNodo + "/cm:" + nombreDoc);




                /******************************************************************************************/
                //3.- EJECUCIÓN DE ACCIÓN PARA CAMBIO DE TIPO ########################################
                /******************************************************************************************/
                /*  Se ejecuta una accion para asignar el tipo de documento indicado por parametros al
                documento que se acaba de subir por WebDav.*/
                ejecutaAccion(ref);
                // Fin de la ejecución de la acción




                /******************************************************************************************/
                //4.- ASPECTO Y METADATOS CORRESPONDIENTES #############################################
                /******************************************************************************************/
                /* Se añaden la propiedades por medio de aspectos */
                ejecutaPropiedades(ref,metad);
                // Fin de la asignación de propiedades
                /******************************************************************************************/



                respuesta.setRespuestaSubida("Documento insertado en Alfresco con exito.");
                return respuesta;
            } catch (RepositoryFault ex) {
                Logger.getLogger(SubirDocServiceSkeleton.class.getName()).log(Level.SEVERE, null, puntoCodigo + "\n" + ex);
                ex.printStackTrace();
                respuesta.setRespuestaSubida(puntoCodigo + "\n" + "Error de repositorio.");
                return respuesta;
            } catch (RemoteException ex) {
                Logger.getLogger(SubirDocServiceSkeleton.class.getName()).log(Level.SEVERE, null, puntoCodigo + "\n" + ex);
                ex.printStackTrace();
                respuesta.setRespuestaSubida(puntoCodigo + "\n" + "Error de invocación remota.");
                return respuesta;
            } catch (IOException ex) {
                Logger.getLogger(SubirDocServiceSkeleton.class.getName()).log(Level.SEVERE, null, puntoCodigo + "\n" + ex);
                ex.printStackTrace();
                respuesta.setRespuestaSubida(puntoCodigo + "\n" + "Error en el Entrada/Salida.");
                return respuesta;
            } catch (Exception ex) {
                Logger.getLogger(SubirDocServiceSkeleton.class.getName()).log(Level.SEVERE, null, puntoCodigo + "\n" + ex);
                respuesta.setRespuestaSubida(puntoCodigo + "\n" + ex.getMessage());
                return respuesta;
            } finally {
                //finaliza sesion
                this.alfhelp.desconectarAlfresco();

            }

        } else {
            respuesta.setRespuestaSubida(respHelp + ". método procesaSubida. Comprobación aplicación usuaria incorrecta. \nNo tiene permiso para hacer gestiones en Alfresco");
            return respuesta;
        }
    }

    private synchronized String creacionEspacios(String nodoDav, String rutaNodo) {
        puntoCodigo = "metodo procesarSubida. Apartado 0.3";    
        // Función split para los espacios sin el prefijo cm:
        String[] nodos1 = nodoDav.split("/");
        String integerNoValido = this.alfhelp.checkAnnoMesExp(nodos1[3], nodos1[4], nodos1[5]);
        if (!integerNoValido.equals("")) {
          
            return "El valor que ha introducido para el espacio " + integerNoValido + " a la longitud adecuada";
        }        
        // Función split para lo espacios con el prefijo cm:
        String[] nodos2 = rutaNodo.split("/");
        // Por defecto estarán creados los nodos de sistema y procedimiento
        String nodoPpal = "/" + nodos2[1] + "/" + nodos2[2] + "/" + nodos2[3];

        // Compruebo los espacios a partir de la 3ª posicion de la cadena sin prefijos cm:.
        // Se comprueba a partir de la 3ª por que los dos primeros espacios corresponden a
        //      sistema/procedimiento que estarán creados por defecto.
        String nodoAComprobar = nodoPpal;
        for (int i = 2; i < nodos1.length; i++) {
                // Construyo la ruta que sera necesaria para crear la ParentReference y posteriormente
                // añado el nuevo subespacio a comprobar
                String nodoPadre = nodoAComprobar;
                nodoAComprobar = nodoAComprobar + "/cm:" + nodos1[i];
                if (this.alfhelp.checkSpace(nodoAComprobar/*, this.storeRef, this.alfEnp, this.autDet*/)) {
                    puntoCodigo = "metodo procesarSubida. Apartado 0.3. Comprobacion de espacios. Existe el espacio";
                //TODO para posible uso futuro. Comprobar que existe el fichero
                //en la misma ruta donde estamos intentando subir y ejecutar las
                //acciones que se describan
                    /*if (i == nodos1.length -1){
                //alfHelp.checkSpace(nodoAComprobar + "/cm:" + nombreFicDav , storeRef, alfEnp, autDet);
                }*/
                } else {
                    puntoCodigo = "metodo procesarSubida. Apartado 0.3. Comprobacion de espacios. No existe el espacio";
                    try {
                        // Crear la referencia al padre del espacio a crear
                        ParentReference parentReference = new ParentReference(this.storeRef, null, nodoPadre, Constants.ASSOC_CONTAINS, Constants.createQNameString(Constants.NAMESPACE_CONTENT_MODEL, nodos1[i]));
                        // Crear el espacio
                        NamedValue[] properties = new NamedValue[]{Utils.createNamedValue(Constants.PROP_NAME, nodos1[i])};
                        CMLCreate create = new CMLCreate("1", parentReference, null, null, null, Constants.TYPE_FOLDER, properties);
                        CML cml = new CML();
                        cml.setCreate(new CMLCreate[]{create});
                        WebServiceFactory.getRepositoryService().update(cml);
                    } catch (RemoteException ex) {
                        Logger.getLogger(SubirDocServiceSkeleton.class.getName()).log(Level.SEVERE, null, puntoCodigo + "\n" + ex);                        
                        return "No se ha podido crear la carpeta…";
                    }
                }
            }        
        return "";
    }

    private synchronized void ejecutaAccion(Reference ref){
        try {
            puntoCodigo = "metodo procesarSubida. Apartado 3.0. Ejecución de la acción para asignar el tipo de documento";
            Predicate pred = new Predicate(new Reference[]{ref}, ref.getStore(), null);
            Action[] ac1 = new Action[1];
            ac1[0] = new Action();
            ac1[0].setActionReference(ref);
            ac1[0].setActionName("specialise-type");
            NamedValue[] matriz = new NamedValue[1];
            matriz[0] = Utils.createNamedValue("type-name", Constants.createQNameString(modelo, tipo));
            ac1[0].setParameters(matriz);
            WebServiceFactory.getActionService().executeActions(pred, ac1);
        } catch (RemoteException ex) {
            Logger.getLogger(SubirDocServiceSkeleton.class.getName()).log(Level.SEVERE, null, ex);
        } 
    }

    private synchronized void ejecutaPropiedades(Reference ref, Datos[] metadatos) {
            puntoCodigo = "metodo procesarSubida. Apartado 4.0. Añadiendo los metadatos al documento";
            Predicate predicate = new Predicate(new Reference[]{ref}, null, null);
            NamedValue[] propiedades = new NamedValue[metadatos.length];
            for (int i = 0; i < metadatos.length; i++) {
                propiedades[i] = Utils.createNamedValue(Constants.createQNameString(modelo, metadatos[i].getPropiedad()), metadatos[i].getValor());
            }
            puntoCodigo = "metodo procesarSubida. Apartado 4.0. Creando el objeto de adición de aspecto";
            CMLAddAspect asp = new CMLAddAspect(Constants.createQNameString(modelo, metadatos[0].getGrupo()), propiedades, predicate, "");
            // Construct CML Block
            CML cml = new CML();
            cml.setAddAspect(new CMLAddAspect[]{asp});
            // Executamos el CML Block
            puntoCodigo = "metodo procesarSubida. Apartado 4.0. Ejecución de la actualizacion de propiedades";
        try {
            WebServiceFactory.getRepositoryService().update(cml);
        } catch (RemoteException ex) {
            Logger.getLogger(SubirDocServiceSkeleton.class.getName()).log(Level.SEVERE, null, ex);
        } 

    }


    /**
     * Subida de un fichero a la ruta especificada
     * <p>
     * @param usu. Usuario para el recurso webdav
     * @param pass. Password para el recurso webdav
     * @param ficheroURL. Ruta del fichero en local.
     * @param nodo. Es la ruta donde se subira el fichero en el repositorio de Alfresco
     * @param nomFic. El nombre que recibirá el documento en Alfresco
     * @param endP. El endpoint de Webdav para Alfresco (http://servidor:puerto/alfresco/webdav/).
     */
    private synchronized void ejecutaSubidaDav(String usu, String pass, DataHandler ficheroURL, String nodo, String nomFic, String endP) {
        puntoCodigo = "metodo ejecutaSubidaDav.";

        try {
            nomFic = nomFic.replaceAll(" ", "_");

            String rutaPut = endP + "/" + nodo + "/" + nomFic; //+ "?ticket=" + this.alfhelp.getAutDet().getTicket();
            // Escribe el contenido
            HttpClient client = new HttpClient();
            Credentials creds = new UsernamePasswordCredentials(usu, pass);
            client.getState().setCredentials(AuthScope.ANY, creds);
            PutMethod method = new PutMethod(rutaPut);
            RequestEntity requestEntity = new InputStreamRequestEntity(ficheroURL.getInputStream()/*bis*/);
            method.setRequestEntity(requestEntity);
            puntoCodigo = "metodo ejecutaSubidaDav. Llamada executeMethod de PutMethod webDav";
            client.executeMethod(method);

            System.out.println(method.getStatusCode() + " " + method.getStatusText());

        } catch (HttpException ex) {
            Logger.getLogger(SubirDocServiceSkeleton.class.getName()).log(Level.SEVERE, null, puntoCodigo + "\n" + ex);
            ex.printStackTrace();
        } catch (FileNotFoundException ex) {
            Logger.getLogger(SubirDocServiceSkeleton.class.getName()).log(Level.SEVERE, null, puntoCodigo + "\n" + ex);
            ex.printStackTrace();
        } catch (IOException ex) {
            Logger.getLogger(SubirDocServiceSkeleton.class.getName()).log(Level.SEVERE, null, puntoCodigo + "\n" + ex);
            ex.printStackTrace();
        } finally {
            puntoCodigo = "metodo ejecutaSubidaDav. Bloque finaly de la subida";
        }

    }
}‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

2.- PARTE DE ALFRESCOHELPER PARA LA CONEXION Y DESCONEXION:

/**
 *
 * @author fastolfi
 */
public class alfrescoHelper {

    private static ResourceBundle rb = ResourceBundle.getBundle("utilAlf.conexApps");
    private AuthenticationDetails autDet;
    private Store storeRef;
    private AuthenticationUtils atu;
    private AuthenticationServiceLocator asl;
    private AuthenticationServiceSoapBindingStub autser;
    private AuthenticationResult autres;

    private String puntoCodigo;
    private String[] usupass;
    private String alfEnp;


    public alfrescoHelper() {
    }


    @SuppressWarnings("static-access")
    private synchronized void autenticarAlfresco(String user, String pass, String endP, int accion) {
        puntoCodigo = "metodo autenticarAlfresco en alfrescoHelper";
        if (accion == 1) {
            try {
                WebServiceFactory.setEndpointAddress(endP);
                atu = new AuthenticationUtils();
                atu.startSession(user, pass);
                autDet = atu.getAuthenticationDetails();
                System.out.println("ID de SESION: " + autDet.getSessionId());
                System.out.println("    Ticket de Sesion " + autDet.getTicket());
                storeRef = new Store(Constants.WORKSPACE_STORE, "SpacesStore");
            } catch (AuthenticationFault ex) {
                Logger.getLogger(alfrescoHelper.class.getName()).log(Level.SEVERE, null, puntoCodigo + "\n" + ex);
                System.out.println("Error al auntenticar en el modulo de subida en " + puntoCodigo);
                ex.printStackTrace();
            }
        } else {
            System.out.println("Terminando sesion con ID: " + autDet.getTicket());
            atu.endSession();
        }

    }

    @SuppressWarnings("static-access")
    public synchronized String conectarAlfresco(String app)  {
        if (compruebaAppUsuaria(app)) {
            usupass = getUsuPassAlf();
            alfEnp = getEndpointAlf();
            autenticarAlfresco(usupass[0], usupass[1], alfEnp, 1);
            return "OK";
        } else {
            return "KO. Aplicacion no permitida";
        }
    }

    public synchronized void desconectarAlfresco() {
        autenticarAlfresco(null, null, null, 2);
    }
}
‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

A la vista de lo que he puesto a mi me parece que el error esta en que el primer hilo que termina cierra la sesion con alfresco.
Asi pues los demas no pueden seguir realizando sus tareas. Lo que no entiendo es que si yo le digo a cada hilo que establezca una nueva conexión, ¿porque no pueden seguir si cada uno tiene la suya?.
Creo que mi problema esta en que no entiendo bien la gestion de sesiones y tickets de alfresco. Si es así quisiera algo de información, sino, espero que puedas darme una solución.

Un saludo y gracias de nuevo

[venzia]

Lo que no entiendo es que si yo le digo a cada hilo que establezca una nueva conexión, ¿porque no pueden seguir si cada uno tiene la suya?.
Creo que mi problema esta en que no entiendo bien la gestion de sesiones y tickets de alfresco.

Porque cuando otro hilo va a realizar la operación, la sesión quedó deshabilitada para ese usuario al terminar el primero. Lo ideal es que realices una sola autenticacion y la utilices para todos los hilos. Una vez realizada la operacion de "vuelco masivo" cierras sesión.
Por otro lado no me parece lo más adecuado subir los documento por webdav y luego añadir las propiedades, puede hacerse todo de una vez atacando al propio repositorio JCR (supongo que le verias alguna complejidad para tirar por webdav). Lo malo que no tengo ejemplos a mano para poder guiarte.
A ver si saco tiempo para echarle un vistazo a tu código y puedo decirte algo más específico (no obstante entiendo que tu conoces mejor como funciona para realizar los cambios que te sugiero :mrgreen.
Saludos y suerte!

[fertuki]

Muchas gracias de nuevo Javier.
Tu idea me parece logica. La verdad es que estoy un poco verde con respecto a multihilo, asi que la cuestion es, ¿como consigo detectar si queda algún hilo en ejecución?.

Con respecto a la subida por WebDav y luego la asignacion de propiedades hay un par de cuestiones.

1.- Lo hice por WebDav por que me encontraba con limitación a la hora de subir ficheros de gran tamaño mediante webservice, y
2.- Tuve que establecer las propiedades despues porque no encontré forma de subirlo por WebDav y a la vez asignarle el tipo y las propiedades. En fin, en programacion cuando las cosas funcionan con presión, ya sabemos todos que hay que buscar soluciones alternativas para ir mejorandolas poco a poco.

Asi pues, espero que me puedas ayudar con este asunto. Te reservo el punto hasta entonces…

Gracias de nuevo y un saludo.

[venzia]

¿como consigo detectar si queda algún hilo en ejecución?

ese es el quid de la cuestión, siento no poder ayudarte en estos momentos ya que entre mi poca experiencia al respecto (tengo compis que son verdaderos gurús en J2EE) y el tiempo del que dispongo poco puedo aportar.

1.- Lo hice por WebDav por que me encontraba con limitación a la hora de subir ficheros de gran tamaño mediante webservice, y
2.- Tuve que establecer las propiedades despues porque no encontré forma de subirlo por WebDav y a la vez asignarle el tipo y las propiedades. En fin, en programacion cuando las cosas funcionan con presión, ya sabemos todos que hay que buscar soluciones alternativas para ir mejorandolas poco a poco.

Algo escuche en su momento del tema de problemas con ficheros "grandes" desde webservices, así que, tu planteamiento me parece correcto a priori ( y como dices, bajo presion hay menos margen para hacer las cosas como a todos nos gustaría ).
Lo mismo en unos dias tengo tiempo y me gano ese puntito con propiedad (aunque te digo .. que por esas no me tientas jeje )
Saludos y suerte!

[fertuki]

Ok, no te preocupes… sigo investigando, aunque si tienes ese ratillo y se te ocurre la idea feliz soy todo oidos (vista en este caso).

Lo del puntito no era un aliciente, lo puse porque con la categoria de gurú y por lo que he estado mirando en el foro seguro que lo mereces. :wink:

Un saludo

[fertuki]

Buenas de nuevo. Siento no haber actualizado este hilo antes, pero he estado bastante liado y… en fin, que voy a intentar dar porfin algo de luz.

En principio cuando cree este hilo era para averiguar como se podia hacer la subida de varios ficheros a la vez con multihilo. Ahora que ya le he dado varias vueltas de tuerca voy a explicar el planteamiento actual de mi aplicativo.

En teoria no debe haber problema para subir varios ficheros a la vez. Mi problema venía porque lo que yo estoy generando son una serie de webservices alojados en un axis2 que a su vez llaman a los webservices de alfresco, con lo cual añado una capa más de gestión. Asi pués toda tercera aplicación que quiera subir un fichero o varios a Alfresco tendrá que hacerlo a través de mi webService intermedio(que se encarga de interactuar con los webservices de alfreco).

Después de mucho estrujarme el cerebro porque para mi tanto java, como alfresco y los webservices eran tecnologias nuevas, llegue al punto en el que funcionaba todo correctamente cuando generaba los stubs del cliente para poder llamar de forma asíncrona a mi webservice de subida.

Una vez en este punto me encontre con el problema de que me fallaba la subida aleatoriamente (a veces si y a veces no) y cuando los ficheros excedian un tamaño. Me di cuenta de que cuando subia ficheros la memoria Java del proceso de servidor que estaba ejecutando axis2 subia astronomicamente. Esto producía que el servidor se colapsara. Entonces después de un tiempo de lectura de documentación de axis2 vi que existen una serie de parámetros de configuracion en el fichero axis2.xml que permite definir una carpeta para cachear los ficheros que se esten mandando por SOAP. Esto libera a java de tener en memoria toda la información que se este enviando(imaginemos por ejemplo 3 ficheros de 300Mb cada uno). Este fichero permite definir para esto una serie de etiquetas que configuran la función de cacheo:

        

         <!–activacion de la funcion de cacheo de adjuntos–>
         <parameter name="cacheAttachments">true</parameter>
         <!–directorio donde se encuentra la carpeta para los ficheros que se esten cacheando–>
         <parameter name="attachmentDIR">..\webapps\axis2\WEB-INF\cache</parameter>
         <!–tamaño en bytes por fichero que permitira axis2 que se suba sin cacheo–>
         <parameter name="sizeThreshold">4000</parameter>
‍‍‍‍‍‍‍‍

Así pues, configurando estos parametros y usando llamadas asíncronas al webservice mediante callbacks mi cliente de prueba ya funciona correctamente de momento.

Espero que esto pueda servir a alguien, aunque entiendo que mi caso es concreto.

Un saludo a todos los que habeis mirado este hilo en algún momento.

[cluizaga]

Buenas ..

Una consulta yo ingrese los documentops  por FTP esto al parecer es permitido ya que luego el contenido es indexado normalmente (probando con una busqueda por ejemplo)