Examples with EmissionException reactor.core.publisher.Sinks.EmissionException used on opensource projects

Example 1 with EmissionException

use of reactor.core.publisher.Sinks.EmissionException in project reactor-core by reactor.

the class NextProcessor method emitEmpty.

void emitEmpty(Sinks.EmitFailureHandler failureHandler) {
    for (; ; ) {
        Sinks.EmitResult emitResult = tryEmitValue(null);
        if (emitResult.isSuccess()) {
            return;
        }
        boolean shouldRetry = failureHandler.onEmitFailure(SignalType.ON_COMPLETE, emitResult);
        if (shouldRetry) {
            continue;
        }
        switch(emitResult) {
            case FAIL_ZERO_SUBSCRIBER:
            case FAIL_OVERFLOW:
            case FAIL_CANCELLED:
            case FAIL_TERMINATED:
                return;
            case FAIL_NON_SERIALIZED:
                throw new EmissionException(emitResult, "Spec. Rule 1.3 - onSubscribe, onNext, onError and onComplete signaled to a Subscriber MUST be signaled serially.");
            default:
                throw new EmissionException(emitResult, "Unknown emitResult value");
        }
    }
}

Example 2 with EmissionException

use of reactor.core.publisher.Sinks.EmissionException in project reactor-core by reactor.

the class InternalOneSinkTest method shouldDelegateToHandler.

@ParameterizedTestWithName
@EnumSource(value = Sinks.EmitResult.class)
void shouldDelegateToHandler(EmitResult emitResult) {
    assumeThat(emitResult.isFailure()).isTrue();
    Sinks.One<Object> sink = new InternalOneSinkAdapter<Object>() {

        @Override
        public Sinks.EmitResult tryEmitValue(Object value) {
            return emitResult;
        }

        @Override
        public Sinks.EmitResult tryEmitError(Throwable error) {
            return emitResult;
        }

        @Override
        public Sinks.EmitResult tryEmitEmpty() {
            return emitResult;
        }
    };
    for (SignalType signalType : new SignalType[] { SignalType.ON_NEXT, SignalType.ON_ERROR, SignalType.ON_COMPLETE }) {
        AtomicReference<Sinks.EmitResult> emissionRef = new AtomicReference<>();
        try {
            EmitFailureHandler handler = (failedSignalType, failedEmission) -> {
                emissionRef.set(failedEmission);
                return false;
            };
            switch(signalType) {
                case ON_NEXT:
                    sink.emitValue("Hello", handler);
                    break;
                case ON_ERROR:
                    sink.emitError(new Exception("boom"), handler);
                    break;
                case ON_COMPLETE:
                    sink.emitEmpty(handler);
                    break;
                default:
                    throw new IllegalStateException();
            }
        } catch (EmissionException e) {
            assertThat(e.getReason()).isEqualTo(Sinks.EmitResult.FAIL_NON_SERIALIZED);
        }
        assertThat(emissionRef).as("emitResult").hasValue(emitResult);
    }
}

Example 3 with EmissionException

use of reactor.core.publisher.Sinks.EmissionException in project reactor-core by reactor.

the class InternalManySinkTest method shouldDelegateToHandler.

@ParameterizedTestWithName
@EnumSource(value = Sinks.EmitResult.class)
void shouldDelegateToHandler(Sinks.EmitResult emitResult) {
    assumeThat(emitResult.isFailure()).isTrue();
    Sinks.Many<Object> sink = new InternalManySinkAdapter<Object>() {

        @Override
        public EmitResult tryEmitNext(Object o) {
            return emitResult;
        }

        @Override
        public Sinks.EmitResult tryEmitError(Throwable error) {
            return emitResult;
        }

        @Override
        public EmitResult tryEmitComplete() {
            return emitResult;
        }
    };
    for (SignalType signalType : new SignalType[] { SignalType.ON_NEXT, SignalType.ON_ERROR, SignalType.ON_COMPLETE }) {
        AtomicReference<EmitResult> emissionRef = new AtomicReference<>();
        try {
            EmitFailureHandler handler = (failedSignalType, failedEmission) -> {
                emissionRef.set(failedEmission);
                return false;
            };
            switch(signalType) {
                case ON_NEXT:
                    sink.emitNext("Hello", handler);
                    break;
                case ON_ERROR:
                    sink.emitError(new Exception("boom"), handler);
                    break;
                case ON_COMPLETE:
                    sink.emitComplete(handler);
                    break;
                default:
                    throw new IllegalStateException();
            }
        } catch (EmissionException e) {
            assertThat(e.getReason()).isEqualTo(EmitResult.FAIL_NON_SERIALIZED);
        }
        assertThat(emissionRef).as("emitResult").hasValue(emitResult);
    }
}

Example 4 with EmissionException

use of reactor.core.publisher.Sinks.EmissionException in project reactor-core by reactor.

the class NextProcessor method onError.

@Override
public final void onError(Throwable cause) {
    for (; ; ) {
        EmitResult emitResult = tryEmitError(cause);
        if (emitResult.isSuccess()) {
            return;
        }
        boolean shouldRetry = EmitFailureHandler.FAIL_FAST.onEmitFailure(SignalType.ON_ERROR, emitResult);
        if (shouldRetry) {
            continue;
        }
        switch(emitResult) {
            case FAIL_ZERO_SUBSCRIBER:
            case FAIL_OVERFLOW:
            case FAIL_CANCELLED:
                return;
            case FAIL_TERMINATED:
                Operators.onErrorDropped(cause, currentContext());
                return;
            case FAIL_NON_SERIALIZED:
                throw new EmissionException(emitResult, "Spec. Rule 1.3 - onSubscribe, onNext, onError and onComplete signaled to a Subscriber MUST be signaled serially.");
            default:
                throw new EmissionException(emitResult, "Unknown emitResult value");
        }
    }
}

Example 5 with EmissionException

use of reactor.core.publisher.Sinks.EmissionException in project reactor-core by reactor.

the class NextProcessor method onNext.

@Override
public final void onNext(@Nullable O value) {
    if (value == null) {
        emitEmpty(EmitFailureHandler.FAIL_FAST);
        return;
    }
    for (; ; ) {
        EmitResult emitResult = tryEmitValue(value);
        if (emitResult.isSuccess()) {
            return;
        }
        boolean shouldRetry = EmitFailureHandler.FAIL_FAST.onEmitFailure(SignalType.ON_NEXT, emitResult);
        if (shouldRetry) {
            continue;
        }
        switch(emitResult) {
            case FAIL_ZERO_SUBSCRIBER:
                // effectively NO-OP cause there's no subscriber, so no context :(
                return;
            case FAIL_OVERFLOW:
                Operators.onDiscard(value, currentContext());
                // the emitError will onErrorDropped if already terminated
                onError(Exceptions.failWithOverflow("Backpressure overflow during Sinks.Many#emitNext"));
                return;
            case FAIL_CANCELLED:
                Operators.onDiscard(value, currentContext());
                return;
            case FAIL_TERMINATED:
                Operators.onNextDropped(value, currentContext());
                return;
            case FAIL_NON_SERIALIZED:
                throw new EmissionException(emitResult, "Spec. Rule 1.3 - onSubscribe, onNext, onError and onComplete signaled to a Subscriber MUST be signaled serially.");
            default:
                throw new EmissionException(emitResult, "Unknown emitResult value");
        }
    }
}