001    /*
002     * Copyright (C) 2006 The Guava Authors
003     *
004     * Licensed under the Apache License, Version 2.0 (the "License");
005     * you may not use this file except in compliance with the License.
006     * You may obtain a copy of the License at
007     *
008     * http://www.apache.org/licenses/LICENSE-2.0
009     *
010     * Unless required by applicable law or agreed to in writing, software
011     * distributed under the License is distributed on an "AS IS" BASIS,
012     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013     * See the License for the specific language governing permissions and
014     * limitations under the License.
015     */
016    
017    package com.google.common.util.concurrent;
018    
019    import static com.google.common.base.Preconditions.checkArgument;
020    import static com.google.common.base.Preconditions.checkNotNull;
021    
022    import com.google.common.annotations.Beta;
023    import com.google.common.collect.ObjectArrays;
024    import com.google.common.collect.Sets;
025    
026    import java.lang.reflect.InvocationHandler;
027    import java.lang.reflect.InvocationTargetException;
028    import java.lang.reflect.Method;
029    import java.lang.reflect.Proxy;
030    import java.util.Set;
031    import java.util.concurrent.Callable;
032    import java.util.concurrent.ExecutionException;
033    import java.util.concurrent.ExecutorService;
034    import java.util.concurrent.Executors;
035    import java.util.concurrent.Future;
036    import java.util.concurrent.TimeUnit;
037    import java.util.concurrent.TimeoutException;
038    
039    /**
040     * A TimeLimiter that runs method calls in the background using an
041     * {@link ExecutorService}.  If the time limit expires for a given method call,
042     * the thread running the call will be interrupted.
043     *
044     * @author Kevin Bourrillion
045     * @since 1.0
046     */
047    @Beta
048    public final class SimpleTimeLimiter implements TimeLimiter {
049    
050      private final ExecutorService executor;
051    
052      /**
053       * Constructs a TimeLimiter instance using the given executor service to
054       * execute proxied method calls.
055       * <p>
056       * <b>Warning:</b> using a bounded executor
057       * may be counterproductive!  If the thread pool fills up, any time callers
058       * spend waiting for a thread may count toward their time limit, and in
059       * this case the call may even time out before the target method is ever
060       * invoked.
061       *
062       * @param executor the ExecutorService that will execute the method calls on
063       *     the target objects; for example, a {@link
064       *     Executors#newCachedThreadPool()}.
065       */
066      public SimpleTimeLimiter(ExecutorService executor) {
067        this.executor = checkNotNull(executor);
068      }
069    
070      /**
071       * Constructs a TimeLimiter instance using a {@link
072       * Executors#newCachedThreadPool()} to execute proxied method calls.
073       *
074       * <p><b>Warning:</b> using a bounded executor may be counterproductive! If
075       * the thread pool fills up, any time callers spend waiting for a thread may
076       * count toward their time limit, and in this case the call may even time out
077       * before the target method is ever invoked.
078       */
079      public SimpleTimeLimiter() {
080        this(Executors.newCachedThreadPool());
081      }
082    
083      @Override
084      public <T> T newProxy(final T target, Class<T> interfaceType,
085          final long timeoutDuration, final TimeUnit timeoutUnit) {
086        checkNotNull(target);
087        checkNotNull(interfaceType);
088        checkNotNull(timeoutUnit);
089        checkArgument(timeoutDuration > 0, "bad timeout: " + timeoutDuration);
090        checkArgument(interfaceType.isInterface(),
091            "interfaceType must be an interface type");
092    
093        final Set<Method> interruptibleMethods
094            = findInterruptibleMethods(interfaceType);
095    
096        InvocationHandler handler = new InvocationHandler() {
097          @Override
098          public Object invoke(Object obj, final Method method, final Object[] args)
099              throws Throwable {
100            Callable<Object> callable = new Callable<Object>() {
101              @Override
102              public Object call() throws Exception {
103                try {
104                  return method.invoke(target, args);
105                } catch (InvocationTargetException e) {
106                  throwCause(e, false);
107                  throw new AssertionError("can't get here");
108                }
109              }
110            };
111            return callWithTimeout(callable, timeoutDuration, timeoutUnit,
112                interruptibleMethods.contains(method));
113          }
114        };
115        return newProxy(interfaceType, handler);
116      }
117    
118      // TODO: should this actually throw only ExecutionException?
119      @Override
120      public <T> T callWithTimeout(Callable<T> callable, long timeoutDuration,
121          TimeUnit timeoutUnit, boolean amInterruptible) throws Exception {
122        checkNotNull(callable);
123        checkNotNull(timeoutUnit);
124        checkArgument(timeoutDuration > 0, "timeout must be positive: %s",
125            timeoutDuration);
126        Future<T> future = executor.submit(callable);
127        try {
128          if (amInterruptible) {
129            try {
130              return future.get(timeoutDuration, timeoutUnit);
131            } catch (InterruptedException e) {
132              future.cancel(true);
133              throw e;
134            }
135          } else {
136            return Uninterruptibles.getUninterruptibly(future, 
137                timeoutDuration, timeoutUnit);
138          }
139        } catch (ExecutionException e) {
140          throw throwCause(e, true);
141        } catch (TimeoutException e) {
142          future.cancel(true);
143          throw new UncheckedTimeoutException(e);
144        }
145      }
146    
147      private static Exception throwCause(Exception e, boolean combineStackTraces)
148          throws Exception {
149        Throwable cause = e.getCause();
150        if (cause == null) {
151          throw e;
152        }
153        if (combineStackTraces) {
154          StackTraceElement[] combined = ObjectArrays.concat(cause.getStackTrace(),
155              e.getStackTrace(), StackTraceElement.class);
156          cause.setStackTrace(combined);
157        }
158        if (cause instanceof Exception) {
159          throw (Exception) cause;
160        }
161        if (cause instanceof Error) {
162          throw (Error) cause;
163        }
164        // The cause is a weird kind of Throwable, so throw the outer exception.
165        throw e;
166      }
167    
168      private static Set<Method> findInterruptibleMethods(Class<?> interfaceType) {
169        Set<Method> set = Sets.newHashSet();
170        for (Method m : interfaceType.getMethods()) {
171          if (declaresInterruptedEx(m)) {
172            set.add(m);
173          }
174        }
175        return set;
176      }
177    
178      private static boolean declaresInterruptedEx(Method method) {
179        for (Class<?> exType : method.getExceptionTypes()) {
180          // debate: == or isAssignableFrom?
181          if (exType == InterruptedException.class) {
182            return true;
183          }
184        }
185        return false;
186      }
187    
188      // TODO: replace with version in common.reflect if and when it's open-sourced
189      private static <T> T newProxy(
190          Class<T> interfaceType, InvocationHandler handler) {
191        Object object = Proxy.newProxyInstance(interfaceType.getClassLoader(),
192            new Class<?>[] { interfaceType }, handler);
193        return interfaceType.cast(object);
194      }
195    }