Prevent archiving already archived files

They were like 90G big...

.gitignore

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

build.sh

@@ -1 +0,0 @@
-docker build -t directory-cleaner .

deploy.sh

@@ -0,0 +1,2 @@
+docker build -t docker.site.quack-lab.dev/directory-cleaner .
+docker push docker.site.quack-lab.dev/directory-cleaner

deploy_nssm.sh

@@ -0,0 +1,4 @@
+sh nssm_stopall.sh
+sh nssm_rmall.sh
+sh nssm_deployall.sh
+sh nssm_startall.sh

dockerfile

@@ -1,30 +1,21 @@
-# syntax=docker/dockerfile:1
+FROM golang:1.21.6 as base
-FROM golang:1.22-rc-alpine
+
-
+WORKDIR $GOPATH/src/app/
-# Set destination for COPY
+
-WORKDIR /app
+COPY . .
-
+
-# Download Go modules
+RUN go mod download
-COPY go.mod go.sum ./
+RUN go mod verify
-RUN go mod download
+
-
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /main .
-# Copy the source code. Note the slash at the end, as explained in
+
-# https://docs.docker.com/engine/reference/builder/#copy
+FROM scratch
-# May not be enough for complex projects
+
-COPY *.go ./
+COPY --from=base /usr/share/zoneinfo /usr/share/zoneinfo
-
+COPY --from=base /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
-# Build
+COPY --from=base /etc/passwd /etc/passwd
-# Add GOOS=linux for linux
+COPY --from=base /etc/group /etc/group
-# GOOS=windows
+
-# GOOS=darwin
+COPY --from=base /main .
-RUN go build -o /main
+
-
-# Optional:
-# To bind to a TCP port, runtime parameters must be supplied to the docker command.
-# But we can document in the Dockerfile what ports
-# the application is going to listen on by default.
-# https://docs.docker.com/engine/reference/builder/#expose
-# EXPOSE 8080
-
-# Run
 CMD ["/main"]

go.mod

@@ -1,7 +1,18 @@
-module main
+module directory-cleaner
 
-go 1.21.6
+go 1.23.6
 
-require github.com/djherbis/times v1.6.0
+require (
+	git.site.quack-lab.dev/dave/cylogger v1.3.0
+	github.com/bmatcuk/doublestar/v4 v4.9.1
+	github.com/djherbis/times v1.6.0
+)
 
-require golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c // indirect
+require (
+	github.com/google/go-cmp v0.5.9 // indirect
+	github.com/hexops/valast v1.5.0 // indirect
+	golang.org/x/mod v0.7.0 // indirect
+	golang.org/x/sys v0.3.0 // indirect
+	golang.org/x/tools v0.4.0 // indirect
+	mvdan.cc/gofumpt v0.4.0 // indirect
+)

go.sum

@@ -1,4 +1,33 @@
+git.site.quack-lab.dev/dave/cylogger v1.3.0 h1:eTWPUD+ThVi8kGIsRcE0XDeoH3yFb5miFEODyKUdWJw=
+git.site.quack-lab.dev/dave/cylogger v1.3.0/go.mod h1:wctgZplMvroA4X6p8f4B/LaCKtiBcT1Pp+L14kcS8jk=
+github.com/bmatcuk/doublestar/v4 v4.9.1 h1:X8jg9rRZmJd4yRy7ZeNDRnM+T3ZfHv15JiBJ/avrEXE=
+github.com/bmatcuk/doublestar/v4 v4.9.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
 github.com/djherbis/times v1.6.0 h1:w2ctJ92J8fBvWPxugmXIv7Nz7Q3iDMKNx9v5ocVH20c=
 github.com/djherbis/times v1.6.0/go.mod h1:gOHeRAz2h+VJNZ5Gmc/o7iD9k4wW7NMVqieYCY99oc0=
-golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c h1:aFV+BgZ4svzjfabn8ERpuB4JI4N6/rdy1iusx77G3oU=
+github.com/frankban/quicktest v1.14.3 h1:FJKSZTDHjyhriyC81FLQ0LY93eSai0ZyR/ZIkd3ZUKE=
+github.com/frankban/quicktest v1.14.3/go.mod h1:mgiwOwqx65TmIk1wJ6Q7wvnVMocbUorkibMOrVTHZps=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/hexops/autogold v0.8.1 h1:wvyd/bAJ+Dy+DcE09BoLk6r4Fa5R5W+O+GUzmR985WM=
+github.com/hexops/autogold v0.8.1/go.mod h1:97HLDXyG23akzAoRYJh/2OBs3kd80eHyKPvZw0S5ZBY=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
+github.com/hexops/valast v1.5.0 h1:FBTuvVi0wjTngtXJRZXMbkN/Dn6DgsUsBwch2DUJU8Y=
+github.com/hexops/valast v1.5.0/go.mod h1:Jcy1pNH7LNraVaAZDLyv21hHg2WBv9Nf9FL6fGxU7o4=
+github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
+github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+golang.org/x/mod v0.7.0 h1:LapD9S96VoQRhi/GrNTqeBJFrUjs5UHCAtTlgwA5oZA=
+golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ=
+golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/tools v0.4.0 h1:7mTAgkunk3fr4GAloyyCasadO6h9zSsQZbwvcaIciV4=
+golang.org/x/tools v0.4.0/go.mod h1:UE5sM2OK9E/d67R0ANs2xJizIymRP5gJU295PvKXxjQ=
+mvdan.cc/gofumpt v0.4.0 h1:JVf4NN1mIpHogBj7ABpgOyZc65/UUOkKQFkoURsz4MM=
+mvdan.cc/gofumpt v0.4.0/go.mod h1:PljLOHDeZqgS8opHRKLzp2It2VBuSdteAgqUfzMTxlQ=

main.go

