Port.java

package au.gov.amsa.ais.router.model;

import java.io.Closeable;
import java.io.IOException;
import java.util.Optional;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import au.gov.amsa.streams.StringServer;
import rx.Observable;

public final class Port implements Closeable {

    private static final Logger log = LoggerFactory.getLogger(Port.class);

    private final int port;
    private final Optional<GroupMember> group;
    private final boolean enabled;
    private final Optional<UserGroup> userGroup;
    private final Observable<String> lines;

    private Port(int port, Optional<GroupMember> group, boolean enabled,
            Optional<UserGroup> userGroup) {
        this.port = port;
        this.group = group;
        this.enabled = enabled;
        this.userGroup = userGroup;
        this.lines = createLines();
    }

    private Observable<String> createLines() {
        if (group.isPresent()) {
            return group.get().lines();
        } else {
            return Observable.empty();
        }
    }

    public int port() {
        return port;
    }

    public Optional<GroupMember> group() {
        return group;
    }

    public Optional<UserGroup> userGroup() {
        return userGroup;
    }

    public boolean enabled() {
        return enabled;
    }

    public static Builder builder() {
        return new Builder();
    }

    private Optional<StringServer> server = Optional.empty();
    private final Object serverLock = new Object();

    public void start() {
        log.info("starting " + this);
        synchronized (serverLock) {
            if (server.isPresent()) {
                throw new RuntimeException("server already started");
            } else if (enabled && group.isPresent()) {
                server = Optional.of(StringServer.create(lines.map(line -> line + "\n"), port));
                server.get().start();
            }
        }
    }

    public void stop() {
        synchronized (serverLock) {
            if (server.isPresent()) {
                server.get().stop();
            }
        }
    }

    public static class Builder {

        private int port;
        private Optional<GroupMember> group = Optional.empty();
        private final Optional<UserGroup> userGroup = Optional.empty();
        private boolean enabled = true;

        private Builder() {
        }

        public Builder port(int port) {
            this.port = port;
            return this;
        }

        public Builder group(GroupMember group) {
            this.group = Optional.of(group);
            return this;
        }

        public Builder enabled(boolean enabled) {
            this.enabled = enabled;
            return this;
        }

        public Port build() {
            return new Port(port, group, enabled, userGroup);
        }
    }

    @Override
    public void close() throws IOException {
        stop();
    }

    @Override
    public String toString() {
        StringBuilder b = new StringBuilder();
        b.append("Port [port=");
        b.append(port);
        b.append(", group=");
        b.append(group);
        b.append(", enabled=");
        b.append(enabled);
        b.append(", userGroup=");
        b.append(userGroup);
        b.append("]");
        return b.toString();
    }

}