set -e

Windows service deployment

build.sh

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

deploy.sh

@@ -1 +1,2 @@
-docker build -t directory-cleaner .
+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

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,303 +9,318 @@ 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 numFilesArchived = 0
-var numFilesDeleted = 0
-
-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
-		}
-
-		// I forgot why this code was here... It doesn't make sense to me now
-		// 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 timeType = "accessed"
-	if constants.USE_MODTIME {
-		timeType = "modified"
-	}
-
-	var fileTime int64 = 0
-	if constants.USE_MODTIME {
-		fileTime = times.Get(info).ModTime().UnixMilli()
-	} else {
-		fileTime = times.Get(info).AccessTime().UnixMilli()
-	}
-	
-	var timeDelta = now - fileTime
-	log.Printf("File %s last %s at %d, %dms ago\n", path, timeType, fileTime, timeDelta)
-	if timeDelta > constants.ARCHIVE_THRESHOLD {
-		log.Printf("File %s was %s more than %dms ago, archiving...\n", path, timeType, constants.ARCHIVE_THRESHOLD)
-		archiveFile(path)
-	}
-}
-
-func processArchiveFile(path string, info os.FileInfo) {
-	var now = time.Now().UnixMilli()
-
-	var timeType = "accessed"
-	if constants.USE_MODTIME {
-		timeType = "modified"
-	}
-
-	var fileTime int64 = 0
-	if constants.USE_MODTIME {
-		fileTime = times.Get(info).ModTime().UnixMilli()
-	} else {
-		fileTime = times.Get(info).AccessTime().UnixMilli()
-	}
-
-	var timeDelta = now - int64(fileTime)
-	log.Printf("File %s last %s at %d, %dms ago\n", path, timeType, fileTime, timeDelta)
-	
-	if timeDelta > constants.DELETE_THRESHOLD {
-		log.Printf("File %s was %s more than %dms ago, deleting...\n", path, timeType, 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
-	}
-	numFilesArchived++
-}
-
-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
-	}
-	numFilesDeleted++
-}
-
-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
+	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 parseDurationMS(expr string) int64 {
+	expr = strings.TrimSpace(expr)
+	if expr == "" {
+		return 0
+	}
+	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
+	}
+	return total
+}
+
+func getenv(key, def string) string {
+	if v, ok := os.LookupEnv(key); ok {
+		return v
+	}
+	return def
+}
+
+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)
+
+	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))
+			}
+		}
+	}
+	// Always ignore ROOT and ROOT_ARCHIVE themselves
+	ignored = append(ignored, filepath.ToSlash(archive))
+	ignored = append(ignored, filepath.ToSlash(root))
+
+	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 {
+	// Match against slash-normalized full path
+	path = filepath.ToSlash(path)
+	for _, pat := range constants.IGNORED_DIRECTORIES {
+		ok, err := doublestar.Match(pat, path)
+		if err != nil {
+			logger.Warning("Ignore pattern error %q vs %q: %v", pat, path, err)
+			continue
+		}
+		if ok || path == 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) {
+	if info.IsDir() {
+		return
+	}
+	now := time.Now().UnixMilli()
+	ft := fileTime(info)
+	if now-ft <= constants.ARCHIVE_THRESHOLD {
+		return
+	}
+
+	rel, err := filepath.Rel(constants.ROOT, path)
+	if err != nil {
+		logger.Warning("rel ROOT->%s: %v", path, err)
+		return
+	}
+	dst := filepath.Join(constants.ROOT_ARCHIVE, rel)
+
+	if err := os.MkdirAll(filepath.Dir(dst), os.ModePerm); err != nil {
+		logger.Error("mkdir %s: %v", filepath.Dir(dst), err)
+		return
+	}
+
+	if err := os.Rename(path, dst); err != nil {
+		logger.Error("archive %s -> %s: %v", path, dst, err)
+		return
+	}
+	numFilesArchived++
+	logger.Info("Archived: %s -> %s", path, dst)
+}
+
+func deleteCandidate(path string, info os.FileInfo) {
+	if info.IsDir() {
+		return
+	}
+	now := time.Now().UnixMilli()
+	ft := fileTime(info)
+	if now-ft <= constants.DELETE_THRESHOLD {
+		return
+	}
+	if err := os.Remove(path); err != nil {
+		logger.Error("delete %s: %v", path, err)
+		return
+	}
+	numFilesDeleted++
+	logger.Info("Deleted: %s", path)
+}
+
+func scanRoot() {
+	log := logger.Default.WithPrefix("scanRoot")
+	root := constants.ROOT
+
+	// doublestar.Glob with os.DirFS(root) returns relative paths
+	paths, err := doublestar.Glob(os.DirFS(root), "**")
+	if err != nil {
+		log.Error("glob %s: %v", root, err)
+		return
+	}
+	for _, rel := range paths {
+		full := filepath.Join(root, rel)
+		if shouldIgnore(full) {
+			continue
+		}
+		info, err := os.Stat(full)
+		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()
-	log.Printf("Archived %d files, deleted %d files\n", numFilesArchived, numFilesDeleted)
-	numFilesArchived = 0
-	numFilesDeleted = 0
+	cleanEmptyDirs()
+	logger.Info("Cycle summary: archived=%d deleted=%d", numFilesArchived, numFilesDeleted)
+	numFilesArchived, numFilesDeleted = 0, 0
 }
 
-var constants = Constants{}
-
 func main() {
-	log.SetFlags(0b111)
-	// Important: Access times don’t accumulate.
-	// This implies that archiving the file won't alter its access time.
-	// Therefore, assign X as the ARCHIVE_TIME and X + Y as the DELETE_TIME,
-	// where X represents the duration it can exist in the folder,
-	// and Y represents the duration it can exist in the archive.
+	flag.Parse()
+	logger.InitFlag()
 
-	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, ",")...)
-	}
-	IGNORED_DIRECTORIES = append(IGNORED_DIRECTORIES, ROOT_ARCHIVE)
-	for key, dir := range IGNORED_DIRECTORIES {
-		IGNORED_DIRECTORIES[key] = filepath.ToSlash(strings.TrimSpace(dir))
-	}
-	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)
-	var USE_MODTIME = strings.TrimSpace(getEnv("USE_MODTIME", "false")) == "true"
-
-	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
-	constants.USE_MODTIME = USE_MODTIME
-
-	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())
-	log.Printf("USE_MODTIME: %s\n", strconv.FormatBool(USE_MODTIME))
+	logger.Info("Starting directory cleaner")
+	constants = loadConfig()
+	logger.Info("Ready. First scan in %s", constants.SCAN_INTERVAL)
 
+	// Run immediately, then on interval
 	doRun()
-	for {
-		log.Printf("Running at %d", time.Now().UnixMilli())
-		time.Sleep(SCAN_INTERVAL)
+	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,50 @@
+#!/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 AppStderr C:\\tmp\\cleaner.log
+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 AppStderr E:\\tmp\\cleaner.log
+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 AppStderr "C:\\Users\\Administrator\\Downloads\\cleaner.log"
+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 AppStderr "C:\\Users\\Administrator\\AppData\\Local\\Temp\\cleaner.log"
+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