Java 类ch.qos.logback.core.util.FileSize 实例源码

protected void setupBasePolicySettings(TimeBasedRollingPolicy<ILoggingEvent> policy) {
    policy.setFileNamePattern(getFileNamePattern());
    if (getHistorySize() > 0) {
        policy.setMaxHistory(getHistorySize());
        policy.setCleanHistoryOnStart(true);
    }
    if (totalSize != null && totalSize.length() > 0) {
        policy.setTotalSizeCap(FileSize.valueOf(totalSize));
    }
}

@Override
public TriggeringPolicy<ILoggingEvent> createTriggeringPolicy(LoggerContext context) {
    SizeBasedTriggeringPolicy<ILoggingEvent> policy = new SizeBasedTriggeringPolicy<ILoggingEvent>();
    if (fileSize != null && fileSize.length() > 0) {
        policy.setMaxFileSize(FileSize.valueOf(fileSize));
    }
    policy.setContext(context);
    return policy;
}

@Override
protected SizeAndTimeBasedRollingPolicy<ILoggingEvent> instantiatePolicy(LoggerContext context) {
    SizeAndTimeBasedRollingPolicy<ILoggingEvent> policy = new SizeAndTimeBasedRollingPolicy<>();
    setupBasePolicySettings(policy);
    if (fileSize != null && fileSize.length() > 0) {
        policy.setMaxFileSize(FileSize.valueOf(fileSize));
    }
    policy.setContext(context);
    return policy;
}

public static void rollingPolicyForAppender(RollingFileAppender rollingFileAppender, String maxFileSize, String totalSizeCap, int maxHistory) {
    SizeAndTimeBasedRollingPolicy rollingPolicy = new SizeAndTimeBasedRollingPolicy();
    rollingPolicy.setContext(LOGGER_CONTEXT);
    rollingPolicy.setMaxHistory(maxHistory);
    rollingPolicy.setMaxFileSize(FileSize.valueOf(maxFileSize));
    rollingPolicy.setTotalSizeCap(FileSize.valueOf(totalSizeCap));
    rollingPolicy.setFileNamePattern(rollingFileAppender.rawFileProperty() + ".%d{yyyy-MM-dd}.%i.gz");
    rollingPolicy.setParent(rollingFileAppender);
    rollingFileAppender.setRollingPolicy(rollingPolicy);
    rollingPolicy.start();
}

/**
 * Creates the file appender for the logger with a custom logging policy
 * (RollingFileAppender with max size of 1 MB and up to 3 backups)
 * @param logFile the file to log into
 * @return the FileAppender for the specified File and current logging
 *         context
 */
@SuppressWarnings({ "rawtypes", "unchecked" })
protected static FileAppender getFileAppender(File logFile) {
    // init rolling file appender
    RollingFileAppender rfAppender = new RollingFileAppender();
    rfAppender.setContext(lc);
    rfAppender.setFile(logFile.getAbsolutePath());
    rfAppender.setAppend(true);

    // rolling policy: keep up to 3 rollover-files with postfix .%i.log
    FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy();
    rollingPolicy.setContext(lc);
    rollingPolicy.setParent(rfAppender);
    rollingPolicy.setFileNamePattern(logFileName + ".%i.log");
    rollingPolicy.setMinIndex(1);
    rollingPolicy.setMaxIndex(3);
    rollingPolicy.start();

    // rollover after logfixe exceeds 1MB
    SizeBasedTriggeringPolicy triggeringPolicy = new SizeBasedTriggeringPolicy();
    triggeringPolicy.setMaxFileSize(FileSize.valueOf("1mb"));
    triggeringPolicy.start();

    // layout of the log entries
    Encoder encoder = getDefaultEncoder();

    // apply settings and start appender
    rfAppender.setEncoder(encoder);
    rfAppender.setRollingPolicy(rollingPolicy);
    rfAppender.setTriggeringPolicy(triggeringPolicy);
    rfAppender.start();

    return rfAppender;
}

public void setMaxFileSize(String maxFileSize) {
  this.maxFileSizeAsString = maxFileSize;
  this.maxFileSize = FileSize.valueOf(maxFileSize);
}

public void setMaxFileSize(String maxFileSize) {
  this.maxFileSizeAsString = maxFileSize;
  this.maxFileSize = FileSize.valueOf(maxFileSize);
}

public FileSize getFs() {
  return fs;
}

public void setFs(FileSize fs) {
  this.fs = fs;
}

public LogConfigurator(File f) {

            Appender appender = null;

            if (f != null) {
                try {
                    String line = Files.readFirstLine(f, Charset.defaultCharset()).trim();
                    switch (line) {
                        case "rolling":
                            String logFile = workingDirectory();
                            message = ("rolling to file://{}" + logFile);

                            RollingFileAppender r = new RollingFileAppender();
                            r.setFile(logFile);
                            r.setAppend(true);

                            SizeBasedTriggeringPolicy triggeringPolicy = new ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy();
                            triggeringPolicy.setMaxFileSize(FileSize.valueOf("5MB"));
                            triggeringPolicy.start();

                            FixedWindowRollingPolicy policy = new FixedWindowRollingPolicy();
                            policy.setFileNamePattern("log.%i.gz");
                            policy.setParent(r);
                            policy.setContext(LOG.getLoggerContext());
                            policy.start();

                            r.setEncoder(logEncoder());
                            r.setRollingPolicy(policy);
                            r.setTriggeringPolicy(triggeringPolicy);


                            appender = r;
                            break;
                        //TODO TCP/UDP etc
                    }
                } catch (IOException e) {
                    logger.error("{}", e);
                    appender = null;
                }
            }

            if (appender == null) {
                //default
                ConsoleAppender a = new ConsoleAppender();
                a.setEncoder(logEncoder());
                appender = a;
                message = "ConsoleAppender";
            }


            LOG.detachAndStopAllAppenders();

            appender.setContext(LOG.getLoggerContext());
            appender.start();

            LOG.addAppender(appender);


            this.appender = appender;
        }

