co.spraybot.messagerunner.datastores.TransientDataStoreVerticle Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of message-runner Show documentation
A micro-framework to allow easily passing specific Vert.x messages to specific addresses for processing of those messages.
The newest version!
package co.spraybot.messagerunner.datastores;

import co.spraybot.messagerunner.DataStoreVerticle;
import co.spraybot.messagerunner.DataStoreParcel;
import co.spraybot.messagerunner.ProcessorAvailabilityParcel;
import co.spraybot.messagerunner.messagecodecs.DataStoreParcelMessageCodec;
import co.spraybot.messagerunner.parcels.DefaultDataStoreParcel;
import io.vertx.core.*;
import io.vertx.core.eventbus.EventBus;
import io.vertx.core.json.JsonArray;
import io.vertx.core.json.JsonObject;

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.function.Function;

public class TransientDataStoreVerticle extends AbstractVerticle implements DataStoreVerticle {

    private String courierAddress;
    private Map data = new HashMap<>();
    private Map>> writeParcelHandlerMap;

    public TransientDataStoreVerticle(String courierAddress) {
        this.courierAddress = courierAddress;
        setwriteParcelHandlerMap();
    }

    private void setwriteParcelHandlerMap() {
        writeParcelHandlerMap = new HashMap<>();
        writeParcelHandlerMap.put(String.class, (DataStoreParcel parcel) -> write(parcel.getKey(), (String) parcel.getValue()));
        writeParcelHandlerMap.put(Integer.class, (DataStoreParcel parcel) -> write(parcel.getKey(), (Integer) parcel.getValue()));
        writeParcelHandlerMap.put(Double.class, (DataStoreParcel parcel) -> write(parcel.getKey(), (Double) parcel.getValue()));
        writeParcelHandlerMap.put(Boolean.class, (DataStoreParcel parcel) -> write(parcel.getKey(), (Boolean) parcel.getValue()));
        writeParcelHandlerMap.put(JsonObject.class, (DataStoreParcel parcel) -> write(parcel.getKey(), (JsonObject) parcel.getValue()));
        writeParcelHandlerMap.put(JsonArray.class, (DataStoreParcel parcel) -> write(parcel.getKey(), (JsonArray) parcel.getValue()));
    }

    @Override
    public void start(Future future) {
        UUID processorAddress = UUID.randomUUID();
        Vertx vertx = getVertx();
        EventBus eventBus = getVertx().eventBus();
        eventBus.registerDefaultCodec(DefaultDataStoreParcel.class, new DataStoreParcelMessageCodec());
        eventBus.consumer(processorAddress.toString()).handler(message -> {
            DataStoreParcel parcel = (DataStoreParcel) message.body();
            switch (parcel.getDataStoreOperation().toString()) {
                case "WRITE":
                    processWriteOperation(parcel, message.replyAddress());
                    break;
                case "READ":
                    processReadOperation(parcel, message.replyAddress());
                    break;
                case "ERASE":
                    processEraseOperation(parcel, message.replyAddress());
                    break;
                case "ERASE_EVERYTHING":
                    processEraseEverythingOperation(message.replyAddress());
                    break;
            }
        }).completionHandler(arVoid -> {
            ProcessorAvailabilityParcel availabilityParcel = ProcessorAvailabilityParcel.builder()
                .ofParcelType(DataStoreParcel.class)
                .sendTo(processorAddress)
                .isAvailable()
                .build();
            eventBus.publish(courierAddress, availabilityParcel);
            vertx.runOnContext(future::complete);
        });
    }

    @Override
    public Future write(String key, JsonObject value) {
        return doWrite(key, value);
    }

    @Override
    public Future write(String key, JsonArray value) {
        return doWrite(key, value);
    }

    @Override
    public Future write(String key, String value) {
        return doWrite(key, value);
    }

    @Override
    public Future write(String key, int value) {
        return doWrite(key, value);
    }

    @Override
    public Future write(String key, double value) {
        return doWrite(key, value);
    }

    @Override
    public Future write(String key, boolean value) {
        return doWrite(key, value);
    }

    private Future doWrite(String key, Object value) {
        data.put(key, value);
        return Future.succeededFuture(true);
    }

    @Override
    public  Future read(String key) {
        return Future.succeededFuture((T) data.get(key));
    }

    @Override
    public  Future erase(String key) {
        return Future.succeededFuture((T) data.remove(key));
    }

    @Override
    public Future eraseEverything() {
        data.clear();
        return Future.succeededFuture();
    }

    private void processWriteOperation(DataStoreParcel parcel, String replyAddress) {
        EventBus eventBus = getVertx().eventBus();
        Class valueType = parcel.getValueType();
        Handler> writtenHandler = ar -> {
            eventBus.send(replyAddress, ar.result());
        };

        for (Map.Entry>> valueTypeHandlerInfo : writeParcelHandlerMap.entrySet()) {
            Class _vt = valueTypeHandlerInfo.getKey();
            Function> function = valueTypeHandlerInfo.getValue();

            if (valueType.isAssignableFrom(_vt)) {
                function.apply(parcel).setHandler(writtenHandler);
            }
        }
    }

    private Future processReadOperation(DataStoreParcel parcel, String replyAddress) {
        Future future = Future.future();

        read(parcel.getKey()).setHandler(ar -> {
            getVertx().eventBus().send(replyAddress, ar.result());
        });

        return future;
    }

    private Future processEraseOperation(DataStoreParcel parcel, String replyAddress) {
        Future future = Future.future();

        erase(parcel.getKey()).setHandler(ar -> {
            getVertx().eventBus().send(replyAddress, ar.result());
        });

        return future;
    }

    private Future processEraseEverythingOperation(String replyAddress) {
        Future future = Future.future();

        eraseEverything().setHandler(ar -> {
            getVertx().eventBus().send(replyAddress, null);
        });

        return future;
    }


}