Bump dependencies to latest stable versions

Change-Id: I5e8903e55843a671408d0fee213b694f1d27669e

gerrit-server/src/main/java/com/google/gerrit/server/cache/CachePool.java

@@ -22,7 +22,6 @@ import com.google.gerrit.server.config.ConfigUtil;
 import com.google.gerrit.server.config.GerritServerConfig;
 import com.google.gerrit.server.config.SitePaths;
 import com.google.inject.Inject;
-import com.google.inject.ProvisionException;
 import com.google.inject.Singleton;
 
 import net.sf.ehcache.CacheManager;
@@ -143,9 +142,12 @@ public class CachePool {
 
         c.setMaxElementsInMemory(getInt(name, "memorylimit", p.memoryLimit()));
 
-        c.setTimeToIdleSeconds(0);
-        c.setTimeToLiveSeconds(getSeconds(name, "maxage", p.maxAge()));
-        c.setEternal(c.getTimeToLiveSeconds() == 0);
+        long ttl = getSeconds(name, "maxage", p.maxAge());
+        c.setEternal(ttl == 0);
+        if (ttl != 0) {
+          c.setTimeToIdleSeconds(0);
+          c.setTimeToLiveSeconds(ttl);
+        }
 
         if (p.disk() && mgr.getDiskStoreConfiguration() != null) {
           c.setMaxElementsOnDisk(getInt(name, "disklimit", p.diskLimit()));
@@ -220,8 +222,6 @@ public class CachePool {
       c.setMaxElementsInMemory(1024);
       c.setMemoryStoreEvictionPolicyFromObject(MemoryStoreEvictionPolicy.LFU);
 
-      c.setTimeToIdleSeconds(0);
-      c.setTimeToLiveSeconds(0 /* infinite */);
       c.setEternal(true);
 
       if (mgr.getDiskStoreConfiguration() != null) {
@@ -237,14 +237,10 @@ public class CachePool {
     }
 
     private CacheConfiguration newCache(final String name) {
-      try {
-        final CacheConfiguration c;
-        c = mgr.getDefaultCacheConfiguration().clone();
-        c.setName(name);
-        return c;
-      } catch (CloneNotSupportedException e) {
-        throw new ProvisionException("Cannot configure cache " + name, e);
-      }
+      final CacheConfiguration c;
+      c = mgr.getDefaultCacheConfiguration().clone();
+      c.setName(name);
+      return c;
     }
   }
 }

gerrit-server/src/main/java/com/google/gerrit/server/cache/ProxyEhcache.java

@@ -29,7 +29,11 @@ import net.sf.ehcache.loader.CacheLoader;
 import net.sf.ehcache.statistics.CacheUsageListener;
 import net.sf.ehcache.statistics.LiveCacheStatistics;
 import net.sf.ehcache.statistics.sampled.SampledCacheStatistics;
+import net.sf.ehcache.transaction.manager.TransactionManagerLookup;
+import net.sf.ehcache.writer.CacheWriter;
+import net.sf.ehcache.writer.CacheWriterManager;
 
+import java.beans.PropertyChangeListener;
 import java.io.Serializable;
 import java.util.Collection;
 import java.util.List;
@@ -70,55 +74,66 @@ final class ProxyEhcache implements Ehcache {
   //
   // Everything else delegates through self.
   //
-
+  @Override
   public void bootstrap() {
     self().bootstrap();
   }
 
+  @Override
   public long calculateInMemorySize() throws IllegalStateException,
       CacheException {
     return self().calculateInMemorySize();
   }
 
+  @Override
   public void clearStatistics() {
     self().clearStatistics();
   }
 
+  @Override
   public void dispose() throws IllegalStateException {
     self().dispose();
   }
 
+  @Override
   public void evictExpiredElements() {
     self().evictExpiredElements();
   }
 
+  @Override
   public void flush() throws IllegalStateException, CacheException {
     self().flush();
   }
 
+  @Override
   public Element get(Object key) throws IllegalStateException, CacheException {
     return self().get(key);
   }
 
+  @Override
   public Element get(Serializable key) throws IllegalStateException,
       CacheException {
     return self().get(key);
   }
 
   @SuppressWarnings("unchecked")
+  @Override
   public Map getAllWithLoader(Collection keys, Object loaderArgument)
       throws CacheException {
     return self().getAllWithLoader(keys, loaderArgument);
   }
 
+  @Override
   public float getAverageGetTime() {
     return self().getAverageGetTime();
   }
 
+  @Override
   public BootstrapCacheLoader getBootstrapCacheLoader() {
     return self().getBootstrapCacheLoader();
   }
 
+  @Override
   public CacheConfiguration getCacheConfiguration() {
     if (self == null) {
       // In Ehcache 1.7, BlockingCache wants to ask us if we are
@@ -131,263 +146,423 @@ final class ProxyEhcache implements Ehcache {
     return self().getCacheConfiguration();
   }
 
+  @Override
   public RegisteredEventListeners getCacheEventNotificationService() {
     return self().getCacheEventNotificationService();
   }
 
+  @Override
   public CacheExceptionHandler getCacheExceptionHandler() {
     return self().getCacheExceptionHandler();
   }
 
+  @Override
   public CacheManager getCacheManager() {
     return self().getCacheManager();
   }
 
+  @Override
   public int getDiskStoreSize() throws IllegalStateException {
     return self().getDiskStoreSize();
   }
 
+  @Override
   public String getGuid() {
     return self().getGuid();
   }
 
   @SuppressWarnings("unchecked")
+  @Override
   public List getKeys() throws IllegalStateException, CacheException {
     return self().getKeys();
   }
 
   @SuppressWarnings("unchecked")
+  @Override
   public List getKeysNoDuplicateCheck() throws IllegalStateException {
     return self().getKeysNoDuplicateCheck();
   }
 
   @SuppressWarnings("unchecked")
+  @Override
   public List getKeysWithExpiryCheck() throws IllegalStateException,
       CacheException {
     return self().getKeysWithExpiryCheck();
   }
 
+  @Override
   public long getMemoryStoreSize() throws IllegalStateException {
     return self().getMemoryStoreSize();
   }
 
+  @Override
   public Element getQuiet(Object key) throws IllegalStateException,
       CacheException {
     return self().getQuiet(key);
   }
 
+  @Override
   public Element getQuiet(Serializable key) throws IllegalStateException,
       CacheException {
     return self().getQuiet(key);
   }
 
+  @Override
   public List<CacheExtension> getRegisteredCacheExtensions() {
     return self().getRegisteredCacheExtensions();
   }
 
+  @Override
   public List<CacheLoader> getRegisteredCacheLoaders() {
     return self().getRegisteredCacheLoaders();
   }
 
+  @Override
   public int getSize() throws IllegalStateException, CacheException {
     return self().getSize();
   }
 
+  @Override
   public Statistics getStatistics() throws IllegalStateException {
     return self().getStatistics();
   }
 
+  @Override
   public int getStatisticsAccuracy() {
     return self().getStatisticsAccuracy();
   }
 
+  @Override
   public Status getStatus() {
     return self().getStatus();
   }
 
+  @Override
   public Element getWithLoader(Object key, CacheLoader loader,
       Object loaderArgument) throws CacheException {
     return self().getWithLoader(key, loader, loaderArgument);
   }
 
+  @Override
   public void initialise() {
     self().initialise();
   }
 
+  @Override
   public boolean isDisabled() {
     return self().isDisabled();
   }
 
+  @Override
   public boolean isElementInMemory(Object key) {
     return self().isElementInMemory(key);
   }
 
+  @Override
   public boolean isElementInMemory(Serializable key) {
     return self().isElementInMemory(key);
   }
 
+  @Override
   public boolean isElementOnDisk(Object key) {
     return self().isElementOnDisk(key);
   }
 
+  @Override
   public boolean isElementOnDisk(Serializable key) {
     return self().isElementOnDisk(key);
   }
 
+  @Override
   public boolean isExpired(Element element) throws IllegalStateException,
       NullPointerException {
     return self().isExpired(element);
   }
 
+  @Override
   public boolean isKeyInCache(Object key) {
     return self().isKeyInCache(key);
   }
 
+  @Override
   public boolean isValueInCache(Object value) {
     return self().isValueInCache(value);
   }
 
+  @Override
   public void load(Object key) throws CacheException {
     self().load(key);
   }
 
   @SuppressWarnings("unchecked")
+  @Override
   public void loadAll(Collection keys, Object argument) throws CacheException {
     self().loadAll(keys, argument);
   }
 
+  @Override
   public void put(Element element, boolean doNotNotifyCacheReplicators)
       throws IllegalArgumentException, IllegalStateException, CacheException {
     self().put(element, doNotNotifyCacheReplicators);
   }
 
+  @Override
   public void put(Element element) throws IllegalArgumentException,
       IllegalStateException, CacheException {
     self().put(element);
   }
 
+  @Override
   public void putQuiet(Element element) throws IllegalArgumentException,
       IllegalStateException, CacheException {
     self().putQuiet(element);
   }
 
+  @Override
   public void registerCacheExtension(CacheExtension cacheExtension) {
     self().registerCacheExtension(cacheExtension);
   }
 
+  @Override
   public void registerCacheLoader(CacheLoader cacheLoader) {
     self().registerCacheLoader(cacheLoader);
   }
 
+  @Override
   public boolean remove(Object key, boolean doNotNotifyCacheReplicators)
       throws IllegalStateException {
     return self().remove(key, doNotNotifyCacheReplicators);
   }
 
+  @Override
   public boolean remove(Object key) throws IllegalStateException {
     return self().remove(key);
   }
 
+  @Override
   public boolean remove(Serializable key, boolean doNotNotifyCacheReplicators)
       throws IllegalStateException {
     return self().remove(key, doNotNotifyCacheReplicators);
   }
 
+  @Override
   public boolean remove(Serializable key) throws IllegalStateException {
     return self().remove(key);
   }
 
+  @Override
   public void removeAll() throws IllegalStateException, CacheException {
     self().removeAll();
   }
 
+  @Override
   public void removeAll(boolean doNotNotifyCacheReplicators)
       throws IllegalStateException, CacheException {
     self().removeAll(doNotNotifyCacheReplicators);
   }
 
+  @Override
   public boolean removeQuiet(Object key) throws IllegalStateException {
     return self().removeQuiet(key);
   }
 
+  @Override
   public boolean removeQuiet(Serializable key) throws IllegalStateException {
     return self().removeQuiet(key);
   }
 
+  @Override
   public void setBootstrapCacheLoader(BootstrapCacheLoader bootstrapCacheLoader)
       throws CacheException {
     self().setBootstrapCacheLoader(bootstrapCacheLoader);
   }
 
+  @Override
   public void setCacheExceptionHandler(
       CacheExceptionHandler cacheExceptionHandler) {
     self().setCacheExceptionHandler(cacheExceptionHandler);
   }
 
+  @Override
   public void setCacheManager(CacheManager cacheManager) {
     self().setCacheManager(cacheManager);
   }
 
+  @Override
   public void setDisabled(boolean disabled) {
     self().setDisabled(disabled);
   }
 
+  @Override
   public void setDiskStorePath(String diskStorePath) throws CacheException {
     self().setDiskStorePath(diskStorePath);
   }
 
+  @Override
   public void setStatisticsAccuracy(int statisticsAccuracy) {
     self().setStatisticsAccuracy(statisticsAccuracy);
   }
 
+  @Override
   public void unregisterCacheExtension(CacheExtension cacheExtension) {
     self().unregisterCacheExtension(cacheExtension);
   }
 
+  @Override
   public void unregisterCacheLoader(CacheLoader cacheLoader) {
     self().unregisterCacheLoader(cacheLoader);
   }
 
+  @Override
   public Object getInternalContext() {
-    return self.getInternalContext();
+    return self().getInternalContext();
   }
 
+  @Override
   public LiveCacheStatistics getLiveCacheStatistics() throws IllegalStateException {
-    return self.getLiveCacheStatistics();
+    return self().getLiveCacheStatistics();
   }
 
+  @Override
   public SampledCacheStatistics getSampledCacheStatistics() {
-    return self.getSampledCacheStatistics();
+    return self().getSampledCacheStatistics();
   }
 
+  @Override
   public int getSizeBasedOnAccuracy(int statisticsAccuracy) throws IllegalArgumentException,
       IllegalStateException, CacheException {
-    return self.getSizeBasedOnAccuracy(statisticsAccuracy);
+    return self().getSizeBasedOnAccuracy(statisticsAccuracy);
   }
 
+  @Override
   public boolean isSampledStatisticsEnabled() {
-    return self.isSampledStatisticsEnabled();
+    return self().isSampledStatisticsEnabled();
   }
 
+  @Override
   public boolean isStatisticsEnabled() {
-    return self.isStatisticsEnabled();
+    return self().isStatisticsEnabled();
   }
 
+  @Override
   public void registerCacheUsageListener(CacheUsageListener cacheUsageListener)
       throws IllegalStateException {
-    self.registerCacheUsageListener(cacheUsageListener);
+    self().registerCacheUsageListener(cacheUsageListener);
   }
 
+  @Override
   public void removeCacheUsageListener(CacheUsageListener cacheUsageListener)
       throws IllegalStateException {
-    self.removeCacheUsageListener(cacheUsageListener);
+    self().removeCacheUsageListener(cacheUsageListener);
   }
 
+  @Override
   public void setSampledStatisticsEnabled(boolean enableStatistics) {
-    self.setSampledStatisticsEnabled(enableStatistics);
+    self().setSampledStatisticsEnabled(enableStatistics);
   }
 
+  @Override
   public void setStatisticsEnabled(boolean enableStatistics) {
-    self.setStatisticsEnabled(enableStatistics);
+    self().setStatisticsEnabled(enableStatistics);
+  }
+
+  @Override
+  public void putWithWriter(Element element) throws IllegalArgumentException, IllegalStateException, CacheException {
+    self().putWithWriter(element);
+  }
+
+  @Override
+  public Element putIfAbsent(Element element) throws NullPointerException {
+    return self().putIfAbsent(element);
+  }
+
+  @Override
+  public boolean removeElement(Element element) throws NullPointerException {
+    return self().removeElement(element);
+  }
+
+  @Override
+  public boolean replace(Element element, Element element1) throws NullPointerException, IllegalArgumentException {
+    return self().replace(element, element1);
+  }
+
+  @Override
+  public Element replace(Element element) throws NullPointerException {
+    return self().replace(element);
+  }
+
+  @Override
+  public boolean removeWithWriter(Object o) throws IllegalStateException, CacheException {
+    return self().removeWithWriter(o);
+  }
+
+  @Override
+  public long calculateOffHeapSize() throws IllegalStateException, CacheException {
+    return self().calculateOffHeapSize();
+  }
+
+  @Override
+  public long getOffHeapStoreSize() throws IllegalStateException {
+    return self().getOffHeapStoreSize();
+  }
+
+  @Override
+  public void registerCacheWriter(CacheWriter cacheWriter) {
+    self().registerCacheWriter(cacheWriter);
+  }
+
+  @Override
+  public void unregisterCacheWriter() {
+    self().unregisterCacheWriter();
+  }
+
+  @Override
+  public CacheWriter getRegisteredCacheWriter() {
+    return self().getRegisteredCacheWriter();
+  }
+
+  @Override
+  public void disableDynamicFeatures() {
+    self().disableDynamicFeatures();
+  }
+
+  @Override
+  public CacheWriterManager getWriterManager() {
+    return self().getWriterManager();
+  }
+
+  @Override
+  public boolean isClusterCoherent() {
+    return self().isClusterCoherent();
+  }
+
+  @Override
+  public boolean isNodeCoherent() {
+    return self().isNodeCoherent();
+  }
+
+  @Override
+  public void setNodeCoherent(boolean b) throws UnsupportedOperationException {
+    self().setNodeCoherent(b);
+  }
+
+  @Override
+  public void waitUntilClusterCoherent() throws UnsupportedOperationException {
+    self().waitUntilClusterCoherent();
+  }
+
+  @Override
+  public void setTransactionManagerLookup(TransactionManagerLookup transactionManagerLookup) {
+    self().setTransactionManagerLookup(transactionManagerLookup);
+  }
+
+  @Override
+  public void addPropertyChangeListener(PropertyChangeListener propertyChangeListener) {
+    self().addPropertyChangeListener(propertyChangeListener);
+  }
+
+  @Override
+  public void removePropertyChangeListener(PropertyChangeListener propertyChangeListener) {
+    self().removePropertyChangeListener(propertyChangeListener);
   }
 }