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 (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 (command *StatusCommand) findNewFiles(searchPath string, report *StatusReport) error {
if command.verbose {
log.Infof("%v: finding new files.", searchPath)
}
relPath := path.Rel(searchPath)
if !report.ContainsRow(relPath) {
report.AddRow(Row{relPath, UNTAGGED})
}
absPath, err := filepath.Abs(searchPath)
if err != nil {
return fmt.Errorf("%v: could not get absolute path: %v", searchPath, err)
}
stat, err := os.Stat(absPath)
if err != nil {
switch {
case os.IsNotExist(err):
return nil
case os.IsPermission(err):
log.Warnf("%v: permission denied.", searchPath)
return nil
default:
return fmt.Errorf("%v: could not stat: %v", searchPath, err)
}
}
if !command.directory && stat.IsDir() {
dir, err := os.Open(absPath)
if err != nil {
return fmt.Errorf("%v: could not open file: %v", searchPath, err)
}
dirNames, err := dir.Readdirnames(0)
if err != nil {
return fmt.Errorf("%v: could not read directory listing: %v", searchPath, err)
}
for _, dirName := range dirNames {
dirPath := filepath.Join(searchPath, dirName)
err = command.findNewFiles(dirPath, report)
if err != nil {
return err
}
}
}
return nil
}
func (command *FilesCommand) listFiles(files database.Files) error {
tree := path.NewTree()
for _, file := range files {
tree.Add(file.Path(), file.IsDir)
}
if command.top {
tree = tree.TopLevel()
} else {
if command.recursive {
fsFiles, err := command.filesystemFiles(tree.TopLevel().Paths())
if err != nil {
return err
}
for _, fsFile := range fsFiles {
tree.Add(fsFile.path, fsFile.isDir)
}
}
}
if command.leaf {
tree = tree.Leaves()
}
if command.file {
tree = tree.Files()
}
if command.directory {
tree = tree.Directories()
}
if command.count {
log.Print(len(tree.Paths()))
} else {
for _, absPath := range tree.Paths() {
relPath := path.Rel(absPath)
if command.print0 {
log.Print0(relPath)
} else {
log.Print(relPath)
}
}
}
return nil
}
func (command *StatusCommand) checkFile(file *database.File, report *StatusReport) error {
relPath := path.Rel(file.Path())
if command.verbose {
log.Infof("%v: checking file status.", file.Path())
}
stat, err := os.Stat(file.Path())
if err != nil {
switch {
case os.IsNotExist(err):
if command.verbose {
log.Infof("%v: file is missing.", file.Path())
}
report.AddRow(Row{relPath, MISSING})
return nil
case os.IsPermission(err):
log.Warnf("%v: permission denied.", file.Path())
case strings.Contains(err.Error(), "not a directory"):
report.AddRow(Row{relPath, MISSING})
return nil
default:
return fmt.Errorf("%v: could not stat: %v", file.Path(), err)
}
} else {
if stat.Size() != file.Size || stat.ModTime().UTC() != file.ModTime {
if command.verbose {
log.Infof("%v: file is modified.", file.Path())
}
report.AddRow(Row{relPath, MODIFIED})
} else {
if command.verbose {
log.Infof("%v: file is unchanged.", file.Path())
}
report.AddRow(Row{relPath, TAGGED})
}
}
return nil
}