internal/modindex/cmd: Command for maintaining module cache indexes

Presently the command will create or update the index of the module
cache, or clean out obsolete indexes. An index is obsolete if it is
both more that an hour old, and not a current index pointed to by some
index-name file.

Change-Id: Ie3a79587e0e230ae7ab0b7d854c97003ace783ff
Reviewed-on: https://go-review.googlesource.com/c/tools/+/616838
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Robert Findley <[email protected]>

Author: pjweinbgo

internal/modindex/gomodindex/cmd.go

@@ -0,0 +1,148 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// A command for building and maintaing the module cache
+// a.out <flags> <command> <args>
+// The commands are 'create' which builds a new index,
+// 'update', which attempts to update an existing index,
+// 'query', which looks up things in the index.
+// 'clean', which remove obsolete index files.
+// If the command is invoked with no arguments, it defaults to 'create'.
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"golang.org/x/tools/internal/modindex"
+)
+
+var verbose = flag.Int("v", 0, "how much information to print")
+
+type cmd struct {
+	name string
+	f    func(string)
+	doc  string
+}
+
+var cmds = []cmd{
+	{"create", index, "create a clean index of GOMODCACHE"},
+	{"update", update, "if there is an existing index of GOMODCACHE, update it. Otherise create one."},
+	{"clean", clean, "removed unreferenced indexes more than an hour old"},
+	{"query", query, "not yet implemented"},
+}
+
+func goEnv(s string) string {
+	out, err := exec.Command("go", "env", s).Output()
+	if err != nil {
+		return ""
+	}
+	out = bytes.TrimSpace(out)
+	return string(out)
+}
+
+func main() {
+	flag.Parse()
+	log.SetFlags(log.Lshortfile)
+	cachedir := goEnv("GOMODCACHE")
+	if cachedir == "" {
+		log.Fatal("can't find GOMODCACHE")
+	}
+	if flag.NArg() == 0 {
+		index(cachedir)
+		return
+	}
+	for _, c := range cmds {
+		if flag.Arg(0) == c.name {
+			c.f(cachedir)
+			return
+		}
+	}
+	flag.Usage()
+}
+
+func init() {
+	var sb strings.Builder
+	fmt.Fprintf(&sb, "usage:\n")
+	for _, c := range cmds {
+		fmt.Fprintf(&sb, "'%s': %s\n", c.name, c.doc)
+	}
+	msg := sb.String()
+	flag.Usage = func() {
+		fmt.Fprint(os.Stderr, msg)
+	}
+}
+
+func index(dir string) {
+	modindex.IndexModCache(dir, true)
+}
+
+func update(dir string) {
+	modindex.IndexModCache(dir, false)
+}
+
+func query(dir string) {
+	panic("implement")
+}
+func clean(_ string) {
+	des, err := modindex.IndexDir()
+	if err != nil {
+		log.Fatal(err)
+	}
+	// look at the files starting with 'index'
+	// the current ones of each version are pointed to by
+	// index-name-%d files. Any others more than an hour old
+	// are deleted.
+	dis, err := os.ReadDir(des)
+	if err != nil {
+		log.Fatal(err)
+	}
+	cutoff := time.Now().Add(-time.Hour)
+	var inames []string               // older files named index*
+	curnames := make(map[string]bool) // current versions of index (different CurrentVersion)
+	for _, de := range dis {
+		if !strings.HasPrefix(de.Name(), "index") {
+			continue
+		}
+		if strings.HasPrefix(de.Name(), "index-name-") {
+			buf, err := os.ReadFile(filepath.Join(des, de.Name()))
+			if err != nil {
+				log.Print(err)
+				continue
+			}
+			curnames[string(buf)] = true
+			if *verbose > 1 {
+				log.Printf("latest index is %s", string(buf))
+			}
+		}
+		info, err := de.Info()
+		if err != nil {
+			log.Print(err)
+			continue
+		}
+		if info.ModTime().Before(cutoff) && !strings.HasPrefix(de.Name(), "index-name-") {
+			// add to the list of files to be removed. index-name-%d files are never removed
+			inames = append(inames, de.Name())
+			if *verbose > 0 {
+				log.Printf("%s:%s", de.Name(), cutoff.Sub(info.ModTime()))
+			}
+		}
+	}
+	for _, nm := range inames {
+		if curnames[nm] {
+			continue
+		}
+		err := os.Remove(filepath.Join(des, nm))
+		if err != nil && *verbose > 0 {
+			log.Printf("%s not removed (%v)", nm, err)
+		}
+	}
+}