Refactor TimeoutConfig

src/java/voldemort/client/ClientConfig.java

@@ -36,7 +36,6 @@
 import voldemort.utils.ConfigurationException;
 import voldemort.utils.Props;
 import voldemort.utils.ReflectUtils;
-import voldemort.utils.TimeoutConfig;
 import voldemort.utils.Utils;
 
 /**
@@ -186,28 +185,28 @@ private void setProperties(Properties properties) {
         timeoutConfig = new TimeoutConfig(routingTimeoutMs, false);
 
         if(props.containsKey(GETALL_ROUTING_TIMEOUT_MS_PROPERTY))
-            timeoutConfig.getAllTimeoutMs(props.getInt(GETALL_ROUTING_TIMEOUT_MS_PROPERTY),
-                                          TimeUnit.MILLISECONDS);
+            timeoutConfig.setOperationTimeout(VoldemortOperation.GETALL,
+                                              props.getInt(GETALL_ROUTING_TIMEOUT_MS_PROPERTY));
 
         if(props.containsKey(GET_ROUTING_TIMEOUT_MS_PROPERTY))
-            timeoutConfig.getTimeoutMs(props.getInt(GET_ROUTING_TIMEOUT_MS_PROPERTY),
-                                       TimeUnit.MILLISECONDS);
+            timeoutConfig.setOperationTimeout(VoldemortOperation.GET,
+                                              props.getInt(GET_ROUTING_TIMEOUT_MS_PROPERTY));
 
         if(props.containsKey(PUT_ROUTING_TIMEOUT_MS_PROPERTY)) {
             long putTimeoutMs = props.getInt(PUT_ROUTING_TIMEOUT_MS_PROPERTY);
-            timeoutConfig.putTimeoutMs(putTimeoutMs, TimeUnit.MILLISECONDS);
+            timeoutConfig.setOperationTimeout(VoldemortOperation.PUT, putTimeoutMs);
             // By default, use the same thing for getVersions() also
-            timeoutConfig.getVersionsTimeoutMs(putTimeoutMs, TimeUnit.MILLISECONDS);
+            timeoutConfig.setOperationTimeout(VoldemortOperation.GETVERSIONS, putTimeoutMs);
         }
 
         // of course, if someone overrides it, we will respect that
         if(props.containsKey(GET_VERSIONS_ROUTING_TIMEOUT_MS_PROPERTY))
-            timeoutConfig.getVersionsTimeoutMs(props.getInt(GET_VERSIONS_ROUTING_TIMEOUT_MS_PROPERTY),
-                                               TimeUnit.MILLISECONDS);
+            timeoutConfig.setOperationTimeout(VoldemortOperation.GETVERSIONS,
+                                              props.getInt(GET_VERSIONS_ROUTING_TIMEOUT_MS_PROPERTY));
 
         if(props.containsKey(DELETE_ROUTING_TIMEOUT_MS_PROPERTY))
-            timeoutConfig.deleteTimeoutMs(props.getInt(DELETE_ROUTING_TIMEOUT_MS_PROPERTY),
-                                          TimeUnit.MILLISECONDS);
+            timeoutConfig.setOperationTimeout(VoldemortOperation.DELETE,
+                                              props.getInt(DELETE_ROUTING_TIMEOUT_MS_PROPERTY));
 
         if(props.containsKey(ALLOW_PARTIAL_GETALLS_PROPERTY))
             timeoutConfig.setPartialGetAllAllowed(props.getBoolean(ALLOW_PARTIAL_GETALLS_PROPERTY));

src/java/voldemort/client/TimeoutConfig.java

@@ -0,0 +1,56 @@
+package voldemort.client;
+
+import java.util.HashMap;
+
+/**
+ * Encapsulates the timeouts for various voldemort operations
+ * 
+ */
+public class TimeoutConfig {
+
+    private HashMap<VoldemortOperation, Long> timeoutMap;
+
+    private boolean partialGetAllAllowed;
+
+    public TimeoutConfig(long globalTimeout, boolean allowPartialGetAlls) {
+        this(globalTimeout,
+             globalTimeout,
+             globalTimeout,
+             globalTimeout,
+             globalTimeout,
+             allowPartialGetAlls);
+    }
+
+    public TimeoutConfig(long getTimeout,
+                         long putTimeout,
+                         long deleteTimeout,
+                         long getAllTimeout,
+                         long getVersionsTimeout,
+                         boolean allowPartialGetAlls) {
+        timeoutMap = new HashMap<VoldemortOperation, Long>();
+        timeoutMap.put(VoldemortOperation.GET, getTimeout);
+        timeoutMap.put(VoldemortOperation.PUT, putTimeout);
+        timeoutMap.put(VoldemortOperation.DELETE, deleteTimeout);
+        timeoutMap.put(VoldemortOperation.GETALL, getAllTimeout);
+        timeoutMap.put(VoldemortOperation.GETVERSIONS, getVersionsTimeout);
+        setPartialGetAllAllowed(allowPartialGetAlls);
+    }
+
+    public long getOperationTimeout(VoldemortOperation operation) {
+        assert timeoutMap.containsKey(operation);
+        return timeoutMap.get(operation);
+    }
+
+    public void setOperationTimeout(VoldemortOperation operation, long timeoutMs) {
+        timeoutMap.put(operation, timeoutMs);
+    }
+
+    public boolean isPartialGetAllAllowed() {
+        return partialGetAllAllowed;
+    }
+
+    public void setPartialGetAllAllowed(boolean allowPartialGetAlls) {
+        this.partialGetAllAllowed = allowPartialGetAlls;
+    }
+
+}

