616 lines
18 KiB
Go
616 lines
18 KiB
Go
package starlog
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"b612.me/starlog/internal/archivex"
|
|
)
|
|
|
|
var archiveStore = archivex.NewStore()
|
|
|
|
type Archive interface {
|
|
ShouldArchiveNow(*StarLogger, string, os.FileInfo) bool
|
|
NextLogFilePath(*StarLogger, string, os.FileInfo) string
|
|
ArchiveLogFilePath(*StarLogger, string, os.FileInfo) string
|
|
Interval() int64
|
|
// Deprecated: use HookBeforeArchive on concrete implementations.
|
|
HookBeforArchive() func(*StarLogger, string, string, os.FileInfo) error //archivePath;currentPath
|
|
HookAfterArchive() func(*StarLogger, string, string, os.FileInfo) error //archivePath;currentPath
|
|
DoArchive() func(*StarLogger, string, string, os.FileInfo) error
|
|
}
|
|
|
|
type archiveStrategy struct {
|
|
interval int64
|
|
shouldRotate func(string, os.FileInfo, *Entry) bool
|
|
nextLogPath func(string, os.FileInfo, time.Time) string
|
|
archivePath func(string, os.FileInfo, time.Time) string
|
|
beforeHook func(*StarLogger, string, string, os.FileInfo) error
|
|
afterHook func(*StarLogger, string, string, os.FileInfo) error
|
|
doArchive func(*StarLogger, string, string, os.FileInfo) error
|
|
}
|
|
|
|
type archiveBeforeHookProvider interface {
|
|
HookBeforeArchive() func(*StarLogger, string, string, os.FileInfo) error
|
|
}
|
|
|
|
func SetLogFile(path string, logger *StarLogger, appendMode bool) error {
|
|
var fileMode int
|
|
if appendMode {
|
|
fileMode = os.O_APPEND | os.O_CREATE | os.O_WRONLY
|
|
} else {
|
|
fileMode = os.O_CREATE | os.O_WRONLY | os.O_TRUNC
|
|
}
|
|
fullpath, err := filepath.Abs(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !appendMode && Exists(fullpath) {
|
|
os.Remove(fullpath)
|
|
}
|
|
fp, err := os.OpenFile(fullpath, fileMode, 0644)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if current, ok := archiveStore.GetFile(logger.logcore.id); ok {
|
|
logger.SetSwitching(true)
|
|
err := current.Pointer.Close()
|
|
if err != nil {
|
|
logger.SetWriter(nil)
|
|
logger.SetSwitching(false)
|
|
return err
|
|
}
|
|
err = archiveStore.DeleteFile(logger.logcore.id)
|
|
if err != nil {
|
|
logger.SetWriter(nil)
|
|
logger.SetSwitching(false)
|
|
return err
|
|
}
|
|
}
|
|
|
|
err = archiveStore.SetFile(logger.logcore.id, archivex.FileRecord{
|
|
FullPath: fullpath,
|
|
Pointer: fp,
|
|
})
|
|
if err != nil {
|
|
fp.Close()
|
|
logger.SetWriter(nil)
|
|
logger.SetSwitching(false)
|
|
return err
|
|
}
|
|
logger.SetSwitching(true)
|
|
logger.SetWriter(fp)
|
|
logger.SetSwitching(false)
|
|
return nil
|
|
}
|
|
|
|
func CloseLogFileWithSwitching(logger *StarLogger) error {
|
|
if current, ok := archiveStore.GetFile(logger.logcore.id); ok {
|
|
logger.SetSwitching(true)
|
|
err := current.Pointer.Close()
|
|
if err != nil {
|
|
logger.SetWriter(nil)
|
|
return err
|
|
}
|
|
err = archiveStore.DeleteFile(logger.logcore.id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
logger.logcore.mu.Lock()
|
|
if logger.logcore.output == current.Pointer {
|
|
logger.logcore.output = nil
|
|
}
|
|
logger.logcore.mu.Unlock()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func CloseLogFile(logger *StarLogger) error {
|
|
defer logger.SetSwitching(false)
|
|
return CloseLogFileWithSwitching(logger)
|
|
}
|
|
|
|
// Deprecated: use CloseLogFileWithSwitching.
|
|
func CloseWithSwitching(logger *StarLogger) error {
|
|
return CloseLogFileWithSwitching(logger)
|
|
}
|
|
|
|
// Deprecated: use (*StarLogger).Close or CloseLogFile.
|
|
func Close(logger *StarLogger) error {
|
|
return CloseLogFile(logger)
|
|
}
|
|
|
|
func GetLogFileInfo(logger *StarLogger) (os.FileInfo, error) {
|
|
if current, ok := archiveStore.GetFile(logger.logcore.id); ok {
|
|
return current.Pointer.Stat()
|
|
}
|
|
return nil, errors.New("logger don't have a register logfile")
|
|
}
|
|
|
|
func resolveBeforeHook(arch Archive) func(*StarLogger, string, string, os.FileInfo) error {
|
|
if arch == nil {
|
|
return nil
|
|
}
|
|
if hookProvider, ok := arch.(archiveBeforeHookProvider); ok {
|
|
return hookProvider.HookBeforeArchive()
|
|
}
|
|
return arch.HookBeforArchive()
|
|
}
|
|
|
|
func startArchiveWithStrategy(logger *StarLogger, strategy archiveStrategy) error {
|
|
archiveKey := "arch" + logger.logcore.id
|
|
if _, ok := archiveStore.GetRunner(archiveKey); ok {
|
|
return errors.New("already running")
|
|
}
|
|
interval := strategy.interval
|
|
if interval <= 0 {
|
|
interval = 1
|
|
}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
runner := &archivex.Runner{
|
|
Cancel: cancel,
|
|
Done: make(chan struct{}),
|
|
}
|
|
if err := archiveStore.SetRunner(archiveKey, runner); err != nil {
|
|
cancel()
|
|
return err
|
|
}
|
|
go func(ctx context.Context, runner *archivex.Runner, logger *StarLogger) {
|
|
defer close(runner.Done)
|
|
defer archiveStore.DeleteRunner(archiveKey)
|
|
ticker := time.NewTicker(time.Second * time.Duration(interval))
|
|
defer ticker.Stop()
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case <-ticker.C:
|
|
}
|
|
fileinfo, err := GetLogFileInfo(logger)
|
|
if err != nil {
|
|
logger.Errorf("cannot get log file info,reason is %v\n", err)
|
|
continue
|
|
}
|
|
current, ok := archiveStore.GetFile(logger.logcore.id)
|
|
if !ok {
|
|
logger.Errorf("cannot get log core info from the map:no such keys\n")
|
|
continue
|
|
}
|
|
fullpath := current.FullPath
|
|
now := time.Now()
|
|
entry := &Entry{
|
|
Time: now,
|
|
LoggerName: logger.GetName(),
|
|
}
|
|
if strategy.shouldRotate == nil || !strategy.shouldRotate(fullpath, fileinfo, entry) {
|
|
continue
|
|
}
|
|
newLogPath := fullpath
|
|
if strategy.nextLogPath != nil {
|
|
newLogPath = strategy.nextLogPath(fullpath, fileinfo, now)
|
|
}
|
|
if newLogPath == "" {
|
|
newLogPath = fullpath
|
|
}
|
|
archiveLogPath := fullpath
|
|
if strategy.archivePath != nil {
|
|
archiveLogPath = strategy.archivePath(fullpath, fileinfo, now)
|
|
}
|
|
if archiveLogPath == "" {
|
|
logger.Errorf("archive path cannot be empty\n")
|
|
continue
|
|
}
|
|
if strategy.doArchive == nil && archiveLogPath == fullpath {
|
|
logger.Errorf("archive path equals current path, skip rotate\n")
|
|
continue
|
|
}
|
|
if strategy.beforeHook != nil {
|
|
if err := strategy.beforeHook(logger, archiveLogPath, fullpath, fileinfo); err != nil {
|
|
logger.Errorf("error occur while executing hook before archive,detail is %v\n", err)
|
|
continue
|
|
}
|
|
}
|
|
err = CloseLogFileWithSwitching(logger)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if strategy.doArchive == nil {
|
|
err = os.Rename(fullpath, archiveLogPath)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
} else {
|
|
err = strategy.doArchive(logger, fullpath, archiveLogPath, fileinfo)
|
|
if err != nil {
|
|
logger.Errorf("error occur while executing archive log file,detail is %v\n", err)
|
|
continue
|
|
}
|
|
}
|
|
if err := SetLogFile(newLogPath, logger, false); err != nil {
|
|
logger.Errorf("error occur while executing coverting new log file,detail is %v\n", err)
|
|
continue
|
|
} else {
|
|
logger.Debugln("Archive Log Success")
|
|
}
|
|
fileinfo, err = GetLogFileInfo(logger)
|
|
if err != nil {
|
|
logger.Errorf("cannot get new log core info from the map:no such keys\n")
|
|
continue
|
|
}
|
|
if strategy.afterHook != nil {
|
|
if err := strategy.afterHook(logger, archiveLogPath, newLogPath, fileinfo); err != nil {
|
|
logger.Errorf("error occur while executing hook after archive,detail is %v\n", err)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
}(ctx, runner, logger)
|
|
return nil
|
|
}
|
|
|
|
func buildRotateStrategy(policy RotatePolicy, checkInterval int64) archiveStrategy {
|
|
return archiveStrategy{
|
|
interval: checkInterval,
|
|
shouldRotate: func(fullpath string, info os.FileInfo, entry *Entry) bool {
|
|
return policy.ShouldRotate(info, entry)
|
|
},
|
|
nextLogPath: func(oldpath string, info os.FileInfo, now time.Time) string {
|
|
return oldpath
|
|
},
|
|
archivePath: func(oldpath string, info os.FileInfo, now time.Time) string {
|
|
return resolveRotateArchivePath(policy, oldpath, now)
|
|
},
|
|
}
|
|
}
|
|
|
|
func buildRotateArchiveStrategy(archive *RotatePolicyArchive) archiveStrategy {
|
|
strategy := buildRotateStrategy(archive.policy, archive.checkInterval)
|
|
strategy.beforeHook = archive.HookBeforeArchive()
|
|
strategy.afterHook = archive.HookAfterArchive()
|
|
if archive.DoArchive() != nil {
|
|
strategy.doArchive = archive.DoArchive()
|
|
}
|
|
if archive.Interval() > 0 {
|
|
strategy.interval = archive.Interval()
|
|
}
|
|
return strategy
|
|
}
|
|
|
|
func buildLegacyArchiveStrategy(logger *StarLogger, arch Archive) archiveStrategy {
|
|
return archiveStrategy{
|
|
interval: arch.Interval(),
|
|
shouldRotate: func(fullpath string, info os.FileInfo, entry *Entry) bool {
|
|
return arch.ShouldArchiveNow(logger, fullpath, info)
|
|
},
|
|
nextLogPath: func(oldpath string, info os.FileInfo, now time.Time) string {
|
|
return arch.NextLogFilePath(logger, oldpath, info)
|
|
},
|
|
archivePath: func(oldpath string, info os.FileInfo, now time.Time) string {
|
|
return arch.ArchiveLogFilePath(logger, oldpath, info)
|
|
},
|
|
beforeHook: resolveBeforeHook(arch),
|
|
afterHook: arch.HookAfterArchive(),
|
|
doArchive: arch.DoArchive(),
|
|
}
|
|
}
|
|
|
|
func StartRotatePolicy(logger *StarLogger, policy RotatePolicy, checkInterval int64) error {
|
|
if policy == nil {
|
|
return errors.New("rotate policy is nil")
|
|
}
|
|
return startArchiveWithStrategy(logger, buildRotateStrategy(policy, checkInterval))
|
|
}
|
|
|
|
// Deprecated: prefer StartRotatePolicy or StartManagedRotatePolicy.
|
|
func StartArchive(logger *StarLogger, arch Archive) error {
|
|
if arch == nil {
|
|
return errors.New("archive is nil")
|
|
}
|
|
if rotateArchive, ok := arch.(*RotatePolicyArchive); ok && rotateArchive != nil && rotateArchive.policy != nil {
|
|
return startArchiveWithStrategy(logger, buildRotateArchiveStrategy(rotateArchive))
|
|
}
|
|
return startArchiveWithStrategy(logger, buildLegacyArchiveStrategy(logger, arch))
|
|
}
|
|
|
|
func IsArchiveRun(logger *StarLogger) bool {
|
|
_, ok := archiveStore.GetRunner("arch" + logger.logcore.id)
|
|
return ok
|
|
}
|
|
|
|
func StopArchive(logger *StarLogger) {
|
|
archiveKey := "arch" + logger.logcore.id
|
|
runner, ok := archiveStore.GetRunner(archiveKey)
|
|
if !ok || runner == nil {
|
|
return
|
|
}
|
|
runner.Cancel()
|
|
<-runner.Done
|
|
_ = archiveStore.DeleteRunner(archiveKey)
|
|
}
|
|
|
|
type ArchiveByDate struct {
|
|
interval int64
|
|
checkInterval int64
|
|
baseFileStyle string
|
|
archiveStyle string
|
|
lastSwitchTime time.Time
|
|
changeArchiveName bool
|
|
hookBefore func(*StarLogger, string, string, os.FileInfo) error
|
|
hookAfter func(*StarLogger, string, string, os.FileInfo) error
|
|
}
|
|
|
|
func (abd *ArchiveByDate) ShouldArchiveNow(l *StarLogger, fullpath string, info os.FileInfo) bool {
|
|
if abd.lastSwitchTime.IsZero() {
|
|
abd.lastSwitchTime = GetFileCreationTime(info)
|
|
}
|
|
sub := time.Now().Unix() - abd.lastSwitchTime.Unix()
|
|
if sub >= abd.interval || abd.interval-sub <= abd.checkInterval/2 {
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
func (abd *ArchiveByDate) NextLogFilePath(l *StarLogger, oldpath string, info os.FileInfo) string {
|
|
var newName string
|
|
dir := filepath.Dir(oldpath)
|
|
if !abd.changeArchiveName {
|
|
base := filepath.Base(abd.baseFileStyle)
|
|
newName = base[:len(base)-len(filepath.Ext(base))] + time.Now().Format(abd.archiveStyle)
|
|
} else {
|
|
newName = abd.baseFileStyle
|
|
}
|
|
return filepath.Join(dir, newName)
|
|
}
|
|
|
|
func (abd *ArchiveByDate) ArchiveLogFilePath(l *StarLogger, oldpath string, info os.FileInfo) string {
|
|
var newName string
|
|
dir := filepath.Dir(oldpath)
|
|
if abd.changeArchiveName {
|
|
base := filepath.Base(abd.baseFileStyle)
|
|
newName = base[:len(base)-len(filepath.Ext(base))] + time.Now().Format(abd.archiveStyle)
|
|
} else {
|
|
newName = abd.baseFileStyle
|
|
}
|
|
return filepath.Join(dir, newName)
|
|
}
|
|
|
|
func (abd *ArchiveByDate) Interval() int64 {
|
|
return abd.checkInterval
|
|
}
|
|
|
|
func (abd *ArchiveByDate) HookBeforArchive() func(*StarLogger, string, string, os.FileInfo) error {
|
|
return abd.HookBeforeArchive()
|
|
}
|
|
|
|
func (abd *ArchiveByDate) HookBeforeArchive() func(*StarLogger, string, string, os.FileInfo) error {
|
|
return abd.hookBefore
|
|
}
|
|
|
|
func (abd *ArchiveByDate) HookAfterArchive() func(*StarLogger, string, string, os.FileInfo) error {
|
|
return func(logger *StarLogger, s string, s2 string, info os.FileInfo) error {
|
|
abd.lastSwitchTime = time.Now()
|
|
if abd.hookAfter != nil {
|
|
return abd.hookAfter(logger, s, s2, info)
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func (abd *ArchiveByDate) DoArchive() func(*StarLogger, string, string, os.FileInfo) error {
|
|
return nil
|
|
}
|
|
|
|
func (abd *ArchiveByDate) SetHookBeforArchive(f func(*StarLogger, string, string, os.FileInfo) error) {
|
|
abd.SetHookBeforeArchive(f)
|
|
}
|
|
|
|
func (abd *ArchiveByDate) SetHookBeforeArchive(f func(*StarLogger, string, string, os.FileInfo) error) {
|
|
abd.hookBefore = f
|
|
}
|
|
|
|
func (abd *ArchiveByDate) SetHookAfterArchive(f func(*StarLogger, string, string, os.FileInfo) error) {
|
|
abd.hookAfter = f
|
|
}
|
|
|
|
func NewArchiveByDate(archInterval int64, checkInterval int64, baseFileName string, archiveFileName string, changeArchiveName bool, hookbefore func(*StarLogger, string, string, os.FileInfo) error, hookafter func(*StarLogger, string, string, os.FileInfo) error) *ArchiveByDate {
|
|
return &ArchiveByDate{
|
|
interval: archInterval,
|
|
checkInterval: checkInterval,
|
|
changeArchiveName: changeArchiveName,
|
|
baseFileStyle: baseFileName,
|
|
archiveStyle: archiveFileName,
|
|
hookBefore: hookbefore,
|
|
hookAfter: hookafter,
|
|
}
|
|
}
|
|
|
|
type ArchiveBySize struct {
|
|
size int64
|
|
checkInterval int64
|
|
changeArchiveName bool
|
|
baseFileStyle string
|
|
archiveStyle string
|
|
hookBefore func(*StarLogger, string, string, os.FileInfo) error
|
|
hookAfter func(*StarLogger, string, string, os.FileInfo) error
|
|
}
|
|
|
|
func (abd *ArchiveBySize) ShouldArchiveNow(l *StarLogger, fullpath string, info os.FileInfo) bool {
|
|
if info.Size() > abd.size {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (abd *ArchiveBySize) NextLogFilePath(l *StarLogger, oldpath string, info os.FileInfo) string {
|
|
var newName string
|
|
dir := filepath.Dir(oldpath)
|
|
if !abd.changeArchiveName {
|
|
base := filepath.Base(abd.baseFileStyle)
|
|
newName = base[:len(base)-len(filepath.Ext(base))] + time.Now().Format(abd.archiveStyle)
|
|
} else {
|
|
newName = abd.baseFileStyle
|
|
}
|
|
return filepath.Join(dir, newName)
|
|
}
|
|
|
|
func (abd *ArchiveBySize) ArchiveLogFilePath(l *StarLogger, oldpath string, info os.FileInfo) string {
|
|
var newName string
|
|
dir := filepath.Dir(oldpath)
|
|
if abd.changeArchiveName {
|
|
base := filepath.Base(abd.baseFileStyle)
|
|
newName = base[:len(base)-len(filepath.Ext(base))] + time.Now().Format(abd.archiveStyle)
|
|
} else {
|
|
newName = abd.baseFileStyle
|
|
}
|
|
return filepath.Join(dir, newName)
|
|
}
|
|
|
|
func (abd *ArchiveBySize) Interval() int64 {
|
|
return abd.checkInterval
|
|
}
|
|
|
|
func (abd *ArchiveBySize) HookBeforArchive() func(*StarLogger, string, string, os.FileInfo) error {
|
|
return abd.HookBeforeArchive()
|
|
}
|
|
|
|
func (abd *ArchiveBySize) HookBeforeArchive() func(*StarLogger, string, string, os.FileInfo) error {
|
|
return abd.hookBefore
|
|
}
|
|
|
|
func (abd *ArchiveBySize) HookAfterArchive() func(*StarLogger, string, string, os.FileInfo) error {
|
|
return abd.hookAfter
|
|
}
|
|
|
|
func (abd *ArchiveBySize) SetHookBeforArchive(f func(*StarLogger, string, string, os.FileInfo) error) {
|
|
abd.SetHookBeforeArchive(f)
|
|
}
|
|
|
|
func (abd *ArchiveBySize) SetHookBeforeArchive(f func(*StarLogger, string, string, os.FileInfo) error) {
|
|
abd.hookBefore = f
|
|
}
|
|
|
|
func (abd *ArchiveBySize) SetHookAfterArchive(f func(*StarLogger, string, string, os.FileInfo) error) {
|
|
abd.hookAfter = f
|
|
}
|
|
|
|
func (abd *ArchiveBySize) DoArchive() func(*StarLogger, string, string, os.FileInfo) error {
|
|
return nil
|
|
}
|
|
|
|
func NewArchiveBySize(size int64, checkInterval int64, baseFileStyle, archiveFileStyle string, changeArchiveFileName bool, hookbefore func(*StarLogger, string, string, os.FileInfo) error, hookafter func(*StarLogger, string, string, os.FileInfo) error) *ArchiveBySize {
|
|
return &ArchiveBySize{
|
|
size: size,
|
|
checkInterval: checkInterval,
|
|
baseFileStyle: baseFileStyle,
|
|
archiveStyle: archiveFileStyle,
|
|
hookBefore: hookbefore,
|
|
hookAfter: hookafter,
|
|
changeArchiveName: changeArchiveFileName,
|
|
}
|
|
}
|
|
|
|
type ArchiveByDateSize struct {
|
|
interval int64
|
|
size int64
|
|
checkInterval int64
|
|
changeArchiveName bool
|
|
lastSwitchTime time.Time
|
|
baseFileStyle string
|
|
archiveStyle string
|
|
hookBefore func(*StarLogger, string, string, os.FileInfo) error
|
|
hookAfter func(*StarLogger, string, string, os.FileInfo) error
|
|
}
|
|
|
|
func (abd *ArchiveByDateSize) ShouldArchiveNow(l *StarLogger, fullpath string, info os.FileInfo) bool {
|
|
if abd.lastSwitchTime.IsZero() {
|
|
abd.lastSwitchTime = GetFileCreationTime(info)
|
|
}
|
|
if info.Size() > abd.size {
|
|
return true
|
|
}
|
|
sub := time.Now().Unix() - abd.lastSwitchTime.Unix()
|
|
if sub >= abd.interval || abd.interval-sub <= abd.checkInterval/2 {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (abd *ArchiveByDateSize) NextLogFilePath(l *StarLogger, oldpath string, info os.FileInfo) string {
|
|
var newName string
|
|
dir := filepath.Dir(oldpath)
|
|
if !abd.changeArchiveName {
|
|
base := filepath.Base(abd.baseFileStyle)
|
|
newName = base[:len(base)-len(filepath.Ext(base))] + time.Now().Format(abd.archiveStyle)
|
|
} else {
|
|
newName = abd.baseFileStyle
|
|
}
|
|
return filepath.Join(dir, newName)
|
|
}
|
|
|
|
func (abd *ArchiveByDateSize) ArchiveLogFilePath(l *StarLogger, oldpath string, info os.FileInfo) string {
|
|
var newName string
|
|
dir := filepath.Dir(oldpath)
|
|
if abd.changeArchiveName {
|
|
base := filepath.Base(abd.baseFileStyle)
|
|
newName = base[:len(base)-len(filepath.Ext(base))] + time.Now().Format(abd.archiveStyle)
|
|
} else {
|
|
newName = abd.baseFileStyle
|
|
}
|
|
return filepath.Join(dir, newName)
|
|
}
|
|
|
|
func (abd *ArchiveByDateSize) Interval() int64 {
|
|
return abd.checkInterval
|
|
}
|
|
|
|
func (abd *ArchiveByDateSize) HookBeforArchive() func(*StarLogger, string, string, os.FileInfo) error {
|
|
return abd.HookBeforeArchive()
|
|
}
|
|
|
|
func (abd *ArchiveByDateSize) HookBeforeArchive() func(*StarLogger, string, string, os.FileInfo) error {
|
|
return abd.hookBefore
|
|
}
|
|
|
|
func (abd *ArchiveByDateSize) HookAfterArchive() func(*StarLogger, string, string, os.FileInfo) error {
|
|
return func(logger *StarLogger, s string, s2 string, info os.FileInfo) error {
|
|
abd.lastSwitchTime = time.Now()
|
|
if abd.hookAfter != nil {
|
|
return abd.hookAfter(logger, s, s2, info)
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func (abd *ArchiveByDateSize) SetHookBeforArchive(f func(*StarLogger, string, string, os.FileInfo) error) {
|
|
abd.SetHookBeforeArchive(f)
|
|
}
|
|
|
|
func (abd *ArchiveByDateSize) SetHookBeforeArchive(f func(*StarLogger, string, string, os.FileInfo) error) {
|
|
abd.hookBefore = f
|
|
}
|
|
|
|
func (abd *ArchiveByDateSize) SetHookAfterArchive(f func(*StarLogger, string, string, os.FileInfo) error) {
|
|
abd.hookAfter = f
|
|
}
|
|
|
|
func (abd *ArchiveByDateSize) DoArchive() func(*StarLogger, string, string, os.FileInfo) error {
|
|
return nil
|
|
}
|
|
|
|
func NewArchiveByDateSize(size int64, interval int64, checkInterval int64, baseFileStyle, archiveFileStyle string, changeArchiveFileName bool, hookbefore func(*StarLogger, string, string, os.FileInfo) error, hookafter func(*StarLogger, string, string, os.FileInfo) error) *ArchiveByDateSize {
|
|
return &ArchiveByDateSize{
|
|
size: size,
|
|
interval: interval,
|
|
checkInterval: checkInterval,
|
|
baseFileStyle: baseFileStyle,
|
|
archiveStyle: archiveFileStyle,
|
|
hookBefore: hookbefore,
|
|
hookAfter: hookafter,
|
|
changeArchiveName: changeArchiveFileName,
|
|
}
|
|
}
|