Feature - RRateLimiter.getConfig method added. #1916

redisson/src/main/java/org/redisson/RedissonRateLimiter.java

@@ -17,15 +17,24 @@ package org.redisson;
 
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
 import org.redisson.api.RFuture;
 import org.redisson.api.RRateLimiter;
 import org.redisson.api.RateIntervalUnit;
+import org.redisson.api.RateLimiterConfig;
 import org.redisson.api.RateType;
 import org.redisson.client.codec.LongCodec;
+import org.redisson.client.codec.StringCodec;
+import org.redisson.client.handler.State;
+import org.redisson.client.protocol.Decoder;
 import org.redisson.client.protocol.RedisCommand;
+import org.redisson.client.protocol.RedisCommand.ValueType;
 import org.redisson.client.protocol.RedisCommands;
+import org.redisson.client.protocol.decoder.MultiDecoder;
 import org.redisson.command.CommandAsyncExecutor;
 import org.redisson.misc.RPromise;
 import org.redisson.misc.RedissonPromise;
@@ -213,4 +222,37 @@ public class RedissonRateLimiter extends RedissonObject implements RRateLimiter
                 Collections.<Object>singletonList(getName()), rate, unit.toMillis(rateInterval), type.ordinal());
     }
     
+    private static final RedisCommand HGETALL = new RedisCommand("HGETALL", new MultiDecoder<RateLimiterConfig>() {
+        @Override
+        public Decoder<Object> getDecoder(int paramNum, State state) {
+            return null;
+        }
+
+        @Override
+        public RateLimiterConfig decode(List<Object> parts, State state) {
+            Map<String, String> map = new HashMap<>(parts.size()/2);
+            for (int i = 0; i < parts.size(); i++) {
+                if (i % 2 != 0) {
+                    map.put(parts.get(i-1).toString(), parts.get(i).toString());
+                }
+            }
+
+            RateType type = RateType.values()[Integer.valueOf(map.get("type"))];
+            Long rateInterval = Long.valueOf(map.get("interval"));
+            Long rate = Long.valueOf(map.get("rate"));
+            return new RateLimiterConfig(type, rateInterval, rate);
+        }
+        
+    }, ValueType.MAP);
+    
+    @Override
+    public RateLimiterConfig getConfig() {
+        return get(getConfigAsync());
+    }
+    
+    @Override
+    public RFuture<RateLimiterConfig> getConfigAsync() {
+        return commandExecutor.readAsync(getName(), StringCodec.INSTANCE, HGETALL, getName());
+    }
+    
 }

redisson/src/main/java/org/redisson/api/RRateLimiter.java

@@ -140,4 +140,11 @@ public interface RRateLimiter extends RRateLimiterAsync, RObject {
      */
     boolean tryAcquire(long permits, long timeout, TimeUnit unit);
 
+    /**
+     * Returns current configuration of this RateLimiter object.
+     * 
+     * @return config object
+     */
+    RateLimiterConfig getConfig();
+    
 }

redisson/src/main/java/org/redisson/api/RRateLimiterAsync.java

@@ -142,4 +142,11 @@ public interface RRateLimiterAsync extends RObjectAsync {
      */
     RFuture<Boolean> tryAcquireAsync(long permits, long timeout, TimeUnit unit);
     
+    /**
+     * Returns current configuration of this RateLimiter object.
+     * 
+     * @return config object
+     */
+    RFuture<RateLimiterConfig> getConfigAsync();
+    
 }

redisson/src/main/java/org/redisson/api/RateLimiterConfig.java

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2013-2019 Nikita Koksharov
+ *
+ * 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.redisson.api;
+
+/**
+ * 
+ * @author Nikita Koksharov
+ *
+ */
+public class RateLimiterConfig {
+
+    private RateType rateType;
+    private Long rateInterval;
+    private Long rate;
+
+    public RateLimiterConfig(RateType rateType, Long rateInterval, Long rate) {
+        super();
+        this.rateType = rateType;
+        this.rateInterval = rateInterval;
+        this.rate = rate;
+    }
+
+    /**
+     * Returns current rate type set through {@link RRateLimiter#trySetRate(RateType, long, long, RateIntervalUnit)} 
+     * or {@link RRateLimiter#trySetRateAsync(RateType, long, long, RateIntervalUnit)} method.
+     * 
+     * @return rate type
+     */
+    public RateType getRateType() {
+        return rateType;
+    }
+    
+    /**
+     * Returns current rate time interval value set through {@link RRateLimiter#trySetRate(RateType, long, long, RateIntervalUnit)} 
+     * or {@link RRateLimiter#trySetRateAsync(RateType, long, long, RateIntervalUnit)} method.
+     * 
+     * @return rate time interval in milliseconds
+     */
+    public Long getRateInterval() {
+        return rateInterval;
+    }
+
+    /**
+     * Returns current rate value set through {@link RRateLimiter#trySetRate(RateType, long, long, RateIntervalUnit)} 
+     * or {@link RRateLimiter#trySetRateAsync(RateType, long, long, RateIntervalUnit)} method.
+     * 
+     * @return rate
+     */
+    public Long getRate() {
+        return rate;
+    }
+
+    
+}