Compare commits

...

5 Commits

Author SHA1 Message Date
beca23447e More betterify logging 2025-03-10 18:47:13 +01:00
6359705714 Fix up logging a little 2025-03-10 18:36:11 +01:00
62bfb91246 Implement wildcards 2025-03-10 18:17:37 +01:00
083d42a9dd No longer support old format 2025-03-10 18:10:59 +01:00
71ea17122c Clean house 2025-03-10 18:08:23 +01:00
7 changed files with 271 additions and 118 deletions

1
.gitignore vendored
View File

@@ -1,3 +1,4 @@
*.exe *.exe
*.exe *.exe
cln cln
cln.log

View File

@@ -2,9 +2,9 @@ package main
import ( import (
"fmt" "fmt"
"log"
"os" "os"
"path/filepath" "path/filepath"
"slices"
"strings" "strings"
"gopkg.in/yaml.v3" "gopkg.in/yaml.v3"
@@ -132,12 +132,14 @@ func isTrue(value string) bool {
func (instruction *LinkInstruction) RunAsync(status chan (error)) { func (instruction *LinkInstruction) RunAsync(status chan (error)) {
defer close(status) defer close(status)
if !FileExists(instruction.Source) { if !FileExists(instruction.Source) {
status <- fmt.Errorf("instruction source %s%s%s does not exist", SourceColor, instruction.Source, DefaultColor) status <- fmt.Errorf("instruction source %s does not exist", FormatSourcePath(instruction.Source))
return return
} }
if !instruction.Force && AreSame(instruction.Source, instruction.Target) { if !instruction.Force && AreSame(instruction.Source, instruction.Target) {
status <- fmt.Errorf("source %s%s%s and target %s%s%s are the same, %snothing to do...%s", SourceColor, instruction.Source, DefaultColor, TargetColor, instruction.Target, DefaultColor, PathColor, DefaultColor) status <- fmt.Errorf("source %s and target %s are the same, nothing to do...",
FormatSourcePath(instruction.Source),
FormatTargetPath(instruction.Target))
return return
} }
@@ -145,47 +147,54 @@ func (instruction *LinkInstruction) RunAsync(status chan (error)) {
if instruction.Force { if instruction.Force {
isSymlink, err := IsSymlink(instruction.Target) isSymlink, err := IsSymlink(instruction.Target)
if err != nil { if err != nil {
status <- fmt.Errorf("could not determine whether %s%s%s is a sym link or not, stopping; err: %s%+v%s", TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor) status <- fmt.Errorf("could not determine whether %s is a sym link or not, stopping; err: %v",
FormatTargetPath(instruction.Target), err)
return return
} }
if instruction.Hard { if instruction.Hard {
info, err := os.Stat(instruction.Target) info, err := os.Stat(instruction.Target)
if err != nil { if err != nil {
status <- fmt.Errorf("could not stat %s%s%s, stopping; err: %s%+v%s", TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor) status <- fmt.Errorf("could not stat %s, stopping; err: %v",
FormatTargetPath(instruction.Target), err)
return return
} }
if info.Mode().IsRegular() && info.Name() == filepath.Base(instruction.Source) { if info.Mode().IsRegular() && info.Name() == filepath.Base(instruction.Source) {
log.Printf("Overwriting existing file %s%s%s", TargetColor, instruction.Target, DefaultColor) LogTarget("Overwriting existing file %s", instruction.Target)
err := os.Remove(instruction.Target) err := os.Remove(instruction.Target)
if err != nil { if err != nil {
status <- fmt.Errorf("could not remove existing file %s%s%s; err: %s%+v%s", TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor) status <- fmt.Errorf("could not remove existing file %s; err: %v",
FormatTargetPath(instruction.Target), err)
return return
} }
} }
} }
if isSymlink { if isSymlink {
log.Printf("Removing symlink at %s%s%s", TargetColor, instruction.Target, DefaultColor) LogTarget("Removing symlink at %s", instruction.Target)
err = os.Remove(instruction.Target) err = os.Remove(instruction.Target)
if err != nil { if err != nil {
status <- fmt.Errorf("failed deleting %s%s%s due to %s%+v%s", TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor) status <- fmt.Errorf("failed deleting %s due to %v",
FormatTargetPath(instruction.Target), err)
return return
} }
} else { } else {
if !instruction.Delete { if !instruction.Delete {
status <- fmt.Errorf("refusing to delte actual (non symlink) file %s%s%s", TargetColor, instruction.Target, DefaultColor) status <- fmt.Errorf("refusing to delte actual (non symlink) file %s",
FormatTargetPath(instruction.Target))
return return
} }
log.Printf("%sDeleting (!!!)%s %s%s%s", ImportantColor, DefaultColor, TargetColor, instruction.Target, DefaultColor) LogImportant("Deleting (!!!) %s", instruction.Target)
err = os.RemoveAll(instruction.Target) err = os.RemoveAll(instruction.Target)
if err != nil { if err != nil {
status <- fmt.Errorf("failed deleting %s%s%s due to %s%+v%s", TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor) status <- fmt.Errorf("failed deleting %s due to %v",
FormatTargetPath(instruction.Target), err)
return return
} }
} }
} else { } else {
status <- fmt.Errorf("target %s%s%s exists - handle manually or set the 'forced' flag (3rd field)", TargetColor, instruction.Target, DefaultColor) status <- fmt.Errorf("target %s exists - handle manually or set the 'forced' flag (3rd field)",
FormatTargetPath(instruction.Target))
return return
} }
} }
@@ -194,7 +203,8 @@ func (instruction *LinkInstruction) RunAsync(status chan (error)) {
if _, err := os.Stat(targetDir); os.IsNotExist(err) { if _, err := os.Stat(targetDir); os.IsNotExist(err) {
err = os.MkdirAll(targetDir, 0755) err = os.MkdirAll(targetDir, 0755)
if err != nil { if err != nil {
status <- fmt.Errorf("failed creating directory %s%s%s due to %s%+v%s", TargetColor, targetDir, DefaultColor, ErrorColor, err, DefaultColor) status <- fmt.Errorf("failed creating directory %s due to %v",
FormatTargetPath(targetDir), err)
return return
} }
} }
@@ -206,10 +216,15 @@ func (instruction *LinkInstruction) RunAsync(status chan (error)) {
err = os.Symlink(instruction.Source, instruction.Target) err = os.Symlink(instruction.Source, instruction.Target)
} }
if err != nil { if err != nil {
status <- fmt.Errorf("failed creating symlink between %s%s%s and %s%s%s with error %s%+v%s", SourceColor, instruction.Source, DefaultColor, TargetColor, instruction.Target, DefaultColor, ErrorColor, err, DefaultColor) status <- fmt.Errorf("failed creating symlink between %s and %s with error %v",
FormatSourcePath(instruction.Source),
FormatTargetPath(instruction.Target),
err)
return return
} }
log.Printf("Created symlink between %s%s%s and %s%s%s", SourceColor, instruction.Source, DefaultColor, TargetColor, instruction.Target, DefaultColor) LogInfo("Created symlink between %s and %s",
FormatSourcePath(instruction.Source),
FormatTargetPath(instruction.Target))
status <- nil status <- nil
} }
@@ -233,12 +248,33 @@ func ParseYAMLFile(filename, workdir string) ([]LinkInstruction, error) {
config.Links = instructions config.Links = instructions
} }
toRemove := []int{}
for i, link := range config.Links {
if strings.Contains(link.Source, "*") {
LogSource("Expanding wildcard source %s in YAML file %s", link.Source, filename)
newlinks, err := ExpandWildcard(link.Source, workdir, link.Target)
if err != nil {
return nil, fmt.Errorf("error expanding wildcard: %w", err)
}
LogInfo("Expanded wildcard source %s in YAML file %s to %d links",
FormatSourcePath(link.Source), FormatSourcePath(filename), len(newlinks))
config.Links = append(config.Links, newlinks...)
toRemove = append(toRemove, i)
}
}
for i := len(toRemove) - 1; i >= 0; i-- {
config.Links = slices.Delete(config.Links, toRemove[i], 1)
}
for i := range config.Links { for i := range config.Links {
config.Links[i].Tidy() link := &config.Links[i]
config.Links[i].Source, _ = ConvertHome(config.Links[i].Source)
config.Links[i].Target, _ = ConvertHome(config.Links[i].Target) link.Tidy()
config.Links[i].Source = NormalizePath(config.Links[i].Source, workdir) link.Source, _ = ConvertHome(link.Source)
config.Links[i].Target = NormalizePath(config.Links[i].Target, workdir) link.Target, _ = ConvertHome(link.Target)
link.Source = NormalizePath(link.Source, workdir)
link.Target = NormalizePath(link.Target, workdir)
// If Delete is true, Force must also be true // If Delete is true, Force must also be true
if config.Links[i].Delete { if config.Links[i].Delete {
@@ -249,6 +285,27 @@ func ParseYAMLFile(filename, workdir string) ([]LinkInstruction, error) {
return config.Links, nil return config.Links, nil
} }
func ExpandWildcard(source, workdir, target string) (links []LinkInstruction, err error) {
dir := filepath.Dir(source)
pattern := filepath.Base(source)
files, err := filepath.Glob(filepath.Join(workdir, dir, pattern))
if err != nil {
return nil, fmt.Errorf("error expanding wildcard: %w", err)
}
for _, file := range files {
link := LinkInstruction{
Source: file,
Target: filepath.Join(target, filepath.Base(file)),
}
links = append(links, link)
}
LogInfo("Expanded wildcard source %s to %d links", FormatSourcePath(source), len(links))
return
}
func IsYAMLFile(filename string) bool { func IsYAMLFile(filename string) bool {
ext := strings.ToLower(filepath.Ext(filename)) ext := strings.ToLower(filepath.Ext(filename))
return ext == ".yaml" || ext == ".yml" return ext == ".yaml" || ext == ".yml"

92
logger.go Normal file
View File

@@ -0,0 +1,92 @@
package main
import (
"fmt"
"log"
)
// Message type prefixes
const (
InfoPrefix = "INFO"
ErrorPrefix = "ERROR"
WarningPrefix = "WARN"
SourcePrefix = "SOURCE"
TargetPrefix = "TARGET"
PathPrefix = "PATH"
ImportantPrefix = "IMPORTANT"
)
// LogInfo logs an informational message
func LogInfo(format string, args ...interface{}) {
message := fmt.Sprintf(format, args...)
log.Printf("%s[%s]%s %s", BGreen, InfoPrefix, Reset, message)
}
// LogSource logs a message about a source file/path with proper coloring
func LogSource(format string, args ...interface{}) {
message := fmt.Sprintf(format, args...)
log.Printf("%s[%s]%s %s%s%s", BPurple, SourcePrefix, Reset, SourceColor, message, Reset)
}
// LogTarget logs a message about a target file/path with proper coloring
func LogTarget(format string, args ...interface{}) {
message := fmt.Sprintf(format, args...)
log.Printf("%s[%s]%s %s%s%s", BYellow, TargetPrefix, Reset, TargetColor, message, Reset)
}
// LogPath logs a message about a path with proper coloring
func LogPath(format string, args ...interface{}) {
message := fmt.Sprintf(format, args...)
log.Printf("%s[%s]%s %s%s%s", BGreen, PathPrefix, Reset, PathColor, message, Reset)
}
// LogImportant logs a message that needs attention with proper coloring
func LogImportant(format string, args ...interface{}) {
message := fmt.Sprintf(format, args...)
log.Printf("%s[%s]%s %s%s%s", BRed, ImportantPrefix, Reset, ImportantColor, message, Reset)
}
// LogError logs an error message with proper coloring that won't be cut off
func LogError(format string, args ...interface{}) {
// Format the message first with normal text (no red coloring)
message := fmt.Sprintf(format, args...)
// The Error prefix itself is bold red on a light background for maximum visibility
prefix := fmt.Sprintf("%s%s[%s]%s ", BRed, On_White, ErrorPrefix, Reset)
// The message is in default color (no red), only the [ERROR] prefix is colored
log.Printf("%s%s", prefix, message)
}
// FormatSourcePath returns a source path with proper coloring
func FormatSourcePath(path string) string {
return fmt.Sprintf("%s%s%s", SourceColor, path, Reset)
}
// FormatTargetPath returns a target path with proper coloring
func FormatTargetPath(path string) string {
return fmt.Sprintf("%s%s%s", TargetColor, path, Reset)
}
// FormatPathValue returns a path with proper coloring
func FormatPathValue(path string) string {
return fmt.Sprintf("%s%s%s", PathColor, path, Reset)
}
// FormatErrorValue returns an error value without any additional formatting
// Since error messages are no longer red, we don't need special formatting
func FormatErrorValue(err error) string {
if err == nil {
return ""
}
// Just return the error string with no color formatting
return fmt.Sprintf("%v", err)
}
// FormatErrorMessage formats an error message with no additional color formatting,
// while preserving the special formatting of embedded source/target/path elements.
func FormatErrorMessage(format string, args ...interface{}) string {
// This just formats the message with no additional color formatting
// The path formatting will still be preserved
return fmt.Sprintf(format, args...)
}

136
main.go
View File

@@ -15,13 +15,12 @@ import (
const deliminer = "," const deliminer = ","
const SourceColor = Purple const SourceColor = Purple
const TargetColor = Yellow const TargetColor = Yellow
const ErrorColor = URed const ErrorColor = Red
const ImportantColor = BRed const ImportantColor = BRed
const DefaultColor = White const DefaultColor = Reset
const PathColor = Green const PathColor = Green
var DirRegex, _ = regexp.Compile(`^(.+?)[/\\]sync(?:\.ya?ml)?$`) var FileRegex, _ = regexp.Compile(`sync\.ya?ml$`)
var FileRegex, _ = regexp.Compile(`^sync(?:\.ya?ml)?$`)
var programName = os.Args[0] var programName = os.Args[0]
func main() { func main() {
@@ -32,9 +31,9 @@ func main() {
if *debug { if *debug {
log.SetFlags(log.Lmicroseconds | log.Lshortfile) log.SetFlags(log.Lmicroseconds | log.Lshortfile)
logFile, err := os.Create("main.log") logFile, err := os.Create("cln.log")
if err != nil { if err != nil {
log.Printf("Error creating log file: %v", err) LogError("Error creating log file: %v", err)
os.Exit(1) os.Exit(1)
} }
logger := io.MultiWriter(os.Stdout, logFile) logger := io.MultiWriter(os.Stdout, logFile)
@@ -49,39 +48,36 @@ func main() {
// Check input sources in priority order // Check input sources in priority order
switch { switch {
case *recurse != "": case *recurse != "":
log.Printf("Recurse: %s", *recurse) LogInfo("Recurse: %s", *recurse)
go ReadFromFilesRecursively(*recurse, instructions, status) go ReadFromFilesRecursively(*recurse, instructions, status)
case *file != "": case *file != "":
log.Printf("File: %s", *file) LogInfo("File: %s", *file)
go ReadFromFile(*file, instructions, status, true) go ReadFromFile(*file, instructions, status, true)
case len(flag.Args()) > 0: case len(flag.Args()) > 0:
log.Printf("Reading from command line arguments") LogInfo("Reading from command line arguments")
go ReadFromArgs(instructions, status) go ReadFromArgs(instructions, status)
case IsPipeInput(): case IsPipeInput():
log.Printf("Reading from stdin pipe") LogInfo("Reading from stdin pipe")
go ReadFromStdin(instructions, status) go ReadFromStdin(instructions, status)
default: default:
if _, err := os.Stat("sync"); err == nil { if _, err := os.Stat("sync.yaml"); err == nil {
log.Printf("Using default sync file") LogInfo("Using default sync.yaml file")
go ReadFromFile("sync", instructions, status, true)
} else if _, err := os.Stat("sync.yaml"); err == nil {
log.Printf("Using default sync.yaml file")
go ReadFromFile("sync.yaml", instructions, status, true) go ReadFromFile("sync.yaml", instructions, status, true)
} else if _, err := os.Stat("sync.yml"); err == nil { } else if _, err := os.Stat("sync.yml"); err == nil {
log.Printf("Using default sync.yml file") LogInfo("Using default sync.yml file")
go ReadFromFile("sync.yml", instructions, status, true) go ReadFromFile("sync.yml", instructions, status, true)
} else { } else {
log.Printf("No input provided") LogInfo("No input provided")
log.Printf("Provide input as: ") LogInfo("Provide input as: ")
log.Printf("Arguments - %s <source>,<target>,<force?>", programName) LogInfo("Arguments - %s <source>,<target>,<force?>", programName)
log.Printf("File - %s -f <file>", programName) LogInfo("File - %s -f <file>", programName)
log.Printf("YAML File - %s -f <file.yaml>", programName) LogInfo("YAML File - %s -f <file.yaml>", programName)
log.Printf("Folder (finding sync files in folder recursively) - %s -r <folder>", programName) LogInfo("Folder (finding sync files in folder recursively) - %s -r <folder>", programName)
log.Printf("stdin - (cat <file> | %s)", programName) LogInfo("stdin - (cat <file> | %s)", programName)
os.Exit(1) os.Exit(1)
} }
} }
@@ -93,36 +89,36 @@ func main() {
break break
} }
if err != nil { if err != nil {
log.Println(err) LogError("%v", err)
} }
} }
}() }()
var instructionsDone int32 var instructionsDone int32 = 0
var wg sync.WaitGroup var wg sync.WaitGroup
for { for {
instruction, ok := <-instructions instruction, ok := <-instructions
if !ok { if !ok {
log.Printf("No more instructions to process") LogInfo("No more instructions to process")
break break
} }
log.Printf("Processing: %s", instruction.String()) LogInfo("Processing: %s", instruction.String())
status := make(chan error) status := make(chan error)
go instruction.RunAsync(status) go instruction.RunAsync(status)
wg.Add(1) wg.Add(1)
err := <-status err := <-status
if err != nil { if err != nil {
log.Printf("Failed parsing instruction %s%s%s due to %s%+v%s", SourceColor, instruction.String(), DefaultColor, ErrorColor, err, DefaultColor) LogError("Failed processing instruction: %v", err)
} }
atomic.AddInt32(&instructionsDone, 1) atomic.AddInt32(&instructionsDone, 1)
wg.Done() wg.Done()
} }
wg.Wait() wg.Wait()
log.Println("All done")
if instructionsDone == 0 { if instructionsDone == 0 {
log.Printf("No instructions were processed") LogInfo("No instructions were processed")
os.Exit(1) os.Exit(1)
} }
LogInfo("All done")
} }
func IsPipeInput() bool { func IsPipeInput() bool {
@@ -139,55 +135,63 @@ func ReadFromFilesRecursively(input string, output chan *LinkInstruction, status
workdir, _ := os.Getwd() workdir, _ := os.Getwd()
input = NormalizePath(input, workdir) input = NormalizePath(input, workdir)
log.Printf("Reading input from files recursively starting in %s%s%s", PathColor, input, DefaultColor) LogInfo("Reading input from files recursively starting in %s", FormatPathValue(input))
files := make(chan string, 128) files := make(chan string, 128)
recurseStatus := make(chan error) fileStatus := make(chan error)
go GetSyncFilesRecursively(input, files, recurseStatus) var wg sync.WaitGroup
go GetSyncFilesRecursively(input, files, fileStatus)
go func() {
wg.Wait()
close(files)
}()
go func() { go func() {
for { for {
err, ok := <-recurseStatus err, ok := <-fileStatus
if !ok { if !ok {
break break
} }
if err != nil { if err != nil {
log.Printf("Failed to get sync files recursively: %s%+v%s", ErrorColor, err, DefaultColor) LogError("Failed to get sync files recursively: %v", err)
status <- err status <- err
} }
} }
}() }()
var wg sync.WaitGroup
for { for {
file, ok := <-files file, ok := <-files
if !ok { if !ok {
log.Printf("No more files to process") LogInfo("No more files to process")
break break
} }
wg.Add(1) wg.Add(1)
go func() { go func() {
defer wg.Done() defer wg.Done()
log.Println(file) LogInfo(file)
file = NormalizePath(file, workdir) file = NormalizePath(file, workdir)
log.Printf("Processing file: %s%s%s", PathColor, file, DefaultColor) LogInfo("Processing file: %s", FormatPathValue(file))
// This "has" to be done because instructions are resolved in relation to cwd // This "has" to be done because instructions are resolved in relation to cwd
fileDir := DirRegex.FindStringSubmatch(file) fileDir := FileRegex.FindStringSubmatch(file)
if fileDir == nil { if fileDir == nil {
log.Printf("Failed to extract directory from %s%s%s", SourceColor, file, DefaultColor) LogError("Failed to extract directory from %s", FormatSourcePath(file))
return return
} }
log.Printf("Changing directory to %s%s%s (for %s%s%s)", PathColor, fileDir[1], DefaultColor, PathColor, file, DefaultColor) LogInfo("Changing directory to %s (for %s)",
FormatPathValue(fileDir[1]),
FormatPathValue(file))
err := os.Chdir(fileDir[1]) err := os.Chdir(fileDir[1])
if err != nil { if err != nil {
log.Printf("Failed to change directory to %s%s%s: %s%+v%s", SourceColor, fileDir[1], DefaultColor, ErrorColor, err, DefaultColor) LogError("Failed to change directory to %s: %v",
FormatSourcePath(fileDir[1]), err)
return return
} }
ReadFromFile(file, output, status, false) ReadFromFile(file, output, status, false)
// Don't return directory, stay where we are
os.Chdir(workdir)
}() }()
} }
wg.Wait()
} }
func ReadFromFile(input string, output chan *LinkInstruction, status chan error, doclose bool) { func ReadFromFile(input string, output chan *LinkInstruction, status chan error, doclose bool) {
@@ -197,48 +201,26 @@ func ReadFromFile(input string, output chan *LinkInstruction, status chan error,
} }
input = NormalizePath(input, filepath.Dir(input)) input = NormalizePath(input, filepath.Dir(input))
log.Printf("Reading input from file: %s%s%s", PathColor, input, DefaultColor) LogInfo("Reading input from file: %s", FormatPathValue(input))
// Check if this is a YAML file // Check if this is a YAML file
if IsYAMLFile(input) { if IsYAMLFile(input) {
log.Printf("Parsing as YAML file") LogInfo("Parsing as YAML file")
instructions, err := ParseYAMLFile(input, filepath.Dir(input)) instructions, err := ParseYAMLFile(input, filepath.Dir(input))
if err != nil { if err != nil {
log.Printf("Failed to parse YAML file %s%s%s: %s%+v%s", LogError("Failed to parse YAML file %s: %v",
SourceColor, input, DefaultColor, ErrorColor, err, DefaultColor) FormatSourcePath(input), err)
status <- err status <- err
return return
} }
for _, instruction := range instructions { for _, instruction := range instructions {
instr := instruction // Create a copy to avoid reference issues instr := instruction // Create a copy to avoid reference issues
log.Printf("Read YAML instruction: %s", instr.String()) LogInfo("Read YAML instruction: %s", instr.String())
output <- &instr output <- &instr
} }
return return
} }
// Handle CSV format (legacy)
file, err := os.Open(input)
if err != nil {
log.Fatalf("Failed to open file %s%s%s: %s%+v%s",
SourceColor, input, DefaultColor, ErrorColor, err, DefaultColor)
return
}
defer file.Close()
scanner := bufio.NewScanner(file)
for scanner.Scan() {
line := scanner.Text()
instruction, err := ParseInstruction(line, filepath.Dir(input))
if err != nil {
log.Printf("Error parsing line: %s'%s'%s, error: %s%+v%s",
SourceColor, line, DefaultColor, ErrorColor, err, DefaultColor)
continue
}
log.Printf("Read instruction: %s", instruction.String())
output <- &instruction
}
} }
func ReadFromArgs(output chan *LinkInstruction, status chan error) { func ReadFromArgs(output chan *LinkInstruction, status chan error) {
@@ -246,11 +228,11 @@ func ReadFromArgs(output chan *LinkInstruction, status chan error) {
defer close(status) defer close(status)
workdir, _ := os.Getwd() workdir, _ := os.Getwd()
log.Printf("Reading input from args") LogInfo("Reading input from args")
for _, arg := range flag.Args() { for _, arg := range flag.Args() {
instruction, err := ParseInstruction(arg, workdir) instruction, err := ParseInstruction(arg, workdir)
if err != nil { if err != nil {
log.Printf("Error parsing arg: %s'%s'%s, error: %s%+v%s", SourceColor, arg, DefaultColor, ErrorColor, err, DefaultColor) LogError("Error parsing arg '%s': %v", arg, err)
continue continue
} }
output <- &instruction output <- &instruction
@@ -262,20 +244,20 @@ func ReadFromStdin(output chan *LinkInstruction, status chan error) {
defer close(status) defer close(status)
workdir, _ := os.Getwd() workdir, _ := os.Getwd()
log.Printf("Reading input from stdin") LogInfo("Reading input from stdin")
scanner := bufio.NewScanner(os.Stdin) scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() { for scanner.Scan() {
line := scanner.Text() line := scanner.Text()
instruction, err := ParseInstruction(line, workdir) instruction, err := ParseInstruction(line, workdir)
if err != nil { if err != nil {
log.Printf("Error parsing line: %s'%s'%s, error: %s%+v%s", SourceColor, line, DefaultColor, ErrorColor, err, DefaultColor) LogError("Error parsing line '%s': %v", line, err)
continue continue
} }
output <- &instruction output <- &instruction
} }
if err := scanner.Err(); err != nil { if err := scanner.Err(); err != nil {
log.Fatalf("Error reading from stdin: %s%+v%s", ErrorColor, err, DefaultColor) LogError("Error reading from stdin: %v", err)
status <- err status <- err
return return
} }

View File

@@ -1,10 +1,2 @@
- source: main.go - source: \*
target: test/main.go target: test/
- source: README.md
target: test/README.md
- source: sync.yaml
target: test/sync.yaml

26
synclib.log Normal file
View File

@@ -0,0 +1,26 @@
18:24:37.967093 Using default sync.yaml file
18:24:37.967093 Input 'sync.yaml' is not absolute, prepending work dir '.'
18:24:37.967593 Reading input from file: C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml
18:24:37.967593 Parsing as YAML file
18:24:37.967593 Failed to parse YAML file C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml: error unmarshaling YAML: yaml: unmarshal errors:
line 1: cannot unmarshal !!seq into main.YAMLConfig
18:24:37.967593 No more instructions to process
18:24:37.968092 No instructions were processed
18:27:59.691333 Using default sync.yaml file
18:27:59.691333 Input 'sync.yaml' is not absolute, prepending work dir '.'
18:27:59.691834 Reading input from file: C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml
18:27:59.691834 Parsing as YAML file
18:27:59.692335 Expanding wildcard source \* in YAML file C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml
18:27:59.692335 Expanded wildcard source \* to 0 links
18:27:59.692836 Expanded wildcard source \* in YAML file C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml to 0 links
18:27:59.692836 No more instructions to process
18:27:59.692836 No instructions were processed
18:28:04.075821 Using default sync.yaml file
18:28:04.076320 Input 'sync.yaml' is not absolute, prepending work dir '.'
18:28:04.076320 Reading input from file: C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml
18:28:04.076320 Parsing as YAML file
18:28:04.076320 Expanding wildcard source \* in YAML file C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml
18:28:04.076821 Expanded wildcard source \* to 0 links
18:28:04.076821 Expanded wildcard source \* in YAML file C:/Users/Administrator/Seafile/Projects-Go/GoProjects/synclib/sync.yaml to 0 links
18:28:04.076821 No more instructions to process
18:28:04.076821 No instructions were processed

23
util.go
View File

@@ -2,7 +2,6 @@ package main
import ( import (
"fmt" "fmt"
"log"
"os" "os"
"path/filepath" "path/filepath"
"strings" "strings"
@@ -33,12 +32,12 @@ func NormalizePath(input, workdir string) string {
input = strings.ReplaceAll(input, "\"", "") input = strings.ReplaceAll(input, "\"", "")
if !filepath.IsAbs(input) { if !filepath.IsAbs(input) {
log.Printf("Input '%s' is not absolute, prepending work dir '%s'", input, workdir) LogInfo("Input '%s' is not absolute, prepending work dir '%s'", input, workdir)
var err error var err error
input = filepath.Join(workdir, input) input = filepath.Join(workdir, input)
input, err = filepath.Abs(input) input, err = filepath.Abs(input)
if err != nil { if err != nil {
log.Printf("Failed to get absolute path for %s%s%s: %s%+v%s", SourceColor, input, DefaultColor, ErrorColor, err, DefaultColor) LogError("Failed to get absolute path for %s: %v", FormatSourcePath(input), err)
return input return input
} }
} }
@@ -104,7 +103,7 @@ func GetSyncFilesRecursively(input string, output chan string, status chan error
dirCount) dirCount)
case <-done: case <-done:
// Final progress update // Final progress update
fmt.Printf("\rFiles processed: %d; Folders processed: %d; Completed successfully\n", fmt.Printf("\nFiles processed: %d; Folders processed: %d; Completed successfully\n",
atomic.LoadInt32(&filesProcessed), atomic.LoadInt32(&filesProcessed),
atomic.LoadInt32(&foldersProcessed)) atomic.LoadInt32(&foldersProcessed))
return return
@@ -115,6 +114,8 @@ func GetSyncFilesRecursively(input string, output chan string, status chan error
allDone := make(chan struct{}) allDone := make(chan struct{})
go func() { go func() {
// WTF is this waitgroup?
// Nowhere is it added...
var wg sync.WaitGroup var wg sync.WaitGroup
go func() { go func() {
@@ -126,7 +127,7 @@ func GetSyncFilesRecursively(input string, output chan string, status chan error
return return
} }
} }
time.Sleep(50 * time.Millisecond) time.Sleep(50 * time.Millisecond)
} }
}() }()
@@ -155,15 +156,17 @@ func GetSyncFilesRecursively(input string, output chan string, status chan error
<-allDone <-allDone
log.Printf("Files processed: %d; Folders processed: %d", if atomic.LoadInt32(&filesProcessed) > 0 {
atomic.LoadInt32(&filesProcessed), LogInfo("Files processed: %d; Folders processed: %d",
atomic.LoadInt32(&foldersProcessed)) atomic.LoadInt32(&filesProcessed),
atomic.LoadInt32(&foldersProcessed))
}
} }
func processDirectory(directory string, directories chan<- string, output chan<- string, filesProcessed *int32) { func processDirectory(directory string, directories chan<- string, output chan<- string, filesProcessed *int32) {
files, err := os.ReadDir(directory) files, err := os.ReadDir(directory)
if err != nil { if err != nil {
log.Printf("Error reading directory %s: %+v", directory, err) LogError("Error reading directory %s: %v", directory, err)
return return
} }
@@ -171,7 +174,7 @@ func processDirectory(directory string, directories chan<- string, output chan<-
if file.IsDir() { if file.IsDir() {
directories <- filepath.Join(directory, file.Name()) directories <- filepath.Join(directory, file.Name())
} else { } else {
if FileRegex.MatchString(file.Name()) || IsYAMLSyncFile(file.Name()) { if IsYAMLSyncFile(file.Name()) {
output <- filepath.Join(directory, file.Name()) output <- filepath.Join(directory, file.Name())
} }
atomic.AddInt32(filesProcessed, 1) atomic.AddInt32(filesProcessed, 1)