/[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 424 by torben, Thu Oct 8 20:39:39 2009 UTC CircuitBreaker/src/dk/thoerup/circuitbreaker/CircuitBreaker.java revision 1161 by torben, Mon Oct 4 17:36:43 2010 UTC
# Line 1  Line 1 
1  package dk.thoerup.curcuitbreaker;  package dk.thoerup.circuitbreaker;
2    
 import java.util.logging.Logger;  
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.notification.Notifier;
8    import dk.thoerup.circuitbreaker.notification.NullNotifier;
9    
10  /* 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
11   *   *
# Line 32  import dk.thoerup.curcuitbreaker.notific Line 34  import dk.thoerup.curcuitbreaker.notific
34                  try {                  try {
35                          String s = (String) cb.invoke(new TestInvocation("http://rafiki/test"));                          String s = (String) cb.invoke(new TestInvocation("http://rafiki/test"));
36                          response.getWriter().print(s);                          response.getWriter().print(s);
37                  } catch (Throwable e) {                  } catch (Exception e) {
38                          logger.warning( e.getMessage() );                          logger.warning( e.getMessage() );
39                          response.sendError(500);                          response.sendError(500);
40                          return;                          return;
# Line 43  import dk.thoerup.curcuitbreaker.notific Line 45  import dk.thoerup.curcuitbreaker.notific
45    
46    
47  public class CircuitBreaker{  public class CircuitBreaker{
         Logger logger = Logger.getLogger(CircuitBreaker.class.getName());  
   
48                    
49          private CircuitBreakerState currentState;          private volatile CircuitBreakerState currentState;
50                    
51          private final OpenState open = new OpenState();          private final OpenState open = new OpenState();
52          private final HalfOpenState halfOpen = new HalfOpenState();          private final HalfOpenState halfOpen = new HalfOpenState();
# Line 54  public class CircuitBreaker{ Line 54  public class CircuitBreaker{
54                    
55          private String name;          private String name;
56                    
57            private ExecutorService executor = null;        
58          private Notifier notifier = new NullNotifier();          private Notifier notifier = new NullNotifier();
59                    
60          public CircuitBreaker(String name, int threshold, long timeoutMS) {          public CircuitBreaker(String name, int threshold, long timeoutMS) {
# Line 61  public class CircuitBreaker{ Line 62  public class CircuitBreaker{
62                  open.setTimeout(timeoutMS);                  open.setTimeout(timeoutMS);
63                                    
64                  this.name = name;                  this.name = name;
65                            
66                  reset();                  //set correct intial state
67                    internalReset();
68            }
69            
70            public synchronized void shutdown() {
71                    if (executor != null) {
72                            executor.shutdown();
73                    }
74          }          }
75                    
76                    
77      public Object invoke(CircuitInvocation invocation) throws Throwable      public Object invoke(CircuitInvocation invocation) throws Exception
78      {      {
79          Object result = null;          Object result = null;
80          try          try
# Line 75  public class CircuitBreaker{ Line 83  public class CircuitBreaker{
83              result = invocation.proceed();              result = invocation.proceed();
84              getState().postInvoke(this);              getState().postInvoke(this);
85          }          }
86          catch(Throwable t)          catch(Exception e)
87          {          {
88              getState().onError(this, t);              getState().onError(this, e);
89              throw t;              throw e;
90          }          }
91          return result;          return result;
92      }      }
93            
94      public void tripBreaker() {      public void tripBreaker() {
95          synchronized(this) {          commonTripBreaker(Notifier.Event.BreakerTripped);
96                  open.trip();      }
97                  currentState = open;      
98                            //a re-trip should basically do the same as a normal trip, but it is here just to differentiate the two different events
99                  notifier.sendNotification(name, Notifier.Event.BreakerTripped);      public void retripBreaker() {
100          }              commonTripBreaker(Notifier.Event.BreakerRetripped);
101      }      }
102            
103        private void commonTripBreaker(Notifier.Event event) {
104            synchronized(this) {
105                    if (currentState != open) { // TODO:Is this conditional necessary ??
106                            open.trip();
107                            currentState = open;
108                    
109                            notifier.sendNotification(this, event);
110                    }
111            }      
112        }
113    
114      public void attemptReset() {      public void attemptReset() {
115          synchronized(this) {          synchronized(this) {
116                  currentState = halfOpen;                  if (currentState != halfOpen) { // TODO:Is this conditional necessary ??
117                  notifier.sendNotification(name, Notifier.Event.BreakerAttemptReset);                          currentState = halfOpen;
118                            notifier.sendNotification(this, Notifier.Event.BreakerAttemptReset);
119                    }
120          }          }
121                    
122      }      }
123            
124      public void reset() {      public void reset() {
125          synchronized(this) {          synchronized(this) {
126                  currentState = closed;                  if (currentState != closed) { // TODO: Is this conditional necessary ??
127                  notifier.sendNotification(name, Notifier.Event.BreakerReset);                          internalReset();
128                            notifier.sendNotification(this, Notifier.Event.BreakerReset);
129                    }
130          }          }
131      }      }
132            
133        //This one actually sets the correct closed/reset state
134        private void internalReset() {
135                    closed.resetFailureCount();
136                    currentState = closed;          
137        }
138        
139            
140      private CircuitBreakerState getState() {      private CircuitBreakerState getState() {
141          synchronized(this) {          synchronized(this) {
# Line 114  public class CircuitBreaker{ Line 143  public class CircuitBreaker{
143          }          }
144      }      }
145            
146        public boolean isClosed() {
147            return (getState() == closed);
148        }
149        
150        public boolean isOpen() {
151            return (getState() == open);
152        }
153        
154      public String getName() {      public String getName() {
155          return name;          return name;
156      }      }
# Line 153  public class CircuitBreaker{ Line 190  public class CircuitBreaker{
190      public String getNotifierName() {      public String getNotifierName() {
191          return notifier.getClass().getName();          return notifier.getClass().getName();
192      }      }
193        
194        public synchronized ExecutorService getExecutor() {
195            
196            if (executor == null) {
197                    executor = Executors.newFixedThreadPool(1);
198            }
199            
200            return executor;
201            
202        }
203    
204  }  }
Legend:
Removed from v.424  
changed lines
  Added in v.1161
  ViewVC Help
Powered by ViewVC 1.1.20