001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 018 package org.apache.activemq.network.jms; 019 020 /** 021 * A policy object that defines how a {@link JmsConnector} deals with 022 * reconnection of the local and foreign connections. 023 * 024 * @org.apache.xbean.XBean element="reconnectionPolicy" 025 */ 026 public class ReconnectionPolicy { 027 028 private int maxSendRetries = 10; 029 private long sendRetryDelay = 1000L; 030 031 private int maxReconnectAttempts = -1; 032 private int maxInitialConnectAttempts = -1; 033 private long maximumReconnectDelay = 30000; 034 private long initialReconnectDelay = 1000L; 035 private boolean useExponentialBackOff = false; 036 private double backOffMultiplier = 2.0; 037 038 /** 039 * Gets the maximum number of a times a Message send should be retried before 040 * a JMSExeception is thrown indicating that the operation failed. 041 * 042 * @return number of send retries that will be performed. 043 */ 044 public int getMaxSendRetries() { 045 return maxSendRetries; 046 } 047 048 /** 049 * Sets the maximum number of a times a Message send should be retried before 050 * a JMSExeception is thrown indicating that the operation failed. 051 * 052 * @param maxRetries 053 * number of send retries that will be performed. 054 */ 055 public void setMaxSendRetries(int maxSendRetries) { 056 this.maxSendRetries = maxSendRetries; 057 } 058 059 /** 060 * Get the amount of time the DestionationBridge will wait between attempts 061 * to forward a message. 062 * 063 * @return time in milliseconds to wait between send attempts. 064 */ 065 public long getSendRetryDelay() { 066 return this.sendRetryDelay; 067 } 068 069 /** 070 * Set the amount of time the DestionationBridge will wait between attempts 071 * to forward a message. The default policy limits the minimum time between 072 * send attempt to one second. 073 * 074 * @param sendRetryDelay 075 * Time in milliseconds to wait before attempting another send. 076 */ 077 public void setSendRetyDelay(long sendRetryDelay) { 078 if (sendRetryDelay < 1000L) { 079 this.sendRetryDelay = 1000L; 080 } 081 082 this.sendRetryDelay = sendRetryDelay; 083 } 084 085 /** 086 * Gets the number of time that {@link JmsConnector} will attempt to connect 087 * or reconnect before giving up. By default the policy sets this value to 088 * a negative value meaning try forever. 089 * 090 * @return the number of attempts to connect before giving up. 091 */ 092 public int getMaxReconnectAttempts() { 093 return maxReconnectAttempts; 094 } 095 096 /** 097 * Sets the number of time that {@link JmsConnector} will attempt to connect 098 * or reconnect before giving up. By default the policy sets this value to 099 * a negative value meaning try forever, set to a positive value to retry a 100 * fixed number of times, or zero to never try and reconnect. 101 * 102 * @param maxReconnectAttempts 103 */ 104 public void setMaxReconnectAttempts(int maxReconnectAttempts) { 105 this.maxReconnectAttempts = maxReconnectAttempts; 106 } 107 108 /** 109 * Gets the maximum number of times that the {@link JmsConnector} will try 110 * to connect on startup to before it marks itself as failed and does not 111 * try any further connections. 112 * 113 * @returns the max number of times a connection attempt is made before failing. 114 */ 115 public int getMaxInitialConnectAttempts() { 116 return this.maxInitialConnectAttempts; 117 } 118 119 /** 120 * Sets the maximum number of times that the {@link JmsConnector} will try 121 * to connect on startup to before it marks itself as failed and does not 122 * try any further connections. 123 * 124 * @param maxAttempts 125 * The max number of times a connection attempt is made before failing. 126 */ 127 public void setMaxInitialConnectAttempts(int maxAttempts) { 128 this.maxInitialConnectAttempts = maxAttempts; 129 } 130 131 /** 132 * Gets the maximum delay that is inserted between each attempt to connect 133 * before another attempt is made. The default setting for this value is 134 * 30 seconds. 135 * 136 * @return the max delay between connection attempts in milliseconds. 137 */ 138 public long getMaximumReconnectDelay() { 139 return maximumReconnectDelay; 140 } 141 142 /** 143 * Sets the maximum delay that is inserted between each attempt to connect 144 * before another attempt is made. 145 * 146 * @param maximumReconnectDelay 147 * The maximum delay between connection attempts in milliseconds. 148 */ 149 public void setMaximumReconnectDelay(long maximumReconnectDelay) { 150 this.maximumReconnectDelay = maximumReconnectDelay; 151 } 152 153 /** 154 * Gets the initial delay value used before a reconnection attempt is made. If the 155 * use exponential back-off value is set to false then this will be the fixed time 156 * between connection attempts. By default this value is set to one second. 157 * 158 * @return time in milliseconds that will be used between connection retries. 159 */ 160 public long getInitialReconnectDelay() { 161 return initialReconnectDelay; 162 } 163 164 /** 165 * Gets the initial delay value used before a reconnection attempt is made. If the 166 * use exponential back-off value is set to false then this will be the fixed time 167 * between connection attempts. By default this value is set to one second. 168 169 * @param initialReconnectDelay 170 * Time in milliseconds to wait before the first reconnection attempt. 171 */ 172 public void setInitialReconnectDelay(long initialReconnectDelay) { 173 this.initialReconnectDelay = initialReconnectDelay; 174 } 175 176 /** 177 * Gets whether the policy uses the set back-off multiplier to grow the time between 178 * connection attempts. 179 * 180 * @return true if the policy will grow the time between connection attempts. 181 */ 182 public boolean isUseExponentialBackOff() { 183 return useExponentialBackOff; 184 } 185 186 /** 187 * Sets whether the policy uses the set back-off multiplier to grow the time between 188 * connection attempts. 189 * 190 * @param useExponentialBackOff 191 */ 192 public void setUseExponentialBackOff(boolean useExponentialBackOff) { 193 this.useExponentialBackOff = useExponentialBackOff; 194 } 195 196 /** 197 * Gets the multiplier used to grow the delay between connection attempts from the initial 198 * time to the max set time. By default this value is set to 2.0. 199 * 200 * @return the currently configured connection delay multiplier. 201 */ 202 public double getBackOffMultiplier() { 203 return backOffMultiplier; 204 } 205 206 /** 207 * Gets the multiplier used to grow the delay between connection attempts from the initial 208 * time to the max set time. By default this value is set to 2.0. 209 * 210 * @param backOffMultiplier 211 * The multiplier value used to grow the reconnection delay. 212 */ 213 public void setBackOffMultiplier(double backOffMultiplier) { 214 this.backOffMultiplier = backOffMultiplier; 215 } 216 217 /** 218 * Returns the next computed delay value that the connection controller should use to 219 * wait before attempting another connection for the {@link JmsConnector}. 220 * 221 * @param attempt 222 * The current connection attempt. 223 * 224 * @return the next delay amount in milliseconds. 225 */ 226 public long getNextDelay(int attempt) { 227 228 if (attempt == 0) { 229 return 0; 230 } 231 232 long nextDelay = initialReconnectDelay; 233 234 if (useExponentialBackOff) { 235 nextDelay = nextDelay * (long)(attempt * backOffMultiplier); 236 } 237 238 if (maximumReconnectDelay > 0 && nextDelay > maximumReconnectDelay) { 239 nextDelay = maximumReconnectDelay; 240 } 241 242 return nextDelay; 243 } 244 }