func (command TagsCommand) listAllTags() error {
store, err := storage.Open()
if err != nil {
return fmt.Errorf("could not open storage: %v", err)
}
defer store.Close()
if command.verbose {
log.Info("retrieving all tags.")
}
if command.count {
count, err := store.TagCount()
if err != nil {
return fmt.Errorf("could not retrieve tag count: %v", err)
}
log.Print(count)
} else {
tags, err := store.Tags()
if err != nil {
return fmt.Errorf("could not retrieve tags: %v", err)
}
for _, tag := range tags {
log.Print(tag.Name)
}
}
return nil
}
func findDuplicatesInDb() error {
store, err := storage.Open()
if err != nil {
return fmt.Errorf("could not open storage: %v", err)
}
defer store.Close()
log.Info(2, "identifying duplicate files.")
fileSets, err := store.DuplicateFiles()
if err != nil {
return fmt.Errorf("could not identify duplicate files: %v", err)
}
log.Infof(2, "found %v sets of duplicate files.", len(fileSets))
for index, fileSet := range fileSets {
if index > 0 {
fmt.Println()
}
fmt.Printf("Set of %v duplicates:\n", len(fileSet))
for _, file := range fileSet {
relPath := _path.Rel(file.Path())
fmt.Printf(" %v\n", relPath)
}
}
return nil
}
func (command ImplyCommand) Exec(options cli.Options, args []string) error {
command.verbose = options.HasOption("--verbose")
store, err := storage.Open()
if err != nil {
return fmt.Errorf("could not open storage: %v", err)
}
defer store.Close()
switch {
case options.HasOption("--list"):
return command.listImplications(store)
case options.HasOption("--delete"):
if len(args) < 2 {
return fmt.Errorf("Implying and implied tag must be specified.")
}
return command.deleteImplication(store, args[0], args[1])
}
if len(args) < 2 {
return fmt.Errorf("Implying and implied tag must be specified.")
}
return command.addImplication(store, args[0], args[1])
}
func TestRenameDestTagAlreadyExists(test *testing.T) {
// set-up
databasePath := configureDatabase()
defer os.Remove(databasePath)
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
_, err = store.AddTag("source")
if err != nil {
test.Fatal(err)
}
_, err = store.AddTag("dest")
if err != nil {
test.Fatal(err)
}
command := RenameCommand{false}
// test
err = command.Exec(cli.Options{}, []string{"source", "dest"})
// validate
if err == nil {
test.Fatal("Existing dest tag not identified.")
}
}
func (command DupesCommand) findDuplicatesInDb() error {
store, err := storage.Open()
if err != nil {
return fmt.Errorf("could not open storage: %v", err)
}
defer store.Close()
if command.verbose {
log.Info("identifying duplicate files.")
}
fileSets, err := store.DuplicateFiles()
if err != nil {
return fmt.Errorf("could not identify duplicate files: %v", err)
}
if command.verbose {
log.Infof("found %v sets of duplicate files.", len(fileSets))
}
for index, fileSet := range fileSets {
if index > 0 {
log.Print()
}
log.Printf("Set of %v duplicates:", len(fileSet))
for _, file := range fileSet {
relPath := _path.Rel(file.Path())
log.Printf(" %v", relPath)
}
}
return nil
}
func (StatsCommand) Exec(options cli.Options, args []string) error {
store, err := storage.Open()
if err != nil {
return fmt.Errorf("could not open storage: %v", err)
}
defer store.Close()
tagCount, err := store.TagCount()
if err != nil {
return fmt.Errorf("could not retrieve tag count: %v", err)
}
fileCount, err := store.FileCount()
if err != nil {
return fmt.Errorf("could not retrieve file count: %v", err)
}
fileTagCount, err := store.FileTagCount()
if err != nil {
return fmt.Errorf("could not retrieve taggings count: %v", err)
}
log.Printf(" Tags: %v", tagCount)
log.Printf(" Files: %v", fileCount)
log.Printf(" Taggings: %v", fileTagCount)
return nil
}
func TestMergeNonExistentDestinationTag(test *testing.T) {
// set-up
databasePath := testDatabase()
defer os.Remove(databasePath)
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
_, err = store.AddTag("a")
if err != nil {
test.Fatal(err)
}
store.Commit()
// test
if err := MergeCommand.Exec(Options{}, []string{"a", "b"}); err == nil {
test.Fatal("Expected non-existent destination tag to be identified.")
}
}
func TestMergeSourceAndDestinationTheSame(test *testing.T) {
// set-up
databasePath := testDatabase()
defer os.Remove(databasePath)
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
_, err = store.AddTag("a")
if err != nil {
test.Fatal(err)
}
store.Commit()
// test
if err := MergeCommand.Exec(Options{}, []string{"a", "a"}); err == nil {
test.Fatal("Expected source and destination the same tag to be identified.")
}
}
func TestMergeNonExistentSourceTag(test *testing.T) {
// set-up
databasePath := configureDatabase()
defer os.Remove(databasePath)
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
_, err = store.AddTag("b")
if err != nil {
test.Fatal(err)
}
command := MergeCommand{false}
// test
if err := command.Exec(cli.Options{}, []string{"a", "b"}); err == nil {
test.Fatal("Expected non-existent source tag to be identified.")
}
}
func TestDupesNoneUntaggedFile(test *testing.T) {
// set-up
databasePath := testDatabase()
defer os.Remove(databasePath)
err := redirectStreams()
if err != nil {
test.Fatal(err)
}
defer restoreStreams()
path := filepath.Join(os.TempDir(), "tmsu-file")
_, err = os.Create(path)
if err != nil {
test.Fatal(err)
}
defer os.Remove(path)
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
_, err = store.AddFile("/tmp/a", fingerprint.Fingerprint("abc"), time.Now(), 123, true)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/a/b", fingerprint.Fingerprint("def"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/b", fingerprint.Fingerprint("ghi"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/e/f", fingerprint.Fingerprint("klm"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/a/d", fingerprint.Fingerprint("nop"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
store.Commit()
// test
if err := DupesCommand.Exec(Options{}, []string{path}); err != nil {
test.Fatal(err)
}
// validate
outFile.Seek(0, 0)
bytes, err := ioutil.ReadAll(outFile)
compareOutput(test, "", string(bytes))
}
func TestDupesMultipleUntaggedFile(test *testing.T) {
// set-up
databasePath := testDatabase()
defer os.Remove(databasePath)
err := redirectStreams()
if err != nil {
test.Fatal(err)
}
defer restoreStreams()
path := filepath.Join(os.TempDir(), "tmsu-file")
_, err = os.Create(path)
if err != nil {
test.Fatal(err)
}
defer os.Remove(path)
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
_, err = store.AddFile("/tmp/a", fingerprint.Fingerprint("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), time.Now(), 123, true)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/a/b", fingerprint.Fingerprint("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/b", fingerprint.Fingerprint("xxx"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/e/f", fingerprint.Fingerprint("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/a/d", fingerprint.Fingerprint("xxx"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
store.Commit()
// test
if err := DupesCommand.Exec(Options{}, []string{path}); err != nil {
test.Fatal(err)
}
// validate
outFile.Seek(0, 0)
bytes, err := ioutil.ReadAll(outFile)
compareOutput(test, "/tmp/a\n/tmp/a/b\n/tmp/e/f\n", string(bytes))
}
func createTags(names []string) error {
store, err := storage.Open()
if err != nil {
return fmt.Errorf("could not open storage: %v", err)
}
defer store.Close()
defer store.Commit()
tags, err := store.TagsByNames(names)
if err != nil {
return fmt.Errorf("could not retrieve tags %v: %v", names, err)
}
wereErrors := false
for _, tag := range tags {
log.Warnf("tag '%v' already exists", tag.Name)
wereErrors = true
}
if wereErrors {
return blankError
}
for _, name := range names {
_, err := store.AddTag(name)
if err != nil {
return fmt.Errorf("could not add tag '%v': %v", name, err)
}
}
return nil
}
func TestCopyDestTagAlreadyExists(test *testing.T) {
// set-up
databasePath := testDatabase()
defer os.Remove(databasePath)
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
_, err = store.AddTag("source")
if err != nil {
test.Fatal(err)
}
_, err = store.AddTag("dest")
if err != nil {
test.Fatal(err)
}
store.Commit()
// test
err = CopyCommand.Exec(Options{}, []string{"source", "dest"})
// validate
if err == nil {
test.Fatal("Existing dest tag not identified.")
}
}
func TestTagsForSingleFile(test *testing.T) {
// set-up
databasePath := configureDatabase()
defer os.Remove(databasePath)
outPath, errPath, err := configureOutput()
if err != nil {
test.Fatal(err)
}
defer os.Remove(outPath)
defer os.Remove(errPath)
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
file, err := store.AddFile("/tmp/tmsu/a", fingerprint.Fingerprint("123"), time.Now(), 0, false)
if err != nil {
test.Fatal(err)
}
appleTag, err := store.AddTag("apple")
if err != nil {
test.Fatal(err)
}
bananaTag, err := store.AddTag("banana")
if err != nil {
test.Fatal(err)
}
_, err = store.AddFileTag(file.Id, appleTag.Id)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFileTag(file.Id, bananaTag.Id)
if err != nil {
test.Fatal(err)
}
tagsCommand := TagsCommand{false, false}
// test
if err := tagsCommand.Exec(cli.Options{}, []string{"/tmp/tmsu/a"}); err != nil {
test.Fatal(err)
}
// verify
log.Outfile.Seek(0, 0)
bytes, err := ioutil.ReadAll(log.Outfile)
compareOutput(test, "apple\nbanana\n", string(bytes))
}
func (command DupesCommand) findDuplicatesOf(paths []string) error {
store, err := storage.Open()
if err != nil {
return fmt.Errorf("could not open storage: %v", err)
}
defer store.Close()
first := true
for _, path := range paths {
if command.verbose {
log.Infof("%v: identifying duplicate files.\n", path)
}
fp, err := fingerprint.Create(path)
if err != nil {
return fmt.Errorf("%v: could not create fingerprint: %v", path, err)
}
if fp == fingerprint.Fingerprint("") {
return nil
}
files, err := store.FilesByFingerprint(fp)
if err != nil {
return fmt.Errorf("%v: could not retrieve files matching fingerprint '%v': %v", path, fp, err)
}
absPath, err := filepath.Abs(path)
if err != nil {
return fmt.Errorf("%v: could not determine absolute path: %v", path, err)
}
// filter out the file we're searching on
dupes := files.Where(func(file *database.File) bool { return file.Path() != absPath })
if len(paths) > 1 && len(dupes) > 0 {
if first {
first = false
} else {
log.Print()
}
log.Printf("%v duplicates of %v:", len(dupes), path)
for _, dupe := range dupes {
relPath := _path.Rel(dupe.Path())
log.Printf(" %v", relPath)
}
} else {
for _, dupe := range dupes {
relPath := _path.Rel(dupe.Path())
log.Print(relPath)
}
}
}
return nil
}
func TestSingleUntag(test *testing.T) {
// set-up
databasePath := configureDatabase()
defer os.Remove(databasePath)
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
file, err := store.AddFile("/tmp/tmsu/a", fingerprint.Fingerprint("abc123"), time.Now(), 0, false)
if err != nil {
test.Fatal(err)
}
appleTag, err := store.AddTag("apple")
if err != nil {
test.Fatal(err)
}
bananaTag, err := store.AddTag("banana")
if err != nil {
test.Fatal(err)
}
_, err = store.AddFileTag(file.Id, appleTag.Id)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFileTag(file.Id, bananaTag.Id)
if err != nil {
test.Fatal(err)
}
untagCommand := UntagCommand{false, false}
// test
if err := untagCommand.Exec(cli.Options{}, []string{"/tmp/tmsu/a", "apple"}); err != nil {
test.Fatal(err)
}
// validate
fileTags, err := store.FileTags()
if err != nil {
test.Fatal(err)
}
if len(fileTags) != 1 {
test.Fatalf("Expected one file-tag but are %v", len(fileTags))
}
if fileTags[0].TagId != bananaTag.Id {
test.Fatalf("Incorrect tag was applied.")
}
}
func TestTagsForSingleFile(test *testing.T) {
// set-up
databasePath := testDatabase()
defer os.Remove(databasePath)
err := redirectStreams()
if err != nil {
test.Fatal(err)
}
defer restoreStreams()
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
file, err := store.AddFile("/tmp/tmsu/a", fingerprint.Fingerprint("123"), time.Now(), 0, false)
if err != nil {
test.Fatal(err)
}
appleTag, err := store.AddTag("apple")
if err != nil {
test.Fatal(err)
}
bananaTag, err := store.AddTag("banana")
if err != nil {
test.Fatal(err)
}
_, err = store.AddFileTag(file.Id, appleTag.Id, 0)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFileTag(file.Id, bananaTag.Id, 0)
if err != nil {
test.Fatal(err)
}
store.Commit()
// test
if err := TagsCommand.Exec(Options{}, []string{"/tmp/tmsu/a"}); err != nil {
test.Fatal(err)
}
// verify
outFile.Seek(0, 0)
bytes, err := ioutil.ReadAll(outFile)
compareOutput(test, "apple\nbanana\n", string(bytes))
}
func TestCopySuccessful(test *testing.T) {
// set-up
databasePath := testDatabase()
defer os.Remove(databasePath)
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
fileA, err := store.AddFile("/tmp/a", fingerprint.Fingerprint("abc"), time.Now(), 123, true)
if err != nil {
test.Fatal(err)
}
fileAB, err := store.AddFile("/tmp/a/b", fingerprint.Fingerprint("abc"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
sourceTag, err := store.AddTag("source")
if err != nil {
test.Fatal(err)
}
if _, err := store.AddFileTag(fileA.Id, sourceTag.Id, 0); err != nil {
test.Fatal(err)
}
if _, err := store.AddFileTag(fileAB.Id, sourceTag.Id, 0); err != nil {
test.Fatal(err)
}
store.Commit()
// test
if err := CopyCommand.Exec(Options{}, []string{"source", "dest"}); err != nil {
test.Fatal(err)
}
// validate
destTag, err := store.TagByName("dest")
if err != nil {
test.Fatal(err)
}
if destTag == nil {
test.Fatal("Destination tag does not exist.")
}
expectTags(test, store, fileA, sourceTag, destTag)
expectTags(test, store, fileAB, sourceTag, destTag)
}
func TestDupesMultiple(test *testing.T) {
// set-up
databasePath := configureDatabase()
defer os.Remove(databasePath)
outPath, errPath, err := configureOutput()
if err != nil {
test.Fatal(err)
}
defer os.Remove(outPath)
defer os.Remove(errPath)
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
_, err = store.AddFile("/tmp/a", fingerprint.Fingerprint("abc"), time.Now(), 123, true)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/a/b", fingerprint.Fingerprint("abc"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/b", fingerprint.Fingerprint("def"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/e/f", fingerprint.Fingerprint("def"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/a/d", fingerprint.Fingerprint("def"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
command := DupesCommand{false}
// test
if err := command.Exec(cli.Options{}, []string{}); err != nil {
test.Fatal(err)
}
// validate
log.Outfile.Seek(0, 0)
bytes, err := ioutil.ReadAll(log.Outfile)
compareOutput(test, "Set of 2 duplicates:\n /tmp/a\n /tmp/a/b\n\nSet of 3 duplicates:\n /tmp/a/d\n /tmp/b\n /tmp/e/f\n", string(bytes))
}
func TestDupesMultiple(test *testing.T) {
// set-up
databasePath := testDatabase()
defer os.Remove(databasePath)
err := redirectStreams()
if err != nil {
test.Fatal(err)
}
defer restoreStreams()
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
_, err = store.AddFile("/tmp/a", fingerprint.Fingerprint("abc"), time.Now(), 123, true)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/a/b", fingerprint.Fingerprint("abc"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/b", fingerprint.Fingerprint("def"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/e/f", fingerprint.Fingerprint("def"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/a/d", fingerprint.Fingerprint("def"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
store.Commit()
// test
if err := DupesCommand.Exec(Options{}, []string{}); err != nil {
test.Fatal(err)
}
// validate
outFile.Seek(0, 0)
bytes, err := ioutil.ReadAll(outFile)
compareOutput(test, "Set of 2 duplicates:\n /tmp/a\n /tmp/a/b\n\nSet of 3 duplicates:\n /tmp/a/d\n /tmp/b\n /tmp/e/f\n", string(bytes))
}
func tagFrom(fromPath string, paths []string, recursive bool) error {
store, err := storage.Open()
if err != nil {
return fmt.Errorf("could not open storage: %v", err)
}
defer store.Close()
defer store.Commit()
fingerprintAlgorithmSetting, err := store.Setting("fingerprintAlgorithm")
if err != nil {
return fmt.Errorf("could not retrieve fingerprint algorithm: %v", err)
}
file, err := store.FileByPath(fromPath)
if err != nil {
return fmt.Errorf("%v: could not retrieve file: %v", fromPath, err)
}
if file == nil {
return fmt.Errorf("%v: path is not tagged")
}
fileTags, err := store.FileTagsByFileId(file.Id)
if err != nil {
return fmt.Errorf("%v: could not retrieve filetags: %v", fromPath, err)
}
tagValuePairs := make([]TagValuePair, len(fileTags))
for index, fileTag := range fileTags {
tagValuePairs[index] = TagValuePair{fileTag.TagId, fileTag.ValueId}
}
wereErrors := false
for _, path := range paths {
if err := tagPath(store, path, tagValuePairs, recursive, fingerprintAlgorithmSetting.Value); err != nil {
switch {
case os.IsPermission(err):
log.Warnf("%v: permisison denied", path)
wereErrors = true
case os.IsNotExist(err):
log.Warnf("%v: no such file", path)
wereErrors = true
default:
return fmt.Errorf("%v: could not stat file: %v", path, err)
}
}
}
if wereErrors {
return blankError
}
return nil
}
func untagPathsAll(paths []string, recursive bool) error {
store, err := storage.Open()
if err != nil {
return fmt.Errorf("could not open storage: %v", err)
}
defer store.Close()
defer store.Commit()
wereErrors := false
for _, path := range paths {
absPath, err := filepath.Abs(path)
if err != nil {
return fmt.Errorf("%v: could not get absolute path: %v", path, err)
}
file, err := store.FileByPath(absPath)
if err != nil {
return fmt.Errorf("%v: could not retrieve file: %v", path, err)
}
if file == nil {
log.Warnf("%v: file is not tagged.", path)
wereErrors = true
continue
}
log.Infof(2, "%v: removing all tags.", file.Path())
if err := store.DeleteFileTagsByFileId(file.Id); err != nil {
return fmt.Errorf("%v: could not remove file's tags: %v", file.Path(), err)
}
if recursive {
childFiles, err := store.FilesByDirectory(file.Path())
if err != nil {
return fmt.Errorf("%v: could not retrieve files for directory: %v", file.Path())
}
for _, childFile := range childFiles {
if err := store.DeleteFileTagsByFileId(childFile.Id); err != nil {
return fmt.Errorf("%v: could not remove file's tags: %v", childFile.Path(), err)
}
}
}
}
if wereErrors {
return blankError
}
return nil
}
func (command FilesCommand) listFilesForTags(args []string) error {
if len(args) == 0 {
return fmt.Errorf("at least one tag must be specified. Use --all to show all files.")
}
store, err := storage.Open()
if err != nil {
return fmt.Errorf("could not open storage: %v", err)
}
defer store.Close()
includeTagIds := make([]uint, 0)
excludeTagIds := make([]uint, 0)
for _, arg := range args {
var tagName string
var include bool
if arg[0] == '-' {
tagName = arg[1:]
include = false
} else {
tagName = arg
include = true
}
tag, err := store.TagByName(tagName)
if err != nil {
return fmt.Errorf("could not retrieve tag '%v': %v", tagName, err)
}
if tag == nil {
log.Fatalf("no such tag '%v'.", tagName)
}
if include {
includeTagIds = append(includeTagIds, tag.Id)
} else {
excludeTagIds = append(excludeTagIds, tag.Id)
}
}
if command.verbose {
log.Info("retrieving set of tagged files from the database.")
}
files, err := store.FilesWithTags(includeTagIds, excludeTagIds)
if err != nil {
return fmt.Errorf("could not retrieve files with tags %v and without tags %v: %v", includeTagIds, excludeTagIds, err)
}
return command.listFiles(files)
}
func (command StatusCommand) statusPaths(paths []string) (*StatusReport, error) {
report := NewReport()
store, err := storage.Open()
if err != nil {
return nil, fmt.Errorf("could not open storage: %v", err)
}
defer store.Close()
for _, path := range paths {
absPath, err := filepath.Abs(path)
if err != nil {
return nil, fmt.Errorf("%v: could not get absolute path: %v", path, err)
}
file, err := store.FileByPath(absPath)
if err != nil {
return nil, fmt.Errorf("%v: could not retrieve file: %v", path, err)
}
if file != nil {
err = command.checkFile(file, report)
if err != nil {
return nil, err
}
}
if !command.directory {
if command.verbose {
log.Infof("%v: retrieving files from database.", path)
}
files, err := store.FilesByDirectory(absPath)
if err != nil {
return nil, fmt.Errorf("%v: could not retrieve files for directory: %v", path, err)
}
err = command.checkFiles(files, report)
if err != nil {
return nil, err
}
}
err = command.findNewFiles(path, report)
if err != nil {
return nil, err
}
}
return report, nil
}
func listFilesForQuery(queryText string, dirOnly, fileOnly, topOnly, leafOnly, recursive, print0, showCount, onePerLine bool) error {
if queryText == "" {
return fmt.Errorf("query must be specified. Use --all to show all files.")
}
store, err := storage.Open()
if err != nil {
return fmt.Errorf("could not open storage: %v", err)
}
defer store.Close()
log.Info(2, "parsing query")
expression, err := query.Parse(queryText)
if err != nil {
return err
}
log.Info(2, "checking tag names")
wereErrors := false
tagNames := query.TagNames(expression)
tags, err := store.TagsByNames(tagNames)
for _, tagName := range tagNames {
if !tags.ContainsName(tagName) {
log.Warnf("no such tag '%v'.", tagName)
wereErrors = true
continue
}
}
if wereErrors {
return blankError
}
log.Info(2, "querying database")
files, err := store.QueryFiles(expression)
if err != nil {
return fmt.Errorf("could not query files: %v", err)
}
if err = listFiles(files, dirOnly, fileOnly, topOnly, leafOnly, recursive, print0, showCount, onePerLine); err != nil {
return err
}
return nil
}
func TestFilesAll(test *testing.T) {
// set-up
databasePath := configureDatabase()
defer os.Remove(databasePath)
outPath, errPath, err := configureOutput()
if err != nil {
test.Fatal(err)
}
defer os.Remove(outPath)
defer os.Remove(errPath)
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
_, err = store.AddFile("/tmp/d", fingerprint.Fingerprint("abc"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/b/a", fingerprint.Fingerprint("abc"), time.Now(), 123, false)
if err != nil {
test.Fatal(err)
}
_, err = store.AddFile("/tmp/b", fingerprint.Fingerprint("abc"), time.Now(), 123, true)
if err != nil {
test.Fatal(err)
}
command := FilesCommand{}
// test
if err := command.Exec(cli.Options{cli.Option{"-a", "--all", "", false, ""}}, []string{}); err != nil {
test.Fatal(err)
}
// validate
log.Outfile.Seek(0, 0)
bytes, err := ioutil.ReadAll(log.Outfile)
compareOutput(test, "/tmp/b\n/tmp/b/a\n/tmp/d\n", string(bytes))
}
func TestRepairModifiedFile(test *testing.T) {
// set-up
databasePath := configureDatabase()
defer os.Remove(databasePath)
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
if err := createFile("/tmp/tmsu/a", "hello"); err != nil {
test.Fatal(err)
}
defer os.Remove("/tmp/tmsu/a")
tagCommand := TagCommand{false, false}
if err := tagCommand.Exec(cli.Options{}, []string{"/tmp/tmsu/a", "a"}); err != nil {
test.Fatal(err)
}
if err := createFile("/tmp/tmsu/a", "banana"); err != nil {
test.Fatal(err)
}
command := RepairCommand{false, false, false}
// test
if err := command.Exec(cli.Options{}, []string{"/tmp/tmsu"}); err != nil {
test.Fatal(err)
}
// validate
files, err := store.Files()
if err != nil {
test.Fatal(err)
}
if len(files) != 1 {
test.Fatalf("Expected one file but are %v", len(files))
}
if files[0].Size != 6 {
test.Fatalf("File modification was not repaired.")
}
}
func statusPaths(paths []string, dirOnly bool) (*StatusReport, error) {
report := NewReport()
store, err := storage.Open()
if err != nil {
return nil, fmt.Errorf("could not open storage: %v", err)
}
defer store.Close()
defer store.Commit()
for _, path := range paths {
absPath, err := filepath.Abs(path)
if err != nil {
return nil, fmt.Errorf("%v: could not get absolute path: %v", path, err)
}
file, err := store.FileByPath(absPath)
if err != nil {
return nil, fmt.Errorf("%v: could not retrieve file: %v", path, err)
}
if file != nil {
err = statusCheckFile(file, report)
if err != nil {
return nil, err
}
}
if !dirOnly {
log.Infof(2, "%v: retrieving files from database.", path)
files, err := store.FilesByDirectory(absPath)
if err != nil {
return nil, fmt.Errorf("%v: could not retrieve files for directory: %v", path, err)
}
err = statusCheckFiles(files, report)
if err != nil {
return nil, err
}
}
err = findNewFiles(path, report, dirOnly)
if err != nil {
return nil, err
}
}
return report, nil
}
func TestRepairMovedFile(test *testing.T) {
// set-up
databasePath := testDatabase()
defer os.Remove(databasePath)
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
if err := createFile("/tmp/tmsu/a", "hello"); err != nil {
test.Fatal(err)
}
defer os.Remove("/tmp/tmsu/a")
if err := TagCommand.Exec(Options{}, []string{"/tmp/tmsu/a", "a"}); err != nil {
test.Fatal(err)
}
if err := os.Rename("/tmp/tmsu/a", "/tmp/tmsu/b"); err != nil {
test.Fatal(err)
}
store.Commit()
// test
if err := RepairCommand.Exec(Options{}, []string{"/tmp/tmsu"}); err != nil {
test.Fatal(err)
}
// validate
files, err := store.Files()
if err != nil {
test.Fatal(err)
}
if len(files) != 1 {
test.Fatalf("Expected one file but are %v", len(files))
}
if files[0].Path() != "/tmp/tmsu/b" {
test.Fatalf("File rename was not repaired.")
}
}
func TestAllValues(test *testing.T) {
// set-up
databasePath := testDatabase()
defer os.Remove(databasePath)
err := redirectStreams()
if err != nil {
test.Fatal(err)
}
defer restoreStreams()
store, err := storage.Open()
if err != nil {
test.Fatal(err)
}
defer store.Close()
_, err = store.AddValue("wood")
if err != nil {
test.Fatal(err)
}
_, err = store.AddValue("metal")
if err != nil {
test.Fatal(err)
}
_, err = store.AddValue("torroid")
if err != nil {
test.Fatal(err)
}
store.Commit()
// test
if err := ValuesCommand.Exec(Options{Option{"--all", "-a", "", false, ""}}, []string{}); err != nil {
test.Fatal(err)
}
// verify
outFile.Seek(0, 0)
bytes, err := ioutil.ReadAll(outFile)
compareOutput(test, "metal\ntorroid\nwood\n", string(bytes))
}