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
}