src/java/voldemort/client/VoldemortOperation.java

@@ -0,0 +1,14 @@
+package voldemort.client;
+
+/**
+ * 
+ * Set of operations supported by Voldemort.
+ * 
+ */
+public enum VoldemortOperation {
+    GET,
+    PUT,
+    GETALL,
+    DELETE,
+    GETVERSIONS
+}

src/java/voldemort/server/VoldemortConfig.java

@@ -21,8 +21,9 @@
 import java.io.Serializable;
 import java.util.List;
 import java.util.Properties;
-import java.util.concurrent.TimeUnit;
 
+import voldemort.client.TimeoutConfig;
+import voldemort.client.VoldemortOperation;
 import voldemort.client.protocol.RequestFormatType;
 import voldemort.cluster.failuredetector.FailureDetectorConfig;
 import voldemort.server.scheduler.slop.StreamingSlopPusherJob;
@@ -35,7 +36,6 @@
 import voldemort.utils.ConfigurationException;
 import voldemort.utils.Props;
 import voldemort.utils.Time;
-import voldemort.utils.TimeoutConfig;
 import voldemort.utils.UndefinedPropertyException;
 import voldemort.utils.Utils;
 
@@ -279,21 +279,21 @@ public VoldemortConfig(Props props) {
         this.clientConnectionTimeoutMs = props.getInt("client.connection.timeout.ms", 500);
         this.clientRoutingTimeoutMs = props.getInt("client.routing.timeout.ms", 15000);
         this.clientTimeoutConfig = new TimeoutConfig(this.clientRoutingTimeoutMs, false);
-        this.clientTimeoutConfig.getTimeoutMs(props.getInt("client.routing.get.timeout.ms",
-                                                           this.clientRoutingTimeoutMs),
-                                              TimeUnit.MILLISECONDS);
-        this.clientTimeoutConfig.getAllTimeoutMs(props.getInt("client.routing.getall.timeout.ms",
-                                                              this.clientRoutingTimeoutMs),
-                                                 TimeUnit.MILLISECONDS);
-        this.clientTimeoutConfig.putTimeoutMs(props.getInt("client.routing.put.timeout.ms",
-                                                           this.clientRoutingTimeoutMs),
-                                              TimeUnit.MILLISECONDS);
-        this.clientTimeoutConfig.getVersionsTimeoutMs(props.getLong("client.routing.getversions.timeout.ms",
-                                                                    this.clientTimeoutConfig.putTimeoutMs()),
-                                                      TimeUnit.MILLISECONDS);
-        this.clientTimeoutConfig.deleteTimeoutMs(props.getInt("client.routing.delete.timeout.ms",
-                                                              this.clientRoutingTimeoutMs),
-                                                 TimeUnit.MILLISECONDS);
+        this.clientTimeoutConfig.setOperationTimeout(VoldemortOperation.GET,
+                                                     props.getInt("client.routing.get.timeout.ms",
+                                                                  this.clientRoutingTimeoutMs));
+        this.clientTimeoutConfig.setOperationTimeout(VoldemortOperation.GETALL,
+                                                     props.getInt("client.routing.getall.timeout.ms",
+                                                                  this.clientRoutingTimeoutMs));
+        this.clientTimeoutConfig.setOperationTimeout(VoldemortOperation.PUT,
+                                                     props.getInt("client.routing.put.timeout.ms",
+                                                                  this.clientRoutingTimeoutMs));
+        this.clientTimeoutConfig.setOperationTimeout(VoldemortOperation.GETVERSIONS,
+                                                     props.getLong("client.routing.getversions.timeout.ms",
+                                                                   this.clientTimeoutConfig.getOperationTimeout(VoldemortOperation.PUT)));
+        this.clientTimeoutConfig.setOperationTimeout(VoldemortOperation.DELETE,
+                                                     props.getInt("client.routing.delete.timeout.ms",
+                                                                  this.clientRoutingTimeoutMs));
         this.clientTimeoutConfig.setPartialGetAllAllowed(props.getBoolean("client.routing.allow.partial.getall",
                                                                           false));
         this.clientMaxThreads = props.getInt("client.max.threads", 500);