NettyTransportOptions.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.activemq.transport.amqp.client.transport;

/**
 * Encapsulates all the TCP Transport options in one configuration object.
 */
public class NettyTransportOptions implements Cloneable {

   public static final int DEFAULT_SEND_BUFFER_SIZE = 64 * 1024;
   public static final int DEFAULT_RECEIVE_BUFFER_SIZE = DEFAULT_SEND_BUFFER_SIZE;
   public static final int DEFAULT_TRAFFIC_CLASS = 0;
   public static final boolean DEFAULT_TCP_NO_DELAY = true;
   public static final boolean DEFAULT_TCP_KEEP_ALIVE = false;
   public static final int DEFAULT_SO_LINGER = Integer.MIN_VALUE;
   public static final int DEFAULT_SO_TIMEOUT = -1;
   public static final int DEFAULT_CONNECT_TIMEOUT = 60000;
   public static final int DEFAULT_TCP_PORT = 5672;
   public static final boolean DEFAULT_TRACE_BYTES = false;

   public static final NettyTransportOptions INSTANCE = new NettyTransportOptions();

   private int sendBufferSize = DEFAULT_SEND_BUFFER_SIZE;
   private int receiveBufferSize = DEFAULT_RECEIVE_BUFFER_SIZE;
   private int trafficClass = DEFAULT_TRAFFIC_CLASS;
   private int connectTimeout = DEFAULT_CONNECT_TIMEOUT;
   private int soTimeout = DEFAULT_SO_TIMEOUT;
   private int soLinger = DEFAULT_SO_LINGER;
   private boolean tcpKeepAlive = DEFAULT_TCP_KEEP_ALIVE;
   private boolean tcpNoDelay = DEFAULT_TCP_NO_DELAY;
   private int defaultTcpPort = DEFAULT_TCP_PORT;
   private boolean traceBytes = DEFAULT_TRACE_BYTES;

   /**
    * @return the currently set send buffer size in bytes.
    */
   public int getSendBufferSize() {
      return sendBufferSize;
   }

   /**
    * Sets the send buffer size in bytes, the value must be greater than zero or an
    * {@link IllegalArgumentException} will be thrown.
    *
    * @param sendBufferSize
    *        the new send buffer size for the TCP Transport.
    *
    * @throws IllegalArgumentException
    *         if the value given is not in the valid range.
    */
   public void setSendBufferSize(int sendBufferSize) {
      if (sendBufferSize <= 0) {
         throw new IllegalArgumentException("The send buffer size must be > 0");
      }

      this.sendBufferSize = sendBufferSize;
   }

   /**
    * @return the currently configured receive buffer size in bytes.
    */
   public int getReceiveBufferSize() {
      return receiveBufferSize;
   }

   /**
    * Sets the receive buffer size in bytes, the value must be greater than zero or an
    * {@link IllegalArgumentException} will be thrown.
    *
    * @param receiveBufferSize
    *        the new receive buffer size for the TCP Transport.
    *
    * @throws IllegalArgumentException
    *         if the value given is not in the valid range.
    */
   public void setReceiveBufferSize(int receiveBufferSize) {
      if (receiveBufferSize <= 0) {
         throw new IllegalArgumentException("The send buffer size must be > 0");
      }

      this.receiveBufferSize = receiveBufferSize;
   }

   /**
    * @return the currently configured traffic class value.
    */
   public int getTrafficClass() {
      return trafficClass;
   }

   /**
    * Sets the traffic class value used by the TCP connection, valid range is between 0 and 255.
    *
    * @param trafficClass
    *        the new traffic class value.
    *
    * @throws IllegalArgumentException
    *         if the value given is not in the valid range.
    */
   public void setTrafficClass(int trafficClass) {
      if (trafficClass < 0 || trafficClass > 255) {
         throw new IllegalArgumentException("Traffic class must be in the range [0..255]");
      }

      this.trafficClass = trafficClass;
   }

   public int getSoTimeout() {
      return soTimeout;
   }

   public void setSoTimeout(int soTimeout) {
      this.soTimeout = soTimeout;
   }

   public boolean isTcpNoDelay() {
      return tcpNoDelay;
   }

   public void setTcpNoDelay(boolean tcpNoDelay) {
      this.tcpNoDelay = tcpNoDelay;
   }

   public int getSoLinger() {
      return soLinger;
   }

   public void setSoLinger(int soLinger) {
      this.soLinger = soLinger;
   }

   public boolean isTcpKeepAlive() {
      return tcpKeepAlive;
   }

   public void setTcpKeepAlive(boolean keepAlive) {
      this.tcpKeepAlive = keepAlive;
   }

   public int getConnectTimeout() {
      return connectTimeout;
   }

   public void setConnectTimeout(int connectTimeout) {
      this.connectTimeout = connectTimeout;
   }

   public int getDefaultTcpPort() {
      return defaultTcpPort;
   }

   public void setDefaultTcpPort(int defaultTcpPort) {
      this.defaultTcpPort = defaultTcpPort;
   }

   /**
    * @return true if the transport should enable byte tracing
    */
   public boolean isTraceBytes() {
      return traceBytes;
   }

   /**
    * Determines if the transport should add a logger for bytes in / out
    *
    * @param traceBytes
    *        should the transport log the bytes in and out.
    */
   public void setTraceBytes(boolean traceBytes) {
      this.traceBytes = traceBytes;
   }

   public boolean isSSL() {
      return false;
   }

   @Override
   public NettyTransportOptions clone() {
      return copyOptions(new NettyTransportOptions());
   }

   protected NettyTransportOptions copyOptions(NettyTransportOptions copy) {
      copy.setConnectTimeout(getConnectTimeout());
      copy.setReceiveBufferSize(getReceiveBufferSize());
      copy.setSendBufferSize(getSendBufferSize());
      copy.setSoLinger(getSoLinger());
      copy.setSoTimeout(getSoTimeout());
      copy.setTcpKeepAlive(isTcpKeepAlive());
      copy.setTcpNoDelay(isTcpNoDelay());
      copy.setTrafficClass(getTrafficClass());

      return copy;
   }
}