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 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;
                
                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) {
                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 ??
                        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	torben	393	package dk.thoerup.curcuitbreaker;
2
3			import java.util.logging.Logger;
4
5	torben	409	import dk.thoerup.curcuitbreaker.notification.Notifier;
6			import dk.thoerup.curcuitbreaker.notification.NullNotifier;
7
8	torben	394	/* 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	torben	395
12			private CircuitBreaker cb = new CircuitBreaker("test", 5, 10000);
13			protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
14	torben	393	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	torben	424	private final OpenState open = new OpenState();
52			private final HalfOpenState halfOpen = new HalfOpenState();
53			private final ClosedState closed = new ClosedState();
54	torben	393
55			private String name;
56
57	torben	409	private Notifier notifier = new NullNotifier();
58
59	torben	393	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	torben	426	if (currentState != open) { // TODO:Is this conditional necessary ??
89			open.trip();
90			currentState = open;
91	torben	393
92	torben	426	notifier.sendNotification(name, Notifier.Event.BreakerTripped);
93			}
94	torben	409	}
95	torben	393	}
96
97			public void attemptReset() {
98			synchronized(this) {
99	torben	426	if (currentState != halfOpen) { // TODO:Is this conditional necessary ??
100			currentState = halfOpen;
101			notifier.sendNotification(name, Notifier.Event.BreakerAttemptReset);
102			}
103	torben	393	}
104	torben	409
105	torben	393	}
106
107			public void reset() {
108			synchronized(this) {
109	torben	426	if (currentState != closed) { // TODO: Is this conditional necessary ??
110			currentState = closed;
111			notifier.sendNotification(name, Notifier.Event.BreakerReset);
112			}
113	torben	393	}
114			}
115
116	torben	397
117	torben	393	private CircuitBreakerState getState() {
118			synchronized(this) {
119			return currentState;
120			}
121			}
122	torben	397
123			public String getName() {
124			return name;
125			}
126
127			public String getStateName() {
128			return getState().getName();
129			}
130
131			public int getThreshold() {
132			return closed.getThreshold();
133			}
134
135	torben	413	public int getTimeout() {
136			return (int)open.getTimeout();
137			}
138
139	torben	397	public int getFailureCount() {
140			if (getState() == closed) {
141			return closed.getFailureCount();
142			} else {
143			return -1;
144			}
145			}
146
147			public long getElapsed() {
148			if (getState() == open) {
149			return open.getElapsed();
150			} else {
151			return -1;
152			}
153			}
154	torben	409
155			public void setNotifier(Notifier notifier) {
156			this.notifier = notifier;
157			}
158
159			public String getNotifierName() {
160	torben	412	return notifier.getClass().getName();
161	torben	409	}
162	torben	397
163	torben	393	}