Example 103. Starting JMS Transport Using WSO2 SOA Enablement Server Runtime API

// Copyright WSO2 Inc. All rights reserved.
// Use is subject to license terms.
package messageProcessing.transports.jmsTransport;

import org.systinet.wasp.Wasp;

public class JmsStart {
    public static void main(String[] args) throws Exception {
        // start WASP server which communicates over SOAP using JMS transport
        Wasp.startServer("jms:queue::testQueue@testQCF:");
        // some code here
        // destroying WASP implicates stopping JMS transport
        Wasp.destroy();
    }
}

Example 104. BEA WebLogic Properties

java.naming.factory.initial=weblogic.jndi.WLInitialContextFactory;
        java.naming.provider.url=t3://localhost:7001

Example 105. JBoss Server Properties

java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory;
        java.naming.provider.url=localhost;
        java.naming.factory.url.pkgs=org.jboss.naming;

Example 106. JMS Transport Server Configuration

<transport name="jms"
           implementation-class="com.idoox.transport.jms.JmsTransport"
           preload="true"
           scheme="jms"
           default-server="true" 
           xmlns:jms="http://wso2.com/wasp/package/j2ee_jms">
    <jms:maxThreads>25</jms:maxThreads>
    <jms:minThreads>1</jms:minThreads>
    <jms:messagePriority>6</jms:messagePriority>
    <jms:messageExpiration>15000</jms:messageExpiration>
    <jms:persistent>false</jms:persistent>
    <jms:clientTimeout>60000</jms:clientTimeout>
    <jms:destination type="queue" 
                     jmsDestinationName="queue/testQueue" 
                     jmsDestinationFactoryName="QueueConnectionFactory" 
                     username="" 
                     password=""/>
    <jms:destination type="topic" 
                     jmsDestinationName="topic/testTopic" 
                     jmsDestinationFactoryName="TopicConnectionFactory" 
                     username="" 
                     password=""/>
    <!-- Here you can add your own reduction or remove unused ones -->
    <!--jms:reduction className="">
        <property key="java.naming.factory.initial" value=""/>
        <property key="java.naming.provider.url" value=""/>
        <property key="" value=""/>
    </jms:reduction-->
    <jms:reduction className="org.systinet.transport.jms.Sun1Reduction"/>
    <jms:reduction className="org.systinet.transport.jms.J2EEReduction"/>
    <jms:reduction className="org.systinet.transport.jms.SwiftMQReduction"/>
    <jms:reduction className="org.systinet.transport.jms.TibcoReduction"/>
    <jms:reduction className="org.systinet.transport.jms.MQSeriesReduction"/>
    <jms:reduction className="com.idoox.transport.jms.JndiReduction"/>
</transport>

Example 109. JumboTransport

package example.processing.transport;

import org.idoox.config.Configurable;

import org.idoox.transport.Transport;
import org.idoox.transport.TransportMethod;
import org.idoox.transport.TransportStartException;
import org.idoox.transport.URI;
import org.idoox.transport.client.ClientConnection;
import org.idoox.transport.client.Endpoint;
import org.idoox.transport.server.ConnectionHandler;

import org.idoox.util.RuntimeWrappedException;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyVetoException;
import java.beans.VetoableChangeListener;

import java.io.IOException;
import java.io.InterruptedIOException;

import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

import java.util.HashSet;
import java.util.Map;
import java.util.Set;


