thoerup/circuitbreaker/CircuitBreaker.java

package dk.thoerup.curcuitbreaker;

import java.util.logging.Logger;

import dk.thoerup.curcuitbreaker.notification.Notifier;
import dk.thoerup.curcuitbreaker.notification.NullNotifier;

/* Simple CircuitBreaker implementation - snipped from http://www.jroller.com/kenwdelong/entry/circuit_breaker_in_java
 * 
 *  example of how it can be used

 private CircuitBreaker cb = new CircuitBreaker("test", 5, 10000);
 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;
        
        private Notifier notifier = new NullNotifier();
        
        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) {
                open.trip();
                currentState = open;
                
                notifier.sendNotification(name, Notifier.Event.BreakerTripped);
        }    
    }
    
    public void attemptReset() {
        synchronized(this) {
                currentState = halfOpen;
                notifier.sendNotification(name, Notifier.Event.BreakerAttemptReset);
        }
        
    }
    
    public void reset() {
        synchronized(this) {
                currentState = closed;
                notifier.sendNotification(name, Notifier.Event.BreakerReset);
        }
    }
    
    
    private CircuitBreakerState getState() {
        synchronized(this) {
                return currentState;
        }
    }
    
    public String getName() {
        return name;
    }
    
    public String getStateName() {
        return getState().getName();
    }
    
    public int getThreshold() {
        return closed.getThreshold();
    }
    
    public int getTimeout() {
        return (int)open.getTimeout();
    }
    
    public int getFailureCount() {
        if (getState() == closed) {
                return closed.getFailureCount();
        } else {
                return -1;
        }
    }
    
    public long getElapsed() {
        if (getState() == open) {
                return open.getElapsed();
        } else {
                return -1;
        }
    }
    
    public void setNotifier(Notifier notifier) {
        this.notifier = notifier;
    }
    
    public String getNotifierName() {
        return notifier.getClass().getName();
    }
 
}
1	package dk.thoerup.curcuitbreaker;
2
3	import java.util.logging.Logger;
4
5	import dk.thoerup.curcuitbreaker.notification.Notifier;
6	import dk.thoerup.curcuitbreaker.notification.NullNotifier;
7
8	/* Simple CircuitBreaker implementation - snipped from http://www.jroller.com/kenwdelong/entry/circuit_breaker_in_java
9	*
10	* example of how it can be used
11
12	private CircuitBreaker cb = new CircuitBreaker("test", 5, 10000);
13	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
14	class TestInvocation implements CircuitInvocation {
15	String url;
16	public TestInvocation(String url) {
17	this.url = url;
18	}
19	public Object proceed() throws Exception{
20
21	URL u = new URL(url);
22	URLConnection c = u.openConnection();
23	c.connect();
24	InputStream in = c.getInputStream();
25	in.close();
26
27
28	return "hello";
29	}
30
31	}
32	try {
33	String s = (String) cb.invoke(new TestInvocation("http://rafiki/test"));
34	response.getWriter().print(s);
35	} catch (Throwable e) {
36	logger.warning( e.getMessage() );
37	response.sendError(500);
38	return;
39	}
40
41	}
42	*/
43
44
45	public class CircuitBreaker{
46	Logger logger = Logger.getLogger(CircuitBreaker.class.getName());
47
48
49	private CircuitBreakerState currentState;
50
51	private OpenState open = new OpenState();
52	private HalfOpenState halfOpen = new HalfOpenState();
53	private ClosedState closed = new ClosedState();
54
55	private String name;
56
57	private Notifier notifier = new NullNotifier();
58
59	public CircuitBreaker(String name, int threshold, long timeoutMS) {
60	closed.setThreshold(threshold);
61	open.setTimeout(timeoutMS);
62
63	this.name = name;
64
65	reset();
66	}
67
68
69	public Object invoke(CircuitInvocation invocation) throws Throwable
70	{
71	Object result = null;
72	try
73	{
74	getState().preInvoke(this);
75	result = invocation.proceed();
76	getState().postInvoke(this);
77	}
78	catch(Throwable t)
79	{
80	getState().onError(this, t);
81	throw t;
82	}
83	return result;
84	}
85
86	public void tripBreaker() {
87	synchronized(this) {
88	open.trip();
89	currentState = open;
90
91	notifier.sendNotification(name, Notifier.Event.BreakerTripped);
92	}
93	}
94
95	public void attemptReset() {
96	synchronized(this) {
97	currentState = halfOpen;
98	notifier.sendNotification(name, Notifier.Event.BreakerAttemptReset);
99	}
100
101	}
102
103	public void reset() {
104	synchronized(this) {
105	currentState = closed;
106	notifier.sendNotification(name, Notifier.Event.BreakerReset);
107	}
108	}
109
110
111	private CircuitBreakerState getState() {
112	synchronized(this) {
113	return currentState;
114	}
115	}
116
117	public String getName() {
118	return name;
119	}
120
121	public String getStateName() {
122	return getState().getName();
123	}
124
125	public int getThreshold() {
126	return closed.getThreshold();
127	}
128
129	public int getTimeout() {
130	return (int)open.getTimeout();
131	}
132
133	public int getFailureCount() {
134	if (getState() == closed) {
135	return closed.getFailureCount();
136	} else {
137	return -1;
138	}
139	}
140
141	public long getElapsed() {
142	if (getState() == open) {
143	return open.getElapsed();
144	} else {
145	return -1;
146	}
147	}
148
149	public void setNotifier(Notifier notifier) {
150	this.notifier = notifier;
151	}
152
153	public String getNotifierName() {
154	return notifier.getClass().getName();
155	}
156
157	}