rt.pipeline.DefaultMessageBus Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of rts-pipeline Show documentation
Framework to build reactive services for reactive application front-ends
The newest version!
package rt.pipeline;

import com.google.common.base.Objects;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import org.eclipse.xtend.lib.annotations.Accessors;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.xbase.lib.ObjectExtensions;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure0;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.eclipse.xtext.xbase.lib.Pure;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import rt.async.AsyncUtils;
import rt.async.pubsub.IMessageBus;
import rt.async.pubsub.IObserver;
import rt.async.pubsub.ISubscription;
import rt.async.pubsub.Message;

@SuppressWarnings("all")
public class DefaultMessageBus implements IMessageBus {
  public static class DefaultSubscription implements ISubscription {
    @Accessors
    private final String address;
    
    private final DefaultMessageBus parent;
    
    private final Procedure1 callback;
    
    DefaultSubscription(final DefaultMessageBus parent, final String address, final Procedure1 callback) {
      this.parent = parent;
      this.address = address;
      this.callback = callback;
    }
    
    public void send(final Message msg) {
      this.callback.apply(msg);
    }
    
    @Override
    public void remove() {
      DefaultMessageBus.logger.info("UNSUBSCRIBE {}", this.address);
      final Set holder = this.parent.subscriptions.get(this.address);
      boolean _notEquals = (!Objects.equal(holder, null));
      if (_notEquals) {
        holder.remove(this);
        int _size = holder.size();
        boolean _equals = (_size == 0);
        if (_equals) {
          IObserver _get = this.parent.observers.get(this.address);
          if (_get!=null) {
            _get.onDestroy(this.address);
          }
          this.parent.subscriptions.remove(this.address);
        }
      }
    }
    
    @Pure
    public String getAddress() {
      return this.address;
    }
  }
  
  private final static Logger logger = LoggerFactory.getLogger("BUS");
  
  private final HashMap> subscriptions = new HashMap>();
  
  private final ConcurrentHashMap> replyListeners = new ConcurrentHashMap>();
  
  private final HashMap observers = new HashMap();
  
  @Override
  public void publish(final String address, final String inCmd, final Object inResult) {
    this.publish(address, address, inCmd, inResult);
  }
  
  @Override
  public void publish(final String address, final String inPath, final String inCmd, final Object inResult) {
    Message _message = new Message();
    final Procedure1 _function = (Message it) -> {
      it.typ = Message.PUBLISH;
      it.path = ("srv:" + inPath);
      it.cmd = inCmd;
      it.setResult(inResult);
    };
    final Message msg = ObjectExtensions.operator_doubleArrow(_message, _function);
    Set _get = this.subscriptions.get(address);
    if (_get!=null) {
      final Consumer _function_1 = (DefaultMessageBus.DefaultSubscription it) -> {
        it.send(msg);
      };
      _get.forEach(_function_1);
    }
  }
  
  @Override
  public void publish(final String address, final Message msg) {
    boolean _notEquals = (!Objects.equal(msg.typ, null));
    if (_notEquals) {
      msg.typ = Message.PUBLISH;
    }
    Set _get = this.subscriptions.get(address);
    if (_get!=null) {
      final Consumer _function = (DefaultMessageBus.DefaultSubscription it) -> {
        it.send(msg);
      };
      _get.forEach(_function);
    }
  }
  
  @Override
  public void send(final String address, final Message msg, final Procedure1 replyCallback) {
    final String replyID = msg.replyID();
    this.replyListener(replyID, replyCallback);
    msg.typ = Message.SEND;
    Set _get = this.subscriptions.get(address);
    if (_get!=null) {
      final Consumer _function = (DefaultMessageBus.DefaultSubscription it) -> {
        it.send(msg);
      };
      _get.forEach(_function);
    }
    final Procedure0 _function_1 = () -> {
      Message _message = new Message();
      final Procedure1 _function_2 = (Message it) -> {
        it.id = msg.id;
        it.clt = msg.clt;
        it.typ = Message.REPLY;
        it.cmd = Message.CMD_ERROR;
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("Timeout for ");
        _builder.append(msg.path, "");
        _builder.append(" -> ");
        _builder.append(msg.cmd, "");
        RuntimeException _runtimeException = new RuntimeException(_builder.toString());
        it.setResult(_runtimeException);
      };
      final Message replyTimeoutMsg = ObjectExtensions.operator_doubleArrow(_message, _function_2);
      this.reply(replyTimeoutMsg);
    };
    AsyncUtils.timeout(_function_1);
  }
  
  @Override
  public void reply(final Message msg) {
    final String replyID = msg.replyID();
    final Procedure1 replyOKBackFun = this.replyListeners.remove((replyID + "/reply-ok"));
    final Procedure1 replyERRORBackFun = this.replyListeners.remove((replyID + "/reply-error"));
    boolean _equals = Objects.equal(msg.cmd, Message.CMD_OK);
    if (_equals) {
      if (replyOKBackFun!=null) {
        replyOKBackFun.apply(msg);
      }
    } else {
      if (replyERRORBackFun!=null) {
        replyERRORBackFun.apply(msg);
      }
    }
    final Procedure1 replyFun = this.replyListeners.remove(replyID);
    if (replyFun!=null) {
      replyFun.apply(msg);
    }
  }
  
  @Override
  public void replyListener(final String replyID, final Procedure1 listener) {
    this.replyListeners.put(replyID, listener);
  }
  
  @Override
  public ISubscription subscribe(final String address, final Procedure1 listener) {
    DefaultMessageBus.logger.info("SUBSCRIBE {}", address);
    Set holder = this.subscriptions.get(address);
    boolean _equals = Objects.equal(holder, null);
    if (_equals) {
      HashSet _hashSet = new HashSet();
      holder = _hashSet;
      this.subscriptions.put(address, holder);
      IObserver _get = this.observers.get(address);
      if (_get!=null) {
        _get.onCreate(address);
      }
    }
    final DefaultMessageBus.DefaultSubscription sub = new DefaultMessageBus.DefaultSubscription(this, address, listener);
    holder.add(sub);
    return sub;
  }
  
  @Override
  public void addObserver(final String address, final IObserver observer) {
    this.observers.put(address, observer);
  }
}