This method is used to create a proxy queue that is used for asynchronous consumers with an
associated message ordering context.

@param context
@param id
@param seqNumber

@throws SIResourceException
@throws SIInvalidStateForOperationException
777926
public synchronized AsynchConsumerProxyQueue createOrderedProxyQueue(OrderingContext context,
                                                                        short id,
                                                                        short seqNumber)
      throws SIResourceException, SIIncorrectCallException
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "createOrderedProxyQueue", context);
      
      checkClosed();
      
      AsynchConsumerProxyQueue proxyQueue = new OrderedSessionProxyQueueImpl(this, 
                                                                             id, 
                                                                             conversation, 
                                                                             context);
      idToProxyQueueMap.put(new ImmutableId(id), proxyQueue);
      
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "createOrderedProxyQueue", proxyQueue);
      return proxyQueue;
   }
868359
function queueOrRequest( el ){
			var url = el.data( "url" );
			if( o.proxy && $.inArray( url, urllist ) === -1 ){
				urllist.push( url );
				elQueue = elQueue.add( el );
			}
			else{
				AI.makeReq( url, el );
			}
		}
1295963
public void forceFlush(SIBUuid12 streamID)
    throws SIResourceException, SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(this, tc, "forceFlush", new Object[] { streamID });

    // Synchronize to resolve racing messages.
    synchronized (flushMap)
    {
      FlushQueryRecord entry = flushMap.remove(streamID);

      // Remove the entry (we may not have even had
      // one), then clean up any existing stream state.  Also, make
      // sure we turn off the alarm if there IS an entry.  Note that
      // an alarm will always be present if an entry exists.
      if (entry != null)
         entry.resend.cancel();

      flush(streamID);

    }

    //If all the inbound stream sets are empty, queue the destination that the
    //inbound streams are for to the asynch deletion thread, incase any cleanup
    //of the destination is required.  If not, the asynch deletion thread will do
    //nothing.
 //   if (isEmpty())
 //   {
 //     DestinationManager destinationManager = messageProcessor.getDestinationManager();
 //     BaseDestinationHandler destinationHandler = protocolItemStream.getDestinationHandler();
 //     destinationManager.markDestinationAsCleanUpPending(destinationHandler);
 //   }


    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "forceFlush");
  }
1249910
private synchronized void onContextReady(final ContextStatusPOJO contextStatus,
                                           final boolean notifyClientOnNewActiveContext) {
    assert ContextState.READY == contextStatus.getContextState();
    final String contextID = contextStatus.getContextId();
    // This could be the first message we get from that context
    if (this.isUnknownContextId(contextID)) {
      this.onNewContext(contextStatus, notifyClientOnNewActiveContext);
    }

    // Dispatch the messages to the application, if there are any.
    for (final ContextMessagePOJO
             contextMessage : contextStatus.getContextMessageList()) {
      final byte[] theMessage = contextMessage.getMessage();
      final String sourceID = contextMessage.getSourceId();
      final long sequenceNumber = contextMessage.getSequenceNumber();
      this.messageDispatcher.onContextMessage(new ContextMessageImpl(theMessage, contextID, sourceID, sequenceNumber));
    }

  }
380393
@Override
	public void queueEnvelope(Envelope envelope) {
		// The sequence number of the envelope to be queued
		final int sequenceNumber = envelope.getSequenceNumber();

		synchronized (this.queuedEnvelopes) {

			if (this.destroyCalled) {
				final Buffer buffer = envelope.getBuffer();
				if (buffer != null) {
					buffer.recycleBuffer();
				}
				return;
			}

			final int expectedSequenceNumber = this.lastReceivedEnvelope + 1;
			if (sequenceNumber != expectedSequenceNumber) {
				// This is a problem, now we are actually missing some data
				reportIOException(new IOException("Expected data packet " + expectedSequenceNumber + " but received " + sequenceNumber));

				// notify that something (an exception) is available
				notifyGateThatInputIsAvailable();

				if (LOG.isDebugEnabled()) {
					LOG.debug("Input channel " + this.toString() + " expected envelope " + expectedSequenceNumber
							+ " but received " + sequenceNumber);
				}

				// rescue the buffer
				final Buffer buffer = envelope.getBuffer();
				if (buffer != null) {
					buffer.recycleBuffer();
				}
			} else {

				this.queuedEnvelopes.add(envelope);
				this.lastReceivedEnvelope = sequenceNumber;
				this.lastSourceID = envelope.getSource();

				// Notify the channel about the new data. notify as much as there is (buffer plus once per event)
				if (envelope.getBuffer() != null) {
					notifyGateThatInputIsAvailable();
				}

				List<? extends AbstractEvent> events = envelope.deserializeEvents();

				if (events != null) {
					for (int i = 0; i < events.size(); i++) {
						notifyGateThatInputIsAvailable();
					}
				}
			}
		}
	}
