com.nikedlab.logRotator.LogRotator Maven / Gradle / Ivy

Go to download
package com.nikedlab.logRotator;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.zip.GZIPOutputStream;

/**
 * Created with NikedLab
 * Date: 10/30/13
 * Time: 12:01 PM
 */
public class LogRotator {

    private static LogRotator instance;
    private static long fileSize = 1024000;
    private static int maxLogFiles = 30;
    private static String logFilePath;
    private static LogFileAttributes logFileAttributes;

    /**
     * Default constructor for singleton
     */
    private LogRotator() {
    }

    /**
     * Singleton instance getter
     * @param fileSize Max log file size
     * @param maxLogFiles Max quantity of log files
     * @return {@link LogRotator} object
     */
    public static synchronized LogRotator init(long fileSize, int maxLogFiles, String logFilePath) {
        LogRotator.maxLogFiles = maxLogFiles;
        LogRotator.fileSize = fileSize;
        LogRotator.logFilePath = logFilePath;
        if (instance == null) {
            instance = new LogRotator();
        }
        instance.prepareFolder();
        instance._removeBck();
        return instance;
    }

    public static String getLogFilePath() {
        return LogRotator.logFilePath;
    }

    /**
     * Prepare folders
     * @return Operation result
     */
    private boolean prepareFolder() {
        logFileAttributes = new LogFileAttributes(logFilePath);
        File tmpDir = new File(logFileAttributes.getLogFolderPath());
        if(!tmpDir.exists()) {
            if(tmpDir.mkdir()) {
                return true;
            }
        } else {
            return true;
        }

        return false;
    }

    /**
     * Write log message
     * @param message Message
     */
    public static void writeLog(String message) {
        if (getFileSize() < fileSize) {
            instance.writeLineToFile(message);
        } else {
            instance.backupFile();
        }

    }

    /**
     * Backup current log file
     */
    private void backupFile() {
        File file = new File(logFileAttributes.getFilePath());
        _reverseFiles();

        File newFile = new File(logFileAttributes.getFilePath() + ".1");
        file.renameTo(newFile);
        file.delete();
    }

    private void compressGzipFile(String file, String gzipFile) {
        try {
            FileInputStream fis = new FileInputStream(file);
            FileOutputStream fos = new FileOutputStream(gzipFile);
            GZIPOutputStream gzipOS = new GZIPOutputStream(fos);
            byte[] buffer = new byte[1024];
            int len;
            while((len=fis.read(buffer)) != -1){
                gzipOS.write(buffer, 0, len);
            }
            //close resources
            gzipOS.close();
            fos.close();
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * File writer
     * @param line {@link java.lang.String} for writing
     * @return Writing result
     */
    private boolean writeLineToFile(String line) {
        File file = new File(logFileAttributes.getFilePath());
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
            if (file.canWrite()) {
                BufferedWriter bw = new BufferedWriter(new FileWriter(file, true));
                bw.append(line);
                bw.newLine();
                bw.close();
            } else {
                return false;
            }
        } catch (IOException e) {
            return false;
        }
        return true;
    }

    /**
     * Rename log files
     */
    private void _reverseFiles() {
        File[] files = _getFilesList();
        ArrayList origFiles = new ArrayList(Arrays.asList(files));


        if(origFiles.size() >= 1) {
            for (File origFile : origFiles) {
                String[] segments = origFile.getName().split("\\.");
                String segment = segments[segments.length - 1];
                boolean flag = false;
                if ("gz".equals(segment)) {
                    segment = segments[segments.length - 2];
                    flag = true;
                }

                try {
                    int index = (Integer.parseInt(segment)) + 1;
                    if (flag) {
                        origFile.renameTo(new File(origFile.getParent() + File.separator + logFileAttributes.getFileName() + "." + index + ".gz.bck"));
                    } else {
                        String name = origFile.getParent() + File.separator + logFileAttributes.getFileName() + "." + index;
                        File dest = new File(name + ".bck");
                        origFile.renameTo(dest);
                        compressGzipFile(dest.getAbsolutePath(), name.concat(".gz.bck"));
                        dest.delete();
                    }
                } catch (NumberFormatException e) {
                    _removeBck();
                }



            }
            _backRenaming();
        }
    }

    /**
     * Remove all backup files
     */
    private void _removeBck() {
        File[] files = _getFilesList();
        if (files != null && files.length > 0) {
            for (File file : files) {
                if(file.getName().endsWith(".bck")) {
                    file.delete();
                }
            }
        }
    }

    /**
     * Rename log files
     */
    private void _backRenaming() {
        File[] files = _getFilesList();
        for (File file : files) {
            String fileName = file.getAbsolutePath().replace(".bck", "");
            File newFile = new File(fileName);
            file.renameTo(newFile);
            if(newFile.getName().equals(logFileAttributes.getFileName() + "." + (maxLogFiles +1) + ".gz")) {
                newFile.delete();
            }
        }
    }

    /**
     * Getter for file list in log folder
     * @return File list
     */
    private File[] _getFilesList() {
        File file = new File(logFileAttributes.getFilePath());
        String parentDir = file.getParent();
        File dir = new File(parentDir);
        return dir.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return name.startsWith(logFileAttributes.getFileName().concat("."));
            }
        });

    }

    /**
     * File size getter
     * @return Size
     */
    private static long getFileSize() {
        long length = 0;

        if (logFileAttributes != null) {
            File file = new File(logFileAttributes.getFilePath());
            length = file.length();
        }
        return length;
    }

    private class LogFileAttributes {
        private String fileName;
        private String filePath;
        private String logFolderPath;

        private LogFileAttributes(String logFile) {
            File log = new File(logFile);
            this.fileName = log.getName();
            this.filePath = logFile;
            this.logFolderPath = log.getParent();
        }

        private String getFileName() {
            return fileName;
        }

        private String getFilePath() {
            return filePath;
        }

        private String getLogFolderPath() {
            return logFolderPath;
        }
    }
}