@@ -1,268 +1,349 @@
-package main
+package main
-
+
-import (
+import (
-	"log"
+	"flag"
-	"os"
+	"os"
-	"path/filepath"
+	"path/filepath"
-	"regexp"
+	"regexp"
-	"strconv"
+	"strconv"
-	"strings"
+	"strings"
-	"time"
+	"time"
-
+
-	"github.com/djherbis/times"
+	logger "git.site.quack-lab.dev/dave/cylogger"
-)
+	"github.com/bmatcuk/doublestar/v4"
-
+	"github.com/djherbis/times"
-var timeUnits = map[string]int64{
+)
-	"ms": 1,
+
-	"s":  1000,
+type Constants struct {
-	"m":  1000 * 60,
+	ROOT                string
-	"h":  1000 * 60 * 60,
+	ROOT_ARCHIVE        string
-	"d":  1000 * 60 * 60 * 24,
+	IGNORED_DIRECTORIES []string
-	"M":  1000 * 60 * 60 * 24 * 30,
+	ARCHIVE_THRESHOLD   int64 // ms
-	"y":  1000 * 60 * 60 * 24 * 365,
+	DELETE_THRESHOLD    int64 // ms
-}
+	SCAN_INTERVAL       time.Duration
-
+	USE_MODTIME         bool
-var valueRegex, _ = regexp.Compile(`\d+`)
+}
-var unitRegex, _ = regexp.Compile(`[a-zA-Z]+`)
+
-
+var (
-func parseDuration(date string) int64 {
+	constants        Constants
-	var milliseconds int64 = 0
+	timeUnits        = map[string]int64{"ms": 1, "s": 1000, "m": 60_000, "h": 3_600_000, "d": 86_400_000, "M": 2_592_000_000, "y": 31_536_000_000}
-
+	valueRegex       = regexp.MustCompile(`\d+`)
-	date = strings.TrimSpace(date)
+	unitRegex        = regexp.MustCompile(`[a-zA-Z]+`)
-	var parts = strings.Split(date, "_")
+	numFilesArchived = 0
-	for _, part := range parts {
+	numFilesDeleted  = 0
-		part = strings.TrimSpace(part)
+)
-		log.Printf("Parsing date part: %s\n", part)
+
-		var value = valueRegex.FindString(part)
+func parseDurationMS(expr string) int64 {
-		var unit = unitRegex.FindString(part)
+	expr = strings.TrimSpace(expr)
-
+	if expr == "" {
-		if value == "" || unit == "" {
+		return 0
-			log.Println("Invalid date part: " + part)
+	}
-			continue
+	var total int64
-		}
+	for _, p := range strings.Split(expr, "_") {
-
+		p = strings.TrimSpace(p)
-		if _, ok := timeUnits[unit]; !ok {
+		if p == "" {
-			log.Println("Invalid date unit: " + unit)
+			continue
-			continue
+		}
-		}
+		v := valueRegex.FindString(p)
-		log.Printf("Part %s parsed as: Value: %s, Unit: %s\n", part, value, unit)
+		u := unitRegex.FindString(p)
-
+		if v == "" || u == "" {
-		var valueMs, _ = strconv.ParseInt(value, 10, 16)
+			logger.Warning("Invalid duration part: %q", p)
-		valueMs = valueMs * timeUnits[unit]
+			continue
-		milliseconds += valueMs
+		}
-		log.Printf("Adding %dms to duration, now: %d\n", valueMs, milliseconds)
+		unit, ok := timeUnits[u]
-	}
+		if !ok {
-
+			logger.Warning("Invalid duration unit: %q", u)
-	return milliseconds
+			continue
-}
+		}
-
+		n, err := strconv.ParseInt(v, 10, 64)
-func getEnv(key, def string) string {
+		if err != nil {
-	var value, exists = os.LookupEnv(key)
+			logger.Warning("Invalid duration value: %q: %v", v, err)
-	if exists {
+			continue
-		return value
+		}
-	}
+		total += n * unit
-	return def
+	}
-}
+	return total
-
+}
-func scanRoot() {
+
-	log.Println("Scanning root directory...")
+func getenv(key, def string) string {
-	filepath.Walk(constants.ROOT, func(path string, info os.FileInfo, err error) error {
+	if v, ok := os.LookupEnv(key); ok {
-		if err != nil {
+		return v
-			log.Printf("Error scanning %s: %s\n", path, err)
+	}
-			return nil
+	return def
-		}
+}
-		path = filepath.ToSlash(path)
+
-
+func loadConfig() Constants {
-		if path == constants.ROOT {
+	flag.Parse()
-			log.Printf("Skipping root directory %s...\n", path)
+	logger.InitFlag()
-			return nil
+
-		}
+	root := filepath.ToSlash(strings.TrimSpace(getenv("ROOT", "/tmp")))
-
+	archive := filepath.ToSlash(strings.TrimSpace(getenv("ROOT_ARCHIVE", root+"/archive")))
-		if info.IsDir() {
+	_ = os.MkdirAll(archive, os.ModePerm)
-			log.Printf("Skipping directory %s...\n", path)
+
-			return filepath.SkipDir
+	// TODO: This just doesn't really work or do what it says it does
-		}
+	// Fix it...
-
+	// Right now we don't care because we're not using it
-		// We hope that IGNORED_DIRECTORIES is a small list, so we can afford to iterate over it
+	// But we might want to...
-		// In fact iteration should be faster for small lists rather than hashing
+	ignored := []string{}
-		for _, ignoredDir := range constants.IGNORED_DIRECTORIES {
+	if ig := strings.TrimSpace(getenv("IGNORED_DIRECTORIES", "")); ig != "" {
-			log.Println(constants.IGNORED_DIRECTORIES, len(constants.IGNORED_DIRECTORIES))
+		for _, s := range strings.Split(ig, ",") {
-			if strings.HasPrefix(path, ignoredDir) {
+			if t := strings.TrimSpace(s); t != "" {
-				log.Printf("Ignoring directory %s\n", path)
+				ignored = append(ignored, filepath.ToSlash(t))
-				return filepath.SkipDir
+			}
-			}
+		}
-		}
+	}
-
+
-		processFile(path, info)
+	archiveMs := parseDurationMS(getenv("ARCHIVE_THRESHOLD", "1d"))
-		return nil
+	deleteMs := parseDurationMS(getenv("DELETE_THRESHOLD", "12h"))
-	})
+	interval := time.Duration(parseDurationMS(getenv("SCAN_INTERVAL", "1m"))) * time.Millisecond
-}
+	useMod := strings.EqualFold(strings.TrimSpace(getenv("USE_MODTIME", "false")), "true")
-
+
-func scanArchive() {
+	logger.Info("Config:")
-	log.Println("Scanning archive...")
+	logger.Info("  ROOT: %s", root)
-	filepath.Walk(constants.ROOT_ARCHIVE, func(path string, info os.FileInfo, err error) error {
+	logger.Info("  ROOT_ARCHIVE: %s", archive)
-		if err != nil {
+	logger.Info("  IGNORED_DIRECTORIES: %v", ignored)
-			log.Printf("Error scanning %s: %s\n", path, err)
+	logger.Info("  ARCHIVE_THRESHOLD(ms): %d", archiveMs)
-			return nil
+	logger.Info("  DELETE_THRESHOLD(ms): %d", deleteMs)
-		}
+	logger.Info("  SCAN_INTERVAL(ms): %d", interval.Milliseconds())
-		path = filepath.ToSlash(path)
+	logger.Info("  USE_MODTIME: %t", useMod)
-
+
-		if path == constants.ROOT_ARCHIVE {
+	return Constants{
-			log.Printf("Skipping root directory %s...\n", path)
+		ROOT:                root,
-			return nil
+		ROOT_ARCHIVE:        archive,
-		}
+		IGNORED_DIRECTORIES: ignored,
-
+		ARCHIVE_THRESHOLD:   archiveMs,
-		processArchiveFile(path, info)
+		DELETE_THRESHOLD:    deleteMs,
-		return nil
+		SCAN_INTERVAL:       interval,
-	})
+		USE_MODTIME:         useMod,
-}
+	}
-
+}
-func processFile(path string, info os.FileInfo) {
+
-	var now = time.Now().UnixMilli()
+func shouldIgnore(path string) bool {
-
+	log := logger.Default.WithPrefix("shouldIgnore").WithPrefix(path)
-	var fileATime int64 = times.Get(info).AccessTime().UnixMilli()
+	// Match against slash-normalized full path
-	var accessTimeDelta = now - fileATime
+	path = filepath.ToSlash(path)
-	log.Printf("File %s last accessed at %d, %dms ago\n", path, fileATime, accessTimeDelta)
+	for _, pat := range constants.IGNORED_DIRECTORIES {
-	if accessTimeDelta > constants.ARCHIVE_THRESHOLD {
+		patLog := log.WithPrefix(pat)
-		log.Printf("File %s was accessed more than %dms ago, archiving...\n", path, constants.ARCHIVE_THRESHOLD)
+		ok, err := doublestar.Match(pat, path)
-		archiveFile(path)
+		if err != nil {
-	}
+			patLog.Warning("Ignore pattern error %q vs %q: %v", pat, path, err)
-}
+			continue
-
+		}
-func processArchiveFile(path string, info os.FileInfo) {
+		if ok {
-	var now = time.Now().UnixMilli()
+			patLog.Debug("ignore due to doublestar %q", pat)
-
+			return true
-	var fileATime int64 = times.Get(info).AccessTime().UnixMilli()
+		}
-	var accessTimeDelta = now - fileATime
+	}
-	log.Printf("File %s last accessed at %d, %dms ago\n", path, fileATime, accessTimeDelta)
+	return false
-	if accessTimeDelta > constants.DELETE_THRESHOLD {
+}
-		log.Printf("File %s was accessed more than %dms ago, deleting...\n", path, constants.DELETE_THRESHOLD)
+
-		deleteFile(path)
+func fileTime(info os.FileInfo) int64 {
-	}
+	t := times.Get(info)
-}
+	if constants.USE_MODTIME {
-
+		return t.ModTime().UnixMilli()
-func archiveFile(path string) {
+	}
-	// defer os.Exit(1)
+	// If AccessTime is not supported, it returns ModTime; times handles that internally.
-	var newPath = constants.ROOT_ARCHIVE + strings.Replace(path, constants.ROOT, "", 1)
+	return t.AccessTime().UnixMilli()
-	log.Printf("Archiving file %s to %s...\n", path, newPath)
+}
-
+
-	os.MkdirAll(filepath.Dir(newPath), os.ModePerm)
+func archiveCandidate(path string, info os.FileInfo) {
-	var err = os.Rename(path, newPath)
+	log := logger.Default.WithPrefix("archiveCandidate")
-	if err != nil {
+	if info.IsDir() {
-		log.Printf("Error archiving file %s: %s\n", path, err)
+		return
-		return
+	}
-	}
+	now := time.Now().UnixMilli()
-}
+	ft := fileTime(info)
-
+	log.Debug("now %s filetime %s", time.UnixMilli(now).Format(time.RFC3339), time.UnixMilli(ft).Format(time.RFC3339))
-func deleteFile(path string) {
+	if now-ft <= constants.ARCHIVE_THRESHOLD {
-	// defer os.Exit(1)
+		log.Debug("skip")
-	log.Printf("Deleting file %s...\n", path)
+		return
-	var err = os.Remove(path)
+	}
-	if err != nil {
+
-		log.Printf("Error deleting file %s: %s\n", path, err)
+	rel, err := filepath.Rel(constants.ROOT, path)
-		return
+	if err != nil {
-	}
+		log.Warning("rel ROOT->%s: %v", path, err)
-}
+		return
-
+	}
-func cleanRoot() {
+	if strings.HasPrefix(rel, "archive") {
-	var files, err = os.ReadDir(constants.ROOT)
+		log.Debug("refusing to archive a file that's already archived")
-	if err != nil {
+		return
-		log.Printf("Error reading root directory %s: %s\n", constants.ROOT, err)
+	}
-		return
+	log.Debug("rel %q", rel)
-	}
+	dst := filepath.Join(constants.ROOT_ARCHIVE, rel)
-	for _, file := range files {
+	log.Debug("dst %q", dst)
-		if !file.IsDir() {
+
-			continue
+	if err := os.MkdirAll(filepath.Dir(dst), os.ModePerm); err != nil {
-		}
+		log.Error("mkdir %s: %v", filepath.Dir(dst), err)
-		var empty, err = isDirEmpty(constants.ROOT + "/" + file.Name())
+		return
-		if err != nil {
+	}
-			log.Printf("Error checking if directory %s is empty: %s\n", file.Name(), err)
+
-			continue
+	if err := os.Rename(path, dst); err != nil {
-		}
+		log.Error("archive %s -> %s: %v", path, dst, err)
-		log.Printf("Directory %s isempty: %t\n", file.Name(), empty)
+		return
-		if empty {
+	}
-			log.Printf("Deleting empty directory %s\n", file.Name())
+	numFilesArchived++
-			var err = os.RemoveAll(constants.ROOT + "/" + file.Name())
+	log.Info("Archived: %s -> %s", path, dst)
-			if err != nil {
+}
-				log.Printf("Error deleting empty directory %s: %s\n", file.Name(), err)
+
-			}
+func deleteCandidate(path string, info os.FileInfo) {
-		}
+	log := logger.Default.WithPrefix("deleteCandidate").WithPrefix(path)
-	}
+	if info.IsDir() {
-}
+		return
-func isDirEmpty(dirPath string) (bool, error) {
+	}
-	var empty = true
+	now := time.Now().UnixMilli()
-	var ferr error = nil
+	ft := fileTime(info)
-
+	log.Debug("now %s filetime %s", time.UnixMilli(now).Format(time.RFC3339), time.UnixMilli(ft).Format(time.RFC3339))
-	filepath.Walk(dirPath, func(path string, info os.FileInfo, err error) error {
+	if now-ft <= constants.DELETE_THRESHOLD {
-		if err != nil {
+		log.Debug("skip")
-			log.Printf("Error scanning %s: %s\n", path, err)
+		return
-			ferr = err
+	}
-			return nil
+	log.Debug("delete")
-		}
+	if err := os.Remove(path); err != nil {
-		if !info.IsDir() {
+		log.Error("delete %s: %v", path, err)
-			empty = false
+		return
-			log.Printf("Directory %s is not empty, found %s\n", dirPath, path)
+	}
-			return filepath.SkipAll
+	numFilesDeleted++
-		}
+	log.Info("Deleted: %s", path)
-		return nil
+}
-	})
+
-	return empty, ferr
+func scanRoot() {
-}
+	log := logger.Default.WithPrefix("scanRoot")
-
+	root := constants.ROOT
-type Constants struct {
+
-	ROOT                string
+	// doublestar.Glob with os.DirFS(root) returns relative paths
-	ROOT_ARCHIVE        string
+	log.Debug("glob %s", root)
-	IGNORED_DIRECTORIES []string
+	paths, err := doublestar.Glob(os.DirFS(root), "**")
-	ARCHIVE_THRESHOLD   int64
+	if err != nil {
-	DELETE_THRESHOLD    int64
+		log.Error("glob %s: %v", root, err)
-	SCAN_INTERVAL       time.Duration
+		return
-}
+	}
-
+	log.Info("Found %d files in root", len(paths))
-var constants = Constants{}
+	for _, rel := range paths {
-
+		pathLog := log.WithPrefix(rel)
-func main() {
+		full := filepath.Join(root, rel)
-	log.SetFlags(0b111)
+		pathLog.Debug("full %s", full)
-
+		if shouldIgnore(full) {
-	var ROOT = filepath.ToSlash(strings.TrimSpace(getEnv("ROOT", "/tmp")))
+			pathLog.Debug("ignore")
-	var ROOT_ARCHIVE = filepath.ToSlash(strings.TrimSpace(getEnv("ROOT_ARCHIVE", ROOT+"/archive")))
+			continue
-	os.Mkdir(ROOT_ARCHIVE, os.ModePerm)
+		}
-	var IGNORED_DIRECTORIES = []string{}
+		info, err := os.Stat(full)
-	var ignoredEnv = getEnv("IGNORED_DIRECTORIES", "")
+		pathLog.Trace("stat %+v", info)
-	if ignoredEnv != "" {
+		if err != nil {
-		ignoredEnv = strings.TrimSpace(ignoredEnv)
+			log.Warning("stat %s: %v", full, err)
-		IGNORED_DIRECTORIES = append(IGNORED_DIRECTORIES, strings.Split(ignoredEnv, ",")...)
+			continue
-	}
+		}
-	IGNORED_DIRECTORIES = append(IGNORED_DIRECTORIES, ROOT_ARCHIVE)
+		archiveCandidate(full, info)
-	for key, dir := range IGNORED_DIRECTORIES {
+	}
-		IGNORED_DIRECTORIES[key] = filepath.ToSlash(strings.TrimSpace(dir))
+}
-	}
+
-	var ARCHIVE_THRESHOLD = parseDuration(getEnv("ARCHIVE_THRESHOLD", "1d"))
+func scanArchive() {
-	var DELETE_THRESHOLD = parseDuration(getEnv("DELETE_THRESHOLD", "12h"))
+	log := logger.Default.WithPrefix("scanArchive")
-	var SCAN_INTERVAL = time.Duration(parseDuration(getEnv("SCAN_INTERVAL", "1m")) * 1e6)
+	base := constants.ROOT_ARCHIVE
-
+
-	constants.ROOT = ROOT
+	paths, err := doublestar.Glob(os.DirFS(base), "**")
-	constants.ROOT_ARCHIVE = ROOT_ARCHIVE
+	if err != nil {
-	constants.IGNORED_DIRECTORIES = IGNORED_DIRECTORIES
+		log.Error("glob %s: %v", base, err)
-	constants.ARCHIVE_THRESHOLD = ARCHIVE_THRESHOLD
+		return
-	constants.DELETE_THRESHOLD = DELETE_THRESHOLD
+	}
-	constants.SCAN_INTERVAL = SCAN_INTERVAL
+	for _, rel := range paths {
-
+		full := filepath.Join(base, rel)
-	log.Println("Input args parsed as:")
+		info, err := os.Stat(full)
-	log.Printf("ROOT: %s\n", ROOT)
+		if err != nil {
-	log.Printf("ROOT_ARCHIVE: %s\n", ROOT_ARCHIVE)
+			log.Warning("stat %s: %v", full, err)
-	log.Printf("IGNORED_DIRECTORIES: %s\n", IGNORED_DIRECTORIES)
+			continue
-	log.Printf("ARCHIVE_THRESHOLD: %d\n", ARCHIVE_THRESHOLD)
+		}
-	log.Printf("DELETE_THRESHOLD: %d\n", DELETE_THRESHOLD)
+		deleteCandidate(full, info)
-	log.Printf("SCAN_INTERVAL: %d\n", SCAN_INTERVAL.Milliseconds())
+	}
-
+}
-	scanRoot()
+
-	scanArchive()
+func cleanEmptyDirs() {
-	cleanRoot()
+	log := logger.Default.WithPrefix("cleanEmptyDirs")
-	for {
+	root := constants.ROOT
-		log.Printf("Running at %d", time.Now().UnixMilli())
+
-		time.Sleep(SCAN_INTERVAL)
+	paths, err := doublestar.Glob(os.DirFS(root), "**")
-		scanRoot()
+	if err != nil {
-		scanArchive()
+		log.Error("glob %s: %v", root, err)
-		cleanRoot()
+		return
-	}
+	}
-}
+	// Remove empty dirs; iterate deepest first by sorting longer paths first
+	// Build a slice of directory paths
+	var dirs []string
+	for _, rel := range paths {
+		full := filepath.Join(root, rel)
+		info, err := os.Stat(full)
+		if err != nil || !info.IsDir() {
+			continue
+		}
+		if shouldIgnore(full) {
+			continue
+		}
+		dirs = append(dirs, full)
+	}
+	// Simple length-based reverse to try delete children before parents
+	for i := 0; i < len(dirs)-1; i++ {
+		for j := i + 1; j < len(dirs); j++ {
+			if len(dirs[i]) < len(dirs[j]) {
+				dirs[i], dirs[j] = dirs[j], dirs[i]
+			}
+		}
+	}
+	for _, d := range dirs {
+		empty, err := isDirEmpty(d)
+		if err != nil {
+			log.Warning("check empty %s: %v", d, err)
+			continue
+		}
+		if empty {
+			if err := os.Remove(d); err == nil {
+				log.Info("Removed empty dir: %s", d)
+			} else {
+				log.Warning("remove %s: %v", d, err)
+			}
+		}
+	}
+}
+
+func isDirEmpty(dir string) (bool, error) {
+	f, err := os.Open(dir)
+	if err != nil {
+		return false, err
+	}
+	defer f.Close()
+	// Read at most one entry; if none, it's empty
+	_, err = f.Readdirnames(1)
+	if err == os.ErrNotExist {
+		// For older Go versions, fall back
+		return true, nil
+	}
+	if err != nil {
+		// io.EOF indicates empty for Readdirnames
+		return true, nil
+	}
+	return false, nil
+}
+
+func doRun() {
+	scanRoot()
+	scanArchive()
+	cleanEmptyDirs()
+	logger.Info("Cycle summary: archived=%d deleted=%d", numFilesArchived, numFilesDeleted)
+	numFilesArchived, numFilesDeleted = 0, 0
+}
+
+func main() {
+	flag.Parse()
+	logger.InitFlag()
+
+	logger.Info("Starting directory cleaner")
+	constants = loadConfig()
+	logger.Info("Ready. First scan in %s", constants.SCAN_INTERVAL)
+
+	// Run immediately, then on interval
+	doRun()
+	t := time.NewTicker(constants.SCAN_INTERVAL)
+	defer t.Stop()
+	for range t.C {
+		logger.Info("Tick %d", time.Now().UnixMilli())
+		doRun()
+	}
+}

