/[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 409 by torben, Wed Oct 7 07:07:00 2009 UTC miscJava/CircuitBreaker/src/main/java/dk/thoerup/circuitbreaker/CircuitBreaker.java revision 2449 by torben, Fri Mar 20 08:58:46 2015 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.config.BreakerConfig;
8    import dk.thoerup.circuitbreaker.config.StaticConfig;
9    import dk.thoerup.circuitbreaker.notification.NotiferHelper;
10    import dk.thoerup.circuitbreaker.notification.Notifier;
11    import dk.thoerup.circuitbreaker.notification.NullNotifier;
12    
13  /* 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
14   *   *
# Line 32  import dk.thoerup.curcuitbreaker.notific Line 37  import dk.thoerup.curcuitbreaker.notific
37                  try {                  try {
38                          String s = (String) cb.invoke(new TestInvocation("http://rafiki/test"));                          String s = (String) cb.invoke(new TestInvocation("http://rafiki/test"));
39                          response.getWriter().print(s);                          response.getWriter().print(s);
40                  } catch (Throwable e) {                  } catch (Exception e) {
41                          logger.warning( e.getMessage() );                          logger.warning( e.getMessage() );
42                          response.sendError(500);                          response.sendError(500);
43                          return;                          return;
# Line 43  import dk.thoerup.curcuitbreaker.notific Line 48  import dk.thoerup.curcuitbreaker.notific
48    
49    
50  public class CircuitBreaker{  public class CircuitBreaker{
         Logger logger = Logger.getLogger(CircuitBreaker.class.getName());  
   
51                    
52          private CircuitBreakerState currentState;          private volatile CircuitBreakerState currentState;
53                    
54          private OpenState open = new OpenState();          private final OpenState open = new OpenState();
55          private HalfOpenState halfOpen = new HalfOpenState();          private final HalfOpenState halfOpen = new HalfOpenState();
56          private ClosedState closed = new ClosedState();          private final ClosedState closed = new ClosedState();
57                    
58          private String name;          private String name;
59                    
60            private ExecutorService executor = null;        
61          private Notifier notifier = new NullNotifier();          private Notifier notifier = new NullNotifier();
62                    
63          public CircuitBreaker(String name, int threshold, long timeoutMS) {          @Deprecated
64                  closed.setThreshold(threshold);          public CircuitBreaker(String name, int threshold, int timeoutMS) {
65                  open.setTimeout(timeoutMS);                  this(name, new StaticConfig(threshold, timeoutMS) );
66            }
67            
68            public CircuitBreaker(String name, BreakerConfig config) {
69                    closed.setThreshold(config);
70                    open.setTimeout(config);
71                                    
72                  this.name = name;                  this.name = name;
73                            
74                  reset();                  //set correct intial state
75                    internalReset();
76          }          }
77                    
78            public synchronized void shutdown() {
79                    if (executor != null) {
80                            executor.shutdown();
81                    }
82            }
83                    
84      public Object invoke(CircuitInvocation invocation) throws Throwable          
85        public Object invoke(CircuitInvocation invocation) throws Exception
86      {      {
87          Object result = null;          Object result = null;
88          try          try
# Line 75  public class CircuitBreaker{ Line 91  public class CircuitBreaker{
91              result = invocation.proceed();              result = invocation.proceed();
92              getState().postInvoke(this);              getState().postInvoke(this);
93          }          }
94          catch(Throwable t)          catch(Exception e)
95          {          {
96              getState().onError(this, t);              getState().onError(this, e);
97              throw t;              throw e;
98          }          }
99          return result;          return result;
100      }      }
101            
102      public void tripBreaker() {      public void tripBreaker() {
103          synchronized(this) {          commonTripBreaker(Notifier.Event.BreakerTripped);
                 open.trip();  
                 currentState = open;  
                   
                 notifier.sendNotification(name, Notifier.Event.BreakerTripped);  
         }      
104      }      }
105            
106            //a re-trip should basically do the same as a normal trip, but it is here just to differentiate the two different events
107        public void retripBreaker() {
108            commonTripBreaker(Notifier.Event.BreakerRetripped);
109        }
110        
111        private void commonTripBreaker(Notifier.Event event) {
112            synchronized(this) {
113                    if (currentState != open) { // TODO:Is this conditional necessary ??
114                            open.trip();
115                            currentState = open;
116                    
117                            notifier.sendNotification(this, event);
118                    }
119            }      
120        }
121    
122      public void attemptReset() {      public void attemptReset() {
123          synchronized(this) {          synchronized(this) {
124                  currentState = halfOpen;                  if (currentState != halfOpen) { // TODO:Is this conditional necessary ??
125                  notifier.sendNotification(name, Notifier.Event.BreakerAttemptReset);                          currentState = halfOpen;
126                            notifier.sendNotification(this, Notifier.Event.BreakerAttemptReset);
127                    }
128          }          }
129                    
130      }      }
131            
132      public void reset() {      public void reset() {
133          synchronized(this) {          synchronized(this) {
134                  currentState = closed;                  if (currentState != closed) { // TODO: Is this conditional necessary ??
135                  notifier.sendNotification(name, Notifier.Event.BreakerReset);                          internalReset();
136                            notifier.sendNotification(this, Notifier.Event.BreakerReset);
137                    }
138          }          }
139      }      }
140            
141        //This one actually sets the correct closed/reset state
142        private void internalReset() {
143                    closed.resetFailureCount();
144                    currentState = closed;          
145        }
146        
147            
148      private CircuitBreakerState getState() {      private CircuitBreakerState getState() {
149          synchronized(this) {          synchronized(this) {
# Line 114  public class CircuitBreaker{ Line 151  public class CircuitBreaker{
151          }          }
152      }      }
153            
154        public boolean isClosed() {
155            return (getState() == closed);
156        }
157        
158        public boolean isOpen() {
159            return (getState() == open);
160        }
161        
162      public String getName() {      public String getName() {
163          return name;          return name;
164      }      }
# Line 126  public class CircuitBreaker{ Line 171  public class CircuitBreaker{
171          return closed.getThreshold();          return closed.getThreshold();
172      }      }
173            
174        public int getTimeout() {
175            return (int)open.getTimeout();
176        }
177        
178      public int getFailureCount() {      public int getFailureCount() {
179          if (getState() == closed) {          if (getState() == closed) {
180                  return closed.getFailureCount();                  return closed.getFailureCount();
# Line 146  public class CircuitBreaker{ Line 195  public class CircuitBreaker{
195          this.notifier = notifier;          this.notifier = notifier;
196      }      }
197            
198      public String getNotifierName() {      public String getNotifierName() {
199          return notifier.toString();          return NotiferHelper.getName(notifier);
200        }
201        
202        public synchronized ExecutorService getExecutor() {
203            
204            if (executor == null) {
205                    executor = Executors.newFixedThreadPool(1);
206            }
207            
208            return executor;
209            
210      }      }
211    
212  }  }
Legend:
Removed from v.409  
changed lines
  Added in v.2449
  ViewVC Help
Powered by ViewVC 1.1.20