Examples with CompletionException java.util.concurrent.CompletionException used on opensource projects

Example 36 with CompletionException

use of java.util.concurrent.CompletionException in project autobahn-java by crossbario.

the class Client method connect.

public CompletableFuture<ExitInfo> connect(TransportOptions options) {
    CompletableFuture<ExitInfo> exitFuture = new CompletableFuture<>();
    mSession.addOnConnectListener((session) -> mSession.join(mRealm, mAuthenticators).thenAccept(details -> LOGGER.i(String.format("JOINED session=%s realm=%s", details.sessionID, details.realm))));
    mSession.addOnDisconnectListener((session, wasClean) -> exitFuture.complete(new ExitInfo(wasClean)));
    CompletableFuture.runAsync(() -> {
        try {
            mTransports.get(0).connect(mSession, options);
        } catch (Exception e) {
            throw new CompletionException(e);
        }
    }, getExecutor());
    return exitFuture;
}

Example 37 with CompletionException

use of java.util.concurrent.CompletionException in project autobahn-java by crossbario.

the class Session method onPreSessionMessage.

private void onPreSessionMessage(IMessage message) throws Exception {
    if (message instanceof Welcome) {
        Welcome msg = (Welcome) message;
        mState = STATE_JOINED;
        mSessionID = msg.session;
        SessionDetails details = new SessionDetails(msg.realm, msg.session);
        mJoinFuture.complete(details);
        List<CompletableFuture<?>> futures = new ArrayList<>();
        for (OnJoinListener listener : mOnJoinListeners) {
            futures.add(runAsync(() -> listener.onJoin(this, details), mExecutor));
        }
        CompletableFuture d = combineFutures(futures);
        d.thenRunAsync(() -> {
            mState = STATE_READY;
            for (OnReadyListener listener : mOnReadyListeners) {
                listener.onReady(this);
            }
        }, mExecutor);
    } else if (message instanceof Abort) {
        Abort abortMessage = (Abort) message;
        CloseDetails details = new CloseDetails(abortMessage.reason, abortMessage.message);
        List<CompletableFuture<?>> futures = new ArrayList<>();
        for (OnLeaveListener listener : mOnLeaveListeners) {
            futures.add(runAsync(() -> listener.onLeave(this, details), mExecutor));
        }
        CompletableFuture d = combineFutures(futures);
        d.thenRunAsync(() -> {
            LOGGER.d("Notified Session.onLeave listeners, now closing transport");
            mState = STATE_DISCONNECTED;
            if (mTransport != null && mTransport.isOpen()) {
                try {
                    mTransport.close();
                } catch (Exception e) {
                    throw new CompletionException(e);
                }
            }
        }, mExecutor);
    } else if (message instanceof Challenge) {
        Challenge msg = (Challenge) message;
        io.crossbar.autobahn.wamp.types.Challenge challenge = new io.crossbar.autobahn.wamp.types.Challenge(msg.method, msg.extra);
        if (mAuthenticators != null) {
            if (msg.method.equals(TicketAuth.authmethod)) {
                for (IAuthenticator authenticator : mAuthenticators) {
                    if (authenticator.getAuthMethod().equals(TicketAuth.authmethod)) {
                        TicketAuth auth = (TicketAuth) authenticator;
                        auth.onChallenge(this, challenge).whenCompleteAsync((response, throwable) -> send(new Authenticate(response.signature, response.extra)), mExecutor);
                        break;
                    }
                }
            } else if (msg.method.equals(ChallengeResponseAuth.authmethod)) {
                for (IAuthenticator authenticator : mAuthenticators) {
                    if (authenticator.getAuthMethod().equals(ChallengeResponseAuth.authmethod)) {
                        ChallengeResponseAuth auth = (ChallengeResponseAuth) authenticator;
                        auth.onChallenge(this, challenge).whenCompleteAsync((response, throwable) -> send(new Authenticate(response.signature, response.extra)), mExecutor);
                        break;
                    }
                }
            } else if (msg.method.equals(CryptosignAuth.authmethod)) {
                for (IAuthenticator authenticator : mAuthenticators) {
                    if (authenticator.getAuthMethod().equals(CryptosignAuth.authmethod)) {
                        CryptosignAuth auth = (CryptosignAuth) authenticator;
                        auth.onChallenge(this, challenge).whenCompleteAsync((response, throwable) -> send(new Authenticate(response.signature, response.extra)), mExecutor);
                        break;
                    }
                }
            }
        }
    }
}

