github.com/searKing/golang/go@v1.2.117/os/file_rotate.go

// Copyright 2021 The searKing Author. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package os

import (
	"errors"
	"fmt"
	"io"
	"os"
	"regexp"
	"sort"
	"strings"
	"sync"
	"time"

	filepath_ "github.com/searKing/golang/go/path/filepath"
	"github.com/searKing/golang/go/sync/atomic"
	time_ "github.com/searKing/golang/go/time"
)

// RotateMode represents a way to rotate file.
// see details: https://man7.org/linux/man-pages/man8/logrotate.8.html
type RotateMode int

const (
	// RotateModeNew create new rotate file directly
	// Immediately after rotation (before the postrotate script is run) the log file is created (with
	// the same name as the log file just rotated).
	// see option: `create` in https://man7.org/linux/man-pages/man8/logrotate.8.html
	RotateModeNew RotateMode = iota

	// RotateModeCopyRename Make a copy of the log file, but don't change the original at all. This option can be
	// used, for instance, to make a snapshot of the current log file, or when some other
	// utility needs to truncate or parse the file. When this option is used, the create
	// option will have no effect, as the old log file stays in place.
	// see option: `copy` in https://man7.org/linux/man-pages/man8/logrotate.8.html
	RotateModeCopyRename RotateMode = iota

	// RotateModeCopyTruncate Truncate the original log file in place after creating a copy, instead of moving the
	// old log file and optionally creating a new one. It can be used when some program can‐
	// not be told to close its rotatefile and thus might continue writing (appending) to the
	// previous log file forever. Note that there is a very small time slice between copying
	// the file and truncating it, so some logging data might be lost. When this option is
	// used, the create option will have no effect, as the old log file stays in place.
	// see option: `copytruncate` in https://man7.org/linux/man-pages/man8/logrotate.8.html
	RotateModeCopyTruncate RotateMode = iota
)

// RotateFile logrotate reads everything about the log files it should be handling from the series of con‐
// figuration files specified on the command line.  Each configuration file can set global
// options (local definitions override global ones, and later definitions override earlier ones)
// and specify rotatefiles to rotate. A simple configuration file looks like this:
type RotateFile struct {
	RotateMode           RotateMode
	FilePathPrefix       string // FilePath = FilePathPrefix + now.Format(filePathRotateLayout)
	FilePathRotateLayout string // Time layout to format rotate file

	RotateFileGlob string // file glob to clean

	// sets the symbolic link name that gets linked to the current file name being used.
	FileLinkPath string

	// Rotate files are rotated until RotateInterval expired before being removed
	// take effects if only RotateInterval is bigger than 0.
	RotateInterval time.Duration

	// Rotate files are rotated if they grow bigger then size bytes.
	// take effects if only RotateSize is bigger than 0.
	RotateSize int64

	// max age of a log file before it gets purged from the file system.
	// Remove rotated logs older than duration. The age is only checked if the file is
	// to be rotated.
	// take effects if only MaxAge is bigger than 0.
	MaxAge time.Duration

	// Rotate files are rotated MaxCount times before being removed
	// take effects if only MaxCount is bigger than 0.
	MaxCount int

	// Force File Rotate when start up
	ForceNewFileOnStartup bool

	// PreRotateHandler called before file rotate
	// name means file path rotated
	PreRotateHandler func(name string)

	// PostRotateHandler called after file rotate
	// name means file path rotated
	PostRotateHandler func(name string)

	cleaning      atomic.Bool
	mu            sync.Mutex
	usingSeq      int // file rotated by size limit meet
	usingFilePath string
	usingFile     *os.File
}

func NewRotateFile(layout string) *RotateFile {
	return NewRotateFileWithStrftime(time_.LayoutTimeToSimilarStrftime(layout))
}

func NewRotateFileWithStrftime(strftimeLayout string) *RotateFile {
	return &RotateFile{
		FilePathRotateLayout: time_.LayoutStrftimeToSimilarTime(strftimeLayout),
		RotateFileGlob:       fileGlobFromStrftimeLayout(strftimeLayout),
		RotateInterval:       24 * time.Hour,
	}
}

