Merge Upstream

.github/workflows/rust.yml

@@ -0,0 +1,30 @@
+name: Rust
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Check
+      run: cargo check
+  test:
+    runs-on: '${{ matrix.os }}'
+    strategy:
+      matrix:
+        include:
+          - os: macos-latest
+          - os: ubuntu-latest
+          - os: windows-latest  
+    steps:
+    - uses: actions/checkout@v3
+    - name: Test
+      run: cargo test

.gitignore

@@ -1,2 +1,3 @@
 Cargo.lock
+logs/
 target/

Cargo.toml

@@ -1,14 +1,20 @@
 [package]
 name = "file-rotate"
-version = "0.2.0"
-authors = ["Kevin Robert Stravers <macocio@gmail.com>"]
+version = "0.8.0"
+authors = ["Kevin Robert Stravers <[email protected]>", "Erlend Langseth <3rlendhl@gmail.com>"]
 edition = "2018"
 description = "Log rotation for files"
-homepage = "https://github.com/BourgondAries/file-rotate"
-repository = "https://github.com/BourgondAries/file-rotate"
+homepage = "https://github.com/kstrafe/file-rotate"
+repository = "https://github.com/kstrafe/file-rotate"
 keywords= ["log", "rotate", "logrotate"]
-license = "LGPL-3.0-or-later"
+license = "MIT"
+
+[dependencies]
+chrono = { version = "0.4.20", default-features = false, features = ["clock"] }
+flate2 = "1.0"
 
 [dev-dependencies]
-quickcheck = "0.9"
-quickcheck_macros = "0.9"
+filetime = "0.2"
+quickcheck = "0.9.2"
+quickcheck_macros = "0.9.1"
+tempfile = "3"

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 BourgondAries
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,98 @@
+# file-rotate
+
+Rotate files with configurable suffix.
+
+Look to the [docs](https://docs.rs/file-rotate/latest/file_rotate/index.html) for explanatory examples of all features, like:
+* Using count or timestamp as suffix
+* Age-based deletion of log files
+* Optional compression
+* Getting a list of log files
+
+Limitations / known issues:
+* `file-rotate` assumes that no other process or user moves files around in the logging directory, but we want to find a way to [support this](https://github.com/BourgondAries/file-rotate/issues/17)
+
+Following are some supplementary examples to get started.
+
+## Basic example
+
+```rust
+use file_rotate::{FileRotate, ContentLimit, compression::Compression, suffix::AppendCount};
+use std::{fs, io::Write, path::PathBuf};
+
+fn main() {
+    let mut log = FileRotate::new("logs/log", AppendCount::new(2), ContentLimit::Lines(3), Compression::None, None);
+
+    // Write a bunch of lines
+    writeln!(log, "Line 1: Hello World!");
+    for idx in 2..=10 {
+        writeln!(log, "Line {}", idx);
+    }
+}
+```
+
+```
+$ ls logs
+log  log.1  log.2
+
+$ cat log.2 log.1 log
+Line 4
+Line 5
+Line 6
+Line 7
+Line 8
+Line 9
+Line 10
+```
+
+## Example with timestamp suffixes
+
+```rust
+let mut log = FileRotate::new(
+    "logs/log",
+    AppendTimestamp::default(FileLimit::MaxFiles(3)),
+    ContentLimit::Lines(3),
+    Compression::None,
+    None,
+);
+
+// Write a bunch of lines
+writeln!(log, "Line 1: Hello World!");
+for idx in 2..=10 {
+    std::thread::sleep(std::time::Duration::from_millis(200));
+    writeln!(log, "Line {}", idx);
+}
+```
+
+```
+$ ls logs
+log                  log.20210825T151133.1
+log.20210825T151133  log.20210825T151134
+
+$ cat logs/*
+Line 10
+Line 1: Hello World!
+Line 2
+Line 3
+Line 4
+Line 5
+Line 6
+Line 7
+Line 8
+Line 9
+```
+
+The timestamp format (including the extra trailing `.N`) works by default so that the lexical ordering of filenames equals the chronological ordering.
+So it almost works perfectly with `cat logs/*`, except that `log` is smaller (lexically "older") than all the rest. This can of course be fixed with a more complex script to assemble the logs.
+
+
+## License
+
+This project is licensed under the [MIT license].
+
+[MIT license]: https://github.com/BourgondAries/file-rotate/blob/master/LICENSE
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in file-rotate by you, shall be licensed as MIT, without any additional
+terms or conditions.

examples/rotate_by_date.rs

@@ -0,0 +1,23 @@
+use file_rotate::{
+    compression::Compression,
+    suffix::{AppendTimestamp, DateFrom, FileLimit},
+    ContentLimit, FileRotate, TimeFrequency,
+};
+use std::io::Write;
+
+fn main() {
+    let mut log = FileRotate::new(
+        "logs/log",
+        AppendTimestamp::with_format("%Y-%m-%d", FileLimit::MaxFiles(7), DateFrom::DateYesterday),
+        ContentLimit::Time(TimeFrequency::Daily),
+        Compression::None,
+        None,
+    );
+
+    // Write a bunch of lines
+    writeln!(log, "Line 1: Hello World!").expect("write log");
+    for idx in 2..=10 {
+        std::thread::sleep(std::time::Duration::from_millis(500));
+        writeln!(log, "Line {}", idx).expect("write log");
+    }
+}

src/compression.rs

@@ -0,0 +1,37 @@
+//! Compression - configuration and implementation
+use flate2::write::GzEncoder;
+use std::{
+    fs::{self, File, OpenOptions},
+    io,
+    path::{Path, PathBuf},
+};
+
+/// Compression mode - when to compress files.
+#[derive(Debug, Clone)]
+pub enum Compression {
+    /// No compression
+    None,
+    /// Look for files to compress when rotating.
+    /// First argument: How many files to keep uncompressed (excluding the original file)
+    OnRotate(usize),
+}
+
+pub(crate) fn compress(path: &Path) -> io::Result<()> {
+    let dest_path = PathBuf::from(format!("{}.gz", path.display()));
+
+    let mut src_file = File::open(path)?;
+    let dest_file = OpenOptions::new()
+        .write(true)
+        .create(true)
+        .append(false)
+        .open(&dest_path)?;
+
+    assert!(path.exists());
+    assert!(dest_path.exists());
+    let mut encoder = GzEncoder::new(dest_file, flate2::Compression::default());
+    io::copy(&mut src_file, &mut encoder)?;
+
+    fs::remove_file(path)?;
+
+    Ok(())
+}