Example 38 with CompletionException

use of java.util.concurrent.CompletionException in project autobahn-java by crossbario.

the class Session method onMessage.

private void onMessage(IMessage message) throws Exception {
    if (message instanceof Result) {
        Result msg = (Result) message;
        CallRequest request = getOrDefault(mCallRequests, msg.request, null);
        if (request == null) {
            throw new ProtocolError(String.format("RESULT received for non-pending request ID %s", msg.request));
        }
        mCallRequests.remove(msg.request);
        if (request.resultTypeRef != null) {
            // FIXME: check args length > 1 and == 0, and kwargs != null
            // we cannot currently POJO automap these cases!
            request.onReply.complete(mSerializer.convertValue(msg.args.get(0), request.resultTypeRef));
        } else if (request.resultTypeClass != null) {
            request.onReply.complete(mSerializer.convertValue(msg.args.get(0), request.resultTypeClass));
        } else {
            request.onReply.complete(new CallResult(msg.args, msg.kwargs));
        }
    } else if (message instanceof Subscribed) {
        Subscribed msg = (Subscribed) message;
        SubscribeRequest request = getOrDefault(mSubscribeRequests, msg.request, null);
        if (request == null) {
            throw new ProtocolError(String.format("SUBSCRIBED received for non-pending request ID %s", msg.request));
        }
        mSubscribeRequests.remove(msg.request);
        if (!mSubscriptions.containsKey(msg.subscription)) {
            mSubscriptions.put(msg.subscription, new ArrayList<>());
        }
        Subscription subscription = new Subscription(msg.subscription, request.topic, request.resultTypeRef, request.resultTypeClass, request.handler, this);
        mSubscriptions.get(msg.subscription).add(subscription);
        request.onReply.complete(subscription);
    } else if (message instanceof Event) {
        Event msg = (Event) message;
        List<Subscription> subscriptions = getOrDefault(mSubscriptions, msg.subscription, null);
        if (subscriptions == null) {
            throw new ProtocolError(String.format("EVENT received for non-subscribed subscription ID %s", msg.subscription));
        }
        List<CompletableFuture<?>> futures = new ArrayList<>();
        for (Subscription subscription : subscriptions) {
            EventDetails details = new EventDetails(subscription, msg.publication, msg.topic != null ? msg.topic : subscription.topic, msg.retained, -1, null, null, this);
            CompletableFuture future = null;
            // Check if we expect a POJO.
            Object arg;
            if (subscription.resultTypeRef != null) {
                arg = mSerializer.convertValue(msg.args.get(0), subscription.resultTypeRef);
            } else if (subscription.resultTypeClass != null) {
                arg = mSerializer.convertValue(msg.args.get(0), subscription.resultTypeClass);
            } else {
                arg = msg.args;
            }
            if (subscription.handler instanceof Consumer) {
                Consumer handler = (Consumer) subscription.handler;
                future = runAsync(() -> handler.accept(arg), mExecutor);
            } else if (subscription.handler instanceof Function) {
                Function handler = (Function) subscription.handler;
                future = runAsync(() -> handler.apply(arg), mExecutor);
            } else if (subscription.handler instanceof BiConsumer) {
                BiConsumer handler = (BiConsumer) subscription.handler;
                future = runAsync(() -> handler.accept(arg, details), mExecutor);
            } else if (subscription.handler instanceof BiFunction) {
                BiFunction handler = (BiFunction) subscription.handler;
                future = runAsync(() -> handler.apply(arg, details), mExecutor);
            } else if (subscription.handler instanceof TriConsumer) {
                TriConsumer handler = (TriConsumer) subscription.handler;
                future = runAsync(() -> handler.accept(arg, msg.kwargs, details), mExecutor);
            } else if (subscription.handler instanceof TriFunction) {
                TriFunction handler = (TriFunction) subscription.handler;
                future = runAsync(() -> handler.apply(arg, msg.kwargs, details), mExecutor);
            } else {
            // FIXME: never going to reach here, though would be better to throw.
            }
            futures.add(future);
        }
        // Not really doing anything with the combined futures.
        combineFutures(futures);
    } else if (message instanceof Published) {
        Published msg = (Published) message;
        PublishRequest request = getOrDefault(mPublishRequests, msg.request, null);
        if (request == null) {
            throw new ProtocolError(String.format("PUBLISHED received for non-pending request ID %s", msg.request));
        }
        mPublishRequests.remove(msg.request);
        Publication publication = new Publication(msg.publication);
        request.onReply.complete(publication);
    } else if (message instanceof Registered) {
        Registered msg = (Registered) message;
        RegisterRequest request = getOrDefault(mRegisterRequest, msg.request, null);
        if (request == null) {
            throw new ProtocolError(String.format("REGISTERED received for already existing registration ID %s", msg.request));
        }
        mRegisterRequest.remove(msg.request);
        Registration registration = new Registration(msg.registration, request.procedure, request.endpoint, this);
        mRegistrations.put(msg.registration, registration);
        request.onReply.complete(registration);
    } else if (message instanceof Invocation) {
        Invocation msg = (Invocation) message;
        Registration registration = getOrDefault(mRegistrations, msg.registration, null);
        if (registration == null) {
            throw new ProtocolError(String.format("INVOCATION received for non-registered registration ID %s", msg.registration));
        }
        InvocationDetails details = new InvocationDetails(registration, registration.procedure, -1, null, null, this);
        runAsync(() -> {
            Object result;
            if (registration.endpoint instanceof Supplier) {
                Supplier endpoint = (Supplier) registration.endpoint;
                result = endpoint.get();
            } else if (registration.endpoint instanceof Function) {
                Function endpoint = (Function) registration.endpoint;
                result = endpoint.apply(msg.args);
            } else if (registration.endpoint instanceof BiFunction) {
                BiFunction endpoint = (BiFunction) registration.endpoint;
                result = endpoint.apply(msg.args, details);
            } else if (registration.endpoint instanceof TriFunction) {
                TriFunction endpoint = (TriFunction) registration.endpoint;
                result = endpoint.apply(msg.args, msg.kwargs, details);
            } else {
                IInvocationHandler endpoint = (IInvocationHandler) registration.endpoint;
                result = endpoint.apply(msg.args, msg.kwargs, details);
            }
            if (result instanceof CompletableFuture) {
                CompletableFuture<InvocationResult> fResult = (CompletableFuture<InvocationResult>) result;
                fResult.whenCompleteAsync((invocRes, throwable) -> {
                    if (throwable != null) {
                        if (throwable instanceof WampException) {
                            WampException casted = (WampException) throwable;
                            send(new Error(Invocation.MESSAGE_TYPE, msg.request, casted.getErrorUri(), casted.getArguments(), casted.getKwArguments()));
                        } else {
                            List<Object> args = new ArrayList<>();
                            args.add(throwable.getMessage());
                            send(new Error(Invocation.MESSAGE_TYPE, msg.request, "wamp.error.runtime_error", args, null));
                        }
                    } else {
                        send(new Yield(msg.request, invocRes.results, invocRes.kwresults));
                    }
                }, mExecutor);
            } else if (result instanceof InvocationResult) {
                InvocationResult res = (InvocationResult) result;
                send(new Yield(msg.request, res.results, res.kwresults));
            } else if (result instanceof List) {
                send(new Yield(msg.request, (List) result, null));
            } else if (result instanceof Map) {
                send(new Yield(msg.request, null, (Map) result));
            } else if (result instanceof Void) {
                send(new Yield(msg.request, null, null));
            } else {
                List<Object> item = new ArrayList<>();
                item.add(result);
                send(new Yield(msg.request, item, null));
            }
        }, mExecutor).whenCompleteAsync((aVoid, throwable) -> {
            // FIXME: implement better errors
            if (throwable != null) {
                if (throwable instanceof WampException) {
                    WampException casted = (WampException) throwable;
                    send(new Error(Invocation.MESSAGE_TYPE, msg.request, casted.getErrorUri(), casted.getArguments(), casted.getKwArguments()));
                } else {
                    List<Object> args = new ArrayList<>();
                    args.add(throwable.getMessage());
                    send(new Error(Invocation.MESSAGE_TYPE, msg.request, "wamp.error.runtime_error", args, null));
                }
            }
        });
    } else if (message instanceof Goodbye) {
        Goodbye msg = (Goodbye) message;
        CloseDetails details = new CloseDetails(msg.reason, msg.message);
        List<CompletableFuture<?>> futures = new ArrayList<>();
        for (OnLeaveListener listener : mOnLeaveListeners) {
            futures.add(runAsync(() -> listener.onLeave(this, details), mExecutor));
        }
        CompletableFuture d = combineFutures(futures);
        d.thenRunAsync(() -> {
            LOGGER.d("Notified Session.onLeave listeners, now closing transport");
            if (mTransport != null && mTransport.isOpen()) {
                try {
                    mTransport.close();
                } catch (Exception e) {
                    throw new CompletionException(e);
                }
            }
            mState = STATE_DISCONNECTED;
        }, mExecutor);
    } else if (message instanceof Unregistered) {
        Unregistered msg = (Unregistered) message;
        UnregisterRequest request = getOrDefault(mUnregisterRequests, msg.request, null);
        if (request == null) {
            throw new ProtocolError(String.format("UNREGISTERED received for already unregistered registration ID %s", msg.registration));
        }
        if (mRegistrations.containsKey(request.registrationID)) {
            mRegistrations.remove(request.registrationID);
        }
        request.onReply.complete(0);
    } else if (message instanceof Unsubscribed) {
        Unsubscribed msg = (Unsubscribed) message;
        UnsubscribeRequest request = getOrDefault(mUnsubscribeRequests, msg.request, null);
        List<Subscription> subscriptions = mSubscriptions.get(request.subscriptionID);
        request.onReply.complete(subscriptions.size());
    } else if (message instanceof Error) {
        Error msg = (Error) message;
        CompletableFuture<?> onReply = null;
        if (msg.requestType == Call.MESSAGE_TYPE && mCallRequests.containsKey(msg.request)) {
            onReply = mCallRequests.get(msg.request).onReply;
            mCallRequests.remove(msg.request);
        } else if (msg.requestType == Publish.MESSAGE_TYPE && mPublishRequests.containsKey(msg.request)) {
            onReply = mPublishRequests.get(msg.request).onReply;
            mPublishRequests.remove(msg.request);
        } else if (msg.requestType == Subscribe.MESSAGE_TYPE && mSubscribeRequests.containsKey(msg.request)) {
            onReply = mSubscribeRequests.get(msg.request).onReply;
            mSubscribeRequests.remove(msg.request);
        } else if (msg.requestType == Register.MESSAGE_TYPE && mRegisterRequest.containsKey(msg.request)) {
            onReply = mRegisterRequest.get(msg.request).onReply;
            mRegisterRequest.remove(msg.request);
        }
        if (onReply != null) {
            onReply.completeExceptionally(new ApplicationError(msg.error, msg.args, msg.kwargs));
        } else {
            throw new ProtocolError(String.format("ERROR received for non-pending request_type: %s and request ID %s", msg.requestType, msg.request));
        }
    } else {
        throw new ProtocolError(String.format("Unexpected message %s", message.getClass().getName()));
    }
}