func fileGlobFromStrftimeLayout(strftimeLayout string) string {
	var regexps = []*regexp.Regexp{
		regexp.MustCompile(`%[%+A-Za-z]`),
		regexp.MustCompile(`\*+`),
	}
	globPattern := strftimeLayout
	for _, re := range regexps {
		globPattern = re.ReplaceAllString(globPattern, "*")
	}
	return globPattern + `*`
}

func (f *RotateFile) Write(b []byte) (n int, err error) {
	if err := f.checkValid("write"); err != nil {
		return 0, err
	}
	// Guard against concurrent writes
	f.mu.Lock()
	defer f.mu.Unlock()

	out, err := f.getWriterLocked(false, false)
	if err != nil {
		return 0, fmt.Errorf("acquite rotated file :%w", err)
	}

	return out.Write(b)
}

// WriteString is like Write, but writes the contents of string s rather than
// a slice of bytes.
func (f *RotateFile) WriteString(s string) (n int, err error) {
	if err := f.checkValid("close"); err != nil {
		return 0, err
	}
	return f.Write([]byte(s))
}

// WriteAt writes len(b) bytes to the File starting at byte offset off.
// It returns the number of bytes written and an error, if any.
// WriteAt returns a non-nil error when n != len(b).
//
// If file was opened with the O_APPEND flag, WriteAt returns an error.
func (f *RotateFile) WriteAt(b []byte, off int64) (n int, err error) {
	if err := f.checkValid("write"); err != nil {
		return 0, err
	}
	// Guard against concurrent writes
	f.mu.Lock()
	defer f.mu.Unlock()

	out, err := f.getWriterLocked(false, false)
	if err != nil {
		return 0, fmt.Errorf("acquite rotated file :%w", err)
	}
	if w, ok := out.(io.WriterAt); ok {
		return w.WriteAt(b, off)
	}
	return 0, fmt.Errorf("WriteAt is not supported")
}

// Close satisfies the io.Closer interface. You must
// call this method if you performed any writes to
// the object.
func (f *RotateFile) Close() error {
	if err := f.checkValid("close"); err != nil {
		return err
	}
	f.mu.Lock()
	defer f.mu.Unlock()

	if f.usingFile == nil { // maybe file is closed or not open
		return nil
	}
	defer f.serializedClean()

	defer func() { f.usingFile = nil }()
	return f.usingFile.Close()
}

// Rotate forcefully rotates the file. If the generated file name
// clash because file already exists, a numeric suffix of the form
// ".1", ".2", ".3" and so forth are appended to the end of the log file
//
// This method can be used in conjunction with a signal handler so to
// emulate servers that generate new log files when they receive a SIGHUP
func (f *RotateFile) Rotate(forceRotate bool) error {
	if err := f.checkValid("rotate"); err != nil {
		return err
	}
	f.mu.Lock()
	defer f.mu.Unlock()
	if _, err := f.getWriterLocked(true, forceRotate); err != nil {
		return err
	}
	return nil
}

func (f *RotateFile) filePathByRotateTime() string {
	// create a new file name using the regular time layout
	return f.FilePathPrefix + time_.TruncateByLocation(time.Now(), f.RotateInterval).Format(f.FilePathRotateLayout)
}

func (f *RotateFile) filePathByRotateSize() (name string, seq int) {
	// instead of just using the regular time layout,
	// we create a new file name using names such as "foo.1", "foo.2", "foo.3", etc
	return nextSeqFileName(f.filePathByRotateTime(), f.usingSeq)
}

func (f *RotateFile) filePathByRotate(forceRotate bool) (name string, seq int, byTime, bySize bool) {
	// name using the regular time layout, without seq
	name = f.filePathByRotateTime()
	// startup
	if f.usingFilePath == "" {
		if f.ForceNewFileOnStartup {
			// instead of just using the regular time layout,
			// we create a new file name using names such as "foo", "foo.1", "foo.2", "foo.3", etc
			name, seq = nextSeqFileName(name, f.usingSeq)
			return name, seq, false, true
		}
		name, seq = maxSeqFileName(name)
		return name, seq, true, false
	}

	// rotate by time
	// compare expect time with current using file
	if name != trimSeqFromNextFileName(f.usingFilePath, f.usingSeq) {
		if forceRotate {
			// instead of just using the regular time layout,
			// we create a new file name using names such as "foo", "foo.1", "foo.2", "foo.3", etc
			name, seq = nextSeqFileName(name, 0)
			return name, seq, true, false
		}
		name, seq = maxSeqFileName(name)
		return name, seq, true, false
	}

	// determine if rotate by size

	// recreate file if file not exist, removed by other process for example
	usingFileInfo, err := os.Stat(f.usingFilePath)
	if os.IsNotExist(err) {
		name = f.usingFilePath
		seq = f.usingSeq
		return name, seq, false, false
	}

	// rotate by size
	// compare rotate size with current using file
	if forceRotate || (err == nil && (f.RotateSize > 0 && usingFileInfo.Size() > f.RotateSize)) {
		// instead of just using the regular time layout,
		// we create a new file name using names such as "foo", "foo.1", "foo.2", "foo.3", etc
		name, seq = nextSeqFileName(name, f.usingSeq)
		return name, seq, false, true
	}
	name = f.usingFilePath
	seq = f.usingSeq
	return name, seq, false, false
}

func (f *RotateFile) makeUsingFileReadyLocked() error {
	// using file exist, close this file if not ready to use
	if f.usingFile != nil {
		_, err := os.Stat(f.usingFile.Name())
		if err == nil {
			return nil
		}
		_ = f.usingFile.Close()
		f.usingFile = nil
	}

	// using file not exist, recreate the file and file link
	file, err := AppendAllIfNotExist(f.usingFilePath)
	if err != nil {
		return err
	}

	// link -> filename
	if f.FileLinkPath != "" {
		if err := ReSymlink(f.usingFilePath, f.FileLinkPath); err != nil {
			return err
		}
	}
	f.usingFile = file
	return nil

}

func (f *RotateFile) getWriterLocked(bailOnRotateFail, forceRotate bool) (out io.Writer, err error) {
	newName, newSeq, byTime, bySize := f.filePathByRotate(forceRotate)
	if !byTime && !bySize { // no need to rotate by time and size
		err = f.makeUsingFileReadyLocked()
		if err != nil {
			return nil, err
		}
		return f.usingFile, nil
	}

	// rotate the file
	if f.PreRotateHandler != nil {
		f.PreRotateHandler(f.usingFilePath)
	}
	newFile, err := f.rotateLocked(newName)
	if err != nil {
		if bailOnRotateFail {
			// Failure to rotate is a problem, but it's really not a great idea
			// to stop your application just because you couldn't rename your log.
			//
			// We only return this error when explicitly needed (as specified by bailOnRotateFail)
			return nil, err
		}
		// no file can be written, it's an error explicitly
		if f.usingFile == nil {
			return nil, err
		}
		return f.usingFile, nil
	}

	// swap file
	if f.usingFile != nil {
		_ = f.usingFile.Close()
		f.usingFile = nil
	}
	f.usingFile = newFile
	f.usingFilePath = newName
	f.usingSeq = newSeq
	if f.PostRotateHandler != nil {
		f.PostRotateHandler(f.usingFilePath)
	}

	return f.usingFile, nil
}

// file may not be nil if err is nil
func (f *RotateFile) rotateLocked(newName string) (*os.File, error) {
	// if we got here, then we need to create a file
	if newName != f.usingFilePath {
		var err error
		var mode string
		switch f.RotateMode {
		case RotateModeCopyRename:
			// for which open the file, and write file not by RotateFile
			// CopyRenameFileAll = RenameFileAll(src->dst) + OpenFile(src)
			// usingFilePath -> newName + recreate usingFilePath
			err = CopyRenameAll(newName, f.usingFilePath)
			mode = "copy_rename"
		case RotateModeCopyTruncate:
			// for which open the file, and write file not by RotateFile
			// CopyTruncateFile = CopyFile(src->dst) + Truncate(src)
			// usingFilePath -> newName + truncate usingFilePath
			err = CopyTruncateAll(newName, f.usingFilePath)
			mode = "copy_truncate"
		case RotateModeNew:
			// for which open the file, and write file by RotateFile
			mode = "new"
			fallthrough
		default:
		}
		if err != nil {
			return nil, fmt.Errorf("failed to %s file %s to %s: %w", mode, f.usingFilePath, newName, err)
		}
	}

	// make sure new file exists
	file, err := AppendAllIfNotExist(newName)
	if err != nil {
		return nil, err
	}

	// link -> filename
	if f.FileLinkPath != "" {
		if err := ReSymlink(newName, f.FileLinkPath); err != nil {
			return nil, err
		}
	}
	// unlink files on a separate goroutine
	go f.serializedClean()

	return file, nil
}

// unlink files
// expect run on a separate goroutine
func (f *RotateFile) serializedClean() error {
	// running already, ignore duplicate clean
	if !f.cleaning.CAS(false, true) {
		return nil
	}
	defer f.cleaning.Store(false)

	now := time.Now()

	// find old files
	var filesNotExpired []string
	filesExpired, err := filepath_.GlobFunc(f.FilePathPrefix+f.RotateFileGlob, func(name string) bool {
		fi, err := os.Stat(name)
		if err != nil {
			return false
		}

		fl, err := os.Lstat(name)
		if err != nil {
			return false
		}
		if f.MaxAge <= 0 {
			filesNotExpired = append(filesNotExpired, name)
			return false
		}

		if now.Sub(fi.ModTime()) < f.MaxAge {
			filesNotExpired = append(filesNotExpired, name)
			return false
		}

		if fl.Mode()&os.ModeSymlink == os.ModeSymlink {
			return false
		}
		return true
	})
	if err != nil {
		return err
	}

	var filesExceedMaxCount []string
	if f.MaxCount > 0 && len(filesNotExpired) > 0 {
		removeCount := len(filesNotExpired) - f.MaxCount
		if removeCount < 0 {
			removeCount = 0
		}
		sort.Sort(rotateFileSlice(filesNotExpired))
		filesExceedMaxCount = filesNotExpired[:removeCount]
	}
	var errs []error
	for _, path := range filesExpired {
		err = os.Remove(path)
		if err != nil {
			errs = append(errs, err)
		}
	}
	for _, path := range filesExceedMaxCount {
		err = os.Remove(path)
		if err != nil {
			errs = append(errs, err)
		}
	}
	return errors.Join(errs...)
}

// checkValid checks whether f is valid for use.
// If not, it returns an appropriate error, perhaps incorporating the operation name op.
func (f *RotateFile) checkValid(op string) error {
	if f == nil {
		return os.ErrInvalid
	}
	return nil
}

// foo.txt, 0 -> foo.txt
// foo.txt, 1 -> foo.txt.[1,2,...], which is not exist and seq is max
func nextSeqFileName(name string, seq int) (string, int) {
	// Special case: if seq is 0, we don't want to append 0 to the file name.
	if seq == 0 {
		nf, err := LockAll(name)
		if !os.IsExist(err) {
			return name, seq
		}
		_ = nf.Close()
		seq++
	}

	// A new file has been requested. Instead of just using the
	// regular strftime pattern, we create a new file name using
	// generational names such as "foo.1", "foo.2", "foo.3", etc
	nf, seqUsed, err := NextFile(name+".*", seq)
	if err != nil {
		return name, seq
	}
	defer nf.Close()
	if seqUsed == 0 {
		return name, seqUsed
	}
	return nf.Name(), seqUsed
}

// foo.txt -> foo.txt
// foo.txt.1 -> foo.txt
// foo.txt.1.1 -> foo.txt.1
func trimSeqFromNextFileName(name string, seq int) string {
	if seq == 0 {
		return name
	}
	return strings.TrimSuffix(name, fmt.Sprintf(".%d", seq))
}

// foo.txt.* -> foo.txt.[1,2,...], which exists and seq is max
func maxSeqFileName(name string) (string, int) {
	prefix, seq, suffix := MaxSeq(name + ".*")
	if seq == 0 {
		return name, seq
	}
	return fmt.Sprintf("%s%d%s", prefix, seq, suffix), seq
}

// sort filename by mode time and ascii in increase order
type rotateFileSlice []string

func (s rotateFileSlice) Len() int {
	return len(s)
}
func (s rotateFileSlice) Swap(i, j int) {
	s[i], s[j] = s[j], s[i]
}

func (s rotateFileSlice) Less(i, j int) bool {
	fi, err := os.Stat(s[i])
	if err != nil {
		return false
	}
	fj, err := os.Stat(s[j])
	if err != nil {
		return false
	}
	if fi.ModTime().Equal(fj.ModTime()) {
		if len(s[i]) == len(s[j]) {
			return s[i] < s[j]
		}
		return len(s[i]) > len(s[j]) // foo.1, foo.2, ..., foo
	}
	return fi.ModTime().Before(fj.ModTime())
}