thoerup/circuitbreaker/CircuitBreaker.java

package dk.thoerup.circuitbreaker;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import dk.thoerup.circuitbreaker.config.BreakerConfig;
import dk.thoerup.circuitbreaker.config.StaticConfig;
import dk.thoerup.circuitbreaker.notification.NotiferHelper;
import dk.thoerup.circuitbreaker.notification.Notifier;
import dk.thoerup.circuitbreaker.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 (Exception e) {
                        logger.warning( e.getMessage() );
                        response.sendError(500);
                        return;
                }
                
        }
 */


public class CircuitBreaker{
        
        private volatile CircuitBreakerState currentState;
        
        private final OpenState open = new OpenState();
        private final HalfOpenState halfOpen = new HalfOpenState();
        private final ClosedState closed = new ClosedState();
        
        private String name;
        
        private ExecutorService executor = null;        
        private Notifier notifier = new NullNotifier();
        
        /*public CircuitBreaker(String name, int threshold, int timeoutMS) {
                this(name, new StaticConfig(threshold, timeoutMS) );
        }*/
        
        public CircuitBreaker(String name, BreakerConfig config) {
                closed.setThreshold(config);
                open.setTimeout(config);
                
                this.name = name;
        
                //set correct intial state
                internalReset();
        }
        
        public synchronized void shutdown() {
                if (executor != null) {
                        executor.shutdown();
                }
        }
        
        
    public Object invoke(CircuitInvocation invocation) throws Exception
    {
        Object result = null;
        try
        {
            getState().preInvoke(this);
            result = invocation.proceed();
            getState().postInvoke(this);
        }
        catch(Exception e)
        {
            getState().onError(this, e);
            throw e;
        }
        return result;
    }
    
    public void tripBreaker() {
        commonTripBreaker(Notifier.Event.BreakerTripped);
    }
    
        //a re-trip should basically do the same as a normal trip, but it is here just to differentiate the two different events
    public void retripBreaker() {
        commonTripBreaker(Notifier.Event.BreakerRetripped);
    }
    
    private void commonTripBreaker(Notifier.Event event) {
        synchronized(this) {
                if (currentState != open) { // TODO:Is this conditional necessary ??
                        open.trip();
                        currentState = open;
                
                        notifier.sendNotification(this, event);
                }
        }       
    }

    public void attemptReset() {
        synchronized(this) {
                if (currentState != halfOpen) { // TODO:Is this conditional necessary ??
                        currentState = halfOpen;
                        notifier.sendNotification(this, Notifier.Event.BreakerAttemptReset);
                }
        }
        
    }
    
    public void reset() {
        synchronized(this) {
                if (currentState != closed) { // TODO: Is this conditional necessary ??
                        internalReset();
                        notifier.sendNotification(this, Notifier.Event.BreakerReset);
                }
        }
    }
    
    //This one actually sets the correct closed/reset state 
    private void internalReset() {
                closed.resetFailureCount();
                currentState = closed;          
    }
    
    
    private CircuitBreakerState getState() {
        synchronized(this) {
                return currentState;
        }
    }
    
    public boolean isClosed() {
        return (getState() == closed); 
    }
    
    public boolean isOpen() {
        return (getState() == open); 
    }
    
    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 NotiferHelper.getName(notifier);
    }
    
    public synchronized ExecutorService getExecutor() {
        
        if (executor == null) {
                executor = Executors.newFixedThreadPool(1);
        }
        
        return executor;
        
    }
 
}
1	package dk.thoerup.circuitbreaker;
2
3
4	import java.util.concurrent.ExecutorService;
5	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
14	*
15	* example of how it can be used
16
17	private CircuitBreaker cb = new CircuitBreaker("test", 5, 10000);
18	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
19	class TestInvocation implements CircuitInvocation {
20	String url;
21	public TestInvocation(String url) {
22	this.url = url;
23	}
24	public Object proceed() throws Exception{
25
26	URL u = new URL(url);
27	URLConnection c = u.openConnection();
28	c.connect();
29	InputStream in = c.getInputStream();
30	in.close();
31
32
33	return "hello";
34	}
35
36	}
37	try {
38	String s = (String) cb.invoke(new TestInvocation("http://rafiki/test"));
39	response.getWriter().print(s);
40	} catch (Exception e) {
41	logger.warning( e.getMessage() );
42	response.sendError(500);
43	return;
44	}
45
46	}
47	*/
48
49
50	public class CircuitBreaker{
51
52	private volatile CircuitBreakerState currentState;
53
54	private final OpenState open = new OpenState();
55	private final HalfOpenState halfOpen = new HalfOpenState();
56	private final ClosedState closed = new ClosedState();
57
58	private String name;
59
60	private ExecutorService executor = null;
61	private Notifier notifier = new NullNotifier();
62
63	/*public CircuitBreaker(String name, int threshold, int timeoutMS) {
64	this(name, new StaticConfig(threshold, timeoutMS) );
65	}*/
66
67	public CircuitBreaker(String name, BreakerConfig config) {
68	closed.setThreshold(config);
69	open.setTimeout(config);
70
71	this.name = name;
72
73	//set correct intial state
74	internalReset();
75	}
76
77	public synchronized void shutdown() {
78	if (executor != null) {
79	executor.shutdown();
80	}
81	}
82
83
84	public Object invoke(CircuitInvocation invocation) throws Exception
85	{
86	Object result = null;
87	try
88	{
89	getState().preInvoke(this);
90	result = invocation.proceed();
91	getState().postInvoke(this);
92	}
93	catch(Exception e)
94	{
95	getState().onError(this, e);
96	throw e;
97	}
98	return result;
99	}
100
101	public void tripBreaker() {
102	commonTripBreaker(Notifier.Event.BreakerTripped);
103	}
104
105	//a re-trip should basically do the same as a normal trip, but it is here just to differentiate the two different events
106	public void retripBreaker() {
107	commonTripBreaker(Notifier.Event.BreakerRetripped);
108	}
109
110	private void commonTripBreaker(Notifier.Event event) {
111	synchronized(this) {
112	if (currentState != open) { // TODO:Is this conditional necessary ??
113	open.trip();
114	currentState = open;
115
116	notifier.sendNotification(this, event);
117	}
118	}
119	}
120
121	public void attemptReset() {
122	synchronized(this) {
123	if (currentState != halfOpen) { // TODO:Is this conditional necessary ??
124	currentState = halfOpen;
125	notifier.sendNotification(this, Notifier.Event.BreakerAttemptReset);
126	}
127	}
128
129	}
130
131	public void reset() {
132	synchronized(this) {
133	if (currentState != closed) { // TODO: Is this conditional necessary ??
134	internalReset();
135	notifier.sendNotification(this, Notifier.Event.BreakerReset);
136	}
137	}
138	}
139
140	//This one actually sets the correct closed/reset state
141	private void internalReset() {
142	closed.resetFailureCount();
143	currentState = closed;
144	}
145
146
147	private CircuitBreakerState getState() {
148	synchronized(this) {
149	return currentState;
150	}
151	}
152
153	public boolean isClosed() {
154	return (getState() == closed);
155	}
156
157	public boolean isOpen() {
158	return (getState() == open);
159	}
160
161	public String getName() {
162	return name;
163	}
164
165	public String getStateName() {
166	return getState().getName();
167	}
168
169	public int getThreshold() {
170	return closed.getThreshold();
171	}
172
173	public int getTimeout() {
174	return (int)open.getTimeout();
175	}
176
177	public int getFailureCount() {
178	if (getState() == closed) {
179	return closed.getFailureCount();
180	} else {
181	return -1;
182	}
183	}
184
185	public long getElapsed() {
186	if (getState() == open) {
187	return open.getElapsed();
188	} else {
189	return -1;
190	}
191	}
192
193	public void setNotifier(Notifier notifier) {
194	this.notifier = notifier;
195	}
196
197	public String getNotifierName() {
198	return NotiferHelper.getName(notifier);
199	}
200
201	public synchronized ExecutorService getExecutor() {
202
203	if (executor == null) {
204	executor = Executors.newFixedThreadPool(1);
205	}
206
207	return executor;
208
209	}
210
211	}