public class JumboTransport implements Transport,
    VetoableChangeListener {
    // transport methods - GET and POST
    public static final Set METHODS = new HashSet(2);

    static {
        METHODS.add(TransportMethod.POST);
        METHODS.add(TransportMethod.GET);
    }

    // server endpoint or 'null' - no server, only client
    private Endpoint serverEndpoint;

    // server socket or 'null' - server is not started
    private ServerSocket serverSocket;

    // server thread for incomming connections
    private ServerThread serverThread;

    // connection handler for new incomming connections
    private ConnectionHandler conHandler;

    // connection timeout
    private nt timeout;

    public void load(Configurable configurable) {
        // default configuration for this transport
        JumboConfig config =
            (JumboConfig) configurable.narrow(JumboConfig.class);

        // port
        int port = -1;

        try {
            port = config.getPort();
        } catch (Exception e) {
            // it throws en exception when the port is not in the configuration
        }

        // connection timeout
        this.timeout = 0;

        try {
            this.timeout = config.getTimeout();
        } catch (Exception e) {
            // it throws an exception when the timeout 
           // is not in the configuration
        }

        // default server endpoint
        if (port != -1) {
            try {
                String hostName = InetAddress.getLocalHost()
                                             .getHostName();
                this.serverEndpoint =
                    new Endpoint(
                        config.getScheme(),
                        null,
                        hostName,
                        port,
                        null,
                        "/");
            } catch (UnknownHostException e) {
                throw new RuntimeWrappedException(e);
            }
        }

        // register listener on configurable
        configurable.addVetoableChangeListener(this);
    }

    public void destroy() {
    }

    public int getType() {
        int type = CLIENT;

        if (this.serverEndpoint != null) {
            type |= SERVER;
        }

        return type;
    }

    public Set getMethods() {
        return METHODS;
    }

    public void start(URI uri) throws TransportStartException {
        if (uri != null) {
            // started with an URI at runtime
            try {
                this.serverEndpoint = new Endpoint(uri.toExternalForm());
                this.serverEndpoint.setPath("/");

                // it ignores context path from the URI for simplicity
            } catch (MalformedURLException e) {
                throw new TransportStartException(e);
            }
        }

        // start server thread with new server socket
        System.out.println("Starting server " + this.serverEndpoint);

        try {
            // new server socket
            this.serverSocket =
                new ServerSocket(this.serverEndpoint.getPort());
            this.serverSocket.setSoTimeout(500);

            // start new server thread
            this.serverThread = new ServerThread();
            this.serverThread.start();
        } catch (IOException e) {
            throw new TransportStartException(e);
        }
    }

    public void stop() {
        if (this.serverSocket != null) {
            System.out.println("Stoping server " + this.serverEndpoint);

            synchronized (this.serverThread) {
                this.serverThread.stopping = true;

                try {
                    this.serverThread.wait(0);
                    this.serverSocket = null;
                } catch (InterruptedException e) {
                    ; // iterrupt on current thread
                }
            }
        }
    }

    public boolean isStarted() {
        return this.serverSocket != null;
    }

    public ConnectionHandler setHandler(ConnectionHandler connectionHandler) {
        ConnectionHandler oldOne = this.conHandler;
        this.conHandler = connectionHandler;

        return oldOne;
    }

    public String getLocalPath(URI uri) {
        // port
        if (this.serverEndpoint.getPort() != uri.getPort()) {
            return null;
        }

        // host name
        try {
            InetAddress hn1 =
                InetAddress.getByName(this.serverEndpoint.getHost());
            InetAddress hn2 = InetAddress.getByName(uri.getHost());

            if (!hn1.equals(hn2)) {
                return null;
            }
        } catch (UnknownHostException e) {
            return null;
        }

        // path
        String path = uri.getPath();

        if (uri.getContextPath() != null) {
            path = uri.getContextPath() + path;
        }

        if (!path.startsWith(this.serverEndpoint.getPath())) {
            return null;
        }

        // return local path
        return path.substring(this.serverEndpoint.getPath().length() - 1);
    }

    public Endpoint[] getAbsolutePath(String path)
        throws MalformedURLException {
        return new Endpoint[] { new Endpoint(this.serverEndpoint, path) };
    }

    public ClientConnection newConnection(
        URI uri,
        TransportMethod transportMethod,
        Map properties) throws IOException {
        Socket socket = new Socket(
                uri.getHost(),
                uri.getPort());
        socket.setSoTimeout(this.timeout);

        return new JumboConnection(socket, uri, transportMethod);
    }

    // example of configuration change at runtime
    public void vetoableChange(PropertyChangeEvent event)
        throws PropertyVetoException {
        if (event.getPropertyName()
                 .equals("timeout")) {
            // timeout
            if (event.getNewValue() != null) {
                this.timeout = ((Integer) event.getNewValue()).intValue();
                System.out.println("timeout is changed to: " + this.timeout);
            }
        }

        // other config properties ... see JumboConfig
    }

    public class ServerThread extends Thread {
        public boolean stopping = false;

        public ServerThread() {
            super("JumboServer");
        }

        public void run() {
            // it's only single thread server for simplicity
            while (true) {
                try {
                    Socket socket = serverSocket.accept();
                    socket.setSoTimeout(timeout);

                    JumboConnection newConnection =
                        new JumboConnection(socket, serverEndpoint);

                    switch (newConnection.getMethod()
                                         .value()) {
                    case TransportMethod._GET:
                        conHandler.handleGet(newConnection);

                    case TransportMethod._POST:
                        conHandler.handlePost(newConnection);
                    }
                } catch (InterruptedIOException e) {
                    // accept timeouted
                    synchronized (this) {
                        if (this.stopping) {
                            try {
                                serverSocket.close();
                            } catch (IOException e1) {
                                ; // ignore IOException during close
                            }

                            notify();

                            break;
                        }
                    }
                } catch (Exception e) {
                    // another exceptions
                    e.printStackTrace();
                }
            }
        }
    }
}

