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.22-rc-alpine
+FROM golang:1.21.6 as base
 
-# Set destination for COPY
-WORKDIR /app
+WORKDIR $GOPATH/src/app/
+
+COPY . .
 
-# Download Go modules
-COPY go.mod go.sum ./
 RUN go mod download
+RUN go mod verify
 
-# Copy the source code. Note the slash at the end, as explained in
-# https://docs.docker.com/engine/reference/builder/#copy
-# May not be enough for complex projects
-COPY *.go ./
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /main .
 
-# Build
-# Add GOOS=linux for linux
-# GOOS=windows
-# GOOS=darwin
-RUN go build -o /main
+FROM scratch
 
-# 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
+COPY --from=base /usr/share/zoneinfo /usr/share/zoneinfo
+COPY --from=base /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
+COPY --from=base /etc/passwd /etc/passwd
+COPY --from=base /etc/group /etc/group
+
+COPY --from=base /main .
 
-# 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,7 +1,7 @@
 package main
 
 import (
-	"log"
+	"flag"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -9,260 +9,341 @@ import (
 	"strings"
 	"time"
 
+	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,
-	"m":  1000 * 60,
-	"h":  1000 * 60 * 60,
-	"d":  1000 * 60 * 60 * 24,
-	"M":  1000 * 60 * 60 * 24 * 30,
-	"y":  1000 * 60 * 60 * 24 * 365,
-}
-
-var valueRegex, _ = regexp.Compile(`\d+`)
-var unitRegex, _ = regexp.Compile(`[a-zA-Z]+`)
-
-func parseDuration(date string) int64 {
-	var milliseconds int64 = 0
-
-	date = strings.TrimSpace(date)
-	var parts = strings.Split(date, "_")
-	for _, part := range parts {
-		part = strings.TrimSpace(part)
-		log.Printf("Parsing date part: %s\n", part)
-		var value = valueRegex.FindString(part)
-		var unit = unitRegex.FindString(part)
-
-		if value == "" || unit == "" {
-			log.Println("Invalid date part: " + part)
-			continue
-		}
-
-		if _, ok := timeUnits[unit]; !ok {
-			log.Println("Invalid date unit: " + unit)
-			continue
-		}
-		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]
-		milliseconds += valueMs
-		log.Printf("Adding %dms to duration, now: %d\n", valueMs, milliseconds)
-	}
-
-	return milliseconds
-}
-
-func getEnv(key, def string) string {
-	var value, exists = os.LookupEnv(key)
-	if exists {
-		return value
-	}
-	return def
-}
-
-func scanRoot() {
-	log.Println("Scanning root directory...")
-	filepath.Walk(constants.ROOT, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			log.Printf("Error scanning %s: %s\n", path, err)
-			return nil
-		}
-		path = filepath.ToSlash(path)
-
-		if path == constants.ROOT {
-			log.Printf("Skipping root directory %s...\n", path)
-			return nil
-		}
-
-		if info.IsDir() {
-			log.Printf("Skipping directory %s...\n", path)
-			return filepath.SkipDir
-		}
-
-		// We hope that IGNORED_DIRECTORIES is a small list, so we can afford to iterate over it
-		// In fact iteration should be faster for small lists rather than hashing
-		for _, ignoredDir := range constants.IGNORED_DIRECTORIES {
-			log.Println(constants.IGNORED_DIRECTORIES, len(constants.IGNORED_DIRECTORIES))
-			if strings.HasPrefix(path, ignoredDir) {
-				log.Printf("Ignoring directory %s\n", path)
-				return filepath.SkipDir
-			}
-		}
-
-		processFile(path, info)
-		return nil
-	})
-}
-
-func scanArchive() {
-	log.Println("Scanning archive...")
-	filepath.Walk(constants.ROOT_ARCHIVE, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			log.Printf("Error scanning %s: %s\n", path, err)
-			return nil
-		}
-		path = filepath.ToSlash(path)
-
-		if path == constants.ROOT_ARCHIVE {
-			log.Printf("Skipping root directory %s...\n", path)
-			return nil
-		}
-
-		processArchiveFile(path, info)
-		return nil
-	})
-}
-
-func processFile(path string, info os.FileInfo) {
-	var now = time.Now().UnixMilli()
-
-	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)
-	if accessTimeDelta > constants.ARCHIVE_THRESHOLD {
-		log.Printf("File %s was accessed more than %dms ago, archiving...\n", path, constants.ARCHIVE_THRESHOLD)
-		archiveFile(path)
-	}
-}
-
-func processArchiveFile(path string, info os.FileInfo) {
-	var now = time.Now().UnixMilli()
-
-	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)
-	if accessTimeDelta > constants.DELETE_THRESHOLD {
-		log.Printf("File %s was accessed more than %dms ago, deleting...\n", path, constants.DELETE_THRESHOLD)
-		deleteFile(path)
-	}
-}
-
-func archiveFile(path string) {
-	// defer os.Exit(1)
-	var newPath = constants.ROOT_ARCHIVE + strings.Replace(path, constants.ROOT, "", 1)
-	log.Printf("Archiving file %s to %s...\n", path, newPath)
-
-	os.MkdirAll(filepath.Dir(newPath), os.ModePerm)
-	var err = os.Rename(path, newPath)
-	if err != nil {
-		log.Printf("Error archiving file %s: %s\n", path, err)
-		return
-	}
-}
-
-func deleteFile(path string) {
-	// defer os.Exit(1)
-	log.Printf("Deleting file %s...\n", path)
-	var err = os.Remove(path)
-	if err != nil {
-		log.Printf("Error deleting file %s: %s\n", path, err)
-		return
-	}
-}
-
-func cleanRoot() {
-	var files, err = os.ReadDir(constants.ROOT)
-	if err != nil {
-		log.Printf("Error reading root directory %s: %s\n", constants.ROOT, err)
-		return
-	}
-	for _, file := range files {
-		if !file.IsDir() {
-			continue
-		}
-		var empty, err = isDirEmpty(constants.ROOT + "/" + file.Name())
-		if err != nil {
-			log.Printf("Error checking if directory %s is empty: %s\n", file.Name(), err)
-			continue
-		}
-		log.Printf("Directory %s isempty: %t\n", file.Name(), empty)
-		if empty {
-			log.Printf("Deleting empty directory %s\n", file.Name())
-			var err = os.RemoveAll(constants.ROOT + "/" + file.Name())
-			if err != nil {
-				log.Printf("Error deleting empty directory %s: %s\n", file.Name(), err)
-			}
-		}
-	}
-}
-func isDirEmpty(dirPath string) (bool, error) {
-	var empty = true
-	var ferr error = nil
-
-	filepath.Walk(dirPath, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			log.Printf("Error scanning %s: %s\n", path, err)
-			ferr = err
-			return nil
-		}
-		if !info.IsDir() {
-			empty = false
-			log.Printf("Directory %s is not empty, found %s\n", dirPath, path)
-			return filepath.SkipAll
-		}
-		return nil
-	})
-	return empty, ferr
-}
-
 type Constants struct {
 	ROOT                string
 	ROOT_ARCHIVE        string
 	IGNORED_DIRECTORIES []string
-	ARCHIVE_THRESHOLD   int64
-	DELETE_THRESHOLD    int64
+	ARCHIVE_THRESHOLD   int64 // ms
+	DELETE_THRESHOLD    int64 // ms
 	SCAN_INTERVAL       time.Duration
+	USE_MODTIME         bool
 }
 
