axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jmsn...@apache.org
Subject cvs commit: xml-axis/java/src/org/apache/axis/ime/internal/util/handler HandlerWrapper1.java HandlerWrapper2.java
Date Sat, 26 Oct 2002 22:05:05 GMT
jmsnell     2002/10/26 15:05:05

  Added:       java/src/org/apache/axis/ime/internal
                        MessageExchangeProvider1.java
                        NonPersistentMessageExchangeCorrelatorService.java
                        MessageExchangeImpl.java
                        MessageExchangeProvider2.java MessageWorker.java
                        NonPersistentMessageChannel.java
                        MessageExchangeProvider.java
                        MessageWorkerGroup.java
               java/src/org/apache/axis/ime/internal/util/uuid
                        UUIDGenFactory.java SimpleUUIDGen.java UUIDGen.java
               java/src/org/apache/axis/ime/internal/util/handler
                        HandlerWrapper1.java HandlerWrapper2.java
  Log:
  Initial checkin of the AIME prototype implementation.  
  This code will not be compiled unless the compileime environment variable is set to true.
  
  Revision  Changes    Path
  1.1                  xml-axis/java/src/org/apache/axis/ime/internal/MessageExchangeProvider1.java
  
  Index: MessageExchangeProvider1.java
  ===================================================================
  package org.apache.axis.ime.internal;
  
  import org.apache.axis.ime.MessageExchangeContextListener;
  import org.apache.axis.ime.MessageExchange;
  
  /**
   * Serves as a base class for MessageExchangeProviders that
   * need to thread pooling on send AND receive message 
   * flows (as opposed to MessageExchangeProvider2 which only
   * does thread pooling on send flows).
   * 
   * @author James M Snell (jasnell@us.ibm.com)
   */
  public abstract class MessageExchangeProvider1
    extends MessageExchangeProvider {
  
    protected abstract MessageExchangeContextListener createSendMessageContextListener();
    
    protected abstract MessageExchangeContextListener createReceiveMessageContextListener();
  
    public void init(long THREAD_COUNT) {
      if (initialized)
        throw new IllegalStateException();
      for (int n = 0; n < THREAD_COUNT; n++) {
        WORKERS.addWorker(SEND, createSendMessageContextListener());
        WORKERS.addWorker(RECEIVE, createReceiveMessageContextListener());
      }
      initialized = true;
    }
    
  }
  
  
  
  1.1                  xml-axis/java/src/org/apache/axis/ime/internal/NonPersistentMessageExchangeCorrelatorService.java
  
  Index: NonPersistentMessageExchangeCorrelatorService.java
  ===================================================================
  package org.apache.axis.ime.internal;
  
  import org.apache.axis.ime.MessageExchangeContext;
  import org.apache.axis.ime.MessageExchangeCorrelator;
  import org.apache.axis.ime.MessageExchangeCorrelatorService;
  import java.util.Hashtable;
  
  /**
   * @author James M Snell (jasnell@us.ibm.com)
   */
  public class NonPersistentMessageExchangeCorrelatorService
    implements MessageExchangeCorrelatorService {
  
    Hashtable contexts = new Hashtable();
  
    /**
     * @see org.apache.axis.ime.MessageExchangeCorrelatorService#put(MessageExchangeCorrelator, MessageExchangeContext)
     */
    public void put(
      MessageExchangeCorrelator correlator,
      MessageExchangeContext context) {
        synchronized(contexts) {
          contexts.put(correlator, context);
        }
      }
  
    /**
     * @see org.apache.axis.ime.MessageExchangeCorrelatorService#get(MessageExchangeCorrelator)
     */
    public MessageExchangeContext get(MessageExchangeCorrelator correlator) {
      synchronized(contexts) {
        return (MessageExchangeContext)contexts.remove(correlator);
      }
    }
  
  }
  
  
  
  1.1                  xml-axis/java/src/org/apache/axis/ime/internal/MessageExchangeImpl.java
  
  Index: MessageExchangeImpl.java
  ===================================================================
  package org.apache.axis.ime.internal;
  
  import org.apache.axis.AxisFault;
  import org.apache.axis.MessageContext;
  import org.apache.axis.ime.MessageChannel;
  import org.apache.axis.ime.MessageExchange;
  import org.apache.axis.ime.MessageExchangeContext;
  import org.apache.axis.ime.MessageExchangeContextListener;
  import org.apache.axis.ime.MessageExchangeCorrelator;
  import org.apache.axis.ime.MessageExchangeLifecycle;
  import org.apache.axis.ime.MessageExchangeStatus;
  import org.apache.axis.ime.MessageExchangeReceiveListener;
  import org.apache.axis.ime.MessageExchangeStatusListener;
  import org.apache.axis.ime.MessageExchangeFaultListener;
  import org.apache.axis.ime.MessageExchangeConstants;
  import org.apache.axis.ime.internal.util.uuid.UUIDGen;
  import org.apache.axis.ime.internal.util.uuid.UUIDGenFactory;
  
  /**
   * @author James M Snell (jasnell@us.ibm.com)
   */
  public class MessageExchangeImpl 
    implements MessageExchange, MessageExchangeLifecycle {
  
    public static final long WORKER_COUNT = 5;
    public static final long DEFAULT_TIMEOUT = 1000 * 20;
  
    private MessageExchangeProvider provider;
    private MessageChannel send;
    private MessageChannel receive;
    private MessageExchangeReceiveListener receiveListener;
    private MessageExchangeStatusListener  statusListener;
    private MessageExchangeFaultListener   faultListener;
    private MessageWorkerGroup             workers = new MessageWorkerGroup();
    private boolean                       listening = false;
    protected  Holder holder;
  
    public MessageExchangeImpl(
      MessageExchangeProvider provider,
      MessageChannel sendChannel,
      MessageChannel receiveChannel) {
        this.send = sendChannel;
        this.receive = receiveChannel;
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchange#send(MessageContext)
     */
    public MessageExchangeCorrelator send(
      MessageContext context) 
        throws AxisFault {
      MessageExchangeCorrelator correlator = 
        (MessageExchangeCorrelator)context.getProperty(
          MessageExchangeConstants.MESSAGE_CORRELATOR_PROPERTY);
      if (correlator == null) {
        correlator = new MessageExchangeCorrelator(
          UUIDGenFactory.getUUIDGen(null).nextUUID());
        context.setProperty(
          MessageExchangeConstants.MESSAGE_CORRELATOR_PROPERTY,
          correlator);
      }
      MessageExchangeContext meContext = 
        MessageExchangeContext.newInstance(
          correlator, 
          statusListener,
          receiveListener,
          faultListener,
          context);
      send.put(correlator, meContext);
      return correlator;
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchange#setMessageExchangeStatusListener(MessageExchangeStatusListener)
     */
    public void setMessageExchangeStatusListener(
      MessageExchangeStatusListener listener)
        throws AxisFault {
      if (listening) 
        throw new IllegalStateException();
      this.statusListener = listener;
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchange#setMessageExchangeReceiveListener(MessageExchangeReceiveListener)
     */
    public void setMessageExchangeReceiveListener(
      MessageExchangeReceiveListener listener)
        throws AxisFault {
      if (listening) 
        throw new IllegalStateException();
      this.receiveListener = listener;
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchange#setMessageExchangeReceiveListener(MessageExchangeReceiveListener)
     */
    public void setMessageExchangeFaultListener(
      MessageExchangeFaultListener listener)
        throws AxisFault {
      if (listening) 
        throw new IllegalStateException();
      this.faultListener = listener;
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchange#cancel(MessageExchangeCorrelator)
     */
    public MessageContext cancel(
      MessageExchangeCorrelator correlator)
        throws AxisFault {
      MessageExchangeContext context = send.cancel(correlator);
      if (context != null) 
        return context.getMessageContext();
      else return null;
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchange#getReceiveChannel()
     */
    public MessageChannel getReceiveChannel() {
      return receive;
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchange#getSendChannel()
     */
    public MessageChannel getSendChannel() {
      return send;
    }
  
  
    public MessageContext sendAndReceive(
      MessageContext context)
        throws AxisFault {
      holder = new Holder();
      Listener listener = new Listener(holder);
      this.setMessageExchangeFaultListener(listener);
      this.setMessageExchangeReceiveListener(listener);
      try {
        this.send(context);
        holder.waitForNotify();
      } catch (InterruptedException ie) {
        throw AxisFault.makeFault(ie);
      }
      if (holder.context != null) {
        return holder.context;
      }
      if (holder.exception != null) {
        throw AxisFault.makeFault((Exception)holder.exception);
      }
      return null;
    }
    
    public MessageContext sendAndReceive(
      MessageContext context,
      long timeout)
        throws AxisFault {
      holder = new Holder();
      Listener listener = new Listener(holder);
      this.setMessageExchangeFaultListener(listener);
      this.setMessageExchangeReceiveListener(listener);
      try {
        this.send(context);
        holder.waitForNotify(timeout);
      } catch (InterruptedException ie) {
        throw AxisFault.makeFault(ie);
      }
      if (holder.context != null) {
        return holder.context;
      }
      if (holder.exception != null) {
        throw AxisFault.makeFault((Exception)holder.exception);
      }
      return null;
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchange#startListening()
     */
    public void startListening() {
      if (provider instanceof MessageExchangeProvider1) 
        throw new UnsupportedOperationException();
      for (int n = 0; n < WORKER_COUNT; n++) {
        workers.addWorker(receive, new ReceiverListener());
      }
      listening = true;
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchange#startListening()
     */
    public void startListening(MessageExchangeCorrelator correlator) {
      throw new UnsupportedOperationException("Unsupported For Now");
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchange#stopListening()
     */
    public void stopListening() {
      stopListening(false);
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchange#stopListening(boolean)
     */
    public void stopListening(boolean force) {
      if (provider instanceof MessageExchangeProvider1) 
        throw new UnsupportedOperationException();
      if (!force) 
        workers.safeShutdown();
      else 
        workers.shutdown();
      listening = false;
    }
  
    private class Holder {
      private MessageExchangeCorrelator correlator;
      private MessageContext context;
      private Throwable exception;
      
      public synchronized void set(
        MessageExchangeCorrelator correlator,
        MessageContext context) {
          this.correlator = correlator;
          this.context = context;
          notifyAll();
      }
      
      public synchronized void set(
        MessageExchangeCorrelator correlator,
        Throwable throwable) {
          this.correlator = correlator;
          this.exception = throwable;
          notifyAll();
      }
      
      public synchronized void waitForNotify()
        throws InterruptedException {
          wait();
          return;
      }
      
      public synchronized void waitForNotify(long timeout)
        throws InterruptedException {
          wait(timeout);
          return;
      }
      
    }
  
    public class Listener 
      implements MessageExchangeReceiveListener,
                  MessageExchangeFaultListener {
                    
      protected Holder holder;
      
      public Listener(Holder holder) {
        this.holder = holder;
      }
                    
      /**
       * @see org.apache.axis.ime.MessageExchangeReceiveListener#onReceive(MessageExchangeCorrelator, MessageContext)
       */
      public void onReceive(
        MessageExchangeCorrelator correlator,
        MessageContext context) {
          holder.set(correlator,context);
      }
  
      /**
       * @see org.apache.axis.ime.MessageExchangeFaultListener#onFault(MessageExchangeCorrelator, Throwable)
       */
      public void onFault(
        MessageExchangeCorrelator correlator,
        Throwable exception) {
          holder.set(correlator,exception);
      }
      
    }
  
  
    private class ReceiverListener 
      implements MessageExchangeContextListener {
        
      /**
       * @see org.apache.axis.ime.MessageExchangeContextListener#onMessageExchangeContext(MessageExchangeContext)
       */
      public void onMessageExchangeContext(
        MessageExchangeContext context) {
  
          MessageContext msgContext = 
            context.getMessageContext();
          MessageExchangeCorrelator correlator = 
            context.getMessageExchangeCorrelator();
  
          try {
            // there should be code here to see if the message
            // contains a fault.  if so, the fault listener should
            // be invoked
            if (msgContext != null &&
                msgContext.getResponseMessage() != null &&
                receiveListener != null) {
              receiveListener.onReceive(correlator, msgContext);
            }        
          } catch (Exception exception) {
            if (faultListener != null) 
              faultListener.onFault(
                correlator, exception);
          }
        
      }
    }
    /**
     * @see org.apache.axis.ime.MessageExchangeLifecycle#awaitShutdown()
     */
    public void awaitShutdown() 
      throws InterruptedException {
      provider.awaitShutdown();
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchangeLifecycle#awaitShutdown(long)
     */
    public void awaitShutdown(long timeout)
      throws InterruptedException {
      provider.awaitShutdown(timeout);
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchangeLifecycle#init()
     */
    public void init() {
      provider.init();
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchangeLifecycle#shutdown()
     */
    public void shutdown() {
      provider.shutdown();
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchangeLifecycle#shutdown(boolean)
     */
    public void shutdown(boolean force) {
      provider.shutdown(force);
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchange#receive()
     */
    public MessageContext receive() throws AxisFault {
      throw new UnsupportedOperationException();
    }
  
    /**
     * @see org.apache.axis.ime.MessageExchange#receive(long)
     */
    public MessageContext receive(long timeout) throws AxisFault {
      throw new UnsupportedOperationException();
    }
  
  }
  
  
  
  1.1                  xml-axis/java/src/org/apache/axis/ime/internal/MessageExchangeProvider2.java
  
  Index: MessageExchangeProvider2.java
  ===================================================================
  package org.apache.axis.ime.internal;
  
  import org.apache.axis.ime.MessageExchangeContextListener;
  import org.apache.axis.ime.MessageExchange;
  
  /**
   * Serves as a base class for MessageExchangeProviders that
   * need to thread pooling only on  send message flows (as 
   * opposed to MessageExchangeProvider1 which does thread 
   * pooling on send AND receive flows)
   * 
   * @author James M Snell (jasnell@us.ibm.com)
   */
  public abstract class MessageExchangeProvider2
    extends MessageExchangeProvider {
  
    protected abstract MessageExchangeContextListener createSendMessageContextListener();
  
    public void init(long THREAD_COUNT) {
      if (initialized)
        throw new IllegalStateException();
      for (int n = 0; n < THREAD_COUNT; n++) {
        WORKERS.addWorker(SEND, createSendMessageContextListener());
      }
      initialized = true;
    }
    
  }
  
  
  
  1.1                  xml-axis/java/src/org/apache/axis/ime/internal/MessageWorker.java
  
  Index: MessageWorker.java
  ===================================================================
  package org.apache.axis.ime.internal;
  
  import org.apache.axis.MessageContext;
  import org.apache.axis.ime.MessageChannel;
  import org.apache.axis.ime.MessageExchangeContext;
  import org.apache.axis.ime.MessageExchangeContextListener;
  
  /**
   * @author James M Snell (jasnell@us.ibm.com)
   */
  public class MessageWorker implements Runnable {
  
    protected static final long SELECT_TIMEOUT = 1000 * 30;
    
    protected MessageWorkerGroup pool;
    protected MessageChannel channel;
    protected MessageExchangeContextListener listener;
    
    private MessageWorker() {}
  
    public MessageWorker(
      MessageWorkerGroup pool,
      MessageChannel channel,
      MessageExchangeContextListener listener) {
      this.pool = pool;
      this.channel = channel;
      this.listener = listener;
    }
  
    public MessageExchangeContextListener getMessageExchangeContextListener() {
      return this.listener;
    }
    
    public MessageChannel getMessageChannel() {
      return this.channel;
    }
  
    /**
     * @see java.lang.Runnable#run()
     */
    public void run() {
      try {
        while (!pool.isShuttingDown()) {
          MessageExchangeContext context = channel.select(SELECT_TIMEOUT);
          if (context != null) 
            listener.onMessageExchangeContext(context);
        }
      } catch (Throwable t) {
        // kill the thread if any type of exception occurs.
        // don't worry, we'll create another one to replace it
        // if we're not currently in the process of shutting down.
        // once I get the logging function plugged in, we'll
        // log whatever errors do occur
      } finally {
        pool.workerDone(this);
      }
    }
  
  }
  
  
  
  1.1                  xml-axis/java/src/org/apache/axis/ime/internal/NonPersistentMessageChannel.java
  
  Index: NonPersistentMessageChannel.java
  ===================================================================
  package org.apache.axis.ime.internal;
  
  import java.util.Vector;
  import org.apache.axis.ime.MessageChannel;
  import org.apache.axis.ime.MessageExchangeContext;
  
  /**
   * Creates a non-persistent message channel.  Queued messages
   * are stored in memory. If the Channel instance is destroyed,
   * so is the Queue.
   * 
   * @author James M Snell (jasnell@us.ibm.com)
   */
  public class NonPersistentMessageChannel
    implements MessageChannel {
  
    private final KeyedQueue messages = new KeyedQueue();
  
    private MessageWorkerGroup WORKERS;
    
    public NonPersistentMessageChannel(
      MessageWorkerGroup workers) {
        this.WORKERS = workers;
    }
  
    public MessageExchangeContext peek() {
      KeyedNode node = null;
      synchronized(messages) {
        node = messages.peek();
      }
      if (node != null) {
        return (MessageExchangeContext)node.value;
      } else {
        return null;
      }
    }
  
    public void put(
      Object key, 
      MessageExchangeContext context) {
  
      if (key == null ||
          context == null)
            throw new IllegalArgumentException();
  
      synchronized(messages) {
        messages.put(new KeyedNode(key,context));
        messages.notify();
      }
    }
  
    public MessageExchangeContext cancel(Object key) {
      if (key == null)
        throw new IllegalArgumentException();
      MessageExchangeContext context = null;
      synchronized(messages) {
        KeyedNode node = messages.select(key); // will attempt to find an remove
        if (node != null) 
          context = (MessageExchangeContext)node.value;
        node.key = null;
        node.value = null;
      }
      return context;
    }
  
    public MessageExchangeContext[] selectAll() {
      Vector v = new Vector();
      KeyedNode node = null;
      synchronized(messages) {
        while ((node = messages.select()) != null) {
          v.add(node.value);
          node.key = null;
          node.value = null;
        }
      }
      MessageExchangeContext[] contexts = new 
        MessageExchangeContext[v.size()];
      v.copyInto(contexts);
      return contexts;
    }
  
    public MessageExchangeContext select()
      throws InterruptedException {
      for (;;) {
        if (WORKERS.isShuttingDown())
          throw new IllegalStateException();
        KeyedNode node = null;
        synchronized(messages) {
          node = messages.select();
        }
        if (node != null) {
          MessageExchangeContext context = (MessageExchangeContext)node.value;
          node.key = null;
          node.value = null;
          return context;
        } else {
          messages.wait();
        }
      }
    }
    
    public MessageExchangeContext select(long timeout)
      throws InterruptedException {
      for (;;) {
        if (WORKERS.isShuttingDown())
          throw new IllegalStateException();
        KeyedNode node = null;
        synchronized(messages) {
          node = messages.select();
        }
        if (node != null) {
          MessageExchangeContext context = (MessageExchangeContext)node.value;
          node.key = null;
          node.value = null;
          return context;
        } else {
          messages.wait(timeout);
        }
      }
    }
    
    public MessageExchangeContext select(Object key)
      throws InterruptedException {
      for (;;) {
        if (WORKERS.isShuttingDown())
          throw new IllegalStateException();
        KeyedNode node = null;
        synchronized(messages) {
          node = messages.select(key);
        }
        if (node != null) {
          MessageExchangeContext context = (MessageExchangeContext)node.value;
          node.key = null;
          node.value = null;
          return context;
        } else {
          messages.wait();
        }
      }
    }
  
    public MessageExchangeContext select(Object key, long timeout)
      throws InterruptedException {
      for (;;) {
        if (WORKERS.isShuttingDown())
          throw new IllegalStateException();
        KeyedNode node = null;
        synchronized(messages) {
          node = messages.select(key);
        }
        if (node != null) {
          MessageExchangeContext context = (MessageExchangeContext)node.value;
          node.key = null;
          node.value = null;
          return context;
        } else {
          messages.wait(timeout);
        }
      }
    }
  
  /// Support Classes ///
    protected static class KeyedNode {
      public Object key;
      public Object value;
      public KeyedNode next;
      public KeyedNode() {}
      public KeyedNode(
        Object key, 
        Object value) {
          this.key = key;
          this.value = value;
      }
      public KeyedNode(
        Object key, 
        Object value, 
        KeyedNode next) {
          this(key,value);
          this.next = next;
      }
    }
    
    protected static class KeyedQueue {
      
      protected KeyedNode head;
      protected KeyedNode last;
      
      protected void put(KeyedNode node) {
        if (last == null) {
          last = head = node;
        } else {
          last = last.next = node;
        }
      }
      
      protected KeyedNode select() {
        KeyedNode node = head;
        if (node != null && (head = node.next) == null) {
          last = null;
        }
        if (node != null) 
          node.next = null;
        return node;
      }
      
      protected KeyedNode select(Object key) {
        KeyedNode previous = null;
        for (KeyedNode node = head;node != null;node = node.next) {
          if (node.key.equals(key)) {
            if (previous != null) 
              previous.next = node.next;
            node.next = null;
            return node;
          }
          previous = node;
        }
        return null;
      }
      
      protected KeyedNode peek() {
        KeyedNode node = head;
        return node;
      }
      
    }
      
  }
  
  
  
  1.1                  xml-axis/java/src/org/apache/axis/ime/internal/MessageExchangeProvider.java
  
  Index: MessageExchangeProvider.java
  ===================================================================
  package org.apache.axis.ime.internal;
  
  import org.apache.axis.ime.MessageExchangeFactory;
  import org.apache.axis.ime.MessageExchange;
  import org.apache.axis.ime.MessageChannel;
  
  /**
   * Serves as a base class for MessageExchangeProviders that
   * need to thread pooling on send AND receive message 
   * flows (as opposed to MessageExchangeProvider2 which only
   * does thread pooling on send flows).
   * 
   * @author James M Snell (jasnell@us.ibm.com)
   */
  public abstract class MessageExchangeProvider
    implements MessageExchangeFactory {
  
    public static final long DEFAULT_THREAD_COUNT = 5;
   
    protected final MessageWorkerGroup WORKERS = new MessageWorkerGroup();
    protected final MessageChannel SEND        = new NonPersistentMessageChannel(WORKERS);
    protected final MessageChannel RECEIVE     = new NonPersistentMessageChannel(WORKERS);
   
    protected boolean initialized = false;
    
    public MessageExchange createMessageExchange() {
      return new MessageExchangeImpl(this,SEND,RECEIVE);
    }
    
    public void init() {
      init(DEFAULT_THREAD_COUNT);
    }
    
    public abstract void init(long THREAD_COUNT);
    
    public void shutdown() {
      shutdown(false);
    }
  
    public void shutdown(boolean force) {
      if (!force) {
        WORKERS.safeShutdown();
      } else {
        WORKERS.shutdown();
      }
    }
    
    public void awaitShutdown()
      throws InterruptedException {
        WORKERS.awaitShutdown();
    }
    
    public void awaitShutdown(long shutdown)
      throws InterruptedException {
        WORKERS.awaitShutdown(shutdown);
    }
    
  }
  
  
  
  1.1                  xml-axis/java/src/org/apache/axis/ime/internal/MessageWorkerGroup.java
  
  Index: MessageWorkerGroup.java
  ===================================================================
  package org.apache.axis.ime.internal;
  
  import java.util.Map;
  import java.util.Hashtable;
  import java.util.Iterator;
  import org.apache.axis.ime.MessageChannel;
  import org.apache.axis.ime.MessageExchangeContextListener;
  
  /**
   * @author James M Snell (jasnell@us.ibm.com)
   */
  public class MessageWorkerGroup {
  
    protected Map threads = new Hashtable();
    protected boolean interrupt;
    protected long threadcount;
    public boolean _shutdown;
  
    /**
     * Returns true if all workers have been shutdown
     */
    public boolean isShutdown() {
      synchronized(this) {
        return _shutdown && threadcount == 0;
      }
    }
  
    /**
     * Returns true if all workers are in the process of shutting down
     */  
    public boolean isShuttingDown() {
      synchronized(this) {
        return _shutdown;
      }
    }
  
    /**
     * Returns the total number of currently active workers
     */  
    public long getWorkerCount() {
      synchronized(this) {
        return threadcount;
      }
    }
    
    /**
     * Adds a new worker to the pool
     */
    public void addWorker(
      MessageChannel channel, 
      MessageExchangeContextListener listener) {
        if (_shutdown)
          throw new IllegalStateException();
        MessageWorker worker =
          new MessageWorker(this, channel, listener);
        Thread thread = new Thread(worker);
        threads.put(worker,thread);
        threadcount++;
        thread.start();
    }
  
    /**
     * Forcefully interrupt all workers
     */
    public void interruptAll() {
      synchronized(threads) {
        for (Iterator i = threads.values().iterator(); i.hasNext();) {
          Thread t = (Thread)i.next();
          t.interrupt();
        }
      }
    }
    
    /**
     * Forcefully shutdown the pool
     */
    public void shutdown() {
      synchronized(this) {
        _shutdown = true;
      }
      interruptAll();
    }
  
    /**
     * Forcefully shutdown the pool
     */
    public void safeShutdown() {
      synchronized(this) {
        _shutdown = true;
      }
    }
    
    /**
     * Await shutdown of the worker
     */  
    public synchronized void awaitShutdown()
      throws InterruptedException {
        if (!_shutdown)
          throw new IllegalStateException();
        while (threadcount > 0)
          wait();
    }
    
    /**
     * Await shutdown of the worker
     */
    public synchronized boolean awaitShutdown(long timeout)
      throws InterruptedException {
        if (!_shutdown)
          throw new IllegalStateException();
        if (threadcount == 0) 
          return true;
        long waittime = timeout;
        if (waittime <= 0) 
          return false;
        long start = System.currentTimeMillis();
        for (;;) {
          wait(waittime);
          if (threadcount == 0) 
            return true;
          waittime = timeout - System.currentTimeMillis();
          if (waittime <= 0)
            return false;
        }
    }
    
    /**
     * Used by MessageWorkers to notify the pool that it is done
     */
    protected synchronized void workerDone(
      MessageWorker worker) {
        threads.remove(worker);
        if (--threadcount == 0 && _shutdown) {
          notifyAll();
        }
        if (!_shutdown) {
          addWorker(
            worker.getMessageChannel(),
            worker.getMessageExchangeContextListener());
        }
    }
  }
  
  
  
  
  1.1                  xml-axis/java/src/org/apache/axis/ime/internal/util/uuid/UUIDGenFactory.java
  
  Index: UUIDGenFactory.java
  ===================================================================
  
  /**
   * 
   *  UUIDGen adopted from the juddi project
   *  (http://sourceforge.net/projects/juddi/)
   * 
   */
  
  package org.apache.axis.ime.internal.util.uuid;
  
  import java.io.*;
  
  /**
   * A Universally Unique Identifier (UUID) is a 128 bit number generated
   * according to an algorithm that is garanteed to be unique in time and space
   * from all other UUIDs. It consists of an IEEE 802 Internet Address and
   * various time stamps to ensure uniqueness. For a complete specification,
   * see ftp://ietf.org/internet-drafts/draft-leach-uuids-guids-01.txt [leach].
   *
   * @author  Steve Viens
   * @version 1.0 11/7/2000
   * @since   JDK1.2.2
   */
  public abstract class UUIDGenFactory
  {
    private static final String defaultUUIDGenClassName = "org.apache.axis.ime.internal.util.uuid.SimpleUUIDGen";
  
    /**
     * getInstance
     *
     * Returns the singleton instance of UUIDGen
     */
    public static UUIDGen getUUIDGen(String uuidgenClassName)
    {
      UUIDGen uuidgen = null;
  
      if ((uuidgenClassName == null) || (uuidgenClassName.length() == 0))
      {
        // use the default UUIDGen implementation
        uuidgenClassName = defaultUUIDGenClassName;
      }
  
      Class uuidgenClass = null;
      try
      {
        // instruct the class loader to load the UUIDGen implementation
        uuidgenClass = java.lang.Class.forName(uuidgenClassName);
      }
      catch(ClassNotFoundException e)
      {
        throw new RuntimeException("The implementation of UUIDGen interface " +
    "specified cannot be found in the classpath: "+uuidgenClassName +
    " not found.");
      }
  
      try
      {
        // try to instantiate the UUIDGen subclass
        uuidgen = (UUIDGen)uuidgenClass.newInstance();
      }
      catch(java.lang.Exception e)
      {
        throw new RuntimeException("Exception encountered while attempting to " +
    "instantiate the specified implementation of UUIDFactory: " +
    uuidgenClass.getName() + "; message = " + e.getMessage());
      }
  
      return uuidgen;
    }
  
    /**
     * Release any aquired external resources and stop any background threads.
     */
    public static void destroyUUIDGen(UUIDGen uuidgen)
    {
      if (uuidgen != null)
        uuidgen.destroy();
    }
  
  
    /***************************************************************************/
    /***************************** TEST DRIVER *********************************/
    /***************************************************************************/
  
  
    // test driver
    public static void main(String argc[])
    {
      long startTime = 0;
      long endTime = 0;
      UUIDGen uuidgen = null;
  
      uuidgen = UUIDGenFactory.getUUIDGen(null);
  //    uuidgen = UUIDGenFactory.getUUIDGen("org.juddi.uuidgen.SimpleUUIDGen");
      startTime = System.currentTimeMillis();
      for (int i = 1; i <= 50; ++i)
      {
        String u = uuidgen.nextUUID();
        System.out.println( i + ":  " + u );
      }
      endTime = System.currentTimeMillis();
      System.out.println("SimpleJavaUUIDGen took "+(endTime-startTime)+" milliseconds");
  
      UUIDGenFactory.destroyUUIDGen(uuidgen);
    }
  }
  
  
  1.1                  xml-axis/java/src/org/apache/axis/ime/internal/util/uuid/SimpleUUIDGen.java
  
  Index: SimpleUUIDGen.java
  ===================================================================
  
  /**
   * 
   *  UUIDGen adopted from the juddi project
   *  (http://sourceforge.net/projects/juddi/)
   * 
   */
  
  package org.apache.axis.ime.internal.util.uuid;
  
  import java.math.*;
  import java.util.*;
  import java.security.SecureRandom;
  
  /**
   * Used to create new universally unique identifiers or UUID's (sometimes called
   * GUID's).  UDDI UUID's are allways formmated according to DCE UUID conventions.
   *
   * @author  Maarten Coene
   * @author  Steve Viens
   * @version 0.3.2 3/25/2001
   * @since   JDK1.2.2
   */
  public class SimpleUUIDGen implements UUIDGen
  {
    private static final BigInteger countStart = new BigInteger("-12219292800000");  // 15 October 1582
    private static final int clock_sequence = (new Random()).nextInt(16384);
  
    /**
     * Creates a new UUID. The algorithm used is described by The Open Group.
     * See <a href="http://www.opengroup.org/onlinepubs/009629399/apdxa.htm">
     * Universal Unique Identifier</a> for more details.
     * <p>
     * Due to a lack of functionality in Java, a part of the UUID is a secure
     * random. This results in a long processing time when this method is called
     * for the first time.
     */
    public String nextUUID()
    {
      // TODO: this method has to be checked for it's correctness. I'm not sure the standard is
      // implemented correctly.
  
      // the count of 100-nanosecond intervals since 00:00:00.00 15 October 1582
      BigInteger count;
  
      // the number of milliseconds since 1 January 1970
      BigInteger current = BigInteger.valueOf(System.currentTimeMillis());
  
      // the number of milliseconds since 15 October 1582
      BigInteger countMillis = current.subtract(countStart);
  
      // the result
      count = countMillis.multiply(BigInteger.valueOf(10000));
  
      String bitString = count.toString(2);
      if (bitString.length() < 60)
      {
        int nbExtraZeros  = 60 - bitString.length();
        String extraZeros = new String();
        for (int i=0; i<nbExtraZeros; i++)
    extraZeros = extraZeros.concat("0");
  
        bitString = extraZeros.concat(bitString);
      }
  
      byte[] bits = bitString.getBytes();
  
      // the time_low field
      byte[] time_low = new byte[32];
      for (int i=0; i<32; i++)
        time_low[i] = bits[bits.length - i - 1];
  
      // the time_mid field
      byte[] time_mid = new byte[16];
      for (int i=0; i<16; i++)
        time_mid[i] = bits[bits.length - 32 - i - 1];
  
      // the time_hi_and_version field
      byte[] time_hi_and_version = new byte[16];
      for (int i=0; i<12; i++)
        time_hi_and_version[i] = bits[bits.length - 48 - i - 1];
  
      time_hi_and_version[12] = ((new String("1")).getBytes())[0];
      time_hi_and_version[13] = ((new String("0")).getBytes())[0];
      time_hi_and_version[14] = ((new String("0")).getBytes())[0];
      time_hi_and_version[15] = ((new String("0")).getBytes())[0];
  
      // the clock_seq_low field
      BigInteger clockSequence = BigInteger.valueOf(clock_sequence);
      String clockString = clockSequence.toString(2);
      if (clockString.length() < 14)
      {
        int nbExtraZeros  = 14 - bitString.length();
        String extraZeros = new String();
        for (int i=0; i<nbExtraZeros; i++)
    extraZeros = extraZeros.concat("0");
  
        clockString = extraZeros.concat(bitString);
      }
  
      byte[] clock_bits = clockString.getBytes();
      byte[] clock_seq_low = new byte[8];
      for (int i=0; i<8; i++)
        clock_seq_low[i] = clock_bits[clock_bits.length - i - 1];
  
      // the clock_seq_hi_and_reserved
      byte[] clock_seq_hi_and_reserved = new byte[8];
      for (int i=0; i<6; i++)
        clock_seq_hi_and_reserved[i] = clock_bits[clock_bits.length - 8 - i - 1];
  
      clock_seq_hi_and_reserved[6] = ((new String("0")).getBytes())[0];
      clock_seq_hi_and_reserved[7] = ((new String("1")).getBytes())[0];
  
      String timeLow = Long.toHexString((new BigInteger(new String(reverseArray(time_low)), 2)).longValue());
      if (timeLow.length() < 8)
      {
        int nbExtraZeros = 8 - timeLow.length();
        String extraZeros = new String();
        for (int i=0; i<nbExtraZeros; i++)
    extraZeros = extraZeros.concat("0");
  
        timeLow = extraZeros.concat(timeLow);
      }
  
      String timeMid = Long.toHexString((new BigInteger(new String(reverseArray(time_mid)), 2)).longValue());
      if (timeMid.length() < 4)
      {
        int nbExtraZeros = 4 - timeMid.length();
        String extraZeros = new String();
        for (int i=0; i<nbExtraZeros; i++)
    extraZeros = extraZeros.concat("0");
        timeMid = extraZeros.concat(timeMid);
      }
  
      String timeHiAndVersion = Long.toHexString((new BigInteger(new String(reverseArray(time_hi_and_version)), 2)).longValue());
      if (timeHiAndVersion.length() < 4)
      {
        int nbExtraZeros = 4 - timeHiAndVersion.length();
        String extraZeros = new String();
        for (int i=0; i<nbExtraZeros; i++)
          extraZeros = extraZeros.concat("0");
  
        timeHiAndVersion = extraZeros.concat(timeHiAndVersion);
      }
  
      String clockSeqHiAndReserved = Long.toHexString((new BigInteger(new String(reverseArray(clock_seq_hi_and_reserved)), 2)).longValue());
      if (clockSeqHiAndReserved.length() < 2)
      {
        int nbExtraZeros = 2 - clockSeqHiAndReserved.length();
        String extraZeros = new String();
        for (int i=0; i<nbExtraZeros; i++)
    extraZeros = extraZeros.concat("0");
  
        clockSeqHiAndReserved = extraZeros.concat(clockSeqHiAndReserved);
      }
  
      String clockSeqLow = Long.toHexString((new BigInteger(new String(reverseArray(clock_seq_low)), 2)).longValue());
      if (clockSeqLow.length() < 2)
      {
        int nbExtraZeros = 2 - clockSeqLow.length();
        String extraZeros = new String();
        for (int i=0; i<nbExtraZeros; i++)
    extraZeros = extraZeros.concat("0");
  
        clockSeqLow = extraZeros.concat(clockSeqLow);
      }
  
      // problem: the node should be the IEEE 802 ethernet address, but can not
      // be retrieved in Java yet.
      // see bug ID 4173528
      // workaround (also suggested in bug ID 4173528)
      // If a system wants to generate UUIDs but has no IEE 802 compliant
      // network card or other source of IEEE 802 addresses, then this section
      // describes how to generate one.
      // The ideal solution is to obtain a 47 bit cryptographic quality random
      // number, and use it as the low 47 bits of the node ID, with the most
      // significant bit of the first octet of the node ID set to 1. This bit
      // is the unicast/multicast bit, which will never be set in IEEE 802
      // addresses obtained from network cards; hence, there can never be a
      // conflict between UUIDs generated by machines with and without network
      // cards.
      Random secureRandom = null;
      try {
        secureRandom = SecureRandom.getInstance("SHA1PRNG", "SUN");
      } catch (Exception e) {
        secureRandom = new Random();
      }
  
      long nodeValue = secureRandom.nextLong();
      nodeValue = Math.abs(nodeValue);
      while (nodeValue > 140737488355328L)
      {
        nodeValue = secureRandom.nextLong();
        nodeValue = Math.abs(nodeValue);
      }
  
      BigInteger nodeInt = BigInteger.valueOf(nodeValue);
      String nodeString = nodeInt.toString(2);
      if (nodeString.length() < 47)
      {
        int nbExtraZeros = 47 - nodeString.length();
        String extraZeros = new String();
        for (int i=0; i<nbExtraZeros; i++)
    extraZeros = extraZeros.concat("0");
  
        nodeString = extraZeros.concat(nodeString);
      }
  
      byte[] node_bits = nodeString.getBytes();
      byte[] node = new byte[48];
      for (int i=0; i<47; i++)
        node[i] = node_bits[node_bits.length - i - 1];
  
      node[47] = ((new String("1")).getBytes())[0];
      String theNode = Long.toHexString((new BigInteger(new String(reverseArray(node)), 2)).longValue());
      if (theNode.length() < 12)
      {
        int nbExtraZeros = 12 - theNode.length();
        String extraZeros = new String();
        for (int i=0; i<nbExtraZeros; i++)
    extraZeros = extraZeros.concat("0");
        theNode = extraZeros.concat(theNode);
      }
  
      String result = timeLow + "-" + timeMid +"-" + timeHiAndVersion + "-" + clockSeqHiAndReserved + clockSeqLow + "-" + theNode;
  
      return result.toUpperCase();
    }
  
    private static byte[] reverseArray(byte[] bits)
    {
      byte[] result = new byte[bits.length];
      for (int i=0; i<result.length; i++)
        result[i] = bits[result.length - 1 - i];
  
      return result;
    }
  
    // test driver
    public static void main(String argc[])
    {
      UUIDGen uuidgen = new SimpleUUIDGen();
      for (int i = 1; i <= 250; ++i)
      {
        String uuid = uuidgen.nextUUID();
        System.out.println( i + ":  " + uuid );
      }
    }
  
    public void destroy()
    {
    }
  
    public void init()
    {
    }
  }
  
  
  
  1.1                  xml-axis/java/src/org/apache/axis/ime/internal/util/uuid/UUIDGen.java
  
  Index: UUIDGen.java
  ===================================================================
  
  /**
   * 
   *  UUIDGen adopted from the juddi project
   *  (http://sourceforge.net/projects/juddi/)
   * 
   */
  
  package org.apache.axis.ime.internal.util.uuid;
  
  import java.io.*;
  
  /**
   * A Universally Unique Identifier (UUID) is a 128 bit number generated
   * according to an algorithm that is garanteed to be unique in time and space
   * from all other UUIDs. It consists of an IEEE 802 Internet Address and
   * various time stamps to ensure uniqueness. For a complete specification,
   * see ftp://ietf.org/internet-drafts/draft-leach-uuids-guids-01.txt [leach].
   *
   * @author  Steve Viens
   * @version 1.0 11/7/2000
   * @since   JDK1.2.2
   */
  public interface UUIDGen
  {
    public void init();
    public void destroy();
    public String nextUUID();
  }
  
  
  1.1                  xml-axis/java/src/org/apache/axis/ime/internal/util/handler/HandlerWrapper1.java
  
  Index: HandlerWrapper1.java
  ===================================================================
  package org.apache.axis.ime.internal.util.handler;
  
  import org.apache.axis.Message;
  import org.apache.axis.MessageContext;
  import org.apache.axis.ime.MessageExchange;
  import org.apache.axis.ime.MessageExchangeContext;
  import org.apache.axis.ime.MessageExchangeContextListener;
  import org.apache.axis.ime.MessageExchangeFaultListener;
  import org.apache.axis.ime.MessageExchangeStatus;
  import org.apache.axis.ime.MessageExchangeStatusListener;
  import org.apache.axis.ime.MessageExchangeReceiveListener;
  import org.apache.axis.ime.MessageExchangeCorrelator;
  import org.apache.axis.ime.internal.NonPersistentMessageChannel;
  import org.apache.axis.ime.internal.MessageExchangeImpl;
  import org.apache.axis.ime.internal.MessageExchangeProvider1;
  import org.apache.axis.ime.internal.MessageWorkerGroup;
  import org.apache.axis.Handler;
  
  /**
   * Used to wrap synchronous handlers (e.g. Axis 1.0 transports)
   * 
   * @author James M Snell (jasnell@us.ibm.com)
   */
  public class HandlerWrapper1 
    extends MessageExchangeProvider1 {
  
    private Handler handler;
    
    public HandlerWrapper1(Handler handler) {
      this.handler = handler;
    }
  
    /**
     * @see org.apache.axis.ime.internal.MessageExchangeProvider1#createReceiveMessageContextListener()
     */
    protected MessageExchangeContextListener createReceiveMessageContextListener() {
      return new ReceiveListener();
    }
  
    /**
     * @see org.apache.axis.ime.internal.MessageExchangeProvider1#createSendMessageContextListener()
     */
    protected MessageExchangeContextListener createSendMessageContextListener() {
      return new SendListener(handler);
    }
  
  
    public class SendListener
      implements MessageExchangeContextListener {
        
      private Handler handler;
      
      public SendListener(Handler handler) {
        this.handler = handler;
      }
        
      /**
       * @see org.apache.axis.ime.MessageExchangeContextListener#onMessageExchangeContext(MessageExchangeContext)
       */
      public void onMessageExchangeContext(
        MessageExchangeContext context) {
          try {
            MessageContext msgContext = 
              context.getMessageContext();
            MessageExchangeCorrelator correlator = 
              context.getMessageExchangeCorrelator();
              
            // should I do init's and cleanup's in here?  
            handler.invoke(msgContext);
            
            
            RECEIVE.put(correlator, context);
          } catch (Exception exception) {
            MessageExchangeFaultListener listener = 
              context.getMessageExchangeFaultListener();
            if (listener != null) 
              listener.onFault(
                context.getMessageExchangeCorrelator(),
                exception);
          }
      }
    }
    
    public class ReceiveListener
      implements MessageExchangeContextListener {
        
      /**
       * @see org.apache.axis.ime.MessageExchangeContextListener#onMessageExchangeContext(MessageExchangeContext)
       */
      public void onMessageExchangeContext(
        MessageExchangeContext context) {
  
          MessageExchangeReceiveListener receiveListener = 
            context.getMessageExchangeReceiveListener();
          MessageExchangeFaultListener faultListener = 
            context.getMessageExchangeFaultListener();
          MessageContext msgContext = 
            context.getMessageContext();
          MessageExchangeCorrelator correlator = 
            context.getMessageExchangeCorrelator();
  
          try {
            // there should be code here to see if the message
            // contains a fault.  if so, the fault listener should
            // be invoked
            if (msgContext != null &&
                msgContext.getResponseMessage() != null &&
                receiveListener != null) {
              receiveListener.onReceive(correlator, msgContext);
            }        
          } catch (Exception exception) {
            if (faultListener != null) 
              faultListener.onFault(
                correlator, exception);
          }
      }
    }
  }
  
  
  
  1.1                  xml-axis/java/src/org/apache/axis/ime/internal/util/handler/HandlerWrapper2.java
  
  Index: HandlerWrapper2.java
  ===================================================================
  package org.apache.axis.ime.internal.util.handler;
  
  import org.apache.axis.Message;
  import org.apache.axis.MessageContext;
  import org.apache.axis.ime.MessageExchange;
  import org.apache.axis.ime.MessageExchangeContext;
  import org.apache.axis.ime.MessageExchangeContextListener;
  import org.apache.axis.ime.MessageExchangeFaultListener;
  import org.apache.axis.ime.MessageExchangeStatus;
  import org.apache.axis.ime.MessageExchangeStatusListener;
  import org.apache.axis.ime.MessageExchangeReceiveListener;
  import org.apache.axis.ime.MessageExchangeCorrelator;
  import org.apache.axis.ime.internal.NonPersistentMessageChannel;
  import org.apache.axis.ime.internal.MessageExchangeImpl;
  import org.apache.axis.ime.internal.MessageExchangeProvider2;
  import org.apache.axis.ime.internal.MessageWorkerGroup;
  import org.apache.axis.Handler;
  
  /**
   * Used to wrap synchronous handlers (e.g. Axis 1.0 transports)
   * 
   * @author James M Snell (jasnell@us.ibm.com)
   */
  public class HandlerWrapper2 
    extends MessageExchangeProvider2 {
  
    private Handler handler;
    
    public HandlerWrapper2(Handler handler) {
      this.handler = handler;
    }
  
    /**
     * @see org.apache.axis.ime.internal.MessageExchangeProvider1#createSendMessageContextListener()
     */
    protected MessageExchangeContextListener createSendMessageContextListener() {
      return new SendListener(handler);
    }
  
  
    public class SendListener
      implements MessageExchangeContextListener {
        
      private Handler handler;
      
      public SendListener(Handler handler) {
        this.handler = handler;
      }
        
      /**
       * @see org.apache.axis.ime.MessageExchangeContextListener#onMessageExchangeContext(MessageExchangeContext)
       */
      public void onMessageExchangeContext(
        MessageExchangeContext context) {
          try {
            MessageContext msgContext = 
              context.getMessageContext();
            MessageExchangeCorrelator correlator = 
              context.getMessageExchangeCorrelator();
              
            // should I do init's and cleanup's in here?  
            handler.invoke(msgContext);
            
            
            RECEIVE.put(correlator, context);
          } catch (Exception exception) {
            MessageExchangeFaultListener listener = 
              context.getMessageExchangeFaultListener();
            if (listener != null) 
              listener.onFault(
                context.getMessageExchangeCorrelator(),
                exception);
          }
      }
    }
  }
  
  
  

Mime
View raw message