private FileSize getMaxFileSize() {
    return FileSize.valueOf(maxSize.get() + "kb");
}

public static void setup(String fileName) {
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();

    RollingFileAppender appender = new RollingFileAppender();
    appender.setContext(loggerContext);
    appender.setFile(fileName + ".log");

    FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy();
    rollingPolicy.setContext(loggerContext);
    rollingPolicy.setParent(appender);
    rollingPolicy.setFileNamePattern(fileName + "_%i.log");
    rollingPolicy.setMinIndex(1);
    rollingPolicy.setMaxIndex(10);
    rollingPolicy.start();

    SizeBasedTriggeringPolicy triggeringPolicy = new SizeBasedTriggeringPolicy();
    triggeringPolicy.setMaxFileSize(FileSize.valueOf("10MB"));
    triggeringPolicy.start();

    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    encoder.setContext(loggerContext);
    encoder.setPattern("%d{MMM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{15}: %msg %xEx%n");
    encoder.start();

    //noinspection unchecked
    appender.setEncoder(encoder);
    appender.setRollingPolicy(rollingPolicy);
    //noinspection unchecked
    appender.setTriggeringPolicy(triggeringPolicy);
    appender.start();

    logbackLogger = loggerContext.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
    //noinspection unchecked
    logbackLogger.addAppender(appender);
    logbackLogger.setLevel(Level.INFO);

    // log errors in separate file
    // not working as expected still.... damn logback...
   /* FileAppender errorAppender = new FileAppender();
    errorAppender.setEncoder(encoder);
    errorAppender.setName("Error");
    errorAppender.setContext(loggerContext);
    errorAppender.setFile(fileName + "_error.log");
    LevelFilter levelFilter = new LevelFilter();
    levelFilter.setLevel(Level.ERROR);
    levelFilter.setOnMatch(FilterReply.ACCEPT);
    levelFilter.setOnMismatch(FilterReply.DENY);
    levelFilter.start();
    errorAppender.addFilter(levelFilter);
    errorAppender.start();
    logbackLogger.addAppender(errorAppender);*/
}

@Override
void capTotalSize(final Date now) {
    int totalSize = 0;
    int totalFilesRemoved = 0;
    int totalBytesRemoved = 0;
    int fileIndex = 0;
    for (int offset = 0; offset < _maxHistory; ++offset) {
        final Date date = rc.getEndOfNextNthPeriod(now, -offset);
        final File[] matchingFileArray = getFilesInPeriod(date);
        descendingSortByLastModified(matchingFileArray);
        for (final File file : matchingFileArray) {
            final long fileSizeInBytes = file.length();
            if (totalSize + fileSizeInBytes > _totalSizeCap) {
                if (fileIndex >= UNTOUCHABLE_ARCHIVE_FILE_COUNT) {
                    addInfo(
                            String.format(
                                    "Deleting [%s] of size %s",
                                    file,
                                    new FileSize(fileSizeInBytes)));
                    totalBytesRemoved += fileSizeInBytes;
                    ++totalFilesRemoved;
                    if (!file.delete()) {
                        addWarn(
                                String.format(
                                        "Deleting [%s] failed.",
                                        file));
                    }
                } else {
                    addWarn(
                            String.format(
                                    "Skipping [%s] of size %s as it is one of the two newest log achives.",
                                    file,
                                    new FileSize(fileSizeInBytes)));
                }
            }
            totalSize += fileSizeInBytes;
            ++fileIndex;
        }
    }
    addInfo(String.format("Removed %d files totalling %s", totalFilesRemoved, new FileSize(totalBytesRemoved)));
}

/**
 *
 * @param logFilePath
 */
public static void startFileLogging(String logFilePath) {
    Logger rootLogger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);

    LoggerContext loggerContext = rootLogger.getLoggerContext();

    RollingFileAppender<ILoggingEvent> rfAppender = new RollingFileAppender<>();
    rfAppender.setContext(loggerContext);
    rfAppender.setFile(logFilePath);

    FixedWindowRollingPolicy fwRollingPolicy = new FixedWindowRollingPolicy();
    fwRollingPolicy.setContext(loggerContext);
    fwRollingPolicy.setFileNamePattern(logFilePath + "-%i.log.zip");
    fwRollingPolicy.setParent(rfAppender);
    fwRollingPolicy.start();

    SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<>();
    triggeringPolicy.setMaxFileSize(FileSize.valueOf("5 mb"));
    triggeringPolicy.start();

    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    encoder.setContext(loggerContext);
    encoder.setPattern("%d{HH:mm:ss.SSS} [%thread] %highlight(%-5level) %logger{36} - %msg%n");
    encoder.start();

    rfAppender.setEncoder(encoder);
    rfAppender.setName("ROLLINGFILE");
    rfAppender.setRollingPolicy(fwRollingPolicy);
    rfAppender.setTriggeringPolicy(triggeringPolicy);
    rfAppender.start();

    AsyncAppender asyncAppender = new AsyncAppender();
    asyncAppender.setContext(loggerContext);
    asyncAppender.setName("ASYNC");
    asyncAppender.setQueueSize(ASYNC_QUEUE_SIZE);
    asyncAppender.setMaxFlushTime(ASYNC_MAX_FLUSH_TIME);
    asyncAppender.addAppender(rfAppender);
    asyncAppender.start();

    rootLogger.addAppender(asyncAppender);
}