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.notification.NotiferHelper;
import dk.thoerup.circuitbreaker.notification.Notifier;
import dk.thoerup.circuitbreaker.notification.NullNotifier;
import dk.thoerup.circuitbreaker.statistics.NullStatistics;
import dk.thoerup.circuitbreaker.statistics.Statistics;

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

 private CircuitBreaker<String> cb = new CircuitBreaker<>("test", 5, 10000);
 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                class TestInvocation implements CircuitInvocation<String> {
                        String url;
                        public TestInvocation(String url) {
                                this.url = url;
                        }
                        public String 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 = 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<T>{
        
        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();
        private Statistics stats = new NullStatistics();
        
        
        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 T invoke(CircuitInvocation<T> invocation) throws Exception
    {
        stats.addStatistics(Event.Invocation);
        
        T result = null;
        try
        {
            getState().preInvoke(this);
            result = invocation.proceed();
            getState().postInvoke(this);
        }
        catch(Exception e)
        {               
                        if (e instanceof CircuitBreakerException) {
                                stats.addStatistics(Event.InvocationBlocked);
                        } else {
                                stats.addStatistics(Event.InvocationFailure);
                        }
                
            getState().onError(this, e);
            throw e;
        }
        return result;
    }
    
    public void tripBreaker() {
        commonTripBreaker(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(Event.BreakerRetripped);
    }
    
    private void commonTripBreaker(Event event) {
        synchronized(this) {
                if (currentState != open) { // TODO:Is this conditional necessary ??
                        open.trip();
                        currentState = open;
                
                        notifier.sendNotification(this, event);
                        stats.addStatistics(event);
                }
        }       
    }

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