DatabaseAppender.java

package com.renomad.minum.database;

import com.renomad.minum.logging.ILogger;

import com.renomad.minum.state.Constants;

import com.renomad.minum.state.Context;

import com.renomad.minum.utils.IFileUtils;

import com.renomad.minum.utils.MyThread;

import com.renomad.minum.utils.ThrowingRunnable;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.Writer;

import java.nio.charset.StandardCharsets;

import java.nio.file.Path;

import java.nio.file.StandardOpenOption;

import java.time.Instant;

import java.time.ZoneId;

import java.util.List;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.locks.ReentrantLock;

import static com.renomad.minum.database.AbstractDb.DATE_TIME_FORMATTER;

/**

 * This class provide the capability of appending database changes

 * to the disk, quickly and efficiently.

 */

final class DatabaseAppender {

    private final Path persistenceDirectory;

    private final IFileUtils fileUtils;

    Writer bufferedWriter;

    /**

     * if true, there is data in the buffered writer that needs to be

     * written to disk using {@link BufferedWriter#flush()}

     */

    private boolean bufferedWriterHasUnwrittenData;

    /**

     * This class field tracks the status of the loop which runs

     * a flush every second

     */

    private boolean flushLoopRunning;

    /**

     * The directory for this database

     */

    private final Path appendLogDirectory;

    /**

     * Used to create a thread that contains an inner loop

     * to flush the data to disk on a periodic basis

     */

    private final ExecutorService executorService;

    private final ILogger logger;

    private final ReentrantLock moveFileLock;

    /**

     * The maximum number of data's we will add to the append-only

     * file before we move on to a new file.

     */

    int maxAppendCount;

    /**

     * this is the current count of how many appends have

     * been made to the current database file.  Once it

     * exceeds a certain maximum, we'll switch to a

     * different file.

     */

    int appendCount;

    /**

     * This is the count of bytes that have been appended

     */

    private int appendBytes;

    /**

     * Creates a new append-file (a file used for appending data) and

     * resets the append count to zero.

     */

    private void createNewAppendFile() throws IOException {

        // if we are starting up with an existing currentAppendLog, set the appendCount

        // appropriately.  Otherwise, initialize to 0.  The currentAppendLog file is

        // never very large - it's mostly a temporary place to store incoming data

        // until we can store it off elsewhere. For that reason, it's not a performance

        // concern to read all the existing lines, just to get the count of current lines.

            // reset the count to zero, we're starting a new file.

        }

            // Close the writer to avoid file descriptor leaks

        }

    /**

     * Appends new data to the end of a file.

     * @return if we created a new append file, we'll return the name of it. Otherwise, an empty string.

     */

    String appendToDatabase(DatabaseChangeAction action, String serializedData) throws IOException {

            try {

            } finally {

        }

    }

    private void setBufferedWriterHasUnwrittenData() {

        }

    /**

     * This method is kicked off when there is new data added to

     * the {@link BufferedWriter}.  While there is data to write, it

     * will wake up every second to flush the data.  Once there is

     * no more data, it will end.

     */

    private void initializeTimedFlusher() {

                // this code only runs when there is data to add, so no need to take a

                // lot of waiting time.  But, if the data is coming fast and furious,

                // at least a small wait will allow greater efficiency.

            }

    /**

     * This helper just wraps a method to enable easier testing.

     * @return the name of the newly-created file if the appendCount is greater or equal to maxAppendCount,

     * meaning that we moved on to calling {@link #saveOffCurrentDataToReadyFolder()},

     * empty-string otherwise.

     */

    String saveOffWrapped(int appendCount, int maxAppendCount) throws IOException {

        }

    }

    /**

     * Move the append-only file to a new place to prepare for

     * consolidation, and reset the append count.

     * @return the name of the newly-created file

     */

    String saveOffCurrentDataToReadyFolder() throws IOException {

    }

    /**

     * When we are done filling a file, move it to the ready

     * folder named by the date + time + millis.

     * @return the name of the new file

     */

    static String moveToReadyFolder(IFileUtils fileUtils, Path persistenceDirectory, Path appendLogDirectory) throws IOException {

    }

    void flush() throws IOException {

}

Mutations