Buscar en el Blog

Mostrando entradas con la etiqueta Mule. Mostrar todas las entradas
Mostrando entradas con la etiqueta Mule. Mostrar todas las entradas

viernes, 2 de agosto de 2013

Cómo generar un TestCase de Mule

Para generar un Test Case de Mule para un proyecto creado a través de un arquetipo de Maven se tiene que realizar lo siguiente:

1) Asegurarnos que en el pom.xml se encuentra la dependencia de JUnit

<dependency>
 <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.9</version>
    <scope>test</scope>
</dependency>

2) Crear una clase en el directorio src/test/java como la siguiente:

package com.blogspot.ingmmurillo.mule.test;

import org.junit.Test;
import org.mule.tck.junit4.FunctionalTestCase;

public class MuleAppFlowTest extends FunctionalTestCase {
    
    @Override
    protected String getConfigResources() {
        return "src/main/app/mule-config.xml";
    }

    @Test
    public void test() {
        try {
            Thread.sleep(4800000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


3) Ejecutar o hacer debug sobre la clase. Con ésta clase se ejecutará el flujo de mensajería definido en el archivo mule-config.xml

NOTA: Colocar los siguientes parámetros a la JVM para que el TestCase no termine inmediatamente, darle más memoria, ejecutarlo con  la codificación UTF-8 y la configuración regional de en/US.
-Xmx1024m -XX:MaxPermSize=512m -Dmule.test.timeoutSecs=4800000 -Dmule.verbose.exceptions=true  -Duser.country=US -Duser.language=en -Dsun.jnu.encoding=UTF-8 -Dfile.encoding=UTF-8

lunes, 17 de septiembre de 2012

Cómo generar un proyecto de Mule 3.3.0 usando el arquetipo de Maven en Windows

Prerrequisitos.-

1. Tener instalado y configurado Maven. En la siguiente publicación se explica como hacerlo.
2. Haber instalado y configurado Mule 3.3, sobre todo la variable MULE_HOME

Procedimiento.-

1. Abrir una consola de comandos (cmd)
2. Ir al directorio dónde se creará el proyecto. Por ejemplo: c:\projects\workspace
3. Ejecutar el siguiente comando:

mvn mule-project-archetype:create -DartifactId=mi-proyecto-mule -DmuleVersion=3.3.0

En dónde:

-DartifactId corresponde al nombre del proyecto
-DmuleVersion corresponde a la versión de Mule que se desea utilizar

4. Continuar con el asistente seleccionando los paquete base, transportes, módulos, etc.

viernes, 10 de febrero de 2012

Cómo instalar el Plugin de Maven en MuleStudio

En esta publicación explico el procedimiento para instalar el plugin de Maven en Mule Studio GA.

1. Descargar las dependencias org.eclipse.zest.core y org.eclipse.zest.layouts

2. Copiarlas en el directorio ../MuleStudio/plugins

3. Abrir MuleStudio e ir a Help > Install New Software > Add (Maven, http://m2eclipse.sonatype.org/sites/m2e)

4. Seleccionar Maven Integration for Eclipse, dar click en Next, y aceptar la licencia.

5. Finalmente, reiniciar Mule Studio

NOTA: Para instalar el plugin de Maven Extras, repetir desde el paso 3 con (Maven Extras, http://m2eclipse.sonatype.org/sites/m2e-extras)

lunes, 30 de enero de 2012

Mis comentarios sobre Mule Studio

… our team started working with Mule 2.2.1 CE, we had to deal directly with XML configuration files. When we started to work with MuleStudio, debugging and flow design become easier. I strongly recommend using MuleStudio because it improves team’s productivity"

Link: http://blogs.mulesoft.org/announcing-mule-studio-general-availability/

Ya está disponible la versión de Disponibilidad Pública (GA, General availability) en los siguientes links:

Windows 32bits: Descargar
Windows 64bits: Descargar 

viernes, 1 de julio de 2011

Cómo publicar un archivo crossdomain.xml en Mule 2.2.1 Standalone

En ésta publicación explico el procedimiento para publicar un archivo crossdomain.xml en Mule2.2.1.

El archivo crossdomain.xml es requerido por las aplicaciones Flex/Flash para poder consumir servicios web que se encuentran en diferentes dominios.

En el archivo de configuración de la aplicación de Mule, se tiene que incluir lo siguiente:

<jetty:connector name="jetty" useContinuations="false" />

<!-- ... -->
<service name="crossdomain">
    <inbound>
  <jetty:inbound-endpoint address="http://127.0.0.1:80/crossdomain.xml"
                                        connector-ref="jetty"
                                        synchronous="true" method="GET">
   <not-filter>
    <wildcard-filter pattern="/favicon.ico"/>
            </not-filter> 
            <response-transformers>
    <message-properties-transformer>
     <add-message-property key="Content-Type" value="application/xml"/>
                </message-properties-transformer>
            </response-transformers>
        </jetty:inbound-endpoint>
    </inbound>
    <component>
        <singleton-object class="org.mule.component.simple.StaticComponent">
   <property key="dataFile" value="flex/crossdomain.xml"/>
  </singleton-object>
 </component>
</service>


Nótese que para ésta configuración el archivo crossdomain.xml tendrá que ser colocado en el directorio %MULE_HOME%\lib\user\flex

jueves, 22 de julio de 2010

Cómo exponer un servicio web en Mule 2 usando Apache Axis - Parte 2

En mi anterior publicación explicaba cómo exponer un servicio web en Mule 2 usando Apache Axis. Este servicio web tenía el método helloAxis() el cuál recibía y devolvía cadenas de texto (java.lang.String). En ésta parte 2 de mi publicación explico cómo exponer un servicio web usando objetos (beans) que no forman parte del API de Java. Estos objetos son los siguientes:


Bean Field

package com.blogspot.ingmmurillo.axisws;

import java.io.Serializable;

public class Field implements Serializable{

    private String name;
    private String value;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        String result = "";
        result += "" + name + "";
        result += "" + value + "";
        result += "";
        return result;
    }
}

Como se puede observar se sobreescribe el método toString() usando tags XML para mostrar el contenido de las variables de instancia del objeto. Además, es importante que los beans que se definan implementen la interface java.io.Serializable.

Bean Message

package com.blogspot.ingmmurillo.axisws;

import java.io.Serializable;

public class Message implements Serializable {

    private Field[] fields;
    private String from;
    private String to;

    public String getFrom() {
        return from;
    }

    public void setFrom(String from) {
        this.from = from;
    }

    public String getTo() {
        return to;
    }

    public void setTo(String to) {
        this.to = to;
    }

    public Field[] getFields() {
        return fields;
    }

    public void setFields(Field[] fields) {
        this.fields = fields;
    }

    @Override
    public String toString() {
        String result = "";
        if (fields != null) {
            if (fields.length > 0) {

                for (Field f : fields) {
                    result += f;
                }
            }
        }
        result += "" + from + "";
        result += "" + to + "";
        result += "";

        return result;
    }
}

Como se puede observar este bean tiene un arreglo de objetos de tipo Field. De igual forma se sobreescribe el método toString() usando tags XML.

Interface WSComplexDataTypes

package com.blogspot.ingmmurillo.axisws;

public interface WSComplexDataTypes {

    public String sendMessage(Message msg);

}

La interface define el método sendMessage() el cúal recibe como parámetro un objeto de tipo com.blogspot.ingmmurillo.axisws.Message.

Clase WSComplexDataTypesImpl

package com.blogspot.ingmmurillo.axisws;

public class WSComplexDataTypesImpl implements WSComplexDataTypes {

    public String sendMessage(Message msg) {
        return msg.toString();
    }
}


Esta clase contiene la implementación del método sendMessage() el cual hace una llamada al método toString() el cual fue redefinido para cada Bean. Cuando se invoque al servicio web se devolverá el contenido en XML.

Configuración en Mule

<service name="wsComplexData">
            <inbound>
                <axis:inbound-endpoint
                        address="http://localhost:8282/webservices/axis"
                        serviceNamespace="http://ingmmurillo.blogspot.com/webservices/axis"
                        synchronous="true">
                </axis:inbound-endpoint>
            </inbound>
            <component class="com.blogspot.ingmmurillo.axisws.WSComplexDataTypesImpl"/>
        </service>


Pruebas

El servicio web será publicado en Mule bajo el siguiente URL:
http://localhost:8282/webservices/axis/wsComplexData?wsdl Obsérvese que el URL del servicio web se compone de la siguiente forma:

[address]/[service name]?wsdl

Se usó soapUI v3.5 para realizar las pruebas de invocación al servicio web como se puede observar a continuación:



Nótese cómo se arma el XML de invocación al servicio web:

<soapenv:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:axis="http://ingmmurillo.blogspot.com/webservices/axis" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/">
   <soapenv:Header/>
   <soapenv:Body>
      <axis:sendMessage soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
         <in0>
            <fields>
               <field>
                  <name>FirstName</name>
                  <value>Mauricio</value>
               </field>
               <field>
                  <name>LastName</name>
                  <value>Mauricio</value>
               </field>
            </fields>
            <from>My Blog</from>
            <to>The World</to>
         </in0>
      </axis:sendMessage>
   </soapenv:Body>
</soapenv:Envelope>



Obteniéndose la siguiente respuesta del servicio web publicado en Mule:

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
   <soapenv:Body>
      <ns1:sendMessageResponse soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" xmlns:ns1="http://ingmmurillo.blogspot.com/webservices/axis">
         <sendMessageReturn xsi:type="xsd:string"><![CDATA[<fields><field><name>Nombre</name><value>Mauricio</value></field><field><name>Apellido</name><value>Mauricio</value></field><from>Blog</from><to>El mundo</to></fields>]]></sendMessageReturn>
      </ns1:sendMessageResponse>
   </soapenv:Body>
</soapenv:Envelope>

lunes, 28 de junio de 2010

Cómo exponer un servicio web en Mule 2 usando Apache Axis

Para crear servicios web existen 2 estilos de desarrollo:
  1. Contract-Last. Se comienza con el código Java y se genera el contrato del servicio web (WSDL) a partir de éste.
  2. Contract-First. Se comienza con el contrato del servicio web (WSDL) y se usa Java para implementar dicho contrato.
Mule 2 provee de dos tecnologías para trabajar con servicios web: Apache Axis y Apache CXF. En éste post explicaré como exponer un servicio web en Mule usando Apache Axis y el estilo de desarrollo Contract-Last.

En el siguiente código expondré un servicio web muy simple que solicita como entrada un nombre y un apellido y devuelve de respuesta una cadena de texto. Para trabajar con el estilo de desarrollo  Contract-Last, primero se debe de partir con la codificación Java, creando una interface con la firma de o los métodos a exponer en el servicio web y una o varias clases que implementen la interface como se muestra a continuación:


Interface HelloAxis

package com.blogspot.ingmmurillo.axisws;

public interface HelloAxis {

    public String helloAxis(String firstName, String lastName);

}

Clase HelloAxisImpl

package com.blogspot.ingmmurillo.axisws;

public class HelloAxisImpl implements HelloAxis {

    public String helloAxis(String firstName, String lastName) {

        String greeting = "Welcome to Axis " + firstName + " " + lastName;

        return greeting; 
    }
}


Una vez que se tenga codificado el código Java se usará la siguiente configuración en Mule para exponer el servicio web usando Axis, es decir para que Mule genere automáticamente el contrato (WSDL).

Configuración en Mule

<service name="helloaxis">
            <inbound>
                <axis:inbound-endpoint
                        address="http://localhost:8282/webservices/axis"
                        serviceNamespace="http://ingmmurillo.blogspot.com/webservices/axis"
                        synchronous="true">
                    <axis:soap-method method="helloAxis">
                        <axis:soap-parameter parameter="firstName" type="string" mode="IN"/>
                        <axis:soap-parameter parameter="lastName" type="string" mode="IN"/>
                        <axis:soap-return type="string"/>
                    </axis:soap-method>
                </axis:inbound-endpoint>
            </inbound>
            <component class="com.blogspot.ingmmurillo.axisws.HelloAxisImpl"/>
        </service>


En la siguiente captura de pantalla se muestra comó se consumiría el servicio web, las parámetros de entrada y la respuesta del mismo usando el cliente de servicios web SoapUI. Tomése en cuenta que la invocación al WSDL es de la siguiente forma: http://localhost:8282/webservices/axis/helloaxis?wsdl


    jueves, 1 de abril de 2010

    Conexión a una base de datos Oracle usando JDBC OCI

    En el siguiente artículo explico cómo configurar Mule para conectarse a una base de datos Oracle usando las librerías de Oracle Instant Client.

    1. Descargar Oracle Instant Client para la plataforma sobre la cuál se va a trabajar.
        http://www.oracle.com/technology/software/tech/oci/instantclient/index.html

       NOTA: Para Oracle 10g sobre plataforma Windows, descargar del siguiente link:
       http://download.oracle.com/otn/nt/instantclient/10204/instantclient-basic-win32-10.2.0.4.zip

    2. Una vez descargado, descomprimir el archivo.
    3. Copiar las siguientes DLLs al directorio MULE_HOME/lib/boot
    • oraociei10.dll
    • oci.dll
    • oraocijdbc10.dll
    • orannzsbb10.dll
    4. Copiar el JDBC ojdbc14.jar al directorio MULE_HOME/lib/user
    5. Incluir el Spring Bean y el conector JDBC en el archivo de configuración de MULE.


    <?xml version="1.0" encoding="UTF-8"?>
    <mule 
    ... >
    <spring:bean id="oracleDataSource" class="oracle.jdbc.pool.OracleOCIConnectionPool" destroy-method="close">
            <spring:property name="user" value="user"/>
            <spring:property name="password" value="password"/>
            <spring:property name="URL" value="jdbc:oracle:oci:@(DESCRIPTION =(ADDRESS_LIST =(ADDRESS =(PROTOCOL = TCP)(HOST = 192.168.10.196)(PORT = 1521)))(CONNECT_DATA =(SERVICE_NAME = DBNAME)))"/>
            <spring:property name="poolConfig" ref="oraclePoolProperties"/>
    
        </spring:bean>
    
        <spring:bean id="oraclePoolProperties"
                     class="org.springframework.beans.factory.config.PropertiesFactoryBean">
            <spring:property name="properties">
                <spring:props>
                    <spring:prop key="connpool_min_limit">1</spring:prop>
                    <spring:prop key="connpool_max_limit">5</spring:prop>
                    <spring:prop key="connpool_increment">2</spring:prop>
                    <spring:prop key="connpool_timeout">10</spring:prop>
                    <spring:prop key="connpool_nowait">true</spring:prop>
                </spring:props>
            </spring:property>
        </spring:bean>
    ...
    <jdbc:connector name="OracleJDBCOCIConnector" dataSource-ref="oracleDataSource">
        </jdbc:connector>
    ...
    </mule>
    

    jueves, 25 de marzo de 2010

    Desconferencia realizada en el barcamp Quito, Ecuador 2010 - Detalles

    Estuvo interesante la desconferencia que di en el barcamp 2010, fue mi primera experiencia en éste tipo de eventos, pero siento que todo salio bien. Expuse sobre el tema de "Integrando aplicaciones en Mule", hablé sobre ESBs, Mule, su arquitectura y su configuración.

    El ejemplo que se mostró fue sobre la integración de una aplicación heredada (archivos planos), con un web service que convertía monedas, y una base de datos para un Data Warehouse.

    Mule permite integrar varias tecnologías y protocolos de forma fácil ya que ofrece a los desarrolladores mucha de ésta lógica abstraída en los tags XML de su archivo de configuración. Además, Mule separa la lógica del negocio de la lógica de mensajería, haciendo énfasis en la Reusabilidad y Flexibilidad.

    Resumo las respuestas a las preguntas realizadas sobre la desconferencia.


    1. Sobre BPMs. El ESB es el punto de entrada para una arquitectura SOA, dentro de un modelo de madurez de SOA, el ESB actúa como el backbone o componente de integración, por lo que arriba de éste podrían estar un motor de reglas, un BPM o lo que se requiera.

    2. Sobre BPEL. BPEL es un lenguaje estándar de ejecución de procesos de negocios que tiene relación con los BPMs, entonces al ser el ESB el componente integrador se podría tener un BPM que use BPEL u otro que no de forma independiente.

    3. Sobre la Transaccionalidad. Mule se conecta a través de endpoints, un endpoint podría ser un directorio, una cola de mensajería, un web service, una base de datos, etc. Mule permite controlar la transaccionalidad por endpoint asegurando que una transacción se comprometa siempre y cuando haya llegado desde su enpoint de entrada hasta su endpoint de salida.

    Comparto algunas de las fotos de la desconferencia.


    miércoles, 17 de marzo de 2010

    Desconferencia en el barcamp Quito, Ecuador 2010

    El día sábado 20 de marzo del 2010 estaré exponiendo como desconferencista en el barcamp, el tema de Integración de Aplicaciones con Mule. El barcamp de éste año será en la PUCE, Auditorios de la Torre 1. Les hago llegar una cordial invitación y les comparto las diapositivas con las cuáles estaré exponiendo ese día.