internal/modindex: new API for incremental update

Create() creates a new index, while Update() may write an
updated index, if there have been any changes in the module cache
since the last index was written. If there is no index it creates
one. It returns true if it wrote a new index, false if there was
no need to write a new index.

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

Author: pjweinbgo

internal/modindex/dir_test.go

@@ -76,7 +76,7 @@ func TestIncremental(t *testing.T) {
 			}
 		}
 	}
-	if err := IndexModCache(dir, true); err != nil {
+	if err := Create(dir); err != nil {
 		t.Fatal(err)
 	}
 	// add new stuff to the module cache
@@ -90,15 +90,17 @@ func TestIncremental(t *testing.T) {
 			}
 		}
 	}
-	if err := IndexModCache(dir, false); err != nil {
+	if ok, err := Update(dir); err != nil {
 		t.Fatal(err)
+	} else if !ok {
+		t.Error("failed to write updated index")
 	}
 	index2, err := ReadIndex(dir)
 	if err != nil {
 		t.Fatal(err)
 	}
 	// build a fresh index
-	if err := IndexModCache(dir, true); err != nil {
+	if err := Create(dir); err != nil {
 		t.Fatal(err)
 	}
 	index1, err := ReadIndex(dir)
@@ -126,7 +128,7 @@ func TestIncrementalNope(t *testing.T) {
 			}
 		}
 	}
-	if err := IndexModCache(dir, true); err != nil {
+	if err := Create(dir); err != nil {
 		t.Fatal(err)
 	}
 	// add new stuff to the module cache
@@ -140,15 +142,17 @@ func TestIncrementalNope(t *testing.T) {
 			}
 		}
 	}
-	if err := IndexModCache(dir, false); err != nil {
+	if ok, err := Update(dir); err != nil {
 		t.Fatal(err)
+	} else if !ok {
+		t.Error("failed to write updated index")
 	}
 	index2, err := ReadIndex(dir)
 	if err != nil {
 		t.Fatal(err)
 	}
 	// build a fresh index
-	if err := IndexModCache(dir, true); err != nil {
+	if err := Create(dir); err != nil {
 		t.Fatal(err)
 	}
 	index1, err := ReadIndex(dir)
@@ -174,7 +178,7 @@ func TestDirsSinglePath(t *testing.T) {
 				}
 			}
 			// build and check the index
-			if err := IndexModCache(dir, false); err != nil {
+			if err := Create(dir); err != nil {
 				t.Fatal(err)
 			}
 			ix, err := ReadIndex(dir)

internal/modindex/gomodindex/cmd.go

@@ -82,11 +82,11 @@ func init() {
 }
 
 func index(dir string) {
-	modindex.IndexModCache(dir, true)
+	modindex.Create(dir)
 }
 
 func update(dir string) {
-	modindex.IndexModCache(dir, false)
+	modindex.Update(dir)
 }
 
 func query(dir string) {

internal/modindex/modindex.go

@@ -21,36 +21,51 @@ import (
 	"golang.org/x/mod/semver"
 )
 
-// Modindex writes an index current as of when it is called.
+// Create always creates a new index for the go module cache that is in cachedir.
+func Create(cachedir string) error {
+	_, err := indexModCache(cachedir, true)
+	return err
+}
+
+// Update the index for the go module cache that is in cachedir,
+// If there is no existing index it will build one.
+// If there are changed directories since the last index, it will
+// write a new one and return true. Otherwise it returns false.
+func Update(cachedir string) (bool, error) {
+	return indexModCache(cachedir, false)
+}
+
+// indexModCache writes an index current as of when it is called.
 // If clear is true the index is constructed from all of GOMODCACHE
 // otherwise the index is constructed from the last previous index
-// and the updates to the cache.
-func IndexModCache(cachedir string, clear bool) error {
+// and the updates to the cache. It returns true if it wrote an index,
+// false otherwise.
+func indexModCache(cachedir string, clear bool) (bool, error) {
 	cachedir, err := filepath.Abs(cachedir)
 	if err != nil {
-		return err
+		return false, err
 	}
 	cd := Abspath(cachedir)
 	future := time.Now().Add(24 * time.Hour) // safely in the future
-	err = modindexTimed(future, cd, clear)
+	ok, err := modindexTimed(future, cd, clear)
 	if err != nil {
-		return err
+		return false, err
 	}
-	return nil
+	return ok, nil
 }
 
 // modindexTimed writes an index current as of onlyBefore.
 // If clear is true the index is constructed from all of GOMODCACHE
 // otherwise the index is constructed from the last previous index
 // and all the updates to the cache before onlyBefore.
-// (this is useful for testing; perhaps it should not be exported)
-func modindexTimed(onlyBefore time.Time, cachedir Abspath, clear bool) error {
+// It returns true if it wrote a new index, false if it wrote nothing.
+func modindexTimed(onlyBefore time.Time, cachedir Abspath, clear bool) (bool, error) {
 	var curIndex *Index
 	if !clear {
 		var err error
 		curIndex, err = ReadIndex(string(cachedir))
 		if clear && err != nil {
-			return err
+			return false, err
 		}
 		// TODO(pjw): check that most of those directorie still exist
 	}
@@ -63,12 +78,16 @@ func modindexTimed(onlyBefore time.Time, cachedir Abspath, clear bool) error {
 		cfg.onlyAfter = curIndex.Changed
 	}
 	if err := cfg.buildIndex(); err != nil {
-		return err
+		return false, err
+	}
+	if len(cfg.newIndex.Entries) == 0 {
+		// no changes, don't write a new index
+		return false, nil
 	}
 	if err := cfg.writeIndex(); err != nil {
-		return err
+		return false, err
 	}
-	return nil
+	return true, nil
 }
 
 type work struct {
@@ -86,6 +105,9 @@ func (w *work) buildIndex() error {
 	// so set it now.
 	w.newIndex = &Index{Changed: time.Now(), Cachedir: w.cacheDir}
 	dirs := findDirs(string(w.cacheDir), w.onlyAfter, w.onlyBefore)
+	if len(dirs) == 0 {
+		return nil
+	}
 	newdirs, err := byImportPath(dirs)
 	if err != nil {
 		return err