Revert "[AMBARI-26076] Upgrade net.sf.ehcache to 3.10.0 (apache#3825)"

This reverts commit b6a3185.

Author: xijunmu

ambari-server/pom.xml

@@ -1367,10 +1367,6 @@
           <groupId>org.codehaus.jackson</groupId>
           <artifactId>jackson-mapper-asl</artifactId>
         </exclusion>
-        <exclusion>
-          <groupId>javax.xml.bind</groupId>
-          <artifactId>jaxb-api</artifactId>
-        </exclusion>
       </exclusions>
     </dependency>
     <dependency>
@@ -1665,30 +1661,9 @@
       <artifactId>jackson-databind</artifactId>
     </dependency>
     <dependency>
-      <groupId>javax.xml.bind</groupId>
-      <artifactId>jaxb-api</artifactId>
-      <version>2.3.1</version>
-    </dependency>
-    <dependency>
-      <groupId>com.sun.istack</groupId>
-      <artifactId>istack-commons-runtime</artifactId>
-      <version>4.0.0</version>
-    </dependency>
-    <dependency>
-      <groupId>com.sun.xml.fastinfoset</groupId>
-      <artifactId>FastInfoset</artifactId>
-      <version>1.2.16</version>
-    </dependency>
-    <dependency>
-      <groupId>org.ehcache</groupId>
+      <groupId>net.sf.ehcache</groupId>
       <artifactId>ehcache</artifactId>
-      <version>3.10.0</version>
-      <exclusions>
-        <exclusion>
-          <groupId>org.glassfish.jaxb</groupId>
-          <artifactId>jaxb-runtime</artifactId>
-        </exclusion>
-      </exclusions>
+      <version>2.10.0</version>
     </dependency>
     <dependency>
       <groupId>com.nimbusds</groupId>

ambari-server/src/main/java/org/apache/ambari/server/configuration/Configuration.java

@@ -2061,15 +2061,6 @@ public class Configuration {
   public static final ConfigurationProperty<Integer> TIMELINE_METRICS_CACHE_IDLE_TIME = new ConfigurationProperty<>(
       "server.timeline.metrics.cache.entry.idle.seconds", 1800);
 
-  /**
-   * Cache size in entry units that ambari metrics cache will hold.
-   */
-  @Markdown(
-          relatedTo = "server.timeline.metrics.cache.disabled",
-          description = "cache size, in entries, that ambari metrics cache will hold.")
-  public static final ConfigurationProperty<Integer> TIMELINE_METRICS_CACHE_ENTRY_UNIT_SIZE = new ConfigurationProperty<>(
-          "server.timeline.metrics.cache.entry.entry.unit.size", 100);
-
   /**
    * The time, in {@link TimeUnit#MILLISECONDS}, that initial requests made to
    * Ambari Metrics will wait while reading from the socket before timing out.
@@ -5278,13 +5269,6 @@ public int getMetricCacheIdleSeconds() {
     return Integer.parseInt(getProperty(TIMELINE_METRICS_CACHE_IDLE_TIME));
   }
 
-  /**
-   * Ambari metrics cache size.
-   */
-  public int getMetricCacheEntryUnitSize() {
-    return Integer.parseInt(getProperty(TIMELINE_METRICS_CACHE_ENTRY_UNIT_SIZE));
-  }
-
   /**
    * Separate timeout settings for metrics cache.
    * @return milliseconds

ambari-server/src/main/java/org/apache/ambari/server/controller/metrics/timeline/cache/TimelineAppMetricCacheKeySerializer.java

@@ -18,36 +18,35 @@
 package org.apache.ambari.server.controller.metrics.timeline.cache;
 
 import java.io.IOException;
+import java.net.ConnectException;
 import java.net.SocketTimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.apache.hadoop.metrics2.sink.timeline.TimelineMetrics;
-import org.ehcache.Cache;
-import org.ehcache.core.internal.statistics.DefaultStatisticsService;
-import org.ehcache.core.statistics.CacheStatistics;
-import org.ehcache.spi.loaderwriter.CacheLoadingException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class TimelineMetricCache {
-  private final Cache<TimelineAppMetricCacheKey, TimelineMetricsCacheValue> cache;
-  private final DefaultStatisticsService statisticsService;
-  private final TimelineMetricCacheEntryFactory cacheEntryFactory;
-  public static final String TIMELINE_METRIC_CACHE_INSTANCE_NAME = "timelineMetricCache";
+import net.sf.ehcache.CacheException;
+import net.sf.ehcache.Ehcache;
+import net.sf.ehcache.Element;
+import net.sf.ehcache.constructs.blocking.LockTimeoutException;
+import net.sf.ehcache.constructs.blocking.UpdatingCacheEntryFactory;
+import net.sf.ehcache.constructs.blocking.UpdatingSelfPopulatingCache;
+import net.sf.ehcache.statistics.StatisticsGateway;
+
+public class TimelineMetricCache extends UpdatingSelfPopulatingCache {
+
   private final static Logger LOG = LoggerFactory.getLogger(TimelineMetricCache.class);
   private static AtomicInteger printCacheStatsCounter = new AtomicInteger(0);
 
   /**
-   * Creates a TimelineMetricCache.
+   * Creates a SelfPopulatingCache.
    *
    * @param cache @Cache
-   * @param cacheEntryFactory @CacheEntryFactory
-   * @param statisticsService @DefaultStatisticsService
+   * @param factory @CacheEntryFactory
    */
-  public TimelineMetricCache(Cache<TimelineAppMetricCacheKey, TimelineMetricsCacheValue> cache, TimelineMetricCacheEntryFactory cacheEntryFactory, DefaultStatisticsService statisticsService) {
-    this.cache = cache;
-    this.cacheEntryFactory = cacheEntryFactory;
-    this.statisticsService = statisticsService;
+  public TimelineMetricCache(Ehcache cache, UpdatingCacheEntryFactory factory) throws CacheException {
+    super(cache, factory);
   }
 
   /**
@@ -64,22 +63,26 @@ public TimelineMetrics getAppTimelineMetricsFromCache(TimelineAppMetricCacheKey
     // Make sure key is valid
     validateKey(key);
 
-    TimelineMetricsCacheValue value = null;
+    Element element = null;
     try {
-      value = cache.get(key);
-    } catch (CacheLoadingException cle) {
-      Throwable t = cle.getCause();
-      if(t instanceof SocketTimeoutException) {
-        throw new SocketTimeoutException(t.getMessage());
-      }
-      if(t instanceof IOException) {
-        throw new IOException(t.getMessage());
+      element = get(key);
+    } catch (LockTimeoutException le) {
+      // Ehcache masks the Socket Timeout to look as a LockTimeout
+      Throwable t = le.getCause();
+      if (t instanceof CacheException) {
+        t = t.getCause();
+        if (t instanceof SocketTimeoutException) {
+          throw new SocketTimeoutException(t.getMessage());
+        }
+        if (t instanceof ConnectException) {
+          throw new ConnectException(t.getMessage());
+        }
       }
-      throw cle;
     }
 
     TimelineMetrics timelineMetrics = new TimelineMetrics();
-    if (value != null) {
+    if (element != null && element.getObjectValue() != null) {
+      TimelineMetricsCacheValue value = (TimelineMetricsCacheValue) element.getObjectValue();
       if (LOG.isDebugEnabled()) {
         LOG.debug("Returning value from cache: {}", value);
       }
@@ -89,21 +92,51 @@ public TimelineMetrics getAppTimelineMetricsFromCache(TimelineAppMetricCacheKey
     if (LOG.isDebugEnabled()) {
       // Print stats every 100 calls - Note: Supported in debug mode only
       if (printCacheStatsCounter.getAndIncrement() == 0) {
-        CacheStatistics cacheStatistics = statisticsService.getCacheStatistics(TIMELINE_METRIC_CACHE_INSTANCE_NAME);
-        if(cacheStatistics == null) {
-          LOG.warn("Cache statistics not available.");
-          return timelineMetrics;
-        }
-        LOG.debug("Metrics cache stats => \n, Evictions = {}, Expired = {}, Hits = {}, Misses = {}, Hit ratio = {}, Puts = {}",
-                cacheStatistics.getCacheEvictions(), cacheStatistics.getCacheExpirations(), cacheStatistics.getCacheHits(), cacheStatistics.getCacheMisses(), cacheStatistics.getCacheHitPercentage(), cacheStatistics.getCachePuts()
-        );
+        StatisticsGateway statistics = this.getStatistics();
+        LOG.debug("Metrics cache stats => \n, Evictions = {}, Expired = {}, Hits = {}, Misses = {}, Hit ratio = {}, Puts = {}, Size in MB = {}",
+          statistics.cacheEvictedCount(), statistics.cacheExpiredCount(), statistics.cacheHitCount(), statistics.cacheMissCount(), statistics.cacheHitRatio(),
+          statistics.cachePutCount(), statistics.getLocalHeapSizeInBytes() / 1048576);
       } else {
         printCacheStatsCounter.compareAndSet(100, 0);
       }
     }
+
     return timelineMetrics;
   }
 
+  /**
+   * Set new time bounds on the cache key so that update can use the new
+   * query window. We do this quietly which means regular get/update logic is
+   * not invoked.
+   */
+  @Override
+  public Element get(Object key) throws LockTimeoutException {
+    Element element = this.getQuiet(key);
+    if (element != null) {
+      if (LOG.isTraceEnabled()) {
+        LOG.trace("key : {}", element.getObjectKey());
+        LOG.trace("value : {}", element.getObjectValue());
+      }
+
+      // Set new time boundaries on the key
+      TimelineAppMetricCacheKey existingKey = (TimelineAppMetricCacheKey) element.getObjectKey();
+
+      LOG.debug("Existing temporal info: {} for : {}", existingKey.getTemporalInfo(), existingKey.getMetricNames());
+
+      TimelineAppMetricCacheKey newKey = (TimelineAppMetricCacheKey) key;
+      existingKey.setTemporalInfo(newKey.getTemporalInfo());
+
+      LOG.debug("New temporal info: {} for : {}", newKey.getTemporalInfo(), existingKey.getMetricNames());
+
+      if (existingKey.getSpec() == null || !existingKey.getSpec().equals(newKey.getSpec())) {
+        existingKey.setSpec(newKey.getSpec());
+        LOG.debug("New spec: {} for : {}", newKey.getSpec(), existingKey.getMetricNames());
+      }
+    }
+
+    return super.get(key);
+  }
+
   private void validateKey(TimelineAppMetricCacheKey key) throws IllegalArgumentException {
     StringBuilder msg = new StringBuilder("Invalid metric key requested.");
     boolean throwException = false;