Bug #183

telegrambots/src/main/java/org/telegram/telegrambots/bots/DefaultBotOptions.java

@@ -2,6 +2,7 @@ package org.telegram.telegrambots.bots;
 
 import org.apache.http.client.config.RequestConfig;
 import org.telegram.telegrambots.generics.BotOptions;
+import org.telegram.telegrambots.updatesreceivers.ExponentialBackOff;
 
 import java.util.List;
 
@@ -14,6 +15,7 @@ import java.util.List;
 public class DefaultBotOptions implements BotOptions {
     private int maxThreads; ///< Max number of threads used for async methods executions (default 1)
     private RequestConfig requestConfig;
+    private ExponentialBackOff exponentialBackOff;
     private Integer maxWebhookConnections;
     private List<String> allowedUpdates;
 
@@ -56,4 +58,16 @@ public class DefaultBotOptions implements BotOptions {
     public void setRequestConfig(RequestConfig requestConfig) {
         this.requestConfig = requestConfig;
     }
+
+    public ExponentialBackOff getExponentialBackOff() {
+        return exponentialBackOff;
+    }
+
+    /**
+     * @implSpec Default implementation assumes starting at 500ms and max time of 60 minutes
+     * @param exponentialBackOff ExponentialBackOff to be used when long polling fails
+     */
+    public void setExponentialBackOff(ExponentialBackOff exponentialBackOff) {
+        this.exponentialBackOff = exponentialBackOff;
+    }
 }

telegrambots/src/main/java/org/telegram/telegrambots/updatesreceivers/DefaultBotSession.java

@@ -133,6 +133,7 @@ public class DefaultBotSession implements BotSession {
 
     private class ReaderThread extends Thread implements UpdatesReader {
         private CloseableHttpClient httpclient;
+        private ExponentialBackOff exponentialBackOff;
         private RequestConfig requestConfig;
 
         @Override
@@ -143,6 +144,11 @@ public class DefaultBotSession implements BotSession {
                     .setMaxConnTotal(100)
                     .build();
             requestConfig = options.getRequestConfig();
+            exponentialBackOff = options.getExponentialBackOff();
+
+            if (exponentialBackOff == null) {
+                exponentialBackOff = new ExponentialBackOff();
+            }
 
             if (requestConfig == null) {
                 requestConfig = RequestConfig.copy(RequestConfig.custom().build())
@@ -191,28 +197,37 @@ public class DefaultBotSession implements BotSession {
                         HttpEntity ht = response.getEntity();
                         BufferedHttpEntity buf = new BufferedHttpEntity(ht);
                         String responseContent = EntityUtils.toString(buf, StandardCharsets.UTF_8);
-                        try {
-                            List<Update> updates = request.deserializeResponse(responseContent);
 
-                            if (updates.isEmpty()) {
-                                synchronized (this) {
-                                    this.wait(500);
-                                }
-                            } else {
-                                updates.removeIf(x -> x.getUpdateId() < lastReceivedUpdate);
-                                lastReceivedUpdate = updates.parallelStream()
-                                        .map(
-                                                Update::getUpdateId)
-                                        .max(Integer::compareTo)
-                                        .orElse(0);
-                                receivedUpdates.addAll(updates);
-
-                                synchronized (receivedUpdates) {
-                                    receivedUpdates.notifyAll();
-                                }
+                        if (response.getStatusLine().getStatusCode() >= 500) {
+                            BotLogger.warn(LOGTAG, responseContent);
+                            synchronized (this) {
+                                this.wait(500);
+                            }
+                        } else {
+                            try {
+                                List<Update> updates = request.deserializeResponse(responseContent);
+                                exponentialBackOff.reset();
+
+                                if (updates.isEmpty()) {
+                                    synchronized (this) {
+                                        this.wait(500);
+                                    }
+                                } else {
+                                    updates.removeIf(x -> x.getUpdateId() < lastReceivedUpdate);
+                                    lastReceivedUpdate = updates.parallelStream()
+                                            .map(
+                                                    Update::getUpdateId)
+                                            .max(Integer::compareTo)
+                                            .orElse(0);
+                                    receivedUpdates.addAll(updates);
+
+                                    synchronized (receivedUpdates) {
+                                        receivedUpdates.notifyAll();
+                                    }
+                                }
+                            } catch (JSONException e) {
+                                BotLogger.severe(responseContent, LOGTAG, e);
                             }
-                        }catch (JSONException e) {
-                            BotLogger.severe(responseContent, LOGTAG, e);
                         }
                     } catch (InvalidObjectException | TelegramApiRequestException e) {
                         BotLogger.severe(LOGTAG, e);
@@ -226,7 +241,7 @@ public class DefaultBotSession implements BotSession {
                     BotLogger.severe(LOGTAG, global);
                     try {
                         synchronized (this) {
-                            this.wait(500);
+                            this.wait(exponentialBackOff.nextBackOffMillis());
                         }
                     } catch (InterruptedException e) {
                         if (!running) {

telegrambots/src/main/java/org/telegram/telegrambots/updatesreceivers/ExponentialBackOff.java

@@ -0,0 +1,483 @@
+/*
+ * Copyright (c) 2011 Google Inc.
+ *
+ * Licensed 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.telegram.telegrambots.updatesreceivers;
+
+import com.google.common.base.Preconditions;
+
+/**
+ * Implementation of BackOff that increases the back off period for each retry attempt using
+ * a randomization function that grows exponentially.
+ *
+ * <p>
+ * {@link #nextBackOffMillis()} is calculated using the following formula:
+ * </p>
+ *
+ * <pre>
+ randomized_interval =
+ retry_interval * (random value in range [1 - randomization_factor, 1 + randomization_factor])
+ * </pre>
+ *
+ * <p>
+ * In other words {@link #nextBackOffMillis()} will range between the randomization factor
+ * percentage below and above the retry interval. For example, using 2 seconds as the base retry
+ * interval and 0.5 as the randomization factor, the actual back off period used in the next retry
+ * attempt will be between 1 and 3 seconds.
+ * </p>
+ *
+ * <p>
+ * <b>Note:</b> max_interval caps the retry_interval and not the randomized_interval.
+ * </p>
+ *
+ * <p>
+ * If the time elapsed since an {@link ExponentialBackOff} instance is created goes past the
+ * max_elapsed_time then the method {@link #nextBackOffMillis()} starts returning
+ * {@link ExponentialBackOff#STOP}. The elapsed time can be reset by calling {@link #reset()}.
+ * </p>
+ *
+ * <p>
+ * Example: The default retry_interval is .5 seconds, default randomization_factor is 0.5, default
+ * multiplier is 1.5 and the default max_interval is 1 minute. For 10 tries the sequence will be
+ * (values in seconds) and assuming we go over the max_elapsed_time on the 10th try:
+ * </p>
+ *
+ * <pre>
+ request#     retry_interval     randomized_interval
+
+ 1             0.5                [0.25,   0.75]
+ 2             0.75               [0.375,  1.125]
+ 3             1.125              [0.562,  1.687]
+ 4             1.687              [0.8435, 2.53]
+ 5             2.53               [1.265,  3.795]
+ 6             3.795              [1.897,  5.692]
+ 7             5.692              [2.846,  8.538]
+ 8             8.538              [4.269, 12.807]
+ 9            12.807              [6.403, 19.210]
+ 10           19.210              {@link ExponentialBackOff#maxElapsedTimeMillis}
+ * </pre>
+ *
+ * <p>
+ * Implementation is not thread-safe.
+ * </p>
+ *
+ * @since 1.15
+ * @author Ravi Mistry
+ */
+public class ExponentialBackOff {
+    /** The default initial interval value in milliseconds (0.5 seconds). */
+    public static final int DEFAULT_INITIAL_INTERVAL_MILLIS = 500;
+
+    /**
+     * The default randomization factor (0.5 which results in a random period ranging between 50%
+     * below and 50% above the retry interval).
+     */
+    public static final double DEFAULT_RANDOMIZATION_FACTOR = 0.5;
+
+    /** The default multiplier value (1.5 which is 50% increase per back off). */
+    public static final double DEFAULT_MULTIPLIER = 1.5;
+
+    /** The default maximum back off time in milliseconds (15 minutes). */
+    public static final int DEFAULT_MAX_INTERVAL_MILLIS = 30000;
+
+    /** The default maximum elapsed time in milliseconds (60 minutes). */
+    public static final int DEFAULT_MAX_ELAPSED_TIME_MILLIS = 3600000;
+
+    /** The current retry interval in milliseconds. */
+    private int currentIntervalMillis;
+
+    /** The initial retry interval in milliseconds. */
+    private final int initialIntervalMillis;
+
+    /**
+     * The randomization factor to use for creating a range around the retry interval.
+     *
+     * <p>
+     * A randomization factor of 0.5 results in a random period ranging between 50% below and 50%
+     * above the retry interval.
+     * </p>
+     */
+    private final double randomizationFactor;
+
+    /** The value to multiply the current interval with for each retry attempt. */
+    private final double multiplier;
+
+    /**
+     * The maximum value of the back off period in milliseconds. Once the retry interval reaches this
+     * value it stops increasing.
+     */
+    private final int maxIntervalMillis;
+
+    /**
+     * The system time in nanoseconds. It is calculated when an ExponentialBackOffPolicy instance is
+     * created and is reset when {@link #reset()} is called.
+     */
+    long startTimeNanos;
+
+    /**
+     * The maximum elapsed time after instantiating {@link ExponentialBackOff} or calling
+     * {@link #reset()} after which {@link #nextBackOffMillis()} returns this value.
+     */
+    private final int maxElapsedTimeMillis;
+
+    /**
+     * Creates an instance of ExponentialBackOffPolicy using default values.
+     *
+     * <p>
+     * To override the defaults use {@link Builder}.
+     * </p>
+     *
+     * <ul>
+     * <li>{@code initialIntervalMillis} defaults to {@link #DEFAULT_INITIAL_INTERVAL_MILLIS}</li>
+     * <li>{@code randomizationFactor} defaults to {@link #DEFAULT_RANDOMIZATION_FACTOR}</li>
+     * <li>{@code multiplier} defaults to {@link #DEFAULT_MULTIPLIER}</li>
+     * <li>{@code maxIntervalMillis} defaults to {@link #DEFAULT_MAX_INTERVAL_MILLIS}</li>
+     * <li>{@code maxElapsedTimeMillis} defaults in {@link #DEFAULT_MAX_ELAPSED_TIME_MILLIS}</li>
+     * </ul>
+     */
+    public ExponentialBackOff() {
+        this(new Builder());
+    }
+
+    /**
+     * @param builder builder
+     */
+    protected ExponentialBackOff(Builder builder) {
+        initialIntervalMillis = builder.initialIntervalMillis;
+        randomizationFactor = builder.randomizationFactor;
+        multiplier = builder.multiplier;
+        maxIntervalMillis = builder.maxIntervalMillis;
+        maxElapsedTimeMillis = builder.maxElapsedTimeMillis;
+        Preconditions.checkArgument(initialIntervalMillis > 0);
+        Preconditions.checkArgument(0 <= randomizationFactor && randomizationFactor < 1);
+        Preconditions.checkArgument(multiplier >= 1);
+        Preconditions.checkArgument(maxIntervalMillis >= initialIntervalMillis);
+        Preconditions.checkArgument(maxElapsedTimeMillis > 0);
+        reset();
+    }
+
+    /** Sets the interval back to the initial retry interval and restarts the timer. */
+    public final void reset() {
+        currentIntervalMillis = initialIntervalMillis;
+        startTimeNanos = nanoTime();
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>
+     * This method calculates the next back off interval using the formula: randomized_interval =
+     * retry_interval +/- (randomization_factor * retry_interval)
+     * </p>
+     *
+     * <p>
+     * Subclasses may override if a different algorithm is required.
+     * </p>
+     */
+    public long nextBackOffMillis() {
+        // Make sure we have not gone over the maximum elapsed time.
+        if (getElapsedTimeMillis() > maxElapsedTimeMillis) {
+            return maxElapsedTimeMillis;
+        }
+        int randomizedInterval =
+                getRandomValueFromInterval(randomizationFactor, Math.random(), currentIntervalMillis);
+        incrementCurrentInterval();
+        return randomizedInterval;
+    }
+
+    /**
+     * Returns a random value from the interval [randomizationFactor * currentInterval,
+     * randomizationFactor * currentInterval].
+     */
+    static int getRandomValueFromInterval(
+            double randomizationFactor, double random, int currentIntervalMillis) {
+        double delta = randomizationFactor * currentIntervalMillis;
+        double minInterval = currentIntervalMillis - delta;
+        double maxInterval = currentIntervalMillis + delta;
+        // Get a random value from the range [minInterval, maxInterval].
+        // The formula used below has a +1 because if the minInterval is 1 and the maxInterval is 3 then
+        // we want a 33% chance for selecting either 1, 2 or 3.
+        int randomValue = (int) (minInterval + (random * (maxInterval - minInterval + 1)));
+        return randomValue;
+    }
+
+    /** Returns the initial retry interval in milliseconds. */
+    public final int getInitialIntervalMillis() {
+        return initialIntervalMillis;
+    }
+
+    /**
+     * Returns the randomization factor to use for creating a range around the retry interval.
+     *
+     * <p>
+     * A randomization factor of 0.5 results in a random period ranging between 50% below and 50%
+     * above the retry interval.
+     * </p>
+     */
+    public final double getRandomizationFactor() {
+        return randomizationFactor;
+    }
+
+    /**
+     * Returns the current retry interval in milliseconds.
+     */
+    public final int getCurrentIntervalMillis() {
+        return currentIntervalMillis;
+    }
+
+    /**
+     * Returns the value to multiply the current interval with for each retry attempt.
+     */
+    public final double getMultiplier() {
+        return multiplier;
+    }
+
+    /**
+     * Returns the maximum value of the back off period in milliseconds. Once the current interval
+     * reaches this value it stops increasing.
+     */
+    public final int getMaxIntervalMillis() {
+        return maxIntervalMillis;
+    }
+
+    /**
+     * Returns the maximum elapsed time in milliseconds.
+     *
+     * <p>
+     * If the time elapsed since an {@link ExponentialBackOff} instance is created goes past the
+     * max_elapsed_time then the method {@link #nextBackOffMillis()} starts returning
+     * this value. The elapsed time can be reset by calling {@link #reset()}.
+     * </p>
+     */
+    public final int getMaxElapsedTimeMillis() {
+        return maxElapsedTimeMillis;
+    }
+
+    /**
+     * Returns the elapsed time in milliseconds since an {@link ExponentialBackOff} instance is
+     * created and is reset when {@link #reset()} is called.
+     *
+     * <p>
+     * The elapsed time is computed using {@link System#nanoTime()}.
+     * </p>
+     */
+    public final long getElapsedTimeMillis() {
+        return (nanoTime() - startTimeNanos) / 1000000;
+    }
+
+    /**
+     * Increments the current interval by multiplying it with the multiplier.
+     */
+    private void incrementCurrentInterval() {
+        // Check for overflow, if overflow is detected set the current interval to the max interval.
+        if (currentIntervalMillis >= maxIntervalMillis / multiplier) {
+            currentIntervalMillis = maxIntervalMillis;
+        } else {
+            currentIntervalMillis *= multiplier;
+        }
+    }
+
+    /**
+     * Nano time using  {@link System#nanoTime()}
+     * @return time in nanoseconds
+     */
+    private long nanoTime() {
+        return System.nanoTime();
+    }
+
+    /**
+     * Builder for {@link ExponentialBackOff}.
+     *
+     * <p>
+     * Implementation is not thread-safe.
+     * </p>
+     */
+    public static class Builder {
+
+        /** The initial retry interval in milliseconds. */
+        int initialIntervalMillis = DEFAULT_INITIAL_INTERVAL_MILLIS;
+
+        /**
+         * The randomization factor to use for creating a range around the retry interval.
+         *
+         * <p>
+         * A randomization factor of 0.5 results in a random period ranging between 50% below and 50%
+         * above the retry interval.
+         * </p>
+         */
+        double randomizationFactor = DEFAULT_RANDOMIZATION_FACTOR;
+
+        /** The value to multiply the current interval with for each retry attempt. */
+        double multiplier = DEFAULT_MULTIPLIER;
+
+        /**
+         * The maximum value of the back off period in milliseconds. Once the retry interval reaches
+         * this value it stops increasing.
+         */
+        int maxIntervalMillis = DEFAULT_MAX_INTERVAL_MILLIS;
+
+        /**
+         * The maximum elapsed time in milliseconds after instantiating {@link ExponentialBackOff} or
+         * calling {@link #reset()} after which {@link #nextBackOffMillis()} returns
+         * this value.
+         */
+        int maxElapsedTimeMillis = DEFAULT_MAX_ELAPSED_TIME_MILLIS;
+
+        public Builder() {
+        }
+
+        /** Builds a new instance of {@link ExponentialBackOff}. */
+        public ExponentialBackOff build() {
+            return new ExponentialBackOff(this);
+        }
+
+        /**
+         * Returns the initial retry interval in milliseconds. The default value is
+         * {@link #DEFAULT_INITIAL_INTERVAL_MILLIS}.
+         */
+        public final int getInitialIntervalMillis() {
+            return initialIntervalMillis;
+        }
+
+        /**
+         * Sets the initial retry interval in milliseconds. The default value is
+         * {@link #DEFAULT_INITIAL_INTERVAL_MILLIS}. Must be {@code > 0}.
+         *
+         * <p>
+         * Overriding is only supported for the purpose of calling the super implementation and changing
+         * the return type, but nothing else.
+         * </p>
+         */
+        public Builder setInitialIntervalMillis(int initialIntervalMillis) {
+            this.initialIntervalMillis = initialIntervalMillis;
+            return this;
+        }
+
+        /**
+         * Returns the randomization factor to use for creating a range around the retry interval. The
+         * default value is {@link #DEFAULT_RANDOMIZATION_FACTOR}.
+         *
+         * <p>
+         * A randomization factor of 0.5 results in a random period ranging between 50% below and 50%
+         * above the retry interval.
+         * </p>
+         *
+         * <p>
+         * Overriding is only supported for the purpose of calling the super implementation and changing
+         * the return type, but nothing else.
+         * </p>
+         */
+        public final double getRandomizationFactor() {
+            return randomizationFactor;
+        }
+
+        /**
+         * Sets the randomization factor to use for creating a range around the retry interval. The
+         * default value is {@link #DEFAULT_RANDOMIZATION_FACTOR}. Must fall in the range
+         * {@code 0 <= randomizationFactor < 1}.
+         *
+         * <p>
+         * A randomization factor of 0.5 results in a random period ranging between 50% below and 50%
+         * above the retry interval.
+         * </p>
+         *
+         * <p>
+         * Overriding is only supported for the purpose of calling the super implementation and changing
+         * the return type, but nothing else.
+         * </p>
+         */
+        public Builder setRandomizationFactor(double randomizationFactor) {
+            this.randomizationFactor = randomizationFactor;
+            return this;
+        }
+
+        /**
+         * Returns the value to multiply the current interval with for each retry attempt. The default
+         * value is {@link #DEFAULT_MULTIPLIER}.
+         */
+        public final double getMultiplier() {
+            return multiplier;
+        }
+
+        /**
+         * Sets the value to multiply the current interval with for each retry attempt. The default
+         * value is {@link #DEFAULT_MULTIPLIER}. Must be {@code >= 1}.
+         *
+         * <p>
+         * Overriding is only supported for the purpose of calling the super implementation and changing
+         * the return type, but nothing else.
+         * </p>
+         */
+        public Builder setMultiplier(double multiplier) {
+            this.multiplier = multiplier;
+            return this;
+        }
+
+        /**
+         * Returns the maximum value of the back off period in milliseconds. Once the current interval
+         * reaches this value it stops increasing. The default value is
+         * {@link #DEFAULT_MAX_INTERVAL_MILLIS}. Must be {@code >= initialInterval}.
+         */
+        public final int getMaxIntervalMillis() {
+            return maxIntervalMillis;
+        }
+
+        /**
+         * Sets the maximum value of the back off period in milliseconds. Once the current interval
+         * reaches this value it stops increasing. The default value is
+         * {@link #DEFAULT_MAX_INTERVAL_MILLIS}.
+         *
+         * <p>
+         * Overriding is only supported for the purpose of calling the super implementation and changing
+         * the return type, but nothing else.
+         * </p>
+         */
+        public Builder setMaxIntervalMillis(int maxIntervalMillis) {
+            this.maxIntervalMillis = maxIntervalMillis;
+            return this;
+        }
+
+        /**
+         * Returns the maximum elapsed time in milliseconds. The default value is
+         * {@link #DEFAULT_MAX_ELAPSED_TIME_MILLIS}.
+         *
+         * <p>
+         * If the time elapsed since an {@link ExponentialBackOff} instance is created goes past the
+         * max_elapsed_time then the method {@link #nextBackOffMillis()} starts returning
+         * this value. The elapsed time can be reset by calling {@link #reset()}.
+         * </p>
+         */
+        public final int getMaxElapsedTimeMillis() {
+            return maxElapsedTimeMillis;
+        }
+
+        /**
+         * Sets the maximum elapsed time in milliseconds. The default value is
+         * {@link #DEFAULT_MAX_ELAPSED_TIME_MILLIS}. Must be {@code > 0}.
+         *
+         * <p>
+         * If the time elapsed since an {@link ExponentialBackOff} instance is created goes past the
+         * max_elapsed_time then the method {@link #nextBackOffMillis()} starts returning
+         * this value. The elapsed time can be reset by calling {@link #reset()}.
+         * </p>
+         *
+         * <p>
+         * Overriding is only supported for the purpose of calling the super implementation and changing
+         * the return type, but nothing else.
+         * </p>
+         */
+        public Builder setMaxElapsedTimeMillis(int maxElapsedTimeMillis) {
+            this.maxElapsedTimeMillis = maxElapsedTimeMillis;
+            return this;
+        }
+    }
+}