boolean idempotentOrAtMostOnce(Method method) throws NoSuchMethodException { final Method m = fpp.getInterface() .getMethod(method.getName(), method.getParameterTypes()); return m.isAnnotationPresent(Idempotent.class) || m.isAnnotationPresent(AtMostOnce.class); }
void close() throws IOException { fpp.close(); } }
synchronized void failover(long expectedFailoverCount, Method method, int callId) { // Make sure that concurrent failed invocations only cause a single // actual failover. if (failoverCount == expectedFailoverCount) { fpp.performFailover(proxyInfo.proxy); failoverCount++; } else { LOG.warn("A failover has occurred since the start of call #" + callId + " " + proxyInfo.getString(method.getName())); } proxyInfo = fpp.getProxy(); }
boolean isIdempotentOrAtMostOnce = proxyProvider.getInterface() .getMethod(method.getName(), method.getParameterTypes()) .isAnnotationPresent(Idempotent.class); if (!isIdempotentOrAtMostOnce) { isIdempotentOrAtMostOnce = proxyProvider.getInterface() .getMethod(method.getName(), method.getParameterTypes()) .isAnnotationPresent(AtMostOnce.class); proxyProvider.performFailover(currentProxy.proxy); proxyProviderFailoverCount++; } else { + " invocation attempt."); currentProxy = proxyProvider.getProxy();
ProxyDescriptor(FailoverProxyProvider<T> fpp) { this.fpp = fpp; this.proxyInfo = fpp.getProxy(); }
@Override public void performFailover(T currentProxy) { proxyProvider.performFailover(currentProxy); }
boolean isIdempotentOrAtMostOnce = proxyProvider.getInterface() .getMethod(method.getName(), method.getParameterTypes()) .isAnnotationPresent(Idempotent.class); if (!isIdempotentOrAtMostOnce) { isIdempotentOrAtMostOnce = proxyProvider.getInterface() .getMethod(method.getName(), method.getParameterTypes()) .isAnnotationPresent(AtMostOnce.class); proxyProvider.performFailover(currentProxy.proxy); proxyProviderFailoverCount++; } else { + " invocation attempt."); currentProxy = proxyProvider.getProxy();
@Override public synchronized ProxyInfo<T> getProxy() { return proxyProvider.getProxy(); }
@Override public void performFailover(T currentProxy) { proxyProvider.performFailover(currentProxy); }
boolean isIdempotentOrAtMostOnce = proxyProvider.getInterface() .getMethod(method.getName(), method.getParameterTypes()) .isAnnotationPresent(Idempotent.class); if (!isIdempotentOrAtMostOnce) { isIdempotentOrAtMostOnce = proxyProvider.getInterface() .getMethod(method.getName(), method.getParameterTypes()) .isAnnotationPresent(AtMostOnce.class); proxyProvider.performFailover(currentProxy.proxy); proxyProviderFailoverCount++; } else { + " invocation attempt."); currentProxy = proxyProvider.getProxy();
/** * Create a proxy for an interface of implementations of that interface using * the given {@link FailoverProxyProvider} and the same retry policy for each * method in the interface. * * @param iface the interface that the retry will implement * @param proxyProvider provides implementation instances whose methods should be retried * @param retryPolicy the policy for retrying or failing over method call failures * @return the retry proxy */ public static <T> Object create(Class<T> iface, FailoverProxyProvider<T> proxyProvider, RetryPolicy retryPolicy) { return Proxy.newProxyInstance( proxyProvider.getInterface().getClassLoader(), new Class<?>[] { iface }, new RetryInvocationHandler<T>(proxyProvider, retryPolicy) ); }
synchronized void failover(long expectedFailoverCount, Method method, int callId) { // Make sure that concurrent failed invocations only cause a single // actual failover. if (failoverCount == expectedFailoverCount) { fpp.performFailover(proxyInfo.proxy); failoverCount++; } else { LOG.warn("A failover has occurred since the start of call #" + callId + " " + proxyInfo.getString(method.getName())); } proxyInfo = fpp.getProxy(); }
protected RetryInvocationHandler(FailoverProxyProvider<T> proxyProvider, RetryPolicy defaultPolicy, Map<String, RetryPolicy> methodNameToPolicyMap) { this.proxyProvider = proxyProvider; this.defaultPolicy = defaultPolicy; this.methodNameToPolicyMap = methodNameToPolicyMap; this.currentProxy = proxyProvider.getProxy(); }
/** * Close the proxy, */ @Override public synchronized void close() throws IOException { proxyProvider.close(); }
@Override public void performFailover(T currentProxy) { proxyProvider.performFailover(currentProxy); }
/** * Create a proxy for an interface of implementations of that interface using * the given {@link FailoverProxyProvider} and the a set of retry policies * specified by method name. If no retry policy is defined for a method then a * default of {@link RetryPolicies#TRY_ONCE_THEN_FAIL} is used. * * @param iface the interface that the retry will implement * @param proxyProvider provides implementation instances whose methods should be retried * @param methodNameToPolicyMapa map of method names to retry policies * @return the retry proxy */ public static <T> Object create(Class<T> iface, FailoverProxyProvider<T> proxyProvider, Map<String,RetryPolicy> methodNameToPolicyMap, RetryPolicy defaultPolicy) { return Proxy.newProxyInstance( proxyProvider.getInterface().getClassLoader(), new Class<?>[] { iface }, new RetryInvocationHandler<T>(proxyProvider, defaultPolicy, methodNameToPolicyMap) ); } }
protected RetryInvocationHandler(FailoverProxyProvider<T> proxyProvider, RetryPolicy defaultPolicy, Map<String, RetryPolicy> methodNameToPolicyMap) { this.proxyProvider = proxyProvider; this.defaultPolicy = defaultPolicy; this.methodNameToPolicyMap = methodNameToPolicyMap; this.currentProxy = proxyProvider.getProxy(); }
/** * Close the proxy, */ @Override public synchronized void close() throws IOException { proxyProvider.close(); }
@Override public Class<T> getInterface() { return proxyProvider.getInterface(); }
protected RetryInvocationHandler(FailoverProxyProvider<T> proxyProvider, RetryPolicy defaultPolicy, Map<String, RetryPolicy> methodNameToPolicyMap) { this.proxyProvider = proxyProvider; this.defaultPolicy = defaultPolicy; this.methodNameToPolicyMap = methodNameToPolicyMap; this.currentProxy = proxyProvider.getProxy(); }