Server.java

package com.renomad.minum.web;

import com.renomad.minum.logging.ILogger;

import com.renomad.minum.state.Constants;

import com.renomad.minum.state.Context;

import com.renomad.minum.utils.ConcurrentSet;

import com.renomad.minum.utils.StacktraceUtils;

import com.renomad.minum.utils.ThrowingRunnable;

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Future;

import java.util.concurrent.LinkedBlockingQueue;

import static com.renomad.minum.utils.ThrowingRunnable.throwingRunnableWrapper;

/**

 * The purpose here is to make it marginally easier to

 * work with a ServerSocket.

 * <p>

 * First, instantiate this class using a running serverSocket

 * Then, by running the start method, we gain access to

 * the server's socket.  This way we can easily test / control

 * the server side but also tie it in with an ExecutorService

 * for controlling lots of server threads.

 */

final class Server implements IServer {

    private final ServerSocket serverSocket;

    private final SetOfSws setOfSWs;

    private final ExecutorService es;

    private final HttpServerType serverType;

    private final ILogger logger;

    private final String serverName;

    private final WebFramework webFramework;

    private final BlockingQueue<Socket> socketQueue;

    private final Constants constants;

    /**

     * This is the future returned when we submitted the

     * thread for the central server loop to the ExecutorService

     */

    private Future<?> centralLoopFuture;

    @Override

    public void start() {

    /**

     * This code is the outermost loop of the server, waiting for incoming

     * connections and then delegating their handling off to a handler.

     */

    private void outermostLoop() {

        try {

            // yes, this infinite loop can only exit by an exception.  But this is

            // the beating heart of a server, and to the best of my current knowledge,

            // when a server socket is force-closed it's going to throw an exception, and

            // that's just part of its life cycle

            //noinspection InfiniteLoopStatement

            while (true) {

                // see takeOffDeque for the code that pulls sockets out of this queue

                // and sends them for processing

        }

    /**

     * An infinite loop that pulls connected sockets out of the

     * deque for processing

     */

    private void takeOffDequeForProcessing() throws InterruptedException {

        // this is a known infinite loop, meant to keep running all during the runtime

        //noinspection InfiniteLoopStatement

        while(true) {

    }

    void doHttpWork(Socket freshSocket) {

        // provide a name for this thread for easier debugging

        try {

            // prepare the socket for later processing

            // add to a set of wrapped sockets so we can precisely close them all at shutdown

    static void handleServerException(IOException ex, ILogger logger) {

        // we do expect to see an exception bubbling up to here if we

        // are closing our server, so if the message includes certain values,

        // we will skip logging an error.

        }

    @Override

    public void close() throws IOException {

        // close all the running sockets

        // close the primary server socket

    @Override

    public String getHost() {

    }

    @Override

    public int getPort() {

    }

    @Override

    public void removeMyRecord(ISocketWrapper socketWrapper) {

    @Override

    public void addToSetOfSws(ISocketWrapper sw) {

    /**

     * Returns the name of this server, which is set

     * when the server is instantiated.

     */

    @Override

    public String toString() {

    }

    @Override

    public Future<?> getCentralLoopFuture() {

    }

    @Override

    public HttpServerType getServerType() {

    }

}

Mutations