712665
@Override
    public java.util.concurrent.Future<CreateQueueResult> createQueueAsync(String queueName) {

        return createQueueAsync(new CreateQueueRequest().withQueueName(queueName));
    }
1310945
public byte[] sendQuerySm(OutputStream os, int sequenceNumber,
            String messageId, TypeOfNumber sourceAddrTon,
            NumberingPlanIndicator sourceAddrNpi, String sourceAddr)
            throws PDUStringException, IOException {
        synchronized (os) {
            return pduSender.sendQuerySm(os, sequenceNumber, messageId,
                    sourceAddrTon, sourceAddrNpi, sourceAddr);
        }
    }
358467
public void deliverAsyncException(Throwable e)
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "deliverAsyncException", e);

      if (proxyQueue != null)
      {
         proxyQueue.deliverException(e);
      }
      else
      {
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "** Odd - we are not async?!");
      }

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "deliverAsyncException");
   }
511717
public JsMessage next() throws SIResourceException, SISessionDroppedException 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "next");
    
    JsMessage msg = null;
    Iterator<BrowseCursor> it = cursors.iterator();
    while(it.hasNext() && msg==null)
      msg = it.next().next();     
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "next");
    
    return msg;
  }
1371575
public void deliverBatch(int batchSize, short sessionId, ConversationHelper convHelper)
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "deliverBatch",
                                           new Object[]
                                           {
                                             ""+batchSize,
                                             ""+sessionId,
                                             convHelper
                                           });

      QueueData queueData = queue.get(0);
      AsynchConsumerProxyQueue proxyQueue = (AsynchConsumerProxyQueue)queueData.getProxyQueue();
      proxyQueue.setAsynchConsumerThread(Thread.currentThread());
      final ConsumerSessionProxy cs = (ConsumerSessionProxy)proxyQueue.getDestinationSessionProxy();

      cs.resetCallbackThreadState();

      boolean unlockAllMessages = false;
      try
      {
         JsMessage[] msgs = getBatch(batchSize, convHelper);

         LockedMessageEnumerationImpl lockedMsgEnum =                                     // D218666.1
                  new LockedMessageEnumerationImpl(proxyQueue,
                                                   this,
                                                   msgs,
                                                   Thread.currentThread(),
                                                   proxyQueue.getLMEOperationMonitor());

         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, " ** About to call user callback **");
         proxyQueue.getAsynchConsumerCallback().consumeMessages(lockedMsgEnum);
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, " ** User callback has returned  **");

         // Check the remaining message count. If it is not 0, then the user did
         // not view all the messages and we need to unlock them.
         int remainingLockedMessages = lockedMsgEnum.getRemainingMessageCount();
         if (remainingLockedMessages != 0)
         {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "There are still " + remainingLockedMessages + " locked messages! - Unlocking them");

            lockedMsgEnum.unlockUnseen();                                                 // D218666.1
         }
      }
      catch(Throwable t)
      {
         // Start f200337

         // Naughty, naughty. A user callback threw an exception. At this point, the user has
         // stuffed themselves a little bit as they cannot really be sure what the state of play
         // is - they may have unlocked some messages, they may have deleted some and some may
         // still be locked.
         // The strategy is therefore to FFDC, pass the exception to any registered connection
         // listeners (through their asynchronousException() method) and then call unlock all.
         // Any messages that have been deleted are gone, and any messages that were not consumed
         // will be made available for consumption again. If the user was using express messages
         // then they will loose any messages in the locked message enumeration.
         // That'll learm 'em.

         FFDCFilter.processException(t,
                                     CLASS_NAME + ".deliverBatch",
                                     CommsConstants.ASYNCHPQ_DELIVER_01,
                                     this);

         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "exception thrown");
         if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(tc, "exception", t);

         proxyQueue.setAsynchConsumerThread(null);

         // Pass the exception to any registered exception listeners
         cs.deliverAsyncException(t);

         // We need to purge our local proxy queue, and unlock all the
         // messages in the ME to redeliver the messages.
         // However, we cannot do this before we act on any stop
         // that might have been called within the asynch consumer
         // before they threw the exception, otherwise the ME
         // will automatically send us the next batch.
         unlockAllMessages = true;
      }

      proxyQueue.setAsynchConsumerThread(null);

      concurrentAccessLock.notifyAll();

      try
      {
         if (cs.performInCallbackActions())
         {
            // Only request the next batch of messages from the messaging engine if the async consumer session
            // is started and is not in the process of stopping, and we are not
            // going to send and unlockAll (which implicitly requests the next batch)
            if (!unlockAllMessages && proxyQueue.getStarted() && !proxyQueue.isStopping()) {
              convHelper.requestNextMessageBatch();
            } else if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                SibTr.debug(this, tc, "Not requesting next message batch: " +
                            "unlockAllMessages=" + unlockAllMessages +
                            "isStarted=" + proxyQueue.getStarted() +
                            "isStopping=" + proxyQueue.isStopping());
            }
         }
      }
      catch(SIException e)
      {
         FFDCFilter.processException(e,
               CLASS_NAME + ".deliverBatch",
               CommsConstants.ASYNCHPQ_DELIVER_04,
               this);
         cs.deliverAsyncException(e);
      }

      // If we handled an exception and might need to redeliver messages,
      // then flow an unlockAll to the messaging engine to unlock all
      // messages and deliver the next batch. We perform this after
      // handling any in-callback actions, so that the messaging engine
      // knows whether or not to send us the next batch.
      // If we handled a close in-callback action (as well as
      // an exception) the unlockAll call will fail. However, there
      // is no method we can call on the consumer session to check whether
      // it is closed or not (isClosed is not properly implemented) so
      // it's safest as an APAR code change to simply accept that in
      // this unlikely circumstance we will generate an FFDC.
      if (unlockAllMessages)
      {
        try
        {
           cs.unlockAll();
        }
        catch(SIException e)
        {
           FFDCFilter.processException(e,
                 CLASS_NAME + ".deliverBatch",
                 CommsConstants.ASYNCHPQ_DELIVER_03,
                 this);
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "exception thrown");
           if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(tc, "exception", e);
        }
      }

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "deliverBatch");
   }
