blob: 28a95654a1987b01e7d372369e7c4aeb9e2eba95 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
//
// 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/Foundation.h"
#include "Poco/LogFile.h"
#include "Poco/File.h"
#include "Poco/DateTimeFormatter.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) = 0;
/// Renames the given log file for archiving
/// and creates and returns a new log file.
/// The given LogFile object is deleted.
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);
};
template <class DT>
class ArchiveByTimestampStrategy: public ArchiveStrategy
/// A timestamp (YYYYMMDDhhmmssiii) is appended to archived
/// log files.
{
public:
ArchiveByTimestampStrategy()
{
}
~ArchiveByTimestampStrategy()
{
}
LogFile* archive(LogFile* pFile)
/// 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 path = pFile->path();
delete pFile;
std::string archPath = path;
archPath.append(".");
DateTimeFormatter::append(archPath, DT().timestamp(), "%Y%m%d%H%M%S%i");
if (exists(archPath)) archiveByNumber(archPath);
else moveFile(path, archPath);
return new LogFile(path);
}
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.
{
int n = -1;
std::string path;
do
{
path = basePath;
path.append(".");
NumberFormatter::append(path, ++n);
}
while (exists(path));
while (n >= 0)
{
std::string oldPath = basePath;
if (n > 0)
{
oldPath.append(".");
NumberFormatter::append(oldPath, n - 1);
}
std::string newPath = basePath;
newPath.append(".");
NumberFormatter::append(newPath, n);
moveFile(oldPath, newPath);
--n;
}
}
};
} // namespace Poco
#endif // Foundation_ArchiveStrategy_INCLUDED
|