nssm_deployall.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+set -e
+
+# tmp-cleaner service
+nssm install DirectoryCleanerTmp C:\\Users\\Administrator\\go\\bin\\directory-cleaner.exe
+nssm set DirectoryCleanerTmp AppEnvironmentExtra ARCHIVE_THRESHOLD=12h DELETE_THRESHOLD=2d SCAN_INTERVAL=20s
+nssm set DirectoryCleanerTmp AppDirectory C:\\tmp
+nssm set DirectoryCleanerTmp AppExit Default Restart
+nssm set DirectoryCleanerTmp AppStdout C:\\tmp\\cleaner.log
+nssm set DirectoryCleanerTmp AppStdoutCreationDisposition 2
+nssm set DirectoryCleanerTmp AppStderr C:\\tmp\\cleaner.log
+nssm set DirectoryCleanerTmp AppStderrCreationDisposition 2
+nssm set DirectoryCleanerTmp AppRotateFiles 1
+nssm set DirectoryCleanerTmp AppRotateOnline 1
+nssm set DirectoryCleanerTmp AppRotateBytes 104857600
+nssm set DirectoryCleanerTmp DisplayName DirectoryCleanerTmp
+nssm set DirectoryCleanerTmp ObjectName LocalSystem
+nssm set DirectoryCleanerTmp Start SERVICE_AUTO_START
+nssm set DirectoryCleanerTmp Type SERVICE_WIN32_OWN_PROCESS
+
+# tmp-cleaner-e service
+nssm install DirectoryCleanerTmpE C:\\Users\\Administrator\\go\\bin\\directory-cleaner.exe
+nssm set DirectoryCleanerTmpE AppEnvironmentExtra ARCHIVE_THRESHOLD=1d DELETE_THRESHOLD=2d SCAN_INTERVAL=20s
+nssm set DirectoryCleanerTmpE AppDirectory E:\\tmp
+nssm set DirectoryCleanerTmpE AppExit Default Restart
+nssm set DirectoryCleanerTmpE AppStdout E:\\tmp\\cleaner.log
+nssm set DirectoryCleanerTmpE AppStdoutCreationDisposition 2
+nssm set DirectoryCleanerTmpE AppStderr E:\\tmp\\cleaner.log
+nssm set DirectoryCleanerTmpE AppStderrCreationDisposition 2
+nssm set DirectoryCleanerTmpE AppRotateFiles 1
+nssm set DirectoryCleanerTmpE AppRotateOnline 1
+nssm set DirectoryCleanerTmpE AppRotateBytes 104857600
+nssm set DirectoryCleanerTmpE DisplayName DirectoryCleanerTmpE
+nssm set DirectoryCleanerTmpE ObjectName LocalSystem
+nssm set DirectoryCleanerTmpE Start SERVICE_AUTO_START
+nssm set DirectoryCleanerTmpE Type SERVICE_WIN32_OWN_PROCESS
+
+# downloads-cleaner service
+nssm install DirectoryCleanerDownloads C:\\Users\\Administrator\\go\\bin\\directory-cleaner.exe
+nssm set DirectoryCleanerDownloads AppEnvironmentExtra ARCHIVE_THRESHOLD=6h DELETE_THRESHOLD=3d SCAN_INTERVAL=20s
+nssm set DirectoryCleanerDownloads AppDirectory "C:\\Users\\Administrator\\Downloads"
+nssm set DirectoryCleanerDownloads AppExit Default Restart
+nssm set DirectoryCleanerDownloads AppStdout "C:\\Users\\Administrator\\Downloads\\cleaner.log"
+nssm set DirectoryCleanerDownloads AppStdoutCreationDisposition 2
+nssm set DirectoryCleanerDownloads AppStderr "C:\\Users\\Administrator\\Downloads\\cleaner.log"
+nssm set DirectoryCleanerDownloads AppStderrCreationDisposition 2
+nssm set DirectoryCleanerDownloads AppRotateFiles 1
+nssm set DirectoryCleanerDownloads AppRotateOnline 1
+nssm set DirectoryCleanerDownloads AppRotateBytes 104857600
+nssm set DirectoryCleanerDownloads DisplayName DirectoryCleanerDownloads
+nssm set DirectoryCleanerDownloads ObjectName LocalSystem
+nssm set DirectoryCleanerDownloads Start SERVICE_AUTO_START
+nssm set DirectoryCleanerDownloads Type SERVICE_WIN32_OWN_PROCESS
+
+# temp-cleaner service
+nssm install DirectoryCleanerTemp C:\\Users\\Administrator\\go\\bin\\directory-cleaner.exe
+nssm set DirectoryCleanerTemp AppEnvironmentExtra ARCHIVE_THRESHOLD=6h DELETE_THRESHOLD=1d SCAN_INTERVAL=20s
+nssm set DirectoryCleanerTemp AppDirectory "C:\\Users\\Administrator\\AppData\\Local\\Temp"
+nssm set DirectoryCleanerTemp AppExit Default Restart
+nssm set DirectoryCleanerTemp AppStdout "C:\\Users\\Administrator\\AppData\\Local\\Temp\\cleaner.log"
+nssm set DirectoryCleanerTemp AppStdoutCreationDisposition 2
+nssm set DirectoryCleanerTemp AppStderr "C:\\Users\\Administrator\\AppData\\Local\\Temp\\cleaner.log"
+nssm set DirectoryCleanerTemp AppStderrCreationDisposition 2
+nssm set DirectoryCleanerTemp AppRotateFiles 1
+nssm set DirectoryCleanerTemp AppRotateOnline 1
+nssm set DirectoryCleanerTemp AppRotateBytes 104857600
+nssm set DirectoryCleanerTemp DisplayName DirectoryCleanerTemp
+nssm set DirectoryCleanerTemp ObjectName LocalSystem
+nssm set DirectoryCleanerTemp Start SERVICE_AUTO_START
+nssm set DirectoryCleanerTemp Type SERVICE_WIN32_OWN_PROCESS

nssm_rmall.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+set -e
+
+# Remove all services
+services=$(nssm list | grep "DirectoryCleaner" | awk '{print $1}')
+
+for service in $services; do
+	echo "Removing $service"
+    nssm remove "$service" confirm
+done

nssm_startall.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+set -e
+
+# Start all services
+services=$(nssm list | grep "DirectoryCleaner" | awk '{print $1}')
+
+for service in $services; do
+	echo "Starting $service"
+    nssm start "$service"
+done

nssm_stopall.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+set -e
+
+# Stop all services
+services=$(nssm list | grep "DirectoryCleaner" | awk '{print $1}')
+
+for service in $services; do
+	echo "Stopping $service"
+    nssm stop "$service"
+done