Rename InitialNode to InitialChild

I want to add a common interface for Leaf and InitialContentsFetcher. I
think the best name for that is InitialNode, but that name is already
taken. Rename the existing InitialNode type to InitialChild, which is a
better fit, because it's based on Child.

Author: EdSchouten

pkg/builder/virtual_build_directory.go

@@ -140,8 +140,8 @@ func (d *virtualBuildDirectory) Lstat(name path.Component) (filesystem.FileInfo,
 }
 
 func (d *virtualBuildDirectory) Mkdir(name path.Component, mode os.FileMode) error {
-	return d.CreateChildren(map[path.Component]virtual.InitialNode{
-		name: virtual.InitialNode{}.FromDirectory(virtual.EmptyInitialContentsFetcher),
+	return d.CreateChildren(map[path.Component]virtual.InitialChild{
+		name: virtual.InitialChild{}.FromDirectory(virtual.EmptyInitialContentsFetcher),
 	}, false)
 }
 
@@ -150,8 +150,8 @@ func (d *virtualBuildDirectory) Mknod(name path.Component, perm os.FileMode, dev
 		return status.Error(codes.InvalidArgument, "The provided file mode is not for a character device")
 	}
 	characterDevice := d.options.characterDeviceFactory.LookupCharacterDevice(deviceNumber)
-	if err := d.CreateChildren(map[path.Component]virtual.InitialNode{
-		name: virtual.InitialNode{}.FromLeaf(characterDevice),
+	if err := d.CreateChildren(map[path.Component]virtual.InitialChild{
+		name: virtual.InitialChild{}.FromLeaf(characterDevice),
 	}, false); err != nil {
 		characterDevice.Unlink()
 		return err

pkg/filesystem/virtual/access_monitoring_initial_contents_fetcher.go

@@ -21,7 +21,7 @@ func NewAccessMonitoringInitialContentsFetcher(base InitialContentsFetcher, root
 	}
 }
 
-func (icf *accessMonitoringInitialContentsFetcher) FetchContents(fileReadMonitorFactory FileReadMonitorFactory) (map[path.Component]InitialNode, error) {
+func (icf *accessMonitoringInitialContentsFetcher) FetchContents(fileReadMonitorFactory FileReadMonitorFactory) (map[path.Component]InitialChild, error) {
 	// Call into underlying initial contents fetcher. Wrap the file
 	// read monitors that are installed on the files, so that we can
 	// detect file access.
@@ -43,16 +43,16 @@ func (icf *accessMonitoringInitialContentsFetcher) FetchContents(fileReadMonitor
 
 	// Wrap all of the child directories, so that we can detect
 	// directory access.
-	wrappedContents := make(map[path.Component]InitialNode, len(contents))
+	wrappedContents := make(map[path.Component]InitialChild, len(contents))
 	for name, node := range contents {
 		childInitialContentsFetcher, leaf := node.GetPair()
 		if childInitialContentsFetcher != nil {
-			wrappedContents[name] = InitialNode{}.FromDirectory(&accessMonitoringInitialContentsFetcher{
+			wrappedContents[name] = InitialChild{}.FromDirectory(&accessMonitoringInitialContentsFetcher{
 				InitialContentsFetcher: childInitialContentsFetcher,
 				unreadDirectoryMonitor: readDirectoryMonitor.ResolvedDirectory(name),
 			})
 		} else {
-			wrappedContents[name] = InitialNode{}.FromLeaf(leaf)
+			wrappedContents[name] = InitialChild{}.FromLeaf(leaf)
 		}
 	}
 	return wrappedContents, nil

pkg/filesystem/virtual/access_monitoring_initial_contents_fetcher_test.go

@@ -49,11 +49,11 @@ func TestAccessMonitoringInitialContentsFetcher(t *testing.T) {
 		baseFileReadMonitorFactory.EXPECT().Call(path.MustNewComponent("file")).Return(baseChildFileReadMonitor.Call)
 		var childFileReadMonitor virtual.FileReadMonitor
 		baseInitialContentsFetcher.EXPECT().FetchContents(gomock.Any()).
-			DoAndReturn(func(fileReadMonitorFactory virtual.FileReadMonitorFactory) (map[path.Component]virtual.InitialNode, error) {
+			DoAndReturn(func(fileReadMonitorFactory virtual.FileReadMonitorFactory) (map[path.Component]virtual.InitialChild, error) {
 				childFileReadMonitor = fileReadMonitorFactory(path.MustNewComponent("file"))
-				return map[path.Component]virtual.InitialNode{
-					path.MustNewComponent("dir"):  virtual.InitialNode{}.FromDirectory(baseChildInitialContentsFetcher),
-					path.MustNewComponent("file"): virtual.InitialNode{}.FromLeaf(baseChildFile),
+				return map[path.Component]virtual.InitialChild{
+					path.MustNewComponent("dir"):  virtual.InitialChild{}.FromDirectory(baseChildInitialContentsFetcher),
+					path.MustNewComponent("file"): virtual.InitialChild{}.FromLeaf(baseChildFile),
 				}, nil
 			})
 		rootReadDirectoryMonitor := mock.NewMockReadDirectoryMonitor(ctrl)
@@ -69,7 +69,7 @@ func TestAccessMonitoringInitialContentsFetcher(t *testing.T) {
 			childInitialContentsFetcher, _ := rootContents[path.MustNewComponent("dir")].GetPair()
 
 			t.Run("FetchContentsSucceeded", func(t *testing.T) {
-				baseChildInitialContentsFetcher.EXPECT().FetchContents(gomock.Any()).Return(map[path.Component]virtual.InitialNode{}, nil)
+				baseChildInitialContentsFetcher.EXPECT().FetchContents(gomock.Any()).Return(map[path.Component]virtual.InitialChild{}, nil)
 				childReadDirectoryMonitor := mock.NewMockReadDirectoryMonitor(ctrl)
 				childUnreadDirectoryMonitor.EXPECT().ReadDirectory().Return(childReadDirectoryMonitor)
 				baseChildFileReadMonitorFactory := mock.NewMockFileReadMonitorFactory(ctrl)

pkg/filesystem/virtual/cas_initial_contents_fetcher.go

@@ -44,7 +44,7 @@ func NewCASInitialContentsFetcher(ctx context.Context, directoryWalker cas.Direc
 	}
 }
 
-func (icf *casInitialContentsFetcher) fetchContentsUnwrapped(fileReadMonitorFactory FileReadMonitorFactory) (map[path.Component]InitialNode, error) {
+func (icf *casInitialContentsFetcher) fetchContentsUnwrapped(fileReadMonitorFactory FileReadMonitorFactory) (map[path.Component]InitialChild, error) {
 	directory, err := icf.directoryWalker.GetDirectory(icf.options.context)
 	if err != nil {
 		return nil, err
@@ -53,7 +53,7 @@ func (icf *casInitialContentsFetcher) fetchContentsUnwrapped(fileReadMonitorFact
 	// Create InitialContentsFetchers for all child directories.
 	// These can yield even more InitialContentsFetchers for
 	// grandchildren.
-	children := make(map[path.Component]InitialNode, len(directory.Directories)+len(directory.Files)+len(directory.Symlinks))
+	children := make(map[path.Component]InitialChild, len(directory.Directories)+len(directory.Files)+len(directory.Symlinks))
 	for _, entry := range directory.Directories {
 		component, ok := path.NewComponent(entry.Name)
 		if !ok {
@@ -67,7 +67,7 @@ func (icf *casInitialContentsFetcher) fetchContentsUnwrapped(fileReadMonitorFact
 		if err != nil {
 			return nil, util.StatusWrapf(err, "Failed to obtain digest for directory %#v", entry.Name)
 		}
-		children[component] = InitialNode{}.FromDirectory(&casInitialContentsFetcher{
+		children[component] = InitialChild{}.FromDirectory(&casInitialContentsFetcher{
 			options:         icf.options,
 			directoryWalker: icf.directoryWalker.GetChild(childDigest),
 		})
@@ -96,7 +96,7 @@ func (icf *casInitialContentsFetcher) fetchContentsUnwrapped(fileReadMonitorFact
 			return nil, util.StatusWrapf(err, "Failed to obtain digest for file %#v", entry.Name)
 		}
 		leaf := icf.options.casFileFactory.LookupFile(childDigest, entry.IsExecutable, fileReadMonitorFactory(component))
-		children[component] = InitialNode{}.FromLeaf(leaf)
+		children[component] = InitialChild{}.FromLeaf(leaf)
 		leavesToUnlink = append(leavesToUnlink, leaf)
 	}
 
@@ -111,15 +111,15 @@ func (icf *casInitialContentsFetcher) fetchContentsUnwrapped(fileReadMonitorFact
 		}
 
 		leaf := icf.options.symlinkFactory.LookupSymlink([]byte(entry.Target))
-		children[component] = InitialNode{}.FromLeaf(leaf)
+		children[component] = InitialChild{}.FromLeaf(leaf)
 		leavesToUnlink = append(leavesToUnlink, leaf)
 	}
 
 	leavesToUnlink = nil
 	return children, nil
 }
 
-func (icf *casInitialContentsFetcher) FetchContents(fileReadMonitorFactory FileReadMonitorFactory) (map[path.Component]InitialNode, error) {
+func (icf *casInitialContentsFetcher) FetchContents(fileReadMonitorFactory FileReadMonitorFactory) (map[path.Component]InitialChild, error) {
 	children, err := icf.fetchContentsUnwrapped(fileReadMonitorFactory)
 	if err != nil {
 		return nil, util.StatusWrap(err, icf.directoryWalker.GetDescription())

pkg/filesystem/virtual/cas_initial_contents_fetcher_test.go

@@ -217,11 +217,11 @@ func TestCASInitialContentsFetcherFetchContents(t *testing.T) {
 		children, err := initialContentsFetcher.FetchContents(fileReadMonitorFactory.Call)
 		require.NoError(t, err)
 		childInitialContentsFetcher, _ := children[path.MustNewComponent("directory")].GetPair()
-		require.Equal(t, map[path.Component]virtual.InitialNode{
-			path.MustNewComponent("directory"):  virtual.InitialNode{}.FromDirectory(childInitialContentsFetcher),
-			path.MustNewComponent("executable"): virtual.InitialNode{}.FromLeaf(executableLeaf),
-			path.MustNewComponent("file"):       virtual.InitialNode{}.FromLeaf(fileLeaf),
-			path.MustNewComponent("symlink"):    virtual.InitialNode{}.FromLeaf(symlinkLeaf),
+		require.Equal(t, map[path.Component]virtual.InitialChild{
+			path.MustNewComponent("directory"):  virtual.InitialChild{}.FromDirectory(childInitialContentsFetcher),
+			path.MustNewComponent("executable"): virtual.InitialChild{}.FromLeaf(executableLeaf),
+			path.MustNewComponent("file"):       virtual.InitialChild{}.FromLeaf(fileLeaf),
+			path.MustNewComponent("symlink"):    virtual.InitialChild{}.FromLeaf(symlinkLeaf),
 		}, children)
 
 		// Check that the InitialContentsFetcher that is created

pkg/filesystem/virtual/empty_initial_contents_fetcher.go

@@ -9,8 +9,8 @@ import (
 
 type emptyInitialContentsFetcher struct{}
 
-func (f emptyInitialContentsFetcher) FetchContents(fileReadMonitorFactory FileReadMonitorFactory) (map[path.Component]InitialNode, error) {
-	return map[path.Component]InitialNode{}, nil
+func (f emptyInitialContentsFetcher) FetchContents(fileReadMonitorFactory FileReadMonitorFactory) (map[path.Component]InitialChild, error) {
+	return map[path.Component]InitialChild{}, nil
 }
 
 func (f emptyInitialContentsFetcher) GetContainingDigests(ctx context.Context) (digest.Set, error) {

pkg/filesystem/virtual/in_memory_prepopulated_directory.go

@@ -167,7 +167,7 @@ func (c *inMemoryDirectoryContents) isDeletable(hiddenFilesMatcher StringMatcher
 	return true
 }
 
-func (c *inMemoryDirectoryContents) createChildren(subtree *inMemorySubtree, children map[path.Component]InitialNode) {
+func (c *inMemoryDirectoryContents) createChildren(subtree *inMemorySubtree, children map[path.Component]InitialChild) {
 	// Either sort or shuffle the children before inserting them
 	// into the directory. This either makes VirtualReadDir() behave
 	// deterministically, or not, based on preference.
@@ -519,7 +519,7 @@ func (i *inMemoryPrepopulatedDirectory) InstallHooks(fileAllocator FileAllocator
 	}
 }
 
-func (i *inMemoryPrepopulatedDirectory) CreateChildren(children map[path.Component]InitialNode, overwrite bool) error {
+func (i *inMemoryPrepopulatedDirectory) CreateChildren(children map[path.Component]InitialChild, overwrite bool) error {
 	i.lock.Lock()
 	contents, err := i.getContents()
 	if err != nil {
@@ -598,7 +598,7 @@ func (i *inMemoryPrepopulatedDirectory) filterChildrenRecursive(childFilter Chil
 		// instantiate it. Simply provide the
 		// InitialContentsFetcher to the callback.
 		i.lock.Unlock()
-		return childFilter(InitialNode{}.FromDirectory(initialContentsFetcher), func() error {
+		return childFilter(InitialChild{}.FromDirectory(initialContentsFetcher), func() error {
 			return i.RemoveAllChildren(false)
 		})
 	}
@@ -626,7 +626,7 @@ func (i *inMemoryPrepopulatedDirectory) filterChildrenRecursive(childFilter Chil
 	// Invoke the callback for all children.
 	for _, child := range leaves {
 		name := child.name
-		if !childFilter(InitialNode{}.FromLeaf(child.leaf), func() error {
+		if !childFilter(InitialChild{}.FromLeaf(child.leaf), func() error {
 			return i.Remove(name)
 		}) {
 			return false