/[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/curcuitbreaker/CircuitBreaker.java revision 452 by torben, Tue Oct 20 10:47:36 2009 UTC miscJava/CircuitBreaker/src/main/java/dk/thoerup/circuitbreaker/CircuitBreaker.java revision 3212 by torben, Thu Dec 28 09:34:47 2017 UTC
# Line 1  Line 1 
1  package dk.thoerup.curcuitbreaker;  package dk.thoerup.circuitbreaker;
2    
3    
4  import dk.thoerup.curcuitbreaker.notification.Notifier;  import java.util.concurrent.ExecutorService;
5  import dk.thoerup.curcuitbreaker.notification.NullNotifier;  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;
10    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.curcuitbreaker.notific Line 36  import dk.thoerup.curcuitbreaker.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.curcuitbreaker.notific Line 48  import dk.thoerup.curcuitbreaker.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                            
72                  reset();                  //set correct intial state
73                    internalReset();
74          }          }
75                    
76            public synchronized void shutdown() {
77                    if (executor != null) {
78                            executor.shutdown();
79                    }
80            }
81                    
82      public Object invoke(CircuitInvocation invocation) throws Exception          
83        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 73  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 81  public class CircuitBreaker{ Line 106  public class CircuitBreaker{
106      }      }
107            
108      public void tripBreaker() {      public void tripBreaker() {
109          synchronized(this) {          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
113        public void retripBreaker() {
114            commonTripBreaker(Event.BreakerRetripped);
115        }
116        
117        private void commonTripBreaker(Event event) {
118            synchronized(this) {
119                  if (currentState != open) { // TODO:Is this conditional necessary ??                  if (currentState != open) { // TODO:Is this conditional necessary ??
120                          open.trip();                          open.trip();
121                          currentState = open;                          currentState = open;
122                                    
123                          notifier.sendNotification(name, Notifier.Event.BreakerTripped);                          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) { // TODO:Is this conditional necessary ??
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 104  public class CircuitBreaker{ Line 140  public class CircuitBreaker{
140      public void reset() {      public void reset() {
141          synchronized(this) {          synchronized(this) {
142                  if (currentState != closed) { // TODO: Is this conditional necessary ??                  if (currentState != closed) { // TODO: Is this conditional necessary ??
143                          currentState = closed;                          internalReset();
144                          notifier.sendNotification(name, Notifier.Event.BreakerReset);                          notifier.sendNotification(this, Event.BreakerReset);
145                            stats.addStatistics(Event.BreakerReset);
146                  }                  }
147          }          }
148      }      }
149            
150        //This one actually sets the correct closed/reset state
151        private void internalReset() {
152                    closed.resetFailureCount();
153                    currentState = closed;          
154        }
155        
156            
157      private CircuitBreakerState getState() {      private CircuitBreakerState getState() {
158          synchronized(this) {          synchronized(this) {
# Line 158  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() {
210            return NotiferHelper.getName(notifier);
211      }      }
212            
213      public String getNotifierName() {      public void setStatistics(Statistics newStats) {
214          return notifier.getClass().getName();          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.452  
changed lines
  Added in v.3212
  ViewVC Help
Powered by ViewVC 1.1.20