path: root/src/main/cpp/timebasedrollingpolicy.cpp

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#if defined(_MSC_VER)
#pragma warning ( disable: 4231 4251 4275 4786 )
#endif

#ifdef LOG4CXX_MULTI_PROCESS
#include <libgen.h>
#endif

#include <log4cxx/logstring.h>
#include <log4cxx/rolling/timebasedrollingpolicy.h>
#include <log4cxx/pattern/filedatepatternconverter.h>
#include <log4cxx/helpers/date.h>
#include <log4cxx/rolling/filerenameaction.h>
#include <log4cxx/helpers/loglog.h>
#include <log4cxx/helpers/exception.h>
#include <log4cxx/rolling/gzcompressaction.h>
#include <log4cxx/rolling/zipcompressaction.h>
#include <log4cxx/rolling/rollingfileappenderskeleton.h>
#include<iostream>

#ifndef INT64_C
#define INT64_C(x) x ## LL
#endif

#include <apr_time.h>

using namespace log4cxx;
using namespace log4cxx::rolling;
using namespace log4cxx::helpers;
using namespace log4cxx::pattern;

IMPLEMENT_LOG4CXX_OBJECT(TimeBasedRollingPolicy)

#ifdef LOG4CXX_MULTI_PROCESS
#define MMAP_FILE_SUFFIX ".map"
#define LOCK_FILE_SUFFIX ".maplck"
#define MAX_FILE_LEN 2048

bool TimeBasedRollingPolicy::isMapFileEmpty(log4cxx::helpers::Pool& pool){
    apr_finfo_t finfo;
    apr_status_t st = apr_stat(&finfo, _mapFileName.c_str(), APR_FINFO_SIZE, pool.getAPRPool());
    if (st != APR_SUCCESS){
        LogLog::warn(LOG4CXX_STR("apr_stat failed."));
    }
    if (st == APR_SUCCESS && !finfo.size)
        return true;
    return false;
}

void TimeBasedRollingPolicy::initMMapFile(const LogString& lastFileName, log4cxx::helpers::Pool& pool){
    int iRet = 0;
    if (!_mmap){
        iRet = createMMapFile(std::string(_fileNamePattern), pool);
    }
    if (!iRet && isMapFileEmpty(pool)) {
        lockMMapFile(APR_FLOCK_EXCLUSIVE);
        memset(_mmap->mm, 0, MAX_FILE_LEN);
        memcpy(_mmap->mm, std::string(lastFileName).c_str(), std::string(lastFileName).size());
        unLockMMapFile();
    }
}

const std::string TimeBasedRollingPolicy::createFile(const std::string& fileName, const std::string& suffix, log4cxx::helpers::Pool& pool) {
   char szUid[MAX_FILE_LEN] = {'\0'};
   char szBaseName[MAX_FILE_LEN] = {'\0'};
   char szDirName[MAX_FILE_LEN] = {'\0'};
   memcpy(szDirName, fileName.c_str(), fileName.size() > MAX_FILE_LEN ? MAX_FILE_LEN : fileName.size());
   memcpy(szBaseName, fileName.c_str(), fileName.size() > MAX_FILE_LEN ? MAX_FILE_LEN : fileName.size());

   apr_uid_t uid;
   apr_gid_t groupid;
   apr_status_t stat = apr_uid_current(&uid, &groupid, pool.getAPRPool());
   if (stat == APR_SUCCESS){
       snprintf(szUid, MAX_FILE_LEN, "%u", uid);
   }
   return std::string(::dirname(szDirName)) + "/." + ::basename(szBaseName) + szUid + suffix;
}

int TimeBasedRollingPolicy::createMMapFile(const std::string& fileName, log4cxx::helpers::Pool& pool){
   _mapFileName = createFile(fileName, MMAP_FILE_SUFFIX, pool);

   apr_status_t stat = apr_file_open(&_file_map, _mapFileName.c_str(), APR_CREATE | APR_READ | APR_WRITE, APR_OS_DEFAULT, _mmapPool->getAPRPool());
   if (stat != APR_SUCCESS){
        std::string err(std::string("open mmap file failed. ") + std::string(strerror(errno)) + ". Check the privilege or try to remove " + _mapFileName + " if exist.");
        LogLog::warn(LOG4CXX_STR(err.c_str()));
        return -1;
   }

   if (isMapFileEmpty(pool)){
       stat = apr_file_trunc(_file_map, MAX_FILE_LEN + 1);
       if (stat != APR_SUCCESS){
           LogLog::warn(LOG4CXX_STR("apr_file_trunc failed."));
           apr_file_close(_file_map);
           return -1;
       }
   }

   stat = apr_mmap_create(&_mmap, _file_map, 0, MAX_FILE_LEN, APR_MMAP_WRITE | APR_MMAP_READ, _mmapPool->getAPRPool());
   if (stat != APR_SUCCESS){
       LogLog::warn(LOG4CXX_STR("mmap failed."));
       apr_file_close(_file_map);
       return -1;
   }

   return 0;
}