Example 110. JumboConnection

package example.processing.transport;

import org.idoox.transport.InputMessage;
import org.idoox.transport.OutputMessage;
import org.idoox.transport.TransportMethod;
import org.idoox.transport.URI;
import org.idoox.transport.client.ClientConnection;
import org.idoox.transport.client.Endpoint;
import org.idoox.transport.server.ServerConnection;

import java.io.IOException;

import java.net.Socket;


/*
 * JUMBO protocol:
 *
 * 5 bytes: <number of headers>
 * 5 bytes: <1st header-name size>
 *        : <1st header-name>
 * 5 bytes: <1st header-value size>
 *        : <1st header-value>
 * ...
 * 5 bytes: <1st chunk size>
 *        : <1st chunk>
 * ...
 * 5 bytes: 00000
 */
public class JumboConnection implements ClientConnection,
    ServerConnection {
    public static final String LOCATION_HEADER = "x-jumbo-location";
    public static final String METHOD_HEADER = "x-jumbo-method";
    public static final String SC_HEADER = "x-jumbo-status";
    private Socket socket;
    private URI endpoint;
    private TransportMethod method;
    private InputMessage input;
    private OutputMessage output;

    // for the client side
    public JumboConnection(
        Socket socket,
        URI endpoint,
        TransportMethod method) throws IOException {
        this.socket = socket;
        this.endpoint = endpoint;
        this.method = method;

        // input & output message
        if (method == TransportMethod.POST) {
            this.output = new JumboOutputMessage(socket.getOutputStream());
            this.input = new JumboInputMessage(socket.getInputStream());
        } else if (method == TransportMethod.GET) {
            this.output = new JumboOutputMessage(socket.getOutputStream());
            this.input = new JumboInputMessage(socket.getInputStream());
        } else {
            throw new IOException("Method " + method
                + " isn't supported JUMBO protocol");
        }

        // sends URI location to the server
        this.output.setStringHeader(
            LOCATION_HEADER,
            endpoint.getLocation());

        // sends tranport method to the server
        this.output.setStringHeader(
            METHOD_HEADER,
            method.toString());

        // do request for GET method
        if (method == TransportMethod.GET) {
            this.output.close();
            this.output = null;
        }
    }

    // for the server side
    public JumboConnection(
        Socket socket,
        URI endpoint) throws IOException {
        this.socket = socket;

        // input & output message
        this.input = new JumboInputMessage(socket.getInputStream());
        this.output = new JumboOutputMessage(socket.getOutputStream());

        // gets URI location from the input message
        String location = this.input.getStringHeader(LOCATION_HEADER);
        this.endpoint = new Endpoint(endpoint, location);

        // gets transport method from the input message
        String method = this.input.getStringHeader(METHOD_HEADER);
        this.method = TransportMethod.fromString(method);

        // close request for GET method
        if (this.method == TransportMethod.GET) {
            this.input.close();
            this.input = null;
        }
    }

    publicvoid setTimeout(int timeout) throws IOException {
        this.socket.setSoTimeout(timeout);
    }

    public InputMessage getInputMessage() {
        return this.input;
    }

    public void setInputMessage(InputMessage inputMessage) {
        this.input = inputMessage;
    }

    public OutputMessage getOutputMessage() {
        return this.output;
    }

    public void setOutputMessage(OutputMessage outputMessage) {
        this.output = outputMessage;
    }

    public TransportMethod getMethod() {
        return this.method;
    }

    public URI getURI() {
        return this.endpoint;
    }

    public String getClientAddress() {
        return this.socket.getInetAddress()
                          .getHostName();
    }
}

Example 111. Jumbo Transport Protocol

/* 
    * JUMBO protocol: 
    * * 5 bytes: <number of headers> 
    * 5 bytes: <1st header-name size> 
    * : <1st header-name> 
    * 5 bytes: <1st header-value size> 
    * : <1st header-value> 
    * ... * 5 bytes: <1st chunk size> 
    * : <1st chunk> 
    * ... 
    * 5 bytes: 00000 
*/

