add degradeCutHalfOpen and fix exceptionCount bug

sentinel-core/src/main/java/com/alibaba/csp/sentinel/node/Node.java

@@ -16,6 +16,9 @@
 package com.alibaba.csp.sentinel.node;
 
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 
 import com.alibaba.csp.sentinel.Entry;
 import com.alibaba.csp.sentinel.node.metric.MetricNode;
@@ -126,10 +129,21 @@ public interface Node {
      */
     void addPassRequest(int count);
 
+    /**
+     * minus exception
+     */
+    void minusMinuteException();
+
+    void minusSecondException();
+    /**
+     * minus Rt
+     */
+    void minusRt(int count);
+
     /**
      * Add rt and success count.
      *
-     * @param rt response time
+     * @param rt      response time
      * @param success success count to add
      */
     void addRtAndSuccess(long rt, int success);
@@ -164,4 +178,25 @@ public interface Node {
      * Debug only.
      */
     void debug();
+
+    /**
+     * reset lastRT
+     */
+    void resetLastRt();
+
+    /**
+     * get lastRT
+     */
+    AtomicLong getLastRt();
+
+    /**
+     * get last Result (true:success;false:exception)
+     */
+    AtomicBoolean getLastResult();
+
+    /**
+     * get last rt(same TimeWindow) sum
+     */
+    AtomicInteger getLastRtSum();
+
 }

sentinel-core/src/main/java/com/alibaba/csp/sentinel/node/StatisticNode.java

@@ -18,7 +18,9 @@
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 
 import com.alibaba.csp.sentinel.util.TimeUtil;
 import com.alibaba.csp.sentinel.node.metric.MetricNode;
@@ -93,7 +95,7 @@ public class StatisticNode implements Node {
      * by given {@code sampleCount}.
      */
     private transient volatile Metric rollingCounterInSecond = new ArrayMetric(SampleCountProperty.SAMPLE_COUNT,
-        IntervalProperty.INTERVAL);
+            IntervalProperty.INTERVAL);
 
     /**
      * Holds statistics of the recent 60 seconds. The windowLengthInMs is deliberately set to 1000 milliseconds,
@@ -110,6 +112,21 @@ public class StatisticNode implements Node {
      * The last timestamp when metrics were fetched.
      */
     private long lastFetchTime = -1;
+    /**
+     * record last rt(Prepare degrade rt sum and same TimeWindow)
+     */
+    private AtomicLong lastRt = new AtomicLong(0);
+
+    /**
+     * record last rt(same TimeWindow) sum
+     */
+    private AtomicInteger lastRtSum = new AtomicInteger(0);
+    /**
+     * lastResult
+     *
+     * @return
+     */
+    private AtomicBoolean lastResult = new AtomicBoolean(true);
 
     @Override
     public Map<Long, MetricNode> metrics() {
@@ -137,7 +154,7 @@ private boolean isNodeInTime(MetricNode node, long currentTime) {
 
     private boolean isValidMetricNode(MetricNode node) {
         return node.getPassQps() > 0 || node.getBlockQps() > 0 || node.getSuccessQps() > 0
-            || node.getExceptionQps() > 0 || node.getRt() > 0;
+                || node.getExceptionQps() > 0 || node.getRt() > 0;
     }
 
     @Override
@@ -232,11 +249,36 @@ public void addPassRequest(int count) {
         rollingCounterInMinute.addPass(count);
     }
 
+    @Override
+    public void minusSecondException() {
+        rollingCounterInSecond.minusException();
+    }
+    @Override
+    public void minusMinuteException() {
+        rollingCounterInMinute.minusException();
+    }
+
+    @Override
+    public void minusRt(int count) {
+        rollingCounterInSecond.minusRt(lastRt.get());
+        rollingCounterInSecond.minusSuccess(count);
+        rollingCounterInMinute.minusRt(lastRt.get());
+        rollingCounterInMinute.minusSuccess(count);
+        lastRt.set(0);
+    }
+
     @Override
     public void addRtAndSuccess(long rt, int successCount) {
         rollingCounterInSecond.addSuccess(successCount);
         rollingCounterInSecond.addRT(rt);
-
+        if (rollingCounterInSecond.newTimeWindow()) {
+            lastRt.set(rt);
+            lastRtSum.set(1);
+        } else {
+            lastRt.set(rt + lastRt.get());
+            lastRtSum.getAndAdd(1);
+        }
+        lastResult.set(true);
         rollingCounterInMinute.addSuccess(successCount);
         rollingCounterInMinute.addRT(rt);
     }
@@ -251,7 +293,13 @@ public void increaseBlockQps(int count) {
     public void increaseExceptionQps(int count) {
         rollingCounterInSecond.addException(count);
         rollingCounterInMinute.addException(count);
+        lastResult.set(false);
+
+    }
 
+    @Override
+    public void resetLastRt() {
+        lastRt.set(0);
     }
 
     @Override
@@ -268,4 +316,20 @@ public void decreaseThreadNum() {
     public void debug() {
         rollingCounterInSecond.debugQps();
     }
+
+    @Override
+    public AtomicLong getLastRt() {
+        return lastRt;
+    }
+
+    @Override
+    public AtomicBoolean getLastResult() {
+        return lastResult;
+    }
+
+    @Override
+    public AtomicInteger getLastRtSum() {
+        return lastRtSum;
+    }
+
 }

sentinel-core/src/main/java/com/alibaba/csp/sentinel/slots/block/RuleConstant.java

@@ -50,9 +50,14 @@ public final class RuleConstant {
 
     public static final String LIMIT_APP_DEFAULT = "default";
     public static final String LIMIT_APP_OTHER = "other";
+    /**
+     * Three states of the degraded switch
+     */
+    public static final int DEGRADE_CUT_CLOSE = 0;
+    public static final int DEGRADE_CUT_OPEN = 1;
+    public static final int DEGRADE_CUT_HALF_OPEN = 2;
 
     public static final int DEFAULT_SAMPLE_COUNT = 2;
     public static final int DEFAULT_WINDOW_INTERVAL_MS = 1000;
-
-    private RuleConstant() {}
+    private RuleConstant(){}
 }