431550
void dispatch(final SibRaMessageToken token, final Map context) {

        final String methodName = "dispatch";
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName,
                    new Object[] { token, context });
        }

        SibRaMessagingEngineConnection connection = null;
        BifurcatedConsumerSession session = null;
        SibRaDispatcher dispatcher = null;
        try {

            /*
             * Obtain connection to messaging engine
             */

            connection = getConnection(token.getBusName(), token.getMeUuid());

            /*
             * Obtain bifurcated consumer session
             */

            synchronized (_sessionsByMeUuid) {

                Map sessionsById = (Map) _sessionsByMeUuid.get(token
                        .getMeUuid());

                if (sessionsById == null) {

                    sessionsById = new HashMap();
                    _sessionsByMeUuid.put(token.getMeUuid(), sessionsById);

                }

                session = (BifurcatedConsumerSession) sessionsById
                        .get(Long.valueOf(token.getSessionId()));

                if (session == null) {

                    /*
                     * Create a new bifurcated consumer session
                     */

                    session = connection.getConnection()
                            .createBifurcatedConsumerSession(
                                    token.getSessionId());
                    sessionsById.put(Long.valueOf(token.getSessionId()), session);

                }

            }

            /**
             * Create the first dispatcher
             */
            if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) SibTr.debug(TRACE, "creating dispatcher for: " + _j2eeName);
            dispatcher = connection.createDispatcher(session, Reliability.getReliability(token.getUnrecoveredReliability()), token.getMaxFailedDeliveries(), token.getSequentialMessageThreshold());

            /*
             * Get the array of message ids
             */
            SIMessageHandle [] msgHandles = token.getMessageHandleArray();
            SIBusMessage [] messages = null;

            /**
             * If we are a non transactional MDB then
             * - If we can delete the messages when they are read then perform a readAndDeleteSet
             * - If the messages should be kept (the message has a higher reliability than unrecovered reliability
             * defined on the session) then just perform a read set.
             * For transactional MDBs do not read the messages yet. This will be done in the dispatcher's
             * dispatch code after a transaction has been started so that the readAndDelete can be performed
             * under this transaction.
             */
            if ((dispatcher instanceof SibRaNonTransactionalDispatcher) && (messages == null)) {
              if (token.isDeleteMessagesWhenRead()) {

                  if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled ()) {
                    SibTr.debug(this, TRACE,
                        "These messages will be deleted when read " + Arrays.toString(token.getMessageHandleArray ()));
                  }

                  messages = session.readAndDeleteSet(token.getMessageHandleArray (), null); // For messages that are being deleted

              } else {

                  if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled ()) {
                    SibTr.debug(this, TRACE,
                        "These messages will be read but not deleted yet " + Arrays.toString(token.getMessageHandleArray ()));
                  }

                  messages = session.readSet (token.getMessageHandleArray ()); // For messages that are not being deleted

              }

            }

            if ((msgHandles != null) && (msgHandles.length > 0)) {

                for (int i = 0; i < msgHandles.length; i++) {

                  /**
                   * Create a new dispatcher if we need one.
                   */
                  if (dispatcher == null) {
                        dispatcher = connection.createDispatcher(session, Reliability.getReliability(token.getUnrecoveredReliability()), token.getMaxFailedDeliveries(), token.getSequentialMessageThreshold());
                  }

                    dispatcher.dispatch(msgHandles[i], messages == null ? null : messages [i], context);

                    // Close the dispatcher and create a new one.
                    connection.closeDispatcher(dispatcher);
                    dispatcher = null;

                }
            } else {

                SibTr.error(TRACE, "READ_SET_CWSIV1051", new Object[] {
                        Long.valueOf(token.getSessionId()), token.getMeUuid(),
                        Arrays.deepToString (msgHandles), token.getJ2EEName() });

            }

        } catch (final SISessionUnavailableException exception) {

            // No FFDC code needed

            /*
             * Session has been closed by listener and message will have been
             * unlocked
             */

            if (TraceComponent.isAnyTracingEnabled() && TRACE.isEventEnabled()) {
                SibTr.exception(this, TRACE, exception);
            }

        }
        catch (final SIMessageNotLockedException exception) {

            // No FFDC code needed

            /*
             * Message lock has expired and message will be reassigned
             */

            if (TraceComponent.isAnyTracingEnabled() && TRACE.isEventEnabled()) {
                SibTr.exception(this, TRACE, exception);
            }

        }
    catch (SIRollbackException exception) {

            FFDCFilter.processException(exception, CLASS_NAME + "."
                    + methodName, "1:348:1.19", this);
            SibTr.warning(TRACE, "EXCEPTION_CWSIV1052", new Object[] {
                    Long.valueOf(token.getSessionId()), token.getMeUuid(),
                    Arrays.deepToString(token.getMessageHandleArray()), exception });

        } catch (final Exception exception) {

            FFDCFilter.processException(exception, CLASS_NAME + "."
                    + methodName, "1:356:1.19", this);
            SibTr.warning(TRACE, "EXCEPTION_CWSIV1052", new Object[] {
                    Long.valueOf(token.getSessionId()), token.getMeUuid(),
                    Arrays.deepToString(token.getMessageHandleArray()), exception });

            /*
             * Close the dispatcher before closing the connection (if the connection is 
             * closed while a dispatcher is open the closeConnection will just hang waiting
             * for the last dispatcher to be closed).
             */
            if (dispatcher != null) {
                connection.closeDispatcher(dispatcher);
            }

            // 255651: Close the connection to the ME if an unknown error occurs
            // to flush the connection and force a new one to be created
            closeConnection(token.getMeUuid(), false);

            // null out the disptacher so we don't try and close it again.
            dispatcher = null;

        } finally {

            /*
             * Close the dispatcher if its not already been closed
             */

            if (dispatcher != null) {
                connection.closeDispatcher(dispatcher);
            }

        }

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName);
        }

    }