Example 112. JumboInputMessage

package example.processing.transport;

import org.idoox.transport.RawInputMessage;

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;


public class JumboInputMessage extends RawInputMessage {
    private Map headers;

    public JumboInputMessage(InputStream inputStream) {
        super(null);
        setWrappedStream(new ChunkableInputStream(inputStream));
    }

    public int getStatusCode() throws IOException {
        return getIntHeader(JumboConnection.SC_HEADER);
    }

    public Set getHeaderNames() throws IOException {
        if (this.headers == null) {
            // parse headers
            initStream();
            this.isInited = true;
        }

        return this.headers.keySet();
    }

    public String getStringHeader(String name) throws IOException {
        if (this.headers == null) {
            // parse headers
            initStream();
            this.isInited = true;
        }

        return (String) this.headers.get(name.toLowerCase());
    }

    protected void initStream() throws IOException {
        // receive headers
        ChunkableInputStream in = (ChunkableInputStream) getWrappedStream();
        int numHeaders = in.readInt();
        this.headers = new HashMap(numHeaders);

        for (int i = 0; i < numHeaders; i++) {
            String name = in.readString();
            String value = in.readString();
            this.headers.put(
                name.toLowerCase(),
                value);
        }
    }

    private class ChunkableInputStream extends FilterInputStream {
        private int size = 0;

        public ChunkableInputStream(InputStream in) {
            super(in);
        }

        public int readInt() throws IOException {
            byte[] buffer = new byte[5];
            readBuffer(buffer);

            return Integer.parseInt(new String(buffer));
        }

        public String readString() throws IOException {
            int length = readInt();
            byte[] buffer = new byte[length];
            readBuffer(buffer);

            return new String(buffer);
        }

        private void readBuffer(byte[] buffer) throws IOException {
            for (int i = 0; i < buffer.length; i++) {
                int x = in.read();

                if (x < 0) {
                    throw new IOException("The socket is closed");
                }

                buffer[i] = (byte) x;
            }
        }

        public int read(byte[] b) throws IOException {
            return read(b, 0, b.length);
        }

        public int read(
            byte[] b,
            int off,
            int len) throws IOException {
            for (int i = 0; i < len; i++) {
                int x = read();

                if (x < 0) {
                    if (i == 0) {
                        return -1;
                    } else {
                        return i;
                    }
                }

                b[i + off] = (byte) x;
            }

            return len;
        }

        public int read() throws IOException {
            if (this.size == -1) {
                // it's closed
                return -1;
            }

            if (this.size == 0) {
                // new chunk?
                this.size = readInt();

                if (this.size == 0) {
                    // end of message
                    this.size = -1;

                    return -1;
                }
            }

            this.size--;

            return in.read();
        }

        public long skip(long n) throws IOException {
            for (int i = 0; i < n; i++) {
                if (read() < 0) {
                    return i;
                }
            }

            return n;
        }

        public int available() throws IOException {
            return this.size;
        }

        public void close() throws IOException {
        }
    }
}

Example 113. JumboOutputMessage

package example.processing.transport;

import org.idoox.transport.RawOutputMessage;

import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;


public class JumboOutputMessage extends RawOutputMessage {
    private Map headers = new HashMap();

    public JumboOutputMessage(OutputStream outputStream) {
        super(null);
        setWrappedStream(new ChunkableOutputStream(outputStream));
    }

    public void setStatusCode(int sc) {
        setIntHeader(JumboConnection.SC_HEADER, sc);
    }

    public void setStringHeader(
        String name,
        String value) {
        this.headers.put(name, value);
    }

    protected void initStream() throws IOException {
        // send headers
        ChunkableOutputStream out = (ChunkableOutputStream) getWrappedStream();
        out.writeInt(this.headers.size());

        for (Iterator i = this.headers.entrySet()
                                      .iterator(); i.hasNext();) {
            Map.Entry header = (Map.Entry) i.next();
            out.writeString((String) header.getKey());
            out.writeString((String) header.getValue());
        }
    }

    private class ChunkableOutputStream extends FilterOutputStream {
        private byte[] buffer = new byte[2048];
        private int size = 0;

        public ChunkableOutputStream(OutputStream out) {
            super(out);
        }

        public void writeInt(int num) throws IOException {
            if (num > 99999) {
                throw new IOException("Number can not be greater than 99999");
            }

            String str = String.valueOf(num);

            for (int i = str.length(); i < 5; i++) {
                out.write('0');
            }

            out.write(str.getBytes());
        }

