Channel.java

package cgl.iotcloud.core.transport;

import cgl.iotcloud.core.msg.MessageContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.BlockingQueue;

public class Channel {
    private static Logger LOG = LoggerFactory.getLogger(Channel.class);

    private BlockingQueue inQueue;

    private BlockingQueue<MessageContext> outQueue;

    private Map properties = new HashMap();

    private Direction direction;

    private String name;

    private String sensorID;

    private boolean grouped = false;

    private enum State {
        OPEN,
        CLOSED
    }

    private State state = State.OPEN;

    public Channel(String name, Direction direction) {
        this.name = name;
        this.direction = direction;
    }

    public void setInQueue(BlockingQueue<MessageContext> inQueue) {
        this.inQueue = inQueue;
    }

    public void setOutQueue(BlockingQueue<MessageContext> outQueue) {
        this.outQueue = outQueue;
    }

    public String getSensorID() {
        return sensorID;
    }

    public void setGrouped(boolean grouped) {
        this.grouped = grouped;
    }

    public void setSensorID(String sensorID) {
        this.sensorID = sensorID;
    }

    public String getName() {
        return name;
    }

    public BlockingQueue getInQueue() {
        return inQueue;
    }

    public BlockingQueue getOutQueue() {
        return outQueue;
    }

    public Direction getDirection() {
        return direction;
    }

    public Map getProperties() {
        return properties;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void open() {
        this.state = State.OPEN;
    }

    public boolean isGrouped() {
        return grouped;
    }

    @SuppressWarnings("unchecked")
    public void addProperties(Map properties) {
        this.properties.putAll(properties);
    }

    public void publish(MessageContext message) {
        checkOpen();
        message.setSensorId(sensorID);
        if (state == State.CLOSED) {
            String msg = "The channel is in closed state and cannot send";
            LOG.warn(msg);
            return;
        }

        try {
            outQueue.put(message);
        } catch (InterruptedException e) {
            LOG.error("Failed to put the message to queue", e);
        }
    }

    private void checkOpen() {
        if (outQueue == null) {
            throw new RuntimeException("The channel must be bound to a transport");
        }
    }

    public void publish(byte []message) {
        MessageContext messageContext = new MessageContext(sensorID, message);
        checkOpen();

        if (state == State.CLOSED) {
            String msg = "The channel is in closed state and cannot send";
            LOG.warn(msg);
            return;
        }

        try {
            outQueue.put(messageContext);
        } catch (InterruptedException e) {
            LOG.error("Failed to put the message to queue", e);
        }
    }

    public void publish(byte []message, Map<String, Object> properties) {
        MessageContext messageContext = new MessageContext(sensorID, message, properties);
        checkOpen();

        if (state == State.CLOSED) {
            String msg = "The channel is in closed state and cannot send";
            LOG.warn(msg);
            return;
        }

        try {
            outQueue.put(messageContext);
        } catch (InterruptedException e) {
            LOG.error("Failed to put the message to queue", e);
        }
    }

    public void close() {
        this.state = State.CLOSED;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Channel channel = (Channel) o;

        if (name != null ? !name.equals(channel.name) : channel.name != null) return false;
        if (sensorID != null ? !sensorID.equals(channel.sensorID) : channel.sensorID != null) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + (sensorID != null ? sensorID.hashCode() : 0);
        return result;
    }
}