GoogleContainerTools/skaffold · error

reading %q in embedded filesystem: %w

Error message

reading %q in embedded filesystem: %w

What it means

Wraps an io.ReadAll failure while draining an opened embedded-asset file during `skaffold credits export`. io.ReadAll on an embedded file essentially only fails on underlying read errors; with go:embed this is rare and usually signals a corrupted binary or a wrapped non-embed FS (e.g. test overlay) whose Read returned an error.

Source

Thrown at cmd/skaffold/app/cmd/credits/export.go:52

// Export writes all the licenses and credit files to the `Path` folder.
func Export(ctx context.Context, out io.Writer) error {
	if err := iofs.WalkDir(fs.AssetsFS, "assets/credits_generated", func(filePath string, dirEntry iofs.DirEntry, err error) error {
		newPath := path.Join(Path, strings.Replace(filePath, "assets/credits_generated", "", 1))
		if dirEntry.IsDir() {
			err := os.Mkdir(newPath, 0755)
			if err != nil && !os.IsExist(err) {
				return fmt.Errorf("creating directory %q: %w", newPath, err)
			}
		} else {
			file, err := fs.AssetsFS.Open(filePath)
			if err != nil {
				return fmt.Errorf("opening %q in embedded filesystem: %w", filePath, err)
			}

			buf, err := io.ReadAll(file)
			if err != nil {
				return fmt.Errorf("reading %q in embedded filesystem: %w", filePath, err)
			}

			if err := os.WriteFile(newPath, buf, 0664); err != nil {
				return fmt.Errorf("writing %q to %q: %w", filePath, newPath, err)
			}
		}
		return nil
	}); err != nil {
		return err
	}

	s, err := filepath.Abs(Path)
	if err != nil {
		return err
	}

	log.Printf("Successfully exported third party notices to %s", s)
	return nil

View on GitHub (pinned to a1189de023)

Solutions

1. Rebuild/reinstall the skaffold binary from official sources
2. If a custom FS wrapper is in play, verify its Read implementation returns the full embedded contents without error
3. Retry the export once; if persistent, report the issue with `skaffold version` output

Example fix

// before
buf, err := io.ReadAll(file)
if err != nil {
    return fmt.Errorf("reading %q in embedded filesystem: %w", filePath, err)
}
// after: nothing to change in caller; verify the embed source instead
// go:embed all:assets
var assets embed.FS  // ensure 'all:' includes dotfiles so paths are not missing

// rare; validate FS wrapper behavior in tests
func TestAssetReadAll(t *testing.T) {
    f, err := fs.AssetsFS.Open("some/asset")
    if err != nil { t.Fatal(err) }
    defer f.Close()
    if _, err := io.ReadAll(f); err != nil { t.Fatal(err) }
}

buf, err := io.ReadAll(file)
if err != nil {
    if errors.Is(err, syscall.EIO) { /* retry or report corrupted binary */ }
    return err
}

When it happens

Trigger: `skaffold credits export` reads an asset via fs.AssetsFS.Open, and the subsequent io.ReadAll(file) returns err != nil — a read/IO failure on the embedded file handle.

Common situations: Custom builds where AssetsFS was replaced or wrapped (e.g. by an overlay FS in tests) that errors on Read; extremely rare disk/IO problems; running on exotic platforms with broken file descriptors.

Related errors

• opening %q in embedded filesystem: %w
• error closing GCS writer: %w
• writing %q to %q: %w
• creating tar gz: %w
• writing string: %w

AI-assisted analysis of GoogleContainerTools/skaffold@a1189de023 (2026-09-05). Data as JSON: /api/errors/15015a0bc3bf7911. Report an issue: GitHub.