FullSystem.java

package com.renomad.minum.web;

import com.renomad.minum.queue.ActionQueueKiller;

import com.renomad.minum.state.Constants;

import com.renomad.minum.logging.ILogger;

import com.renomad.minum.logging.Logger;

import com.renomad.minum.security.ITheBrig;

import com.renomad.minum.security.TheBrig;

import com.renomad.minum.state.Context;

import com.renomad.minum.utils.*;

import java.nio.file.Files;

import java.nio.file.Path;

import java.time.ZoneId;

import java.time.ZonedDateTime;

import java.util.concurrent.CancellationException;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

 * This class is responsible for instantiating necessary classes

 * for a valid system, in the proper order.

 * @see #initialize()

 * @see #start()

 */

public final class FullSystem {

    final ILogger logger;

    private final Constants constants;

    private final FileUtils fileUtils;

    private IServer server;

    private WebFramework webFramework;

    private IServer sslServer;

    Thread shutdownHook;

    private ITheBrig theBrig;

    final ExecutorService es;

    private WebEngine webEngine;

    /**

     * This flag gives us some control if we need

     * to call {@link #shutdown()} manually, so close()

     * doesn't get run again when the shutdownHook

     * tries calling it.  This is primarily an issue just during

     * testing.

     */

    private boolean hasShutdown;

    private final Context context;

    /**

     * This constructor requires a {@link Context} object,

     * but it is easier and recommended to use {@link #initialize()}

     * instead.

     */

    /**

     * Builds a context object that is appropriate as a

     * parameter to constructing a {@link FullSystem}

     */

    public static Context buildContext() {

    }

    /**

     * This is the typical entry point for system instantiation.  It will build

     * a {@link Context} object for you, and then properly instantiates the {@link FullSystem}.

     * <p>

     *     <em>Here is an example of a simple Main file using this method:</em>

     * </p>

     * <pre>{@code

     *   package org.example;

     *

     *   import com.renomad.minum.web.FullSystem;

     *   import com.renomad.minum.web.Response;

     *

     *   import static com.renomad.minum.web.RequestLine.Method.GET;

     *

     *   public class Main {

     *

     *       public static void main(String[] args) {

     *           FullSystem fs = FullSystem.initialize();

     *           fs.getWebFramework().registerPath(GET, "", request -> Response.htmlOk("<p>Hi there world!</p>"));

     *           fs.block();

     *       }

     *   }

     * }</pre>

     */

    public static FullSystem initialize() {

    }

    /**

     * This method runs the necessary methods for starting the Minum

     * web server.  It is unlikely you will want to use this, unless you

     * require it for more control in testing.

     * @see #initialize()

     */

    public FullSystem start() {

        // create a file in our current working directory to indicate we are running

        // set up an action to take place if the user shuts us down

        // instantiate our security code

        } else {

        }

        // the web framework handles the HTTP communications

        // kick off the servers - low level internet handlers

        // document how long it took to start up the system

    }

    /**

     * this adds a hook to the Java runtime, so that if the app is running

     * and a user stops it - by pressing ctrl+c or a unix "kill" command - the

     * server socket will be shutdown and some messages about closing the server

     * will log

     */

    private void addShutdownHook() {

    /**

     * this saves a file to the home directory, SYSTEM_RUNNING,

     * that will indicate the system is active.  It can be disabled

     * by configuring ENABLE_SYSTEM_RUNNING_MARKER to false.

     */

    private void createSystemRunningMarker() {

    /**

     * Returns current information on the non-encrypted server

     */

    public IServer getServer() {

    }

    /**

     * Returns current information on the encrypted server

     */

    public IServer getSslServer() {

    }

    /**

     * A convenience method to get the instance registered for this property

     */

    public WebFramework getWebFramework() {

    }

    /**

     * A convenience method to get the instance registered for this property

     */

    public ITheBrig getTheBrig() {

    }

    /**

     * A convenience function to get the {@link Context} used in

     * this class's construction

     */

    public Context getContext() {

    }

    WebEngine getWebEngine() {

    }

    /**

     * Shut down the system, set up to be run by a hook during initialization

     */

    public void shutdown() {

        }

    /**

     * The core code for closing resources

     * @param fullSystemName the name of this FullSystem, in cases where several are running concurrently

     */

    static void closeCore(ILogger logger, Context context, IServer server, IServer sslServer, String fullSystemName) {

        try {

            }

            }

    /**

     * A blocking call for our multi-threaded application.

     * <p>

     * This method is needed because the entire application is

     * multi-threaded.  Let me help contextualize the problem

     * for you:

     * </p>

     * <p>

     *     For this application, multi-threaded means that we

     *     are wrapping our code in {@link Thread} classes and

     *     having them run using a {@link ExecutorService}.  It's

     *     sort of like giving instructions to someone else to carry

     *     out the work and sending them away, trusting the work will

     *     get done, rather than doing it yourself.

     * </p>

     * <p>

     *     But, since our entire system is done this way, once we

     *     have sent all our threads on their way, there's nothing

     *     left for us to do! Continuing the analogy, it is like

     *     our whole job is to give other people instructions, and

     *     then just wait for them to return.

     * </p>

     * <p>

     *     That's the purpose of this method.  It's to wait for

     *     the return.

     * </p>

     * <p>

     *     It's probably best to call this method as one of the

     *     last statements in the main method, so it is clear where

     *     execution is blocking.

     * </p>

     */

    public void block() {

    static void blockCore(IServer server, IServer sslServer, ILogger logger) {

        try {

            }

            }

}

Mutations