        public void writeString(String str) throws IOException {
            writeInt(str.length());
            out.write(str.getBytes());
        }

        public void write(byte[] b) throws IOException {
            write(b, 0, b.length);
        }

        public void write(
            byte[] b,
            int off,
            int len) throws IOException {
            for (int i = 0; i < len; i++) {
                write(b[off + i]);
            }
        }

        public void write(int b) throws IOException {
            if (this.size >= this.buffer.length) {
                // dump output
                flush();
            }

            this.buffer[this.size] = (byte) b;
            this.size++;
        }

        public void flush() throws IOException {
            if (this.size > 0) {
                writeInt(this.size);
                out.write(this.buffer, 0, this.size);
                this.size = 0;
                out.flush();
            }
        }

        public void close() throws IOException {
            flush();
            writeInt(0);
        }
    }
}

Example 114. JumboConfig

package example.processing.transport;

import org.idoox.transport.config.TransportConfig;


public interface JumboConfig extends TransportConfig {
    int getPort();

    void setPort(int port);

    int getTimeout();

    void setTimeout(int timeout);
}

Example 118. HTTP Header-Checking Interceptor

// Copyright WSO2 Inc. All rights reserved.
// Use is subject to license terms.
package example.processing.interceptor;

import org.idoox.config.Configurable;

import org.idoox.transport.Connection;
import org.idoox.transport.InputMessage;

import org.idoox.wasp.WaspInternalException;
import org.idoox.wasp.interceptor.InterceptorChain;
import org.idoox.wasp.interceptor.TransportInterceptor;

import java.io.IOException;


public class HTTPHeaderCheckingInterceptor implements TransportInterceptor {
    public void intercept(
        Connection connection,
        InterceptorChain chain,
        int position) throws IOException {
        InputMessage imsg = connection.getInputMessage();

        if (imsg != null) {
            String header = imsg.getStringHeader("my-header");

            if (header == null) {
                // there should be an IOException in the future ...
                throw new RuntimeException(
                    "Expected header 'my-header' not found in the message !");
            }
        }
    }

    public void load(Configurable config) throws WaspInternalException {
        // no initialization required
    }

    public void destroy() {
        // no destroy required
    }
}

Example 120. Interface Initializing the

// Copyright WSO2 Inc. All rights reserved.
// Use is subject to license terms.
package examples.processing.interceptor;

public interface AccessConfig {
    GuestConfig[] getGuestComputer();

    interface GuestConfig {
        public String getClientAddress(); // read-only item

        public Integer getAccessCount();

        public void setAccessCount(Integer accessCount);
    }
}

Example 121. Using Configuration of an Interceptor - Interceptor Code

// Copyright WSO2 Inc. All rights reserved.
// Use is subject to license terms.
package example.processing.interceptor;

import org.idoox.config.Configurable;

import org.idoox.transport.Connection;
import org.idoox.transport.server.ServerConnection;

import org.idoox.wasp.WaspInternalException;
import org.idoox.wasp.interceptor.InterceptorChain;
import org.idoox.wasp.interceptor.StopProcessingException;
import org.idoox.wasp.interceptor.TransportInterceptor;

import java.io.IOException;


public class AccessInterceptor implements TransportInterceptor {
    AccessConfig.GuestConfig[] accesses;

    publicvoid load(Configurable config) throws WaspInternalException {
        AccessConfig ac = (AccessConfig) config.narrow(AccessConfig.class);
        accesses = ac.getGuestComputer();
    }

    publicvoid destroy() {
        // nothing needed here
    }

    public void intercept(
        Connection connection,
        InterceptorChain chain,
        int position) throws IOException, 
        StopProcessingException {
        String clientAddress =
            ((ServerConnection) connection).getClientAddress();

        for (int guestIndex = 0; guestIndex < accesses.length; guestIndex++) {
            if (accesses[guestIndex].getClientAddress()
                                    .equals(clientAddress)) {
                Integer ac = accesses[guestIndex].getAccessCount();

                if (ac == null) {
                    ac = new Integer(1); // not set up
                } else {
                    ac = new Integer(ac.intValue() + 1);
                }

                accesses[guestIndex].setAccessCount(ac);
                System.out.println("Client " + clientAddress
                    + " has accessed the service " + ac + " times");

                return;
            }
        }

        // this exception should be changed in the future to IOException
        throw new IOException("Unconfigured client address " + clientAddress);
    }
}