ClickHouse/base/poco/Foundation/include/Poco/ArchiveStrategy.h

172 lines
4.2 KiB
C++

//
// ArchiveStrategy.h
//
// Library: Foundation
// Package: Logging
// Module: FileChannel
//
// Definition of the ArchiveStrategy class and subclasses.
//
// Copyright (c) 2004-2008, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_ArchiveStrategy_INCLUDED
#define Foundation_ArchiveStrategy_INCLUDED
#include "Poco/CompressedLogFile.h"
#include "Poco/DateTimeFormatter.h"
#include "Poco/File.h"
#include "Poco/Foundation.h"
#include "Poco/LogFile.h"
#include "Poco/NumberFormatter.h"
namespace Poco
{
class ArchiveCompressor;
class Foundation_API ArchiveStrategy
/// The ArchiveStrategy is used by FileChannel
/// to rename a rotated log file for archiving.
///
/// Archived files can be automatically compressed,
/// using the gzip file format.
{
public:
ArchiveStrategy();
virtual ~ArchiveStrategy();
virtual LogFile * archive(LogFile * pFile, bool streamCompress = false) = 0;
/// Renames the given log file for archiving
/// and creates and returns a new log file.
/// The given LogFile object is deleted.
/// Returns CompressedLogFile if streamCompress flag is set.
void compress(bool flag = true);
/// Enables or disables compression of archived files.
protected:
void moveFile(const std::string & oldName, const std::string & newName);
bool exists(const std::string & name);
private:
ArchiveStrategy(const ArchiveStrategy &);
ArchiveStrategy & operator=(const ArchiveStrategy &);
bool _compress;
ArchiveCompressor * _pCompressor;
};
class Foundation_API ArchiveByNumberStrategy : public ArchiveStrategy
/// A monotonic increasing number is appended to the
/// log file name. The most recent archived file
/// always has the number zero.
{
public:
ArchiveByNumberStrategy();
~ArchiveByNumberStrategy();
LogFile * archive(LogFile * pFile, bool streamCompress = false);
};
template <class DT>
class ArchiveByTimestampStrategy : public ArchiveStrategy
/// A timestamp (YYYYMMDDhhmmssiii) is appended to archived
/// log files.
{
public:
ArchiveByTimestampStrategy() { }
~ArchiveByTimestampStrategy() { }
LogFile * archive(LogFile * pFile, bool streamCompress = false)
/// Archives the file by appending the current timestamp to the
/// file name. If the new file name exists, additionally a monotonic
/// increasing number is appended to the log file name.
{
std::string base = pFile->path();
std::string ext = "";
if (base.ends_with(".lz4"))
{
base.resize(base.size() - 4);
ext = ".lz4";
}
delete pFile;
std::string archPath = base;
archPath.append(".");
DateTimeFormatter::append(archPath, DT().timestamp(), "%Y%m%d%H%M%S%i");
archPath.append(ext);
if (exists(archPath))
archiveByNumber(archPath);
else
moveFile(base + ext, archPath);
if (streamCompress)
return new CompressedLogFile(base);
else
return new LogFile(base);
}
private:
void archiveByNumber(const std::string & basePath)
/// A monotonic increasing number is appended to the
/// log file name. The most recent archived file
/// always has the number zero.
{
std::string base = basePath;
std::string ext = "";
if (base.ends_with(".lz4"))
{
base.resize(base.size() - 4);
ext = ".lz4";
}
int n = -1;
std::string path;
do
{
path = base;
path.append(".");
NumberFormatter::append(path, ++n);
path.append(ext);
} while (exists(path));
while (n >= 0)
{
std::string oldPath = base;
if (n > 0)
{
oldPath.append(".");
NumberFormatter::append(oldPath, n - 1);
}
oldPath.append(ext);
std::string newPath = base;
newPath.append(".");
NumberFormatter::append(newPath, n);
newPath.append(ext);
moveFile(oldPath, newPath);
--n;
}
}
};
} // namespace Poco
#endif // Foundation_ArchiveStrategy_INCLUDED