965173
@Override
    public void registerAsynchConsumerCallback(
                                               AsynchConsumerCallback callback,
                                               int maxActiveMessages,
                                               long messageLockExpiry,
                                               int maxBatchSize,
                                               OrderingContext context)
                    throws SISessionUnavailableException, SISessionDroppedException,
                    SIErrorException,
                    SIIncorrectCallException
    {
        if (TraceComponent.isAnyTracingEnabled() && CoreSPIConsumerSession.tc.isEntryEnabled())
            SibTr.entry(CoreSPIConsumerSession.tc, "registerAsynchConsumerCallback",
                        new Object[] { this,
                                      callback,
                                      new Integer(maxActiveMessages),
                                      new Long(messageLockExpiry),
                                      new Integer(maxBatchSize),
                                      context });
        registerAsynchConsumerCallback(callback,
                                       maxActiveMessages,
                                       messageLockExpiry,
                                       maxBatchSize,
                                       null,
                                       false,
                                       context);

        if (TraceComponent.isAnyTracingEnabled() && CoreSPIConsumerSession.tc.isEntryEnabled())
            SibTr.exit(CoreSPIConsumerSession.tc, "registerAsynchConsumerCallback");
    }
128040
function(id, msg, result) {
        var q = queues[id], sc;
        if (q && q.onEnd) {
            sc = q.context || q;
            q.onEnd.call(sc, _returnData(q, msg, result));
        }
    }
