thoerup/circuitbreaker/CircuitBreaker.java

package dk.thoerup.curcuitbreaker;

import java.util.logging.Logger;

/* Simple CircuitBreaker implementation - snipped from http://www.jroller.com/kenwdelong/entry/circuit_breaker_in_java
 * 
 *  example of how it can be used
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                class TestInvocation implements CircuitInvocation {
                        String url;
                        public TestInvocation(String url) {
                                this.url = url;
                        }
                        public Object proceed() throws Exception{
                                
                                URL u = new URL(url);
                                URLConnection c = u.openConnection();
                                c.connect();
                                InputStream in = c.getInputStream();
                                in.close();
                                                        
                                
                                return "hello";
                        }
                        
                }
                try {
                        String s = (String) cb.invoke(new TestInvocation("http://rafiki/test"));
                        response.getWriter().print(s);
                } catch (Throwable e) {
                        logger.warning( e.getMessage() );
                        response.sendError(500);
                        return;
                }
                
        }
 */


public class CircuitBreaker{
        Logger logger = Logger.getLogger(CircuitBreaker.class.getName());

        
        private CircuitBreakerState currentState;
        
        private OpenState open = new OpenState();
        private HalfOpenState halfOpen = new HalfOpenState();
        private ClosedState closed = new ClosedState();
        
        private String name;
        
        public CircuitBreaker(String name, int threshold, long timeoutMS) {
                closed.setThreshold(threshold);
                open.setTimeout(timeoutMS);
                
                this.name = name;
                
                reset();
        }
        
        
    public Object invoke(CircuitInvocation invocation) throws Throwable
    {
        Object result = null;
        try
        {
            getState().preInvoke(this);
            result = invocation.proceed();
            getState().postInvoke(this);
        }
        catch(Throwable t)
        {
            getState().onError(this, t);
            throw t;
        }
        return result;
    }
    
    public void tripBreaker() {
        synchronized(this) {
                currentState = open;
                open.trip();
                
                logger.warning("Circuitbreaker tripBreaker - " + name);
        }
    
    }
    
    public void attemptReset() {
        synchronized(this) {
                currentState = halfOpen;
                
                logger.warning("Circuitbreaker attemptReset - " + name);
        }
    }
    
    public void reset() {
        synchronized(this) {
                currentState = closed;
                
                logger.warning("Circuitbreaker reset - " + name);
        }
    }
    
    private CircuitBreakerState getState() {
        synchronized(this) {
                return currentState;
        }
    }
}
1	torben	393	package dk.thoerup.curcuitbreaker;
2
3			import java.util.logging.Logger;
4
5	torben	394	/* Simple CircuitBreaker implementation - snipped from http://www.jroller.com/kenwdelong/entry/circuit_breaker_in_java
6			*
7			* example of how it can be used
8	torben	393	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
9			class TestInvocation implements CircuitInvocation {
10			String url;
11			public TestInvocation(String url) {
12			this.url = url;
13			}
14			public Object proceed() throws Exception{
15
16			URL u = new URL(url);
17			URLConnection c = u.openConnection();
18			c.connect();
19			InputStream in = c.getInputStream();
20			in.close();
21
22
23			return "hello";
24			}
25
26			}
27			try {
28			String s = (String) cb.invoke(new TestInvocation("http://rafiki/test"));
29			response.getWriter().print(s);
30			} catch (Throwable e) {
31			logger.warning( e.getMessage() );
32			response.sendError(500);
33			return;
34			}
35
36			}
37			*/
38
39
40			public class CircuitBreaker{
41			Logger logger = Logger.getLogger(CircuitBreaker.class.getName());
42
43
44			private CircuitBreakerState currentState;
45
46			private OpenState open = new OpenState();
47			private HalfOpenState halfOpen = new HalfOpenState();
48			private ClosedState closed = new ClosedState();
49
50			private String name;
51
52			public CircuitBreaker(String name, int threshold, long timeoutMS) {
53			closed.setThreshold(threshold);
54			open.setTimeout(timeoutMS);
55
56			this.name = name;
57
58			reset();
59			}
60
61
62			public Object invoke(CircuitInvocation invocation) throws Throwable
63			{
64			Object result = null;
65			try
66			{
67			getState().preInvoke(this);
68			result = invocation.proceed();
69			getState().postInvoke(this);
70			}
71			catch(Throwable t)
72			{
73			getState().onError(this, t);
74			throw t;
75			}
76			return result;
77			}
78
79			public void tripBreaker() {
80			synchronized(this) {
81			currentState = open;
82			open.trip();
83
84			logger.warning("Circuitbreaker tripBreaker - " + name);
85			}
86
87			}
88
89			public void attemptReset() {
90			synchronized(this) {
91			currentState = halfOpen;
92
93			logger.warning("Circuitbreaker attemptReset - " + name);
94			}
95			}
96
97			public void reset() {
98			synchronized(this) {
99			currentState = closed;
100
101			logger.warning("Circuitbreaker reset - " + name);
102			}
103			}
104
105			private CircuitBreakerState getState() {
106			synchronized(this) {
107			return currentState;
108			}
109			}
110			}