int TimeBasedRollingPolicy::lockMMapFile(int type)
{
    apr_status_t stat = apr_file_lock(_lock_file, type);
    if (stat != APR_SUCCESS) {
        LogLog::warn(LOG4CXX_STR("apr_file_lock for mmap failed."));
    }
}
int TimeBasedRollingPolicy::unLockMMapFile()
{
    apr_status_t stat = apr_file_unlock(_lock_file);
    if (stat != APR_SUCCESS) {
        LogLog::warn(LOG4CXX_STR("apr_file_unlock for mmap failed."));
    }
}

#endif

TimeBasedRollingPolicy::TimeBasedRollingPolicy()
#ifdef LOG4CXX_MULTI_PROCESS
    :_mmap(NULL), _file_map(NULL), bAlreadyInitialized(false), _mmapPool(new Pool()), _lock_file(NULL), bRefreshCurFile(false)
#endif
{
}

#ifdef LOG4CXX_MULTI_PROCESS
TimeBasedRollingPolicy::~TimeBasedRollingPolicy() {
    //no-need to delete mmap
    delete _mmapPool;
}
#endif

void TimeBasedRollingPolicy::addRef() const {
    TriggeringPolicy::addRef();
}

void TimeBasedRollingPolicy::releaseRef() const {
    TriggeringPolicy::releaseRef();
}

void TimeBasedRollingPolicy::activateOptions(log4cxx::helpers::Pool& pool) {
    // find out period from the filename pattern
    if (getFileNamePattern().length() > 0) {
      parseFileNamePattern();
    } else {
      LogLog::warn(
         LOG4CXX_STR("The FileNamePattern option must be set before using TimeBasedRollingPolicy. "));
      throw IllegalStateException();
    }

    PatternConverterPtr dtc(getDatePatternConverter());

    if (dtc == NULL) {
      throw IllegalStateException();
    }

    apr_time_t n = apr_time_now();
    LogString buf;
    ObjectPtr obj(new Date(n));
    formatFileName(obj, buf, pool);
    lastFileName = buf;

#ifdef LOG4CXX_MULTI_PROCESS
    if (getPatternConverterList().size()){
        (*(getPatternConverterList().begin()))->format(obj, _fileNamePattern, pool);
    }else{
        _fileNamePattern = lastFileName;
    }

    if (!_lock_file) {
        const std::string lockname = createFile(std::string(_fileNamePattern), LOCK_FILE_SUFFIX, *_mmapPool);
        apr_status_t stat = apr_file_open(&_lock_file, lockname.c_str(), APR_CREATE | APR_READ | APR_WRITE, APR_OS_DEFAULT, (*_mmapPool).getAPRPool());
        if (stat != APR_SUCCESS) {
            LogLog::warn(LOG4CXX_STR("open lock file failed."));
        }
    }

    initMMapFile(lastFileName, *_mmapPool);
#endif

    suffixLength = 0;

    if (lastFileName.length() >= 3) {
      if (lastFileName.compare(lastFileName.length() - 3, 3, LOG4CXX_STR(".gz")) == 0) {
        suffixLength = 3;
      } else if (lastFileName.length() >= 4 && lastFileName.compare(lastFileName.length() - 4, 4, LOG4CXX_STR(".zip")) == 0) {
        suffixLength = 4;
      }
    }
}


#define RULES_PUT(spec, cls) \
specs.insert(PatternMap::value_type(LogString(LOG4CXX_STR(spec)), (PatternConstructor) cls ::newInstance))

log4cxx::pattern::PatternMap TimeBasedRollingPolicy::getFormatSpecifiers() const {
  PatternMap specs;
  RULES_PUT("d", FileDatePatternConverter);
  RULES_PUT("date", FileDatePatternConverter);
  return specs;
}

/**
 * {@inheritDoc}
 */