-var constants = Constants{}
+var (
+	constants        Constants
+	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+`)
+	unitRegex        = regexp.MustCompile(`[a-zA-Z]+`)
+	numFilesArchived = 0
+	numFilesDeleted  = 0
+)
 
-func main() {
-	log.SetFlags(0b111)
-
-	var ROOT = filepath.ToSlash(strings.TrimSpace(getEnv("ROOT", "/tmp")))
-	var ROOT_ARCHIVE = filepath.ToSlash(strings.TrimSpace(getEnv("ROOT_ARCHIVE", ROOT+"/archive")))
-	os.Mkdir(ROOT_ARCHIVE, os.ModePerm)
-	var IGNORED_DIRECTORIES = []string{}
-	var ignoredEnv = getEnv("IGNORED_DIRECTORIES", "")
-	if ignoredEnv != "" {
-		ignoredEnv = strings.TrimSpace(ignoredEnv)
-		IGNORED_DIRECTORIES = append(IGNORED_DIRECTORIES, strings.Split(ignoredEnv, ",")...)
+func parseDurationMS(expr string) int64 {
+	expr = strings.TrimSpace(expr)
+	if expr == "" {
+		return 0
 	}
-	IGNORED_DIRECTORIES = append(IGNORED_DIRECTORIES, ROOT_ARCHIVE)
-	for key, dir := range IGNORED_DIRECTORIES {
-		IGNORED_DIRECTORIES[key] = filepath.ToSlash(strings.TrimSpace(dir))
+	var total int64
+	for _, p := range strings.Split(expr, "_") {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		v := valueRegex.FindString(p)
+		u := unitRegex.FindString(p)
+		if v == "" || u == "" {
+			logger.Warning("Invalid duration part: %q", p)
+			continue
+		}
+		unit, ok := timeUnits[u]
+		if !ok {
+			logger.Warning("Invalid duration unit: %q", u)
+			continue
+		}
+		n, err := strconv.ParseInt(v, 10, 64)
+		if err != nil {
+			logger.Warning("Invalid duration value: %q: %v", v, err)
+			continue
+		}
+		total += n * unit
 	}
-	var ARCHIVE_THRESHOLD = parseDuration(getEnv("ARCHIVE_THRESHOLD", "1d"))
-	var DELETE_THRESHOLD = parseDuration(getEnv("DELETE_THRESHOLD", "12h"))
-	var SCAN_INTERVAL = time.Duration(parseDuration(getEnv("SCAN_INTERVAL", "1m")) * 1e6)
+	return total
+}
 
-	constants.ROOT = ROOT
-	constants.ROOT_ARCHIVE = ROOT_ARCHIVE
-	constants.IGNORED_DIRECTORIES = IGNORED_DIRECTORIES
-	constants.ARCHIVE_THRESHOLD = ARCHIVE_THRESHOLD
-	constants.DELETE_THRESHOLD = DELETE_THRESHOLD
-	constants.SCAN_INTERVAL = SCAN_INTERVAL
+func getenv(key, def string) string {
+	if v, ok := os.LookupEnv(key); ok {
+		return v
+	}
+	return def
+}
 
-	log.Println("Input args parsed as:")
-	log.Printf("ROOT: %s\n", ROOT)
-	log.Printf("ROOT_ARCHIVE: %s\n", ROOT_ARCHIVE)
-	log.Printf("IGNORED_DIRECTORIES: %s\n", IGNORED_DIRECTORIES)
-	log.Printf("ARCHIVE_THRESHOLD: %d\n", ARCHIVE_THRESHOLD)
-	log.Printf("DELETE_THRESHOLD: %d\n", DELETE_THRESHOLD)
-	log.Printf("SCAN_INTERVAL: %d\n", SCAN_INTERVAL.Milliseconds())
+func loadConfig() Constants {
+	flag.Parse()
+	logger.InitFlag()
 
+	root := filepath.ToSlash(strings.TrimSpace(getenv("ROOT", "/tmp")))
+	archive := filepath.ToSlash(strings.TrimSpace(getenv("ROOT_ARCHIVE", root+"/archive")))
+	_ = os.MkdirAll(archive, os.ModePerm)
+
+	// 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
+	// But we might want to...
+	ignored := []string{}
+	if ig := strings.TrimSpace(getenv("IGNORED_DIRECTORIES", "")); ig != "" {
+		for _, s := range strings.Split(ig, ",") {
+			if t := strings.TrimSpace(s); t != "" {
+				ignored = append(ignored, filepath.ToSlash(t))
+			}
+		}
+	}
+
+	archiveMs := parseDurationMS(getenv("ARCHIVE_THRESHOLD", "1d"))
+	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")
+
+	logger.Info("Config:")
+	logger.Info("  ROOT: %s", root)
+	logger.Info("  ROOT_ARCHIVE: %s", archive)
+	logger.Info("  IGNORED_DIRECTORIES: %v", ignored)
+	logger.Info("  ARCHIVE_THRESHOLD(ms): %d", archiveMs)
+	logger.Info("  DELETE_THRESHOLD(ms): %d", deleteMs)
+	logger.Info("  SCAN_INTERVAL(ms): %d", interval.Milliseconds())
+	logger.Info("  USE_MODTIME: %t", useMod)
+
+	return Constants{
+		ROOT:                root,
+		ROOT_ARCHIVE:        archive,
+		IGNORED_DIRECTORIES: ignored,
+		ARCHIVE_THRESHOLD:   archiveMs,
+		DELETE_THRESHOLD:    deleteMs,
+		SCAN_INTERVAL:       interval,
+		USE_MODTIME:         useMod,
+	}
+}
+
+func shouldIgnore(path string) bool {
+	log := logger.Default.WithPrefix("shouldIgnore").WithPrefix(path)
+	// Match against slash-normalized full path
+	path = filepath.ToSlash(path)
+	for _, pat := range constants.IGNORED_DIRECTORIES {
+		patLog := log.WithPrefix(pat)
+		ok, err := doublestar.Match(pat, path)
+		if err != nil {
+			patLog.Warning("Ignore pattern error %q vs %q: %v", pat, path, err)
+			continue
+		}
+		if ok {
+			patLog.Debug("ignore due to doublestar %q", pat)
+			return true
+		}
+	}
+	return false
+}
+
+func fileTime(info os.FileInfo) int64 {
+	t := times.Get(info)
+	if constants.USE_MODTIME {
+		return t.ModTime().UnixMilli()
+	}
+	// If AccessTime is not supported, it returns ModTime; times handles that internally.
+	return t.AccessTime().UnixMilli()
+}
+
+func archiveCandidate(path string, info os.FileInfo) {
+	log := logger.Default.WithPrefix("archiveCandidate")
+	if info.IsDir() {
+		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))
+	if now-ft <= constants.ARCHIVE_THRESHOLD {
+		log.Debug("skip")
+		return
+	}
+
+	rel, err := filepath.Rel(constants.ROOT, path)
+	if err != nil {
+		log.Warning("rel ROOT->%s: %v", path, err)
+		return
+	}
+	if strings.HasPrefix(rel, "archive") {
+		log.Debug("refusing to archive a file that's already archived")
+		return
+	}
+	log.Debug("rel %q", rel)
+	dst := filepath.Join(constants.ROOT_ARCHIVE, rel)
+	log.Debug("dst %q", dst)
+
+	if err := os.MkdirAll(filepath.Dir(dst), os.ModePerm); err != nil {
+		log.Error("mkdir %s: %v", filepath.Dir(dst), err)
+		return
+	}
+
+	if err := os.Rename(path, dst); err != nil {
+		log.Error("archive %s -> %s: %v", path, dst, err)
+		return
+	}
+	numFilesArchived++
+	log.Info("Archived: %s -> %s", path, dst)
+}
+
+func deleteCandidate(path string, info os.FileInfo) {
+	log := logger.Default.WithPrefix("deleteCandidate").WithPrefix(path)
+	if info.IsDir() {
+		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))
+	if now-ft <= constants.DELETE_THRESHOLD {
+		log.Debug("skip")
+		return
+	}
+	log.Debug("delete")
+	if err := os.Remove(path); err != nil {
+		log.Error("delete %s: %v", path, err)
+		return
+	}
+	numFilesDeleted++
+	log.Info("Deleted: %s", path)
+}
+
+func scanRoot() {
+	log := logger.Default.WithPrefix("scanRoot")
+	root := constants.ROOT
+
+	// doublestar.Glob with os.DirFS(root) returns relative paths
+	log.Debug("glob %s", root)
+	paths, err := doublestar.Glob(os.DirFS(root), "**")
+	if err != nil {
+		log.Error("glob %s: %v", root, err)
+		return
+	}
+	log.Info("Found %d files in root", len(paths))
+	for _, rel := range paths {
+		pathLog := log.WithPrefix(rel)
+		full := filepath.Join(root, rel)
+		pathLog.Debug("full %s", full)
+		if shouldIgnore(full) {
+			pathLog.Debug("ignore")
+			continue
+		}
+		info, err := os.Stat(full)
+		pathLog.Trace("stat %+v", info)
+		if err != nil {
+			log.Warning("stat %s: %v", full, err)
+			continue
+		}
+		archiveCandidate(full, info)
+	}
+}
+
+func scanArchive() {
+	log := logger.Default.WithPrefix("scanArchive")
+	base := constants.ROOT_ARCHIVE
+
+	paths, err := doublestar.Glob(os.DirFS(base), "**")
+	if err != nil {
+		log.Error("glob %s: %v", base, err)
+		return
+	}
+	for _, rel := range paths {
+		full := filepath.Join(base, rel)
+		info, err := os.Stat(full)
+		if err != nil {
+			log.Warning("stat %s: %v", full, err)
+			continue
+		}
+		deleteCandidate(full, info)
+	}
+}
+
+func cleanEmptyDirs() {
+	log := logger.Default.WithPrefix("cleanEmptyDirs")
+	root := constants.ROOT
+
+	paths, err := doublestar.Glob(os.DirFS(root), "**")
+	if err != nil {
+		log.Error("glob %s: %v", root, err)
+		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()
-	cleanRoot()
-	for {
-		log.Printf("Running at %d", time.Now().UnixMilli())
-		time.Sleep(SCAN_INTERVAL)
-		scanRoot()
-		scanArchive()
-		cleanRoot()
+	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