1175257
public synchronized void incrementUseCount()
          throws SIConnectionUnavailableException, SIConnectionDroppedException, SIErrorException
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "incrementUseCount");

      // Check if this ordering conext instance is "dead". If it is, then this order context has been closed and
      // we need to obtain a new proxy id for it.
      if (dead) {
        setOrderingContextProxyId();
        dead = false;
      }

      useCount++;
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Use count is now: " + useCount);

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "incrementUseCount");
   }
202069
@Override
    public void registerAsynchConsumerCallback(
                                               AsynchConsumerCallback callback,
                                               int maxActiveMessages,
                                               long messageLockExpiry,
                                               int maxBatchSize,
                                               Reliability unrecoverableReliability,
                                               boolean inLine,
                                               OrderingContext context)
                    throws SISessionDroppedException, SISessionUnavailableException, SIErrorException, SIIncorrectCallException
    {
        if (TraceComponent.isAnyTracingEnabled() && CoreSPIConsumerSession.tc.isEntryEnabled())
            SibTr.entry(CoreSPIConsumerSession.tc, "registerAsynchConsumerCallback",
                        new Object[] { this,
                                      callback,
                                      new Integer(maxActiveMessages),
                                      new Long(messageLockExpiry),
                                      new Integer(maxBatchSize),
                                      unrecoverableReliability,
                                      Boolean.valueOf(inLine),
                                      context });

        //register the AsynchConsumer with the LCP
        _localConsumerPoint.registerAsynchConsumer(
                                                   callback,
                                                   maxActiveMessages,
                                                   messageLockExpiry,
                                                   maxBatchSize,
                                                   unrecoverableReliability,
                                                   inLine,
                                                   (OrderingContextImpl) context,
                                                   null // No callback busy lock is used for non-mediation consumers.
        );

        if (TraceComponent.isAnyTracingEnabled() && CoreSPIConsumerSession.tc.isEntryEnabled())
            SibTr.exit(CoreSPIConsumerSession.tc, "registerAsynchConsumerCallback");
    }
740278
void updateQueue(String queue) throws ManagerCommunicationException
    {
        ResponseEvents re;

        try
        {
            QueueStatusAction queueStatusAction = new QueueStatusAction();
            queueStatusAction.setQueue(queue);
            re = server.sendEventGeneratingAction(queueStatusAction);
        }
        catch (ManagerCommunicationException e)
        {
            final Throwable cause = e.getCause();

            if (cause instanceof EventTimeoutException)
            {
                // this happens with Asterisk 1.0.x as it doesn't send a
                // QueueStatusCompleteEvent
                re = ((EventTimeoutException) cause).getPartialResult();
            }
            else
            {
                throw e;
            }
        }

        for (ManagerEvent event : re.getEvents())
        {
            // 101119 OLB: solo actualizamos el QUEUE por ahora
            if (event instanceof QueueParamsEvent)
            {
                handleQueueParamsEvent((QueueParamsEvent) event);
            }

            else if (event instanceof QueueMemberEvent)
            {
                handleQueueMemberEvent((QueueMemberEvent) event);
            }
            else if (event instanceof QueueEntryEvent)
            {
                handleQueueEntryEvent((QueueEntryEvent) event);
            }

        }
    }
951919
private void createProxyListener() throws SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "createProxyListener");

    // Create the proxy listener instance
    _proxyListener = new NeighbourProxyListener(_neighbours, this);

    /*
     * Now we can create our asynchronous consumer to listen on      
     * SYSTEM.MENAME.PROXY.QUEUE  Queue for receiving subscription
     * updates   
     */
    // 169897.1 modified parameters
    try
    {
      _proxyAsyncConsumer =
        _messageProcessor
          .getSystemConnection()
          .createSystemConsumerSession(
            _messageProcessor.getProxyHandlerDestAddr(), // destination name
            null, //Destination filter
            null, // SelectionCriteria - discriminator and selector
            Reliability.ASSURED_PERSISTENT, // reliability
            false, // enable read ahead
            false,
            null,
            false);

      // 169897.1 modified parameters

      _proxyAsyncConsumer.registerAsynchConsumerCallback(
        _proxyListener,
        0, 0, 1,
        null);

      _proxyAsyncConsumer.start(false);
    }
    catch (SIException e)
    {
      FFDCFilter.processException(
        e,
        "com.ibm.ws.sib.processor.proxyhandler.MultiMEProxyHandler.createProxyListener",
        "1:1271:1.96",
        this);
        
      SibTr.exception(tc, e);
      
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
        SibTr.exit(tc, "createProxyListener", "SIResourceException");
        
      // The Exceptions should already be NLS'd
      throw new SIResourceException(e);
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "createProxyListener");
  }