/** * Start this job in several seconds * * @param seconds * time in seconds * @return the job completion */ public Promise<V> in(int seconds) { Promise<V> smartFuture = new Promise<>(); JobsPlugin.executor.schedule(getJobCallingCallable(smartFuture), seconds, TimeUnit.SECONDS); return smartFuture; }
private Promise<HttpResponse> execute(BoundRequestBuilder builder) { try { final Promise<HttpResponse> smartFuture = new Promise<>(); prepare(builder).execute(new AsyncCompletionHandler<HttpResponse>() { @Override public HttpResponse onCompleted(Response response) throws Exception { HttpResponse httpResponse = new HttpAsyncResponse(response); smartFuture.invoke(httpResponse); return httpResponse; } @Override public void onThrowable(Throwable t) { // An error happened - must "forward" the exception to // the one waiting for the result smartFuture.invokeWithException(t); } }); return smartFuture; } catch (Exception e) { throw new RuntimeException(e); } }
/** * Retrieve the URL where the user should be redirected to start the OpenID authentication process */ public static F.Promise<String> redirectURL(String openID, String callbackURL, Map<String, String> axRequired, Map<String, String> axOptional, String realm) { if (axRequired == null) axRequired = new HashMap<String, String>(); if (axOptional == null) axOptional = new HashMap<String, String>(); return new F.Promise<String>(play.api.libs.openid.OpenID.redirectURL(openID, callbackURL, JavaConversions.mapAsScalaMap(axRequired).toSeq(), JavaConversions.mapAsScalaMap(axOptional).toSeq(), Scala.Option(realm))); }
public static <A, B, C, D, E> Promise<F.E5<A, B, C, D, E>> waitEither(Promise<A> tA, Promise<B> tB, Promise<C> tC, Promise<D> tD, Promise<E> tE) { final Promise<F.E5<A, B, C, D, E>> result = new Promise<>(); Promise<F.Tuple<Integer, Promise<Object>>> t = waitEitherInternal(tA, tB, tC, tD, tE); t.onRedeem(new F.Action<Promise<F.Tuple<Integer, Promise<Object>>>>() { @Override public void invoke(Promise<F.Tuple<Integer, Promise<Object>>> completed) { F.Tuple<Integer, Promise<Object>> value = completed.getOrNull(); switch (value._1) { case 1: result.invoke(F.E5.<A, B, C, D, E>_1((A) value._2.getOrNull())); break; case 2: result.invoke(F.E5.<A, B, C, D, E>_2((B) value._2.getOrNull())); break; case 3: result.invoke(F.E5.<A, B, C, D, E>_3((C) value._2.getOrNull())); break; case 4: result.invoke(F.E5.<A, B, C, D, E>_4((D) value._2.getOrNull())); break; case 5: result.invoke(F.E5.<A, B, C, D, E>_5((E) value._2.getOrNull())); break; } } }); return result; }
public static <T> Promise<T> waitAny(Promise<T>... futures) { final Promise<T> result = new Promise<>(); F.Action<Promise<T>> action = new F.Action<Promise<T>>() { @Override public void invoke(Promise<T> completed) { synchronized (this) { if (result.isDone()) { return; } } T resultOrNull = completed.getOrNull(); if(resultOrNull != null) { result.invoke(resultOrNull); } else { result.invokeWithException(completed.exception); } } }; for (Promise<T> f : futures) { f.onRedeem(action); } return result; } }
public static <A, B, C, D> Promise<F.E4<A, B, C, D>> waitEither(Promise<A> tA, Promise<B> tB, Promise<C> tC, Promise<D> tD) { final Promise<F.E4<A, B, C, D>> result = new Promise<>(); Promise<F.Tuple<Integer, Promise<Object>>> t = waitEitherInternal(tA, tB, tC, tD); t.onRedeem(new F.Action<Promise<F.Tuple<Integer, Promise<Object>>>>() { @Override public void invoke(Promise<F.Tuple<Integer, Promise<Object>>> completed) { F.Tuple<Integer, Promise<Object>> value = completed.getOrNull(); switch (value._1) { case 1: result.invoke(F.E4.<A, B, C, D>_1((A) value._2.getOrNull())); break; case 2: result.invoke(F.E4.<A, B, C, D>_2((B) value._2.getOrNull())); break; case 3: result.invoke(F.E4.<A, B, C, D>_3((C) value._2.getOrNull())); break; case 4: result.invoke(F.E4.<A, B, C, D>_4((D) value._2.getOrNull())); break; } } }); return result; }
public static <A, B, C> Promise<F.E3<A, B, C>> waitEither(Promise<A> tA, Promise<B> tB, Promise<C> tC) { final Promise<F.E3<A, B, C>> result = new Promise<>(); Promise<F.Tuple<Integer, Promise<Object>>> t = waitEitherInternal(tA, tB, tC); t.onRedeem(new F.Action<Promise<F.Tuple<Integer, Promise<Object>>>>() { @Override public void invoke(Promise<F.Tuple<Integer, Promise<Object>>> completed) { F.Tuple<Integer, Promise<Object>> value = completed.getOrNull(); switch (value._1) { case 1: result.invoke(F.E3.<A, B, C>_1((A) value._2.getOrNull())); break; case 2: result.invoke(F.E3.<A, B, C>_2((B) value._2.getOrNull())); break; case 3: result.invoke(F.E3.<A, B, C>_3((C) value._2.getOrNull())); break; } } }); return result; }
/** * If is called in a 'HttpRequest' invocation context, waits until request is served and schedules job then. * * Otherwise is the same as now(); * * If you want to schedule a job to run after some other job completes, wait till a promise redeems of just override * first Job's call() to schedule the second one. * * @return the job completion */ public Promise<V> afterRequest() { InvocationContext current = Invoker.InvocationContext.current(); if (current == null || !Http.invocationType.equals(current.getInvocationType())) { return now(); } Promise<V> smartFuture = new Promise<>(); Callable<V> callable = getJobCallingCallable(smartFuture); JobsPlugin.addAfterRequestAction(callable); return smartFuture; }
public static <A, B> Promise<F.Either<A, B>> waitEither(Promise<A> tA, Promise<B> tB) { final Promise<F.Either<A, B>> result = new Promise<>(); Promise<F.Tuple<Integer, Promise<Object>>> t = waitEitherInternal(tA, tB); t.onRedeem(new F.Action<Promise<F.Tuple<Integer, Promise<Object>>>>() { @Override public void invoke(Promise<F.Tuple<Integer, Promise<Object>>> completed) { F.Tuple<Integer, Promise<Object>> value = completed.getOrNull(); switch (value._1) { case 1: result.invoke(F.Either.<A, B>_1((A) value._2.getOrNull())); break; case 2: result.invoke(F.Either.<A, B>_2((B) value._2.getOrNull())); break; } } }); return result; }
public Promise<Response> execute() { final scala.concurrent.Promise<Response> scalaPromise = scala.concurrent.Promise$.MODULE$.<Response>apply(); try { WS.client().executeRequest(request, new AsyncCompletionHandler<com.ning.http.client.Response>() { @Override public com.ning.http.client.Response onCompleted(com.ning.http.client.Response response) { final com.ning.http.client.Response ahcResponse = response; scalaPromise.success(new Response(ahcResponse)); return response; } @Override public void onThrowable(Throwable t) { scalaPromise.failure(t); } }); } catch (IOException exception) { scalaPromise.failure(exception); } return new Promise<Response>(scalaPromise.future()); } }
public static <A, B, C, D> Promise<F.T4<A, B, C, D>> wait4(Promise<A> tA, Promise<B> tB, Promise<C> tC, Promise<D> tD) { final Promise<F.T4<A, B, C, D>> result = new Promise<>(); Promise<List<Object>> t = waitAll(new Promise[]{tA, tB, tC, tD}); t.onRedeem(new F.Action<Promise<List<Object>>>() { @Override public void invoke(Promise<List<Object>> completed) { List<Object> values = completed.getOrNull(); if(values != null) { result.invoke(new F.T4((A) values.get(0), (B) values.get(1), (C) values.get(2), (D) values.get(3))); } else { result.invokeWithException(completed.exception); } } }); return result; }
public static <A, B> Promise<F.Tuple<A, B>> wait2(Promise<A> tA, Promise<B> tB) { final Promise<F.Tuple<A, B>> result = new Promise<>(); Promise<List<Object>> t = waitAll(new Promise[]{tA, tB}); t.onRedeem(new F.Action<Promise<List<Object>>>() { @Override public void invoke(Promise<List<Object>> completed) { List<Object> values = completed.getOrNull(); if(values != null) { result.invoke(new F.Tuple((A) values.get(0), (B) values.get(1))); } else { result.invokeWithException(completed.exception); } } }); return result; }
public static <A, B, C, D, E> Promise<F.T5<A, B, C, D, E>> wait5(Promise<A> tA, Promise<B> tB, Promise<C> tC, Promise<D> tD, Promise<E> tE) { final Promise<F.T5<A, B, C, D, E>> result = new Promise<>(); Promise<List<Object>> t = waitAll(new Promise[]{tA, tB, tC, tD, tE}); t.onRedeem(new F.Action<Promise<List<Object>>>() { @Override public void invoke(Promise<List<Object>> completed) { List<Object> values = completed.getOrNull(); if(values != null) { result.invoke(new F.T5((A) values.get(0), (B) values.get(1), (C) values.get(2), (D) values.get(3), (E) values.get(4))); } else { result.invokeWithException(completed.exception); } } }); return result; }
public static <A, B, C> Promise<F.T3<A, B, C>> wait3(Promise<A> tA, Promise<B> tB, Promise<C> tC) { final Promise<F.T3<A, B, C>> result = new Promise<>(); Promise<List<Object>> t = waitAll(new Promise[]{tA, tB, tC}); t.onRedeem(new F.Action<Promise<List<Object>>>() { @Override public void invoke(Promise<List<Object>> completed) { List<Object> values = completed.getOrNull(); if(values != null) { result.invoke(new F.T3((A) values.get(0), (B) values.get(1), (C) values.get(2))); } else { result.invokeWithException(completed.exception); } } }); return result; }
@Override public synchronized void close() { closeTask = new Promise<>(); closeTask.onRedeem(new Action<Promise<Void>>() { @Override public void invoke(Promise<Void> completed) { writeFutures.clear(); ctx.getChannel().disconnect(); closeTask = null; } }); futureClose(); } };
/** * Check the identity of the user from the current request, that should be the callback from the OpenID server */ public static F.Promise<UserInfo> verifiedId() { Request request = Http.Context.current().request(); scala.concurrent.Future<UserInfo> scalaPromise = play.api.libs.openid.OpenID.verifiedId(request.queryString()).map( new AbstractFunction1<play.api.libs.openid.UserInfo, UserInfo>() { @Override public UserInfo apply(play.api.libs.openid.UserInfo scalaUserInfo) { return new UserInfo(scalaUserInfo.id(), JavaConversions.mapAsJavaMap(scalaUserInfo.attributes())); } },Invoker.executionContext()); return new F.Promise<UserInfo>(scalaPromise); }
/** * Start this job now (well ASAP) * * @return the job completion */ public Promise<V> now() { Promise<V> smartFuture = new Promise<>(); JobsPlugin.executor.submit(getJobCallingCallable(smartFuture)); return smartFuture; }
private static Promise<F.Tuple<Integer, Promise<Object>>> waitEitherInternal(Promise<?>... futures) { final Promise<F.Tuple<Integer, Promise<Object>>> result = new Promise<>(); for (int i = 0; i < futures.length; i++) { final int index = i + 1; ((Promise<Object>) futures[i]).onRedeem(new F.Action<Promise<Object>>() { @Override public void invoke(Promise<Object> completed) { result.invoke(new F.Tuple(index, completed)); } }); } return result; }
/** * Creates a Promise that wraps a Scala Future. * * @param future The Scala Future to wrap */ @SuppressWarnings("deprecation") public static <A> Promise<A> wrap(Future<A> future) { return new Promise<A>(future); }