Example 39 with CompletionException

use of java.util.concurrent.CompletionException in project mycore by MyCoRe-Org.

the class MCRXMLFunctions method isWorldReadable.

/**
 * Checks if the given object is readable to guest user.
 * @param objId MCRObjectID as String
 */
public static boolean isWorldReadable(String objId) {
    if (objId == null || !MCRObjectID.isValid(objId)) {
        return false;
    }
    MCRObjectID mcrObjectID = MCRObjectID.getInstance(objId);
    CompletableFuture<Boolean> permission = MCRAccessManager.checkPermission(MCRSystemUserInformation.getGuestInstance(), () -> MCRAccessManager.checkPermission(mcrObjectID, MCRAccessManager.PERMISSION_READ));
    try {
        return permission.join();
    } catch (CancellationException | CompletionException e) {
        LOGGER.error("Error while retriving ACL information for Object {}", objId, e);
        return false;
    }
}

Example 40 with CompletionException

use of java.util.concurrent.CompletionException in project qpp-conversion-tool by CMSgov.

the class AnyOrderAsyncActionServiceTest method testInterruptedException.

@Test
void testInterruptedException() {
    objectUnderTest.failuresUntilSuccess(1).failWithInterruptException();
    CompletableFuture<Object> completableFuture = objectUnderTest.actOnItem(new Object());
    CompletionException exception = assertThrows(CompletionException.class, completableFuture::join);
    assertThat(exception).hasCauseThat().isInstanceOf(UncheckedInterruptedException.class);
    // not two
    assertThat(objectUnderTest.timesAsynchronousActionCalled.get()).isEqualTo(1);
}