RolloverDescriptionPtr TimeBasedRollingPolicy::initialize(
	const	LogString&	currentActiveFile,
	const	bool		append,
			Pool&		pool)
{
  apr_time_t n = apr_time_now();
  nextCheck = ((n / APR_USEC_PER_SEC) + 1) * APR_USEC_PER_SEC;

  File currentFile(currentActiveFile);

  LogString buf;
  ObjectPtr obj(new Date(currentFile.exists(pool) ? currentFile.lastModified(pool) : n));
  formatFileName(obj, buf, pool);
  lastFileName = buf;

  ActionPtr noAction;

  if (currentActiveFile.length() > 0) {
    return new RolloverDescription(
      currentActiveFile, append, noAction, noAction);
  } else {
      bRefreshCurFile = true;
    return new RolloverDescription(
      lastFileName.substr(0, lastFileName.length() - suffixLength), append,
      noAction, noAction);
  }
}

RolloverDescriptionPtr TimeBasedRollingPolicy::rollover(
	const	LogString&	currentActiveFile,
	const	bool		append,
			Pool&		pool)
{
  apr_time_t n = apr_time_now();
  nextCheck = ((n / APR_USEC_PER_SEC) + 1) * APR_USEC_PER_SEC;

  LogString buf;
  ObjectPtr obj(new Date(n));
  formatFileName(obj, buf, pool);

  LogString newFileName(buf);

#ifdef LOG4CXX_MULTI_PROCESS
  bAlreadyInitialized = true;
  if (_mmap && !isMapFileEmpty(*_mmapPool)){
      lockMMapFile(APR_FLOCK_SHARED);
      LogString mapLastFile((char *)_mmap->mm);
      lastFileName = mapLastFile;
      unLockMMapFile();
  }else{
      _mmap = NULL;
      initMMapFile(lastFileName, *_mmapPool);
  }
#endif

  //
  //  if file names haven't changed, no rollover
  //
  if (newFileName == lastFileName) {
    RolloverDescriptionPtr desc;
    return desc;
  }

  ActionPtr renameAction;
  ActionPtr compressAction;
  LogString lastBaseName(
    lastFileName.substr(0, lastFileName.length() - suffixLength));
  LogString nextActiveFile(
    newFileName.substr(0, newFileName.length() - suffixLength));

  //
  //   if currentActiveFile is not lastBaseName then
  //        active file name is not following file pattern
  //        and requires a rename plus maintaining the same name
  if (currentActiveFile != lastBaseName) {
    renameAction =
      new FileRenameAction(
        File().setPath(currentActiveFile), File().setPath(lastBaseName), true);
    nextActiveFile = currentActiveFile;
  }

  if (suffixLength == 3) {
    compressAction =
      new GZCompressAction(
        File().setPath(lastBaseName), File().setPath(lastFileName), true);
  }

  if (suffixLength == 4) {
    compressAction =
      new ZipCompressAction(
        File().setPath(lastBaseName), File().setPath(lastFileName), true);
  }

#ifdef LOG4CXX_MULTI_PROCESS
  if (_mmap && !isMapFileEmpty(*_mmapPool)){
      lockMMapFile(APR_FLOCK_EXCLUSIVE);
      memset(_mmap->mm, 0, MAX_FILE_LEN);
      memcpy(_mmap->mm, std::string(newFileName).c_str(), std::string(newFileName).size());
      unLockMMapFile();
  }else{
      _mmap = NULL;
      initMMapFile(newFileName, *_mmapPool);
  }
#else
  lastFileName = newFileName;
#endif

  return new RolloverDescription(nextActiveFile, append, renameAction, compressAction);
}

bool TimeBasedRollingPolicy::isTriggeringEvent(
  Appender* appender,
  const log4cxx::spi::LoggingEventPtr& /* event */,
  const LogString&  filename ,
  size_t /* fileLength */)  {
#ifdef LOG4CXX_MULTI_PROCESS
    if (bRefreshCurFile && _mmap && !isMapFileEmpty(*_mmapPool)) {
        lockMMapFile(APR_FLOCK_SHARED);
        LogString mapCurrent((char *)_mmap->mm);
        unLockMMapFile();
        LogString mapCurrentBase(mapCurrent.substr(0, mapCurrent.length() - suffixLength));
        if (!mapCurrentBase.empty() && mapCurrentBase != filename) {
            dynamic_cast<FileAppender *>(appender)->setFile(mapCurrentBase);
        }
    }
    return ((apr_time_now()) > nextCheck) || (!bAlreadyInitialized);
#else
    return apr_time_now() > nextCheck;
#endif
}