Merge branch 'grpc:master' into Issue_fixed_12142

Author: Sangamesh1997

binder/src/main/java/io/grpc/binder/internal/BinderTransport.java

@@ -300,7 +300,10 @@ protected boolean setOutgoingBinder(OneWayBinderProxy binder) {
 
   @Override
   public synchronized void binderDied() {
-    shutdownInternal(Status.UNAVAILABLE.withDescription("Peer process crashed, exited or was killed (binderDied)"), true);
+    shutdownInternal(
+        Status.UNAVAILABLE.withDescription(
+            "Peer process crashed, exited or was killed (binderDied)"),
+        true);
   }
 
   @GuardedBy("this")

rls/src/main/java/io/grpc/rls/LinkedHashLruCache.java

@@ -43,7 +43,8 @@ abstract class LinkedHashLruCache<K, V> implements LruCache<K, V> {
 
   private final LinkedHashMap<K, SizedValue> delegate;
   private final Ticker ticker;
-  private final EvictionListener<K, SizedValue> evictionListener;
+  @Nullable
+  private final EvictionListener<K, V> evictionListener;
   private long estimatedSizeBytes;
   private long estimatedMaxSizeBytes;
 
@@ -53,7 +54,7 @@ abstract class LinkedHashLruCache<K, V> implements LruCache<K, V> {
       final Ticker ticker) {
     checkState(estimatedMaxSizeBytes > 0, "max estimated cache size should be positive");
     this.estimatedMaxSizeBytes = estimatedMaxSizeBytes;
-    this.evictionListener = new SizeHandlingEvictionListener(evictionListener);
+    this.evictionListener = evictionListener;
     this.ticker = checkNotNull(ticker, "ticker");
     delegate = new LinkedHashMap<K, SizedValue>(
         // rough estimate or minimum hashmap default
@@ -135,7 +136,7 @@ public final V cache(K key, V value) {
     estimatedSizeBytes += size;
     existing = delegate.put(key, new SizedValue(size, value));
     if (existing != null) {
-      evictionListener.onEviction(key, existing, EvictionType.REPLACED);
+      fireOnEviction(key, existing, EvictionType.REPLACED);
     }
     return existing == null ? null : existing.value;
   }
@@ -174,7 +175,7 @@ private V invalidate(K key, EvictionType cause) {
     checkNotNull(cause, "cause");
     SizedValue existing = delegate.remove(key);
     if (existing != null) {
-      evictionListener.onEviction(key, existing, cause);
+      fireOnEviction(key, existing, cause);
     }
     return existing == null ? null : existing.value;
   }
@@ -185,7 +186,7 @@ public final void invalidateAll() {
     while (iterator.hasNext()) {
       Map.Entry<K, SizedValue> entry = iterator.next();
       if (entry.getValue() != null) {
-        evictionListener.onEviction(entry.getKey(), entry.getValue(), EvictionType.EXPLICIT);
+        fireOnEviction(entry.getKey(), entry.getValue(), EvictionType.EXPLICIT);
       }
       iterator.remove();
     }
@@ -215,23 +216,22 @@ public final List<V> values() {
   protected final boolean fitToLimit() {
     boolean removedAnyUnexpired = false;
     if (estimatedSizeBytes <= estimatedMaxSizeBytes) {
-      // new size is larger no need to do cleanup
       return false;
     }
     // cleanup expired entries
     long now = ticker.read();
     cleanupExpiredEntries(now);
 
-    // cleanup eldest entry until new size limit
+    // cleanup eldest entry until the size of all entries fits within the limit
     Iterator<Map.Entry<K, SizedValue>> lruIter = delegate.entrySet().iterator();
     while (lruIter.hasNext() && estimatedMaxSizeBytes < this.estimatedSizeBytes) {
       Map.Entry<K, SizedValue> entry = lruIter.next();
       if (!shouldInvalidateEldestEntry(entry.getKey(), entry.getValue().value, now)) {
         break; // Violates some constraint like minimum age so stop our cleanup
       }
       lruIter.remove();
-      // eviction listener will update the estimatedSizeBytes
-      evictionListener.onEviction(entry.getKey(), entry.getValue(), EvictionType.SIZE);
+      // fireOnEviction will update the estimatedSizeBytes
+      fireOnEviction(entry.getKey(), entry.getValue(), EvictionType.SIZE);
       removedAnyUnexpired = true;
     }
     return removedAnyUnexpired;
@@ -270,7 +270,7 @@ private boolean cleanupExpiredEntries(int maxExpiredEntries, long now) {
       Map.Entry<K, SizedValue> entry = lruIter.next();
       if (isExpired(entry.getKey(), entry.getValue().value, now)) {
         lruIter.remove();
-        evictionListener.onEviction(entry.getKey(), entry.getValue(), EvictionType.EXPIRED);
+        fireOnEviction(entry.getKey(), entry.getValue(), EvictionType.EXPIRED);
         removedAny = true;
         maxExpiredEntries--;
       }
@@ -283,21 +283,10 @@ public final void close() {
     invalidateAll();
   }
 
-  /** A {@link EvictionListener} keeps track of size. */
-  private final class SizeHandlingEvictionListener implements EvictionListener<K, SizedValue> {
-
-    private final EvictionListener<K, V> delegate;
-
-    SizeHandlingEvictionListener(@Nullable EvictionListener<K, V> delegate) {
-      this.delegate = delegate;
-    }
-
-    @Override
-    public void onEviction(K key, SizedValue value, EvictionType cause) {
-      estimatedSizeBytes -= value.size;
-      if (delegate != null) {
-        delegate.onEviction(key, value.value, cause);
-      }
+  private void fireOnEviction(K key, SizedValue value, EvictionType cause) {
+    estimatedSizeBytes -= value.size;
+    if (evictionListener != null) {
+      evictionListener.onEviction(key, value.value, cause);
     }
   }
 

util/src/main/java/io/grpc/util/OutlierDetectionLoadBalancer.java

@@ -142,7 +142,7 @@ public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
     // If outlier detection is actually configured, start a timer that will periodically try to
     // detect outliers.
     if (config.outlierDetectionEnabled()) {
-      Long initialDelayNanos;
+      long initialDelayNanos;
 
       if (detectionTimerStartNanos == null) {
         // On the first go we use the configured interval.
@@ -723,7 +723,7 @@ void swapCounters() {
      * that don't have ejected subchannels and uneject ones that have spent the maximum ejection
      * time allowed.
      */
-    void maybeUnejectOutliers(Long detectionTimerStartNanos) {
+    void maybeUnejectOutliers(long detectionTimerStartNanos) {
       for (EndpointTracker tracker : trackerMap.values()) {
         if (!tracker.subchannelsEjected()) {
           tracker.decrementEjectionTimeMultiplier();
@@ -951,64 +951,54 @@ private static boolean hasSingleAddress(List<EquivalentAddressGroup> addressGrou
    */
   public static final class OutlierDetectionLoadBalancerConfig {
 
-    public final Long intervalNanos;
-    public final Long baseEjectionTimeNanos;
-    public final Long maxEjectionTimeNanos;
-    public final Integer maxEjectionPercent;
+    public final long intervalNanos;
+    public final long baseEjectionTimeNanos;
+    public final long maxEjectionTimeNanos;
+    public final int maxEjectionPercent;
     public final SuccessRateEjection successRateEjection;
     public final FailurePercentageEjection failurePercentageEjection;
     public final Object childConfig;
 
-    private OutlierDetectionLoadBalancerConfig(Long intervalNanos,
-        Long baseEjectionTimeNanos,
-        Long maxEjectionTimeNanos,
-        Integer maxEjectionPercent,
-        SuccessRateEjection successRateEjection,
-        FailurePercentageEjection failurePercentageEjection,
-        Object childConfig) {
-      this.intervalNanos = intervalNanos;
-      this.baseEjectionTimeNanos = baseEjectionTimeNanos;
-      this.maxEjectionTimeNanos = maxEjectionTimeNanos;
-      this.maxEjectionPercent = maxEjectionPercent;
-      this.successRateEjection = successRateEjection;
-      this.failurePercentageEjection = failurePercentageEjection;
-      this.childConfig = childConfig;
+    private OutlierDetectionLoadBalancerConfig(Builder builder) {
+      this.intervalNanos = builder.intervalNanos;
+      this.baseEjectionTimeNanos = builder.baseEjectionTimeNanos;
+      this.maxEjectionTimeNanos = builder.maxEjectionTimeNanos;
+      this.maxEjectionPercent = builder.maxEjectionPercent;
+      this.successRateEjection = builder.successRateEjection;
+      this.failurePercentageEjection = builder.failurePercentageEjection;
+      this.childConfig = builder.childConfig;
     }
 
     /** Builds a new {@link OutlierDetectionLoadBalancerConfig}. */
     public static class Builder {
-      Long intervalNanos = 10_000_000_000L; // 10s
-      Long baseEjectionTimeNanos = 30_000_000_000L; // 30s
-      Long maxEjectionTimeNanos = 300_000_000_000L; // 300s
-      Integer maxEjectionPercent = 10;
+      long intervalNanos = 10_000_000_000L; // 10s
+      long baseEjectionTimeNanos = 30_000_000_000L; // 30s
+      long maxEjectionTimeNanos = 300_000_000_000L; // 300s
+      int maxEjectionPercent = 10;
       SuccessRateEjection successRateEjection;
       FailurePercentageEjection failurePercentageEjection;
       Object childConfig;
 
       /** The interval between outlier detection sweeps. */
-      public Builder setIntervalNanos(Long intervalNanos) {
-        checkArgument(intervalNanos != null);
+      public Builder setIntervalNanos(long intervalNanos) {
         this.intervalNanos = intervalNanos;
         return this;
       }
 
       /** The base time an address is ejected for. */
-      public Builder setBaseEjectionTimeNanos(Long baseEjectionTimeNanos) {
-        checkArgument(baseEjectionTimeNanos != null);
+      public Builder setBaseEjectionTimeNanos(long baseEjectionTimeNanos) {
         this.baseEjectionTimeNanos = baseEjectionTimeNanos;
         return this;
       }
 
       /** The longest time an address can be ejected. */
-      public Builder setMaxEjectionTimeNanos(Long maxEjectionTimeNanos) {
-        checkArgument(maxEjectionTimeNanos != null);
+      public Builder setMaxEjectionTimeNanos(long maxEjectionTimeNanos) {
         this.maxEjectionTimeNanos = maxEjectionTimeNanos;
         return this;
       }
 
       /** The algorithm agnostic maximum percentage of addresses that can be ejected. */
-      public Builder setMaxEjectionPercent(Integer maxEjectionPercent) {
-        checkArgument(maxEjectionPercent != null);
+      public Builder setMaxEjectionPercent(int maxEjectionPercent) {
         this.maxEjectionPercent = maxEjectionPercent;
         return this;
       }
@@ -1040,118 +1030,106 @@ public Builder setChildConfig(Object childConfig) {
       /** Builds a new instance of {@link OutlierDetectionLoadBalancerConfig}. */
       public OutlierDetectionLoadBalancerConfig build() {
         checkState(childConfig != null);
-        return new OutlierDetectionLoadBalancerConfig(intervalNanos, baseEjectionTimeNanos,
-            maxEjectionTimeNanos, maxEjectionPercent, successRateEjection,
-            failurePercentageEjection, childConfig);
+        return new OutlierDetectionLoadBalancerConfig(this);
       }
     }
 
     /** The configuration for success rate ejection. */
     public static class SuccessRateEjection {
 
-      public final Integer stdevFactor;
-      public final Integer enforcementPercentage;
-      public final Integer minimumHosts;
-      public final Integer requestVolume;
-
-      SuccessRateEjection(Integer stdevFactor, Integer enforcementPercentage, Integer minimumHosts,
-          Integer requestVolume) {
-        this.stdevFactor = stdevFactor;
-        this.enforcementPercentage = enforcementPercentage;
-        this.minimumHosts = minimumHosts;
-        this.requestVolume = requestVolume;
+      public final int stdevFactor;
+      public final int enforcementPercentage;
+      public final int minimumHosts;
+      public final int requestVolume;
+
+      SuccessRateEjection(Builder builder) {
+        this.stdevFactor = builder.stdevFactor;
+        this.enforcementPercentage = builder.enforcementPercentage;
+        this.minimumHosts = builder.minimumHosts;
+        this.requestVolume = builder.requestVolume;
       }
 
       /** Builds new instances of {@link SuccessRateEjection}. */
       public static final class Builder {
 
-        Integer stdevFactor = 1900;
-        Integer enforcementPercentage = 100;
-        Integer minimumHosts = 5;
-        Integer requestVolume = 100;
+        int stdevFactor = 1900;
+        int enforcementPercentage = 100;
+        int minimumHosts = 5;
+        int requestVolume = 100;
 
         /** The product of this and the standard deviation of success rates determine the ejection
          * threshold.
          */
-        public Builder setStdevFactor(Integer stdevFactor) {
-          checkArgument(stdevFactor != null);
+        public Builder setStdevFactor(int stdevFactor) {
           this.stdevFactor = stdevFactor;
           return this;
         }
 
         /** Only eject this percentage of outliers. */
-        public Builder setEnforcementPercentage(Integer enforcementPercentage) {
-          checkArgument(enforcementPercentage != null);
+        public Builder setEnforcementPercentage(int enforcementPercentage) {
           checkArgument(enforcementPercentage >= 0 && enforcementPercentage <= 100);
           this.enforcementPercentage = enforcementPercentage;
           return this;
         }
 
         /** The minimum amount of hosts needed for success rate ejection. */
-        public Builder setMinimumHosts(Integer minimumHosts) {
-          checkArgument(minimumHosts != null);
+        public Builder setMinimumHosts(int minimumHosts) {
           checkArgument(minimumHosts >= 0);
           this.minimumHosts = minimumHosts;
           return this;
         }
 
         /** The minimum address request volume to be considered for success rate ejection. */
-        public Builder setRequestVolume(Integer requestVolume) {
-          checkArgument(requestVolume != null);
+        public Builder setRequestVolume(int requestVolume) {
           checkArgument(requestVolume >= 0);
           this.requestVolume = requestVolume;
           return this;
         }
 
         /** Builds a new instance of {@link SuccessRateEjection}. */
         public SuccessRateEjection build() {
-          return new SuccessRateEjection(stdevFactor, enforcementPercentage, minimumHosts,
-              requestVolume);
+          return new SuccessRateEjection(this);
         }
       }
     }
 
     /** The configuration for failure percentage ejection. */
     public static class FailurePercentageEjection {
-      public final Integer threshold;
-      public final Integer enforcementPercentage;
-      public final Integer minimumHosts;
-      public final Integer requestVolume;
-
-      FailurePercentageEjection(Integer threshold, Integer enforcementPercentage,
-          Integer minimumHosts, Integer requestVolume) {
-        this.threshold = threshold;
-        this.enforcementPercentage = enforcementPercentage;
-        this.minimumHosts = minimumHosts;
-        this.requestVolume = requestVolume;
+      public final int threshold;
+      public final int enforcementPercentage;
+      public final int minimumHosts;
+      public final int requestVolume;
+
+      FailurePercentageEjection(Builder builder) {
+        this.threshold = builder.threshold;
+        this.enforcementPercentage = builder.enforcementPercentage;
+        this.minimumHosts = builder.minimumHosts;
+        this.requestVolume = builder.requestVolume;
       }
 
       /** For building new {@link FailurePercentageEjection} instances. */
       public static class Builder {
-        Integer threshold = 85;
-        Integer enforcementPercentage = 100;
-        Integer minimumHosts = 5;
-        Integer requestVolume = 50;
+        int threshold = 85;
+        int enforcementPercentage = 100;
+        int minimumHosts = 5;
+        int requestVolume = 50;
 
         /** The failure percentage that will result in an address being considered an outlier. */
-        public Builder setThreshold(Integer threshold) {
-          checkArgument(threshold != null);
+        public Builder setThreshold(int threshold) {
           checkArgument(threshold >= 0 && threshold <= 100);
           this.threshold = threshold;
           return this;
         }
 
         /** Only eject this percentage of outliers. */
-        public Builder setEnforcementPercentage(Integer enforcementPercentage) {
-          checkArgument(enforcementPercentage != null);
+        public Builder setEnforcementPercentage(int enforcementPercentage) {
           checkArgument(enforcementPercentage >= 0 && enforcementPercentage <= 100);
           this.enforcementPercentage = enforcementPercentage;
           return this;
         }
 
         /** The minimum amount of host for failure percentage ejection to be enabled. */
-        public Builder setMinimumHosts(Integer minimumHosts) {
-          checkArgument(minimumHosts != null);
+        public Builder setMinimumHosts(int minimumHosts) {
           checkArgument(minimumHosts >= 0);
           this.minimumHosts = minimumHosts;
           return this;
@@ -1161,17 +1139,15 @@ public Builder setMinimumHosts(Integer minimumHosts) {
          * The request volume required for an address to be considered for failure percentage
          * ejection.
          */
-        public Builder setRequestVolume(Integer requestVolume) {
-          checkArgument(requestVolume != null);
+        public Builder setRequestVolume(int requestVolume) {
           checkArgument(requestVolume >= 0);
           this.requestVolume = requestVolume;
           return this;
         }
 
         /** Builds a new instance of {@link FailurePercentageEjection}. */
         public FailurePercentageEjection build() {
-          return new FailurePercentageEjection(threshold, enforcementPercentage, minimumHosts,
-              requestVolume);
+          return new FailurePercentageEjection(this);
         }
       }
     }