This commit is contained in:
2024-07-20 18:58:30 +02:00
parent 37e2321551
commit 3f2f961791
2 changed files with 177 additions and 168 deletions

1
.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
main.log

344
main.go
View File

@@ -1,168 +1,176 @@
package main package main
import ( import (
"log" "log"
"os" "os"
"path" "path"
"path/filepath" "path/filepath"
"regexp" "regexp"
"strconv" "strconv"
"strings" "strings"
"time" "time"
"github.com/go-git/go-git/v5" "github.com/go-git/go-git/v5"
) "github.com/go-git/go-git/v5/plumbing/object"
)
var timeUnits = map[string]int64{
"ms": 1, var timeUnits = map[string]int64{
"s": 1000, "ms": 1,
"m": 1000 * 60, "s": 1000,
"h": 1000 * 60 * 60, "m": 1000 * 60,
"d": 1000 * 60 * 60 * 24, "h": 1000 * 60 * 60,
"M": 1000 * 60 * 60 * 24 * 30, "d": 1000 * 60 * 60 * 24,
"y": 1000 * 60 * 60 * 24 * 365, "M": 1000 * 60 * 60 * 24 * 30,
} "y": 1000 * 60 * 60 * 24 * 365,
}
var valueRegex, _ = regexp.Compile(`\d+`)
var unitRegex, _ = regexp.Compile(`[a-zA-Z]+`) var valueRegex, _ = regexp.Compile(`\d+`)
var unitRegex, _ = regexp.Compile(`[a-zA-Z]+`)
func parseDuration(date string) int64 {
var milliseconds int64 = 0 func parseDuration(date string) int64 {
var milliseconds int64 = 0
date = strings.TrimSpace(date)
var parts = strings.Split(date, "_") date = strings.TrimSpace(date)
for _, part := range parts { var parts = strings.Split(date, "_")
part = strings.TrimSpace(part) for _, part := range parts {
log.Printf("Parsing date part: %s\n", part) part = strings.TrimSpace(part)
var value = valueRegex.FindString(part) log.Printf("Parsing date part: %s\n", part)
var unit = unitRegex.FindString(part) var value = valueRegex.FindString(part)
var unit = unitRegex.FindString(part)
if value == "" || unit == "" {
log.Println("Invalid date part: " + part) if value == "" || unit == "" {
continue log.Println("Invalid date part: " + part)
} continue
}
if _, ok := timeUnits[unit]; !ok {
log.Println("Invalid date unit: " + unit) if _, ok := timeUnits[unit]; !ok {
continue log.Println("Invalid date unit: " + unit)
} continue
log.Printf("Part %s parsed as: Value: %s, Unit: %s\n", part, value, unit) }
log.Printf("Part %s parsed as: Value: %s, Unit: %s\n", part, value, unit)
var valueMs, _ = strconv.ParseInt(value, 10, 16)
valueMs = valueMs * timeUnits[unit] var valueMs, _ = strconv.ParseInt(value, 10, 16)
milliseconds += valueMs valueMs = valueMs * timeUnits[unit]
log.Printf("Adding %dms to duration, now: %d\n", valueMs, milliseconds) milliseconds += valueMs
} log.Printf("Adding %dms to duration, now: %d\n", valueMs, milliseconds)
}
return milliseconds
} return milliseconds
func getEnv(key, def string) string { }
var value, exists = os.LookupEnv(key) func getEnv(key, def string) string {
if exists { var value, exists = os.LookupEnv(key)
return value if exists {
} return value
return def }
} return def
}
func main() {
log.SetFlags(log.Lmicroseconds) func main() {
log.SetFlags(log.Lmicroseconds)
var ROOT = filepath.ToSlash(strings.TrimSpace(getEnv("ROOT", "/tmp")))
ROOT = path.Clean(ROOT) var ROOT = filepath.ToSlash(strings.TrimSpace(getEnv("ROOT", "/tmp")))
var SCAN_INTERVAL = time.Duration(parseDuration(getEnv("SCAN_INTERVAL", "1m")) * 1e6) ROOT = path.Clean(ROOT)
var SCAN_INTERVAL = time.Duration(parseDuration(getEnv("SCAN_INTERVAL", "1m")) * 1e6)
log.Println("Input args parsed as:")
log.Printf("ROOT: %s\n", ROOT) log.Println("Input args parsed as:")
log.Printf("SCAN_INTERVAL: %d\n", SCAN_INTERVAL.Milliseconds()) log.Printf("ROOT: %s\n", ROOT)
log.Printf("SCAN_INTERVAL: %d\n", SCAN_INTERVAL.Milliseconds())
// This shit DOES NOT run correctly on windows
// It absolutely butchers CRLF -> LF // This shit DOES NOT run correctly on windows
// And shits the bed // It absolutely butchers CRLF -> LF
// Thinking there are changed files // And shits the bed
// Making empty commits // Thinking there are changed files
// And other stupid shit // Making empty commits
// It does run on unix though // And other stupid shit
doRun(ROOT) // It does run on unix though
for { doRun(ROOT)
log.Printf("Running at %s", time.Now().Format(time.RFC3339)) for {
time.Sleep(SCAN_INTERVAL) log.Printf("Running at %s", time.Now().Format(time.RFC3339))
doRun(ROOT) time.Sleep(SCAN_INTERVAL)
} doRun(ROOT)
} }
}
func doRun(root string) {
log.Printf("Opening repository at %s...", root) func doRun(root string) {
worktree, err := OpenRepositoryAndWorktree(root) log.Printf("Opening repository at %s...", root)
if err != nil { worktree, err := OpenRepositoryAndWorktree(root)
log.Printf("error opening repository at %s: %v", root, err) if err != nil {
return log.Printf("error opening repository at %s: %v", root, err)
} return
log.Printf("Checking for changes in %s...", root) }
files, err := GetNumChangedFiles(worktree) log.Printf("Checking for changes in %s...", root)
if err != nil { files, err := GetNumChangedFiles(worktree)
log.Printf("error checking for changes in %s: %v", root, err) if err != nil {
return log.Printf("error checking for changes in %s: %v", root, err)
} return
if files == 0 { }
log.Printf("No changes in %s", root) if files == 0 {
return log.Printf("No changes in %s", root)
} return
log.Printf("Staging %d files in %s...", files, root) }
err = AddAll(worktree) log.Printf("Staging %d files in %s...", files, root)
if err != nil { err = AddAll(worktree)
log.Printf("error staging files in %s: %v", root, err) if err != nil {
return log.Printf("error staging files in %s: %v", root, err)
} return
log.Printf("Committing changes in %s...", root) }
err = CommitUpdate(worktree) log.Printf("Committing changes in %s...", root)
if err != nil { err = CommitUpdate(worktree)
log.Printf("error committing changes in %s: %v", root, err) if err != nil {
return log.Printf("error committing changes in %s: %v", root, err)
} return
log.Printf("Done committing updates in %s", root) }
} log.Printf("Done committing updates in %s", root)
}
func OpenRepositoryAndWorktree(root string) (*git.Worktree, error) {
repository, err := git.PlainOpen(root) func OpenRepositoryAndWorktree(root string) (*git.Worktree, error) {
if err != nil { repository, err := git.PlainOpen(root)
return nil, err if err != nil {
} return nil, err
}
worktree, err := repository.Worktree()
if err != nil { worktree, err := repository.Worktree()
return nil, err if err != nil {
} return nil, err
return worktree, nil }
} return worktree, nil
}
func HasChanges(worktree *git.Worktree) (bool, error) {
status, err := worktree.Status() func HasChanges(worktree *git.Worktree) (bool, error) {
if err != nil { status, err := worktree.Status()
return false, err if err != nil {
} return false, err
return !status.IsClean(), nil }
} return !status.IsClean(), nil
}
func GetNumChangedFiles(worktree *git.Worktree) (int, error) {
status, err := worktree.Status() func GetNumChangedFiles(worktree *git.Worktree) (int, error) {
if err != nil { status, err := worktree.Status()
return 0, err if err != nil {
} return 0, err
return len(status), nil }
} return len(status), nil
}
func AddAll(worktree *git.Worktree) error {
err := worktree.AddGlob("*") func AddAll(worktree *git.Worktree) error {
if err != nil { err := worktree.AddGlob("*")
return err if err != nil {
} return err
return nil }
} return nil
}
func CommitUpdate(worktree *git.Worktree) error {
_, err := worktree.Commit("Update", &git.CommitOptions{}) func CommitUpdate(worktree *git.Worktree) error {
if err != nil { _, err := worktree.Commit("Update", &git.CommitOptions{
return err AllowEmptyCommits: false,
} Author: &object.Signature{
return nil Name: "system",
} Email: "system@localhost",
When: time.Now(),
},
})
if err != nil {
return err
}
return nil
}