org.jetlinks.rule.engine.defaults.LocalEventBus Maven / Gradle / Ivy

Go to download
package org.jetlinks.rule.engine.defaults;

import io.netty.buffer.ByteBuf;
import lombok.extern.slf4j.Slf4j;
import org.jetlinks.core.topic.Topic;
import org.jetlinks.rule.engine.api.*;
import org.jetlinks.rule.engine.api.codec.Codecs;
import org.reactivestreams.Publisher;
import reactor.core.publisher.Flux;
import reactor.core.publisher.FluxSink;
import reactor.core.publisher.Mono;

import java.util.function.Function;

@Slf4j
@SuppressWarnings("all")
public class LocalEventBus implements EventBus {

    private final Topic> subs = Topic.createRoot();

    @Override
    public  Flux subscribe(String topic, Decoder decoder) {
        return subscribe(topic)
                .map(v -> {
                    Payload payload = v.getPayload();
                    if (payload instanceof NativePayload) {
                        return (T) ((NativePayload) payload).getNativeObject();
                    }
                    return decoder.decode(v.getPayload());
                });
    }

    @Override
    public  Mono publish(String topic, Publisher event) {
        return publish(topic, (Function) v -> Codecs.lookup((Class) v.getClass()).encode(v).getBody(), event);
    }

    public  Mono publish(String topic, Function encoder, Publisher eventStream) {
        return subs
                .findTopic(topic)
                .map(Topic::getSubscribers)
                .flatMap(subscriber -> {
                    log.debug("publish topic: {}", topic);
                    return Flux
                            .from(eventStream)
                            .doOnNext(data -> {
                                for (FluxSink fluxSink : subscriber) {
                                    try {
                                        fluxSink.next(SubscribePayload.of(topic, NativePayload.of(data, () -> encoder.apply(data))));
                                    } catch (Exception e) {
                                        log.error(e.getMessage(), e);
                                    }
                                }
                            })
                            .then(Mono.just(subscriber.size()));
                })
                .reduce(Math::addExact)
                ;
    }

    @Override
    public  Mono publish(String topic, Encoder encoder, Publisher eventStream) {
        return publish(topic, (Function) v -> encoder.encode(v).getBody(), eventStream);
    }

    @Override
    public Flux subscribe(String topic) {
        return Flux.create((sink) -> {
            log.debug("subscription topic: {}", topic);
            Topic> sub = subs.append(topic);
            sub.subscribe(sink);
            sink.onDispose(() -> {
                log.debug("unsubscription topic: {}", topic);
                sub.unsubscribe(sink);
            });
        });
    }
}