tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 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 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "rtc_base/filerotatingstream.h" |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 12 | |
| 13 | #include <algorithm> |
| 14 | #include <iostream> |
| 15 | #include <string> |
| 16 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 17 | #include "rtc_base/checks.h" |
| 18 | #include "rtc_base/fileutils.h" |
| 19 | #include "rtc_base/pathutils.h" |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 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 | |
| 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 | |
| 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) { |
kwiberg | af476c7 | 2016-11-28 15:21:39 -0800 | [diff] [blame] | 40 | RTC_DCHECK_GT(max_file_size, 0); |
| 41 | RTC_DCHECK_GT(num_files, 1); |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 42 | } |
| 43 | |
| 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) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 58 | RTC_DCHECK(Filesystem::IsFolder(dir_path)); |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 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 | |
| 80 | FileRotatingStream::~FileRotatingStream() { |
| 81 | } |
| 82 | |
| 83 | 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 | |
| 93 | StreamResult FileRotatingStream::Read(void* buffer, |
| 94 | size_t buffer_len, |
| 95 | size_t* read, |
| 96 | int* error) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 97 | RTC_DCHECK(buffer); |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 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 | |
| 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. |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 155 | RTC_DCHECK_LT(current_bytes_written_, max_file_size_); |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 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_) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 167 | RTC_DCHECK_EQ(current_bytes_written_, max_file_size_); |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 168 | RotateFiles(); |
| 169 | } |
| 170 | return result; |
| 171 | } |
| 172 | |
| 173 | bool FileRotatingStream::Flush() { |
| 174 | if (!file_stream_) { |
| 175 | return false; |
| 176 | } |
| 177 | return file_stream_->Flush(); |
| 178 | } |
| 179 | |
tkchin | 28bae02 | 2015-07-23 12:27:02 -0700 | [diff] [blame] | 180 | 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 | } |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 186 | RTC_DCHECK(size); |
tkchin | 28bae02 | 2015-07-23 12:27:02 -0700 | [diff] [blame] | 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 | |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 200 | void FileRotatingStream::Close() { |
| 201 | CloseCurrentFile(); |
| 202 | } |
| 203 | |
| 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 | |
| 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 | |
| 234 | std::string FileRotatingStream::GetFilePath(size_t index) const { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 235 | RTC_DCHECK_LT(index, file_names_.size()); |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 236 | return file_names_[index]; |
| 237 | } |
| 238 | |
| 239 | bool FileRotatingStream::OpenCurrentFile() { |
| 240 | CloseCurrentFile(); |
| 241 | |
| 242 | // Opens the appropriate file in the appropriate mode. |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 243 | RTC_DCHECK_LT(current_file_index_, file_names_.size()); |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 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. |
kwiberg | af476c7 | 2016-11-28 15:21:39 -0800 | [diff] [blame] | 251 | RTC_DCHECK_EQ(current_file_index_, 0); |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 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 | |
| 270 | void FileRotatingStream::CloseCurrentFile() { |
| 271 | if (!file_stream_) { |
| 272 | return; |
| 273 | } |
| 274 | current_bytes_written_ = 0; |
| 275 | file_stream_.reset(); |
| 276 | } |
| 277 | |
| 278 | void FileRotatingStream::RotateFiles() { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 279 | RTC_DCHECK_EQ(mode_, kWrite); |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 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. |
haysc | d02b0fa | 2015-12-08 13:59:05 -0800 | [diff] [blame] | 284 | RTC_DCHECK_LT(rotation_index_, file_names_.size()); |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 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 | |
| 306 | 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 | |
| 326 | std::string FileRotatingStream::GetFilePath(size_t index, |
| 327 | size_t num_files) const { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 328 | RTC_DCHECK_LT(index, num_files); |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 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; |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 334 | RTC_DCHECK_LE(num_digits, max_digits); |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 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 | |
| 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 | |
| 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) { |
kwiberg | af476c7 | 2016-11-28 15:21:39 -0800 | [diff] [blame] | 363 | RTC_DCHECK_GE(max_total_log_size, 4); |
tkchin | 9341191 | 2015-07-22 12:12:17 -0700 | [diff] [blame] | 364 | } |
| 365 | |
| 366 | const char* CallSessionFileRotatingStream::kLogPrefix = "webrtc_log"; |
| 367 | const size_t CallSessionFileRotatingStream::kRotatingLogFileDefaultSize = |
| 368 | 1024 * 1024; |
| 369 | |
| 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 | |
| 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 | |
| 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 |