/[projects]/miscJava/CircuitBreaker/src/main/java/dk/thoerup/circuitbreaker/CircuitBreaker.java
ViewVC logotype

Diff of /miscJava/CircuitBreaker/src/main/java/dk/thoerup/circuitbreaker/CircuitBreaker.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

CircuitBreaker/src/dk/thoerup/circuitbreaker/CircuitBreaker.java revision 871 by torben, Mon Jun 21 17:16:46 2010 UTC miscJava/CircuitBreaker/src/main/java/dk/thoerup/circuitbreaker/CircuitBreaker.java revision 3215 by torben, Thu Dec 28 13:20:04 2017 UTC
# Line 1  Line 1 
1  package dk.thoerup.circuitbreaker;  package dk.thoerup.circuitbreaker;
2    
3    
4    import java.util.concurrent.ExecutorService;
5    import java.util.concurrent.Executors;
6    
7    import dk.thoerup.circuitbreaker.config.BreakerConfig;
8    import dk.thoerup.circuitbreaker.notification.NotiferHelper;
9  import dk.thoerup.circuitbreaker.notification.Notifier;  import dk.thoerup.circuitbreaker.notification.Notifier;
10  import dk.thoerup.circuitbreaker.notification.NullNotifier;  import dk.thoerup.circuitbreaker.notification.NullNotifier;
11    import dk.thoerup.circuitbreaker.statistics.NullStatistics;
12    import dk.thoerup.circuitbreaker.statistics.Statistics;
13    
14  /* Simple CircuitBreaker implementation - snipped from http://www.jroller.com/kenwdelong/entry/circuit_breaker_in_java  /* Simple CircuitBreaker implementation - snipped from http://www.jroller.com/kenwdelong/entry/circuit_breaker_in_java
15   *   *
16   *  example of how it can be used   *  example of how it can be used
17    
18   private CircuitBreaker cb = new CircuitBreaker("test", 5, 10000);   private CircuitBreaker<String> cb = new CircuitBreaker<>("test", 5, 10000);
19   protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {   protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
20                  class TestInvocation implements CircuitInvocation {                  class TestInvocation implements CircuitInvocation<String> {
21                          String url;                          String url;
22                          public TestInvocation(String url) {                          public TestInvocation(String url) {
23                                  this.url = url;                                  this.url = url;
24                          }                          }
25                          public Object proceed() throws Exception{                          public String proceed() throws Exception{
26                                                                    
27                                  URL u = new URL(url);                                  URL u = new URL(url);
28                                  URLConnection c = u.openConnection();                                  URLConnection c = u.openConnection();
# Line 29  import dk.thoerup.circuitbreaker.notific Line 36  import dk.thoerup.circuitbreaker.notific
36                                                    
37                  }                  }
38                  try {                  try {
39                          String s = (String) cb.invoke(new TestInvocation("http://rafiki/test"));                          String s = cb.invoke(new TestInvocation("http://rafiki/test"));
40                          response.getWriter().print(s);                          response.getWriter().print(s);
41                  } catch (Exception e) {                  } catch (Exception e) {
42                          logger.warning( e.getMessage() );                          logger.warning( e.getMessage() );
# Line 41  import dk.thoerup.circuitbreaker.notific Line 48  import dk.thoerup.circuitbreaker.notific
48   */   */
49    
50    
51  public class CircuitBreaker{  public class CircuitBreaker<T>{
52                    
53          private volatile CircuitBreakerState currentState;          private volatile CircuitBreakerState currentState;
54                    
# Line 51  public class CircuitBreaker{ Line 58  public class CircuitBreaker{
58                    
59          private String name;          private String name;
60                    
61            private ExecutorService executor = null;        
62          private Notifier notifier = new NullNotifier();          private Notifier notifier = new NullNotifier();
63            private Statistics stats = new NullStatistics();
64            
65                    
66          public CircuitBreaker(String name, int threshold, long timeoutMS) {          public CircuitBreaker(String name, BreakerConfig config) {
67                  closed.setThreshold(threshold);                  closed.setThreshold(config);
68                  open.setTimeout(timeoutMS);                  open.setTimeout(config);
69                                    
70                  this.name = name;                  this.name = name;
71                    
# Line 63  public class CircuitBreaker{ Line 73  public class CircuitBreaker{
73                  internalReset();                  internalReset();
74          }          }
75                    
76            public synchronized void shutdown() {
77                    if (executor != null) {
78                            executor.shutdown();
79                    }
80            }
81            
82                    
83      public Object invoke(CircuitInvocation invocation) throws Exception      public T invoke(CircuitInvocation<T> invocation) throws Exception
84      {      {
85          Object result = null;          stats.addStatistics(Event.Invocation);
86            
87            T result = null;
88          try          try
89          {          {
90              getState().preInvoke(this);              getState().preInvoke(this);
# Line 74  public class CircuitBreaker{ Line 92  public class CircuitBreaker{
92              getState().postInvoke(this);              getState().postInvoke(this);
93          }          }
94          catch(Exception e)          catch(Exception e)
95          {          {              
96                            if (e instanceof CircuitBreakerException) {
97                                    stats.addStatistics(Event.InvocationBlocked);
98                            } else {
99                                    stats.addStatistics(Event.InvocationFailure);
100                            }
101                    
102              getState().onError(this, e);              getState().onError(this, e);
103              throw e;              throw e;
104          }          }
# Line 82  public class CircuitBreaker{ Line 106  public class CircuitBreaker{
106      }      }
107            
108      public void tripBreaker() {      public void tripBreaker() {
109          commonTripBreaker(Notifier.Event.BreakerTripped);          commonTripBreaker(Event.BreakerTripped);
110      }      }
111            
112          //a re-trip should basically do the same as a normal trip, but it is here just to differentiate the two different events          //a re-trip should basically do the same as a normal trip, but it is here just to differentiate the two different events
113      public void retripBreaker() {      public void retripBreaker() {
114          commonTripBreaker(Notifier.Event.BreakerRetripped);          commonTripBreaker(Event.BreakerRetripped);
115      }      }
116            
117      private void commonTripBreaker(Notifier.Event event) {      private void commonTripBreaker(Event event) {
118          synchronized(this) {          synchronized(this) {
119                  if (currentState != open) { // TODO:Is this conditional necessary ??                  if (currentState != open) {
120                          open.trip();                          open.trip();
121                          currentState = open;                          currentState = open;
122                                    
123                          notifier.sendNotification(name, event);                          notifier.sendNotification(this, event);
124                            stats.addStatistics(event);
125                  }                  }
126          }                }      
127      }      }
128    
129      public void attemptReset() {      public void attemptReset() {
130          synchronized(this) {          synchronized(this) {
131                  if (currentState != halfOpen) { // TODO:Is this conditional necessary ??                  if (currentState != halfOpen) {
132                          currentState = halfOpen;                          currentState = halfOpen;
133                          notifier.sendNotification(name, Notifier.Event.BreakerAttemptReset);                          notifier.sendNotification(this, Event.BreakerAttemptReset);
134                            stats.addStatistics(Event.BreakerAttemptReset);
135                  }                  }
136          }          }
137                    
# Line 113  public class CircuitBreaker{ Line 139  public class CircuitBreaker{
139            
140      public void reset() {      public void reset() {
141          synchronized(this) {          synchronized(this) {
142                  if (currentState != closed) { // TODO: Is this conditional necessary ??                  if (currentState != closed) {
143                          internalReset();                          internalReset();
144                          notifier.sendNotification(name, Notifier.Event.BreakerReset);                          notifier.sendNotification(this, Event.BreakerReset);
145                            stats.addStatistics(Event.BreakerReset);
146                  }                  }
147          }          }
148      }      }
# Line 174  public class CircuitBreaker{ Line 201  public class CircuitBreaker{
201      }      }
202            
203      public void setNotifier(Notifier notifier) {      public void setNotifier(Notifier notifier) {
204          this.notifier = notifier;          synchronized(this) {
205                    this.notifier = notifier;
206            }
207      }      }
208            
209      public String getNotifierName() {      public String getNotifierName() {
210          return notifier.getClass().getName();          return NotiferHelper.getName(notifier);
211        }
212        
213        public void setStatistics(Statistics newStats) {
214            this.stats = newStats;
215        }
216        
217        public Statistics getStatistics() {
218            return this.stats;
219        }
220        
221        public synchronized ExecutorService getExecutor() {
222            
223            if (executor == null) {
224                    executor = Executors.newFixedThreadPool(1);
225            }
226            
227            return executor;
228            
229      }      }
230    
231  }  }
Legend:
Removed from v.871  
changed lines
  Added in v.3215
  ViewVC Help
Powered by ViewVC 1.1.20