syncthing/internal/versioner/simple.go

129 lines
2.9 KiB
Go
Raw Normal View History

2014-11-16 20:13:20 +00:00
// Copyright (C) 2014 The Syncthing Authors.
2014-09-29 19:43:32 +00:00
//
2015-03-07 20:36:35 +00:00
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at http://mozilla.org/MPL/2.0/.
2014-06-01 20:50:14 +00:00
2014-05-25 18:49:08 +00:00
package versioner
import (
"os"
"path/filepath"
"strconv"
2014-09-22 19:42:11 +00:00
"github.com/syncthing/syncthing/internal/osutil"
2014-05-25 18:49:08 +00:00
)
func init() {
// Register the constructor for this type of versioner with the name "simple"
Factories["simple"] = NewSimple
}
type Simple struct {
2014-09-28 11:05:25 +00:00
keep int
folderPath string
2014-05-25 18:49:08 +00:00
}
func NewSimple(folderID, folderPath string, params map[string]string) Versioner {
2014-05-25 18:49:08 +00:00
keep, err := strconv.Atoi(params["keep"])
if err != nil {
keep = 5 // A reasonable default
}
s := Simple{
2014-09-28 11:05:25 +00:00
keep: keep,
folderPath: folderPath,
2014-05-25 18:49:08 +00:00
}
if debug {
l.Debugf("instantiated %#v", s)
}
return s
}
2015-04-28 20:32:10 +00:00
// Archive moves the named file away to a version archive. If this function
// returns nil, the named file does not exist any more (has been archived).
func (v Simple) Archive(filePath string) error {
2015-04-14 10:31:25 +00:00
fileInfo, err := osutil.Lstat(filePath)
2015-03-19 10:31:21 +00:00
if os.IsNotExist(err) {
if debug {
l.Debugln("not archiving nonexistent file", filePath)
}
2015-03-19 10:31:21 +00:00
return nil
} else if err != nil {
2014-12-08 15:36:15 +00:00
return err
2014-05-25 18:49:08 +00:00
}
versionsDir := filepath.Join(v.folderPath, ".stversions")
_, err = os.Stat(versionsDir)
if err != nil {
if os.IsNotExist(err) {
if debug {
l.Debugln("creating versions dir", versionsDir)
}
os.MkdirAll(versionsDir, 0755)
osutil.HideFile(versionsDir)
} else {
return err
}
}
2014-05-25 18:49:08 +00:00
if debug {
l.Debugln("archiving", filePath)
2014-05-25 18:49:08 +00:00
}
file := filepath.Base(filePath)
inFolderPath, err := filepath.Rel(v.folderPath, filepath.Dir(filePath))
if err != nil {
return err
}
dir := filepath.Join(versionsDir, inFolderPath)
2014-05-25 18:49:08 +00:00
err = os.MkdirAll(dir, 0755)
if err != nil && !os.IsExist(err) {
return err
}
ver := taggedFilename(file, fileInfo.ModTime().Format(TimeFormat))
dst := filepath.Join(dir, ver)
if debug {
l.Debugln("moving to", dst)
}
err = osutil.Rename(filePath, dst)
2014-05-25 18:49:08 +00:00
if err != nil {
return err
}
// Glob according to the new file~timestamp.ext pattern.
newVersions, err := osutil.Glob(filepath.Join(dir, taggedFilename(file, TimeGlob)))
2014-05-25 18:49:08 +00:00
if err != nil {
l.Warnln("globbing:", err)
2014-05-25 18:49:08 +00:00
return nil
}
// Also according to the old file.ext~timestamp pattern.
oldVersions, err := osutil.Glob(filepath.Join(dir, file+"~"+TimeGlob))
if err != nil {
l.Warnln("globbing:", err)
return nil
}
// Use all the found filenames. "~" sorts after "." so all old pattern
// files will be deleted before any new, which is as it should be.
versions := uniqueSortedStrings(append(oldVersions, newVersions...))
2014-05-25 18:49:08 +00:00
if len(versions) > v.keep {
for _, toRemove := range versions[:len(versions)-v.keep] {
if debug {
l.Debugln("cleaning out", toRemove)
}
2014-05-25 18:49:08 +00:00
err = os.Remove(toRemove)
if err != nil {
l.Warnln("removing old version:", err)
2014-05-25 18:49:08 +00:00
}
}
}
return nil
}