org.osgi.util.promise.Promise Java Examples

/**
 * OSGi promises are a great way to do asynchronous work, and should be handled
 * natively just like a CompletionStage
 */
protected AsyncResponseImpl checkFutureResponse(Message inMessage, Object result) {
    if (inMessage == null || result == null) {
        return null;
    }

    // Fast path - do they share our view of the Promise
    if (result instanceof Promise) {
        return handlePromise(inMessage, (Promise<?>) result);
    } 
    
    // Slower check, is it a Promise?
    Class<?> clazz = result.getClass();
    if(Arrays.stream(clazz.getInterfaces())
        .map(Class::getName)
        .anyMatch(n -> "org.osgi.util.promise.Promise".equals(n))) {
        
        return handlePromiseFromAnotherClassSpace(inMessage, result, clazz);
    }
    
    return super.checkFutureResponse(inMessage, result);
}
 

@GET
@Path("promise/{name}")
@Produces(MediaType.TEXT_PLAIN)
public Promise<String> echoPromise(@PathParam("name") String value) {
    
    Deferred<String> d = new Deferred<>();
    
    new Thread(() -> {
        try {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                preResume.run();
                d.fail(e);
                return;
            }
            preResume.run();
            d.resolve(value);
        } finally {
            postResume.run();
        }
    }).start();
    
    return d.getPromise();
}
 

@Test
public void testAsyncResourceClientWithPromises()
    throws ExecutionException, InterruptedException,
    InvocationTargetException {

    WebTarget webTarget =
        createDefaultTarget().
            path("whiteboard").
            path("async").
            path("promise").
            path("HelloAsync");

    AtomicBoolean pre = new AtomicBoolean();
    AtomicBoolean post = new AtomicBoolean();

    CountDownLatch countDownLatch = new CountDownLatch(1);

    registerAddon(
        new TestAsyncResource(
            () -> pre.set(true),
            () -> {
                post.set(true);

                countDownLatch.countDown();
            }));

    Promise<String> promise =
        webTarget.
            request().
            rx(PromiseRxInvoker.class).
            get(String.class);

    String result = promise.getValue();

    countDownLatch.await(1, TimeUnit.MINUTES);

    assertTrue(post.get());

    assertEquals("This should say HelloAsync", "HelloAsync", result);
}
 

@Override
public Promise<Collection<Resource>> findProviders(RequirementExpression expression) {
  Deferred<Collection<Resource>> d = new Deferred<Collection<Resource>>();
  try {
    new ExpressionResolver(this, expression, d).start();
  } catch (Exception e) {
    d.fail(e);
  }
  return d.getPromise();
}
 

/**
 *  {@inheritDoc}
 */
public Promise<Void> enableComponent(ComponentDescriptionDTO description) {
  Component c = getComponent(description);
  Deferred<Void> d = new Deferred<Void>();
  if (c != null) {
    c.enable(d);
  } else {
    d.fail(new IllegalArgumentException("Unknown component"));
  }
  return d.getPromise();
}
 

/**
 *  {@inheritDoc}
 */
public Promise<Void> disableComponent(ComponentDescriptionDTO description) {
  Component c = getComponent(description);
  Deferred<Void> d = new Deferred<Void>();
  if (c != null) {
    c.disable(d);
  } else {
    d.fail(new IllegalArgumentException("Unknown component"));
  }
  return d.getPromise();
}
 

@Override
public <R> Promise<R> method(
    String s, Entity<?> entity, GenericType<R> genericType) {

        Deferred<R> deferred = _promiseFactory.deferred();
    
    _webClient.doInvokeAsync(s, entity, null, null, genericType.getRawType(), genericType.getType(), 
            new DeferredHandler<R>(deferred));

    return deferred.getPromise();
}
 

@Override
public <R> Promise<R> method(String s, GenericType<R> genericType) {
    Deferred<R> deferred = _promiseFactory.deferred();
    
    _webClient.doInvokeAsync(s, null, null, null, genericType.getRawType(), genericType.getType(), 
            new DeferredHandler<R>(deferred));

    return deferred.getPromise();
}
 

@Override
public synchronized Promise<String> nextRFID() {
	return nextRFID.getPromise();
}
 

@Override
public <R> Promise<R> trace(GenericType<R> genericType) {
    return method("TRACE", genericType);
}
 

@Override
public synchronized Promise<String> nextLocation() {
    return nextLocation.getPromise();
}
 

@Override
public synchronized Promise<String> nextRFID() {
	return nextRFID.getPromise();
}
 

@Override
public synchronized Promise<String> nextLocation() {
    return nextLocation.getPromise();
}
 

@Override
public <R> Promise<R> trace(Class<R> aClass) {
    return method("TRACE", aClass);
}
 

@Override
public synchronized Promise<String> nextRFID() {
	return nextRFID.getPromise();
}
 

public Promise<T> onResolve(Runnable callback) {
	return deferred.getPromise().onResolve(callback);
}
 

public <R> Promise<R> then(Success<? super T, ? extends R> success,
		Failure failure) {
	return deferred.getPromise().then(success, failure);
}
 

public <R> Promise<R> then(Success<? super T, ? extends R> success) {
	return deferred.getPromise().then(success);
}
 

public Promise<T> filter(Predicate<? super T> predicate) {
	return deferred.getPromise().filter(predicate);
}
 

public <R> Promise<R> map(Function<? super T, ? extends R> mapper) {
	return deferred.getPromise().map(mapper);
}
 

public <R> Promise<R> flatMap(
		Function<? super T, Promise<? extends R>> mapper) {
	return deferred.getPromise().flatMap(mapper);
}
 

public Promise<T> recover(Function<Promise<?>, ? extends T> recovery) {
	return deferred.getPromise().recover(recovery);
}
 

public Promise<T> recoverWith(
		Function<Promise<?>, Promise<? extends T>> recovery) {
	return deferred.getPromise().recoverWith(recovery);
}
 

public Promise<T> fallbackTo(Promise<? extends T> fallback) {
	return deferred.getPromise().fallbackTo(fallback);
}
 

@Override
public Promise<Response> method(String s) {
    return method(s, Response.class);
}
 

private AsyncResponseImpl handlePromise(Message inMessage, final Promise<?> promise) {
    final AsyncResponseImpl asyncResponse = new AsyncResponseImpl(inMessage);
    promise.onSuccess(asyncResponse::resume)
           .onFailure(asyncResponse::resume);
    return asyncResponse;
}
 

@Override
public Promise<Response> delete() {
    return method(HttpMethod.DELETE);
}
 

@Override
public <R> Promise<R> delete(Class<R> aClass) {
    return method(HttpMethod.DELETE, aClass);
}
 

@Override
public <R> Promise<R> delete(GenericType<R> genericType) {
    return method(HttpMethod.DELETE, genericType);
}
 

@Override
public Promise<Response> get() {
    return method(HttpMethod.GET);
}