thoerup/circuitbreaker/CircuitBreaker.java

package dk.thoerup.circuitbreaker;


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