BrokerClientStub xref

    1   /***
    2    *
    3    * Copyright 2004 Protique Ltd
    4    *
    5    * Licensed under the Apache License, Version 2.0 (the "License");
    6    * you may not use this file except in compliance with the License.
    7    * You may obtain a copy of the License at
    8    *
    9    * http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   *
    17   **/
    18  package org.codehaus.activemq.broker;
    19
    20  import org.codehaus.activemq.message.ActiveMQMessage;
    21  import org.codehaus.activemq.transport.TransportChannel;
    22
    23  import javax.jms.JMSException;
    24  import java.util.ArrayList;
    25  import java.util.List;
    26
    27
    28  /***
    29   * A mock dispatcher for testing
    30   *
    31   * @version $Revision: 1.3 $
    32   */
    33  public class BrokerClientStub implements BrokerClient {
    34
    35      private List messages = new ArrayList();
    36      private Object semaphore;
    37
    38      public BrokerClientStub() {
    39          this(new Object());
    40      }
    41
    42      public BrokerClientStub(Object semaphore) {
    43          this.semaphore = semaphore;
    44      }
    45
    46      /***
    47       * @return all the messages on the list so far, clearing the buffer
    48       */
    49      public synchronized List flushMessages() {
    50          List answer = new ArrayList(messages);
    51          messages.clear();
    52          return answer;
    53      }
    54
    55      public synchronized void dispatch(ActiveMQMessage message) {
    56          messages.add(message);
    57          synchronized (semaphore) {
    58              semaphore.notifyAll();
    59          }
    60      }
    61
    62      public void initialize(BrokerConnector brokerConnector, TransportChannel channel) {
    63      }
    64
    65      public void waitForMessageToArrive() {
    66          System.out.println("Waiting for message to arrive");
    67
    68          long start = System.currentTimeMillis();
    69
    70          try {
    71              if (messages.isEmpty()) {
    72                  synchronized (semaphore) {
    73                      semaphore.wait(4000);
    74                  }
    75              }
    76          }
    77          catch (InterruptedException e) {
    78              System.out.println("Caught: " + e);
    79          }
    80          long end = System.currentTimeMillis() - start;
    81
    82          System.out.println("End of wait for " + end + " millis");
    83      }
    84
    85      public void start() throws JMSException {
    86      }
    87
    88      public void stop() throws JMSException {
    89      }
    90
    91      /***
    92       * @return true if the peer for this Client is itself another Broker
    93       */
    94      public boolean isBrokerConnection() {
    95          return false;
    96      }
    97
    98
    99      /***
    100      * Get the Capacity for in-progress messages at the peer (probably a JMSConnection)
    101      * Legimate values between 0-100. 100 representing that the peer cannot process
    102      * any more messages at the current time
    103      *
    104      * @return
    105      */
    106     public int getCapacity() {
    107         return 100;
    108     }
    109
    110     /***
    111      * Get an indication if the peer should be considered as a slow consumer
    112      *
    113      * @return true id the peer should be considered as a slow consumer
    114      */
    115     public boolean isSlowConsumer() {
    116         return false;
    117     }
    118
    119     /***
    120      * Update the peer Connection about the Broker's capacity for messages
    121      *
    122      * @param capacity
    123      */
    124     public void updateBrokerCapacity(int capacity) {
    125
    126     }
    127
    128     public String getClientID() {
    129         return "dummyClientID";
    130     }
    131
    132     public void cleanUp() {
    133     }
    134
    135     public TransportChannel getChannel() {
    136         return null;
    137     }
    138
    139
    140     public BrokerConnector getBrokerConnector() {
    141         return null;
    142     }
    143
    144
    145     public boolean isClusteredConnection() {
    146         return false;
    147     }
    148 }