1 /*
2 * Copyright 2015 The WebRTC Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "webrtc/base/filerotatingstream.h"
12
13 #include <algorithm>
14 #include <iostream>
15 #include <string>
16
17 #include "webrtc/base/checks.h"
18 #include "webrtc/base/fileutils.h"
19 #include "webrtc/base/pathutils.h"
20
21 // Note: We use std::cerr for logging in the write paths of this stream to avoid
22 // infinite loops when logging.
23
24 namespace rtc {
25
FileRotatingStream(const std::string & dir_path,const std::string & file_prefix)26 FileRotatingStream::FileRotatingStream(const std::string& dir_path,
27 const std::string& file_prefix)
28 : FileRotatingStream(dir_path, file_prefix, 0, 0, kRead) {
29 }
30
FileRotatingStream(const std::string & dir_path,const std::string & file_prefix,size_t max_file_size,size_t num_files)31 FileRotatingStream::FileRotatingStream(const std::string& dir_path,
32 const std::string& file_prefix,
33 size_t max_file_size,
34 size_t num_files)
35 : FileRotatingStream(dir_path,
36 file_prefix,
37 max_file_size,
38 num_files,
39 kWrite) {
40 RTC_DCHECK_GT(max_file_size, 0u);
41 RTC_DCHECK_GT(num_files, 1u);
42 }
43
FileRotatingStream(const std::string & dir_path,const std::string & file_prefix,size_t max_file_size,size_t num_files,Mode mode)44 FileRotatingStream::FileRotatingStream(const std::string& dir_path,
45 const std::string& file_prefix,
46 size_t max_file_size,
47 size_t num_files,
48 Mode mode)
49 : dir_path_(dir_path),
50 file_prefix_(file_prefix),
51 mode_(mode),
52 file_stream_(nullptr),
53 max_file_size_(max_file_size),
54 current_file_index_(0),
55 rotation_index_(0),
56 current_bytes_written_(0),
57 disable_buffering_(false) {
58 RTC_DCHECK(Filesystem::IsFolder(dir_path));
59 switch (mode) {
60 case kWrite: {
61 file_names_.clear();
62 for (size_t i = 0; i < num_files; ++i) {
63 file_names_.push_back(GetFilePath(i, num_files));
64 }
65 rotation_index_ = num_files - 1;
66 break;
67 }
68 case kRead: {
69 file_names_ = GetFilesWithPrefix();
70 std::sort(file_names_.begin(), file_names_.end());
71 if (file_names_.size() > 0) {
72 // |file_names_| is sorted newest first, so read from the end.
73 current_file_index_ = file_names_.size() - 1;
74 }
75 break;
76 }
77 }
78 }
79
~FileRotatingStream()80 FileRotatingStream::~FileRotatingStream() {
81 }
82
GetState() const83 StreamState FileRotatingStream::GetState() const {
84 if (mode_ == kRead && current_file_index_ < file_names_.size()) {
85 return SS_OPEN;
86 }
87 if (!file_stream_) {
88 return SS_CLOSED;
89 }
90 return file_stream_->GetState();
91 }
92
Read(void * buffer,size_t buffer_len,size_t * read,int * error)93 StreamResult FileRotatingStream::Read(void* buffer,
94 size_t buffer_len,
95 size_t* read,
96 int* error) {
97 RTC_DCHECK(buffer);
98 if (mode_ != kRead) {
99 return SR_EOS;
100 }
101 if (current_file_index_ >= file_names_.size()) {
102 return SR_EOS;
103 }
104 // We will have no file stream initially, and when we are finished with the
105 // previous file.
106 if (!file_stream_) {
107 if (!OpenCurrentFile()) {
108 return SR_ERROR;
109 }
110 }
111 int local_error = 0;
112 if (!error) {
113 error = &local_error;
114 }
115 StreamResult result = file_stream_->Read(buffer, buffer_len, read, error);
116 if (result == SR_EOS || result == SR_ERROR) {
117 if (result == SR_ERROR) {
118 LOG(LS_ERROR) << "Failed to read from: "
119 << file_names_[current_file_index_] << "Error: " << error;
120 }
121 // Reached the end of the file, read next file. If there is an error return
122 // the error status but allow for a next read by reading next file.
123 CloseCurrentFile();
124 if (current_file_index_ == 0) {
125 // Just finished reading the last file, signal EOS by setting index.
126 current_file_index_ = file_names_.size();
127 } else {
128 --current_file_index_;
129 }
130 if (read) {
131 *read = 0;
132 }
133 return result == SR_EOS ? SR_SUCCESS : result;
134 } else if (result == SR_SUCCESS) {
135 // Succeeded, continue reading from this file.
136 return SR_SUCCESS;
137 } else {
138 RTC_NOTREACHED();
139 }
140 return result;
141 }
142
Write(const void * data,size_t data_len,size_t * written,int * error)143 StreamResult FileRotatingStream::Write(const void* data,
144 size_t data_len,
145 size_t* written,
146 int* error) {
147 if (mode_ != kWrite) {
148 return SR_EOS;
149 }
150 if (!file_stream_) {
151 std::cerr << "Open() must be called before Write." << std::endl;
152 return SR_ERROR;
153 }
154 // Write as much as will fit in to the current file.
155 RTC_DCHECK_LT(current_bytes_written_, max_file_size_);
156 size_t remaining_bytes = max_file_size_ - current_bytes_written_;
157 size_t write_length = std::min(data_len, remaining_bytes);
158 size_t local_written = 0;
159 if (!written) {
160 written = &local_written;
161 }
162 StreamResult result = file_stream_->Write(data, write_length, written, error);
163 current_bytes_written_ += *written;
164
165 // If we're done with this file, rotate it out.
166 if (current_bytes_written_ >= max_file_size_) {
167 RTC_DCHECK_EQ(current_bytes_written_, max_file_size_);
168 RotateFiles();
169 }
170 return result;
171 }
172
Flush()173 bool FileRotatingStream::Flush() {
174 if (!file_stream_) {
175 return false;
176 }
177 return file_stream_->Flush();
178 }
179
GetSize(size_t * size) const180 bool FileRotatingStream::GetSize(size_t* size) const {
181 if (mode_ != kRead) {
182 // Not possible to get accurate size on disk when writing because of
183 // potential buffering.
184 return false;
185 }
186 RTC_DCHECK(size);
187 *size = 0;
188 size_t total_size = 0;
189 for (auto file_name : file_names_) {
190 Pathname pathname(file_name);
191 size_t file_size = 0;
192 if (Filesystem::GetFileSize(file_name, &file_size)) {
193 total_size += file_size;
194 }
195 }
196 *size = total_size;
197 return true;
198 }
199
Close()200 void FileRotatingStream::Close() {
201 CloseCurrentFile();
202 }
203
Open()204 bool FileRotatingStream::Open() {
205 switch (mode_) {
206 case kRead:
207 // Defer opening to when we first read since we want to return read error
208 // if we fail to open next file.
209 return true;
210 case kWrite: {
211 // Delete existing files when opening for write.
212 std::vector<std::string> matching_files = GetFilesWithPrefix();
213 for (auto matching_file : matching_files) {
214 if (!Filesystem::DeleteFile(matching_file)) {
215 std::cerr << "Failed to delete: " << matching_file << std::endl;
216 }
217 }
218 return OpenCurrentFile();
219 }
220 }
221 return false;
222 }
223
DisableBuffering()224 bool FileRotatingStream::DisableBuffering() {
225 disable_buffering_ = true;
226 if (!file_stream_) {
227 std::cerr << "Open() must be called before DisableBuffering()."
228 << std::endl;
229 return false;
230 }
231 return file_stream_->DisableBuffering();
232 }
233
GetFilePath(size_t index) const234 std::string FileRotatingStream::GetFilePath(size_t index) const {
235 RTC_DCHECK_LT(index, file_names_.size());
236 return file_names_[index];
237 }
238
OpenCurrentFile()239 bool FileRotatingStream::OpenCurrentFile() {
240 CloseCurrentFile();
241
242 // Opens the appropriate file in the appropriate mode.
243 RTC_DCHECK_LT(current_file_index_, file_names_.size());
244 std::string file_path = file_names_[current_file_index_];
245 file_stream_.reset(new FileStream());
246 const char* mode = nullptr;
247 switch (mode_) {
248 case kWrite:
249 mode = "w+";
250 // We should always we writing to the zero-th file.
251 RTC_DCHECK_EQ(current_file_index_, 0u);
252 break;
253 case kRead:
254 mode = "r";
255 break;
256 }
257 int error = 0;
258 if (!file_stream_->Open(file_path, mode, &error)) {
259 std::cerr << "Failed to open: " << file_path << "Error: " << error
260 << std::endl;
261 file_stream_.reset();
262 return false;
263 }
264 if (disable_buffering_) {
265 file_stream_->DisableBuffering();
266 }
267 return true;
268 }
269
CloseCurrentFile()270 void FileRotatingStream::CloseCurrentFile() {
271 if (!file_stream_) {
272 return;
273 }
274 current_bytes_written_ = 0;
275 file_stream_.reset();
276 }
277
RotateFiles()278 void FileRotatingStream::RotateFiles() {
279 RTC_DCHECK_EQ(mode_, kWrite);
280 CloseCurrentFile();
281 // Rotates the files by deleting the file at |rotation_index_|, which is the
282 // oldest file and then renaming the newer files to have an incremented index.
283 // See header file comments for example.
284 RTC_DCHECK_LT(rotation_index_, file_names_.size());
285 std::string file_to_delete = file_names_[rotation_index_];
286 if (Filesystem::IsFile(file_to_delete)) {
287 if (!Filesystem::DeleteFile(file_to_delete)) {
288 std::cerr << "Failed to delete: " << file_to_delete << std::endl;
289 }
290 }
291 for (auto i = rotation_index_; i > 0; --i) {
292 std::string rotated_name = file_names_[i];
293 std::string unrotated_name = file_names_[i - 1];
294 if (Filesystem::IsFile(unrotated_name)) {
295 if (!Filesystem::MoveFile(unrotated_name, rotated_name)) {
296 std::cerr << "Failed to move: " << unrotated_name << " to "
297 << rotated_name << std::endl;
298 }
299 }
300 }
301 // Create a new file for 0th index.
302 OpenCurrentFile();
303 OnRotation();
304 }
305
GetFilesWithPrefix() const306 std::vector<std::string> FileRotatingStream::GetFilesWithPrefix() const {
307 std::vector<std::string> files;
308 // Iterate over the files in the directory.
309 DirectoryIterator it;
310 Pathname dir_path;
311 dir_path.SetFolder(dir_path_);
312 if (!it.Iterate(dir_path)) {
313 return files;
314 }
315 do {
316 std::string current_name = it.Name();
317 if (current_name.size() && !it.IsDirectory() &&
318 current_name.compare(0, file_prefix_.size(), file_prefix_) == 0) {
319 Pathname path(dir_path_, current_name);
320 files.push_back(path.pathname());
321 }
322 } while (it.Next());
323 return files;
324 }
325
GetFilePath(size_t index,size_t num_files) const326 std::string FileRotatingStream::GetFilePath(size_t index,
327 size_t num_files) const {
328 RTC_DCHECK_LT(index, num_files);
329 std::ostringstream file_name;
330 // The format will be "_%<num_digits>zu". We want to zero pad the index so
331 // that it will sort nicely.
332 size_t max_digits = ((num_files - 1) / 10) + 1;
333 size_t num_digits = (index / 10) + 1;
334 RTC_DCHECK_LE(num_digits, max_digits);
335 size_t padding = max_digits - num_digits;
336
337 file_name << file_prefix_ << "_";
338 for (size_t i = 0; i < padding; ++i) {
339 file_name << "0";
340 }
341 file_name << index;
342
343 Pathname file_path(dir_path_, file_name.str());
344 return file_path.pathname();
345 }
346
CallSessionFileRotatingStream(const std::string & dir_path)347 CallSessionFileRotatingStream::CallSessionFileRotatingStream(
348 const std::string& dir_path)
349 : FileRotatingStream(dir_path, kLogPrefix),
350 max_total_log_size_(0),
351 num_rotations_(0) {
352 }
353
CallSessionFileRotatingStream(const std::string & dir_path,size_t max_total_log_size)354 CallSessionFileRotatingStream::CallSessionFileRotatingStream(
355 const std::string& dir_path,
356 size_t max_total_log_size)
357 : FileRotatingStream(dir_path,
358 kLogPrefix,
359 max_total_log_size / 2,
360 GetNumRotatingLogFiles(max_total_log_size) + 1),
361 max_total_log_size_(max_total_log_size),
362 num_rotations_(0) {
363 RTC_DCHECK_GE(max_total_log_size, 4u);
364 }
365
366 const char* CallSessionFileRotatingStream::kLogPrefix = "webrtc_log";
367 const size_t CallSessionFileRotatingStream::kRotatingLogFileDefaultSize =
368 1024 * 1024;
369
OnRotation()370 void CallSessionFileRotatingStream::OnRotation() {
371 ++num_rotations_;
372 if (num_rotations_ == 1) {
373 // On the first rotation adjust the max file size so subsequent files after
374 // the first are smaller.
375 SetMaxFileSize(GetRotatingLogSize(max_total_log_size_));
376 } else if (num_rotations_ == (GetNumFiles() - 1)) {
377 // On the next rotation the very first file is going to be deleted. Change
378 // the rotation index so this doesn't happen.
379 SetRotationIndex(GetRotationIndex() - 1);
380 }
381 }
382
GetRotatingLogSize(size_t max_total_log_size)383 size_t CallSessionFileRotatingStream::GetRotatingLogSize(
384 size_t max_total_log_size) {
385 size_t num_rotating_log_files = GetNumRotatingLogFiles(max_total_log_size);
386 size_t rotating_log_size = num_rotating_log_files > 2
387 ? kRotatingLogFileDefaultSize
388 : max_total_log_size / 4;
389 return rotating_log_size;
390 }
391
GetNumRotatingLogFiles(size_t max_total_log_size)392 size_t CallSessionFileRotatingStream::GetNumRotatingLogFiles(
393 size_t max_total_log_size) {
394 // At minimum have two rotating files. Otherwise split the available log size
395 // evenly across 1MB files.
396 return std::max((size_t)2,
397 (max_total_log_size / 2) / kRotatingLogFileDefaultSize);
398 }
399
400 } // namespace rtc
401