src/sys/pkg/bin/pm/build/package.go - fuchsia - Git at Google

 // Copyright 2017 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 package build

 import (
 	"bufio"
 	"encoding/binary"
 	"encoding/json"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 	"regexp"
 	"runtime"
 	"sync"

 	"go.fuchsia.dev/fuchsia/src/sys/pkg/bin/pm/pkg"
 	far "go.fuchsia.dev/fuchsia/src/sys/pkg/lib/far/go"
 	"go.fuchsia.dev/fuchsia/src/sys/pkg/lib/merkle"
 )

 const abiRevisionKey string = "meta/fuchsia.abi/abi-revision"

 // invalidRepositoryCharsPattern contains all characters not allowed by the spec in
 // https://fuchsia.dev/fuchsia-src/concepts/packages/package_url#repository
 var InvalidRepositoryCharsPattern = regexp.MustCompile("[^a-z0-9-.]").MatchString

 // Build-time information about a subpackage
 type SubpackageInfo struct {
 	// If provided, the subpackage name (relative URI path), relative to the
 	// parent package.
 	Name *string `json:"name,omitempty"`

 	// If a subpackage-specific Name override is not explicitly provided,
 	// this field is the path to a JSON serialized pkg.Package object
 	// containing the subpackage's declared package_name.
 	MetaPackageFile *string `json:"meta_package_file,omitempty"`

 	// The path to the package_manifest.json of the subpackage (may not be
 	// used by pm tool)
 	PackageManifestFile string `json:"package_manifest_file"`
 }

 // subpackages metafile content
 type MetaSubpackages struct {
 	Version     string            `json:"version"`
 	Subpackages map[string]string `json:"subpackages"`
 }

 // PackageManifest is the json structure representation of a full package
 // manifest.
 type PackageManifest struct {
 	Version     string                  `json:"version"`
 	Repository  string                  `json:"repository,omitempty"`
 	Package     pkg.Package             `json:"package"`
 	Blobs       []PackageBlobInfo       `json:"blobs"`
 	Subpackages []PackageSubpackageInfo `json:"subpackages,omitempty"`
 }

 // packageManifestMaybeRelative is the json structure representation of a package
 // manifest that may contain file-relative source paths. This is a separate type
 // from PackageManifest so we don't need to touch every use of PackageManifest to
 // avoid writing invalid blob_sources_relative values to disk.
 type packageManifestMaybeRelative struct {
 	Version     string                  `json:"version"`
 	Repository  string                  `json:"repository,omitempty"`
 	Package     pkg.Package             `json:"package"`
 	Blobs       []PackageBlobInfo       `json:"blobs"`
 	Subpackages []PackageSubpackageInfo `json:"subpackages,omitempty"`
 	// TODO(https://fxbug.dev/42066050): rename the json field to `paths_relative` since it
 	// applies to both blobs and subpackages.
 	PathsRelativeTo string `json:"blob_sources_relative"`
 }

 // LoadPackageManifest parses the package manifest for a particular package,
 // resolving file-relative blob source paths before returning if needed.
 func LoadPackageManifest(packageManifestPath string) (*PackageManifest, error) {
 	fileContents, err := os.ReadFile(packageManifestPath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read %s: %w", packageManifestPath, err)
 	}

 	rawManifest := &packageManifestMaybeRelative{}
 	if err := json.Unmarshal(fileContents, rawManifest); err != nil {
 		return nil, fmt.Errorf("failed to unmarshal %s: %w", packageManifestPath, err)
 	}

 	manifest := &PackageManifest{}
 	manifest.Version = rawManifest.Version
 	manifest.Repository = rawManifest.Repository
 	manifest.Package = rawManifest.Package

 	if manifest.Version != "1" {
 		return nil, fmt.Errorf("unknown version %q, can't load manifest", manifest.Version)
 	}

 	// if the manifest has file-relative paths, make them relative to the working directory
 	if rawManifest.PathsRelativeTo == "file" {
 		basePath := filepath.Dir(packageManifestPath)
 		for i := 0; i < len(rawManifest.Blobs); i++ {
 			blob := rawManifest.Blobs[i]
 			blob.SourcePath = filepath.Join(basePath, blob.SourcePath)
 			manifest.Blobs = append(manifest.Blobs, blob)
 		}

 		for i := 0; i < len(rawManifest.Subpackages); i++ {
 			subpackage := rawManifest.Subpackages[i]
 			subpackage.ManifestPath = filepath.Join(basePath, subpackage.ManifestPath)
 			manifest.Subpackages = append(manifest.Subpackages, subpackage)
 		}
 	} else {
 		manifest.Blobs = rawManifest.Blobs
 		manifest.Subpackages = rawManifest.Subpackages
 	}

 	return manifest, nil
 }

 // Init initializes package metadata in the output directory. A manifest
 // is generated with a name matching the output directory name.
 func Init(cfg *Config) error {
 	metadir := filepath.Join(cfg.OutputDir, "meta")
 	if err := os.MkdirAll(metadir, os.ModePerm); err != nil {
 		return err
 	}

 	meta := filepath.Join(metadir, "package")
 	if _, err := os.Stat(meta); os.IsNotExist(err) {
 		f, err := os.Create(meta)
 		if err != nil {
 			return err
 		}

 		p, err := cfg.Package()
 		if err != nil {
 			return err
 		}

 		err = json.NewEncoder(f).Encode(&p)
 		f.Close()
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }

 // Update walks the contents of the package and updates the merkle root values
 // within the contents file.
 func Update(cfg *Config) error {
 	metadir := filepath.Join(cfg.OutputDir, "meta")
 	os.MkdirAll(metadir, os.ModePerm)
 	manifest, err := cfg.Manifest()
 	if err != nil {
 		return err
 	}

 	if err := writeABIRevision(cfg, manifest); err != nil {
 		return err
 	}

 	contentsPath := filepath.Join(metadir, "contents")
 	pkgContents := manifest.Content()

 	if cfg.SubpackagesPath != "" {
 		if err := writeSubpackagesMeta(cfg, cfg.SubpackagesPath); err != nil {
 			return err
 		}
 	}

 	// manifestLines is a channel containing unpacked manifest paths
 	var manifestLines = make(chan struct{ src, dest string }, len(pkgContents))
 	go func() {
 		for dest, src := range pkgContents {
 			manifestLines <- struct{ src, dest string }{src, dest}
 		}
 		close(manifestLines)
 	}()

 	// contentCollector receives entries to include in contents
 	type contentEntry struct {
 		path string
 		root MerkleRoot
 	}
 	var contentCollector = make(chan contentEntry, len(pkgContents))
 	var errors = make(chan error)

 	// w is a group that is done when contentCollector is fully populated
 	var w sync.WaitGroup
 	for i := runtime.NumCPU(); i > 0; i-- {
 		w.Add(1)

 		go func() {
 			defer w.Done()

 			for in := range manifestLines {
 				var t merkle.Tree
 				cf, err := os.Open(in.src)
 				if err != nil {
 					errors <- fmt.Errorf("build.Update: open %s for %s: %s", in.src, in.dest, err)
 					return
 				}
 				_, err = t.ReadFrom(bufio.NewReader(cf))
 				cf.Close()
 				if err != nil {
 					errors <- err
 					return
 				}

 				var root MerkleRoot
 				copy(root[:], t.Root())
 				contentCollector <- contentEntry{in.dest, root}
 			}
 		}()
 	}

 	// close the collector channel when all workers are done
 	go func() {
 		w.Wait()
 		close(contentCollector)
 	}()

 	// collect all results and close done to signal the waiting select
 	var done = make(chan struct{})
 	contents := MetaContents{}
 	go func() {
 		for entry := range contentCollector {
 			contents[entry.path] = entry.root
 		}
 		close(done)
 	}()

 	select {
 	case <-done:
 		// contents is populated
 	case err := <-errors:
 		// exit on the first error
 		return err
 	}

 	manifest.Paths["meta/contents"] = contentsPath

 	return os.WriteFile(contentsPath,
 		[]byte(contents.String()), os.ModePerm)
 }

 func writeABIRevision(cfg *Config, manifest *Manifest) error {
 	// Read the ABI file from the manifest, if it exists.
 	manifestABIRevision, err := readABIRevision(manifest)
 	if err != nil {
 		return err
 	}

 	if manifestABIRevision == nil && cfg.PkgABIRevision == 0 {
 		// FIXME(https://fxbug.dev/42168415): We can stop treating the ABI
 		// revision as optional once the ecosystem has migrated to
 		// specifying it everywhere.
 		//return fmt.Errorf("the Fuchsia SDK version must be specified with either the -api-level or -abi-revision arguments, or manually creating meta/fuchsia.abi/abi-revision in the package directory")
 		return nil
 	}

 	var abiRevision uint64

 	if manifestABIRevision != nil {
 		if cfg.PkgABIRevision != 0 && *manifestABIRevision != cfg.PkgABIRevision {
 			return fmt.Errorf("Manifest ABI revision %x does not match the CLI revision %x", *manifestABIRevision, cfg.PkgABIRevision)
 		}

 		abiRevision = *manifestABIRevision
 	} else {
 		abiRevision = cfg.PkgABIRevision
 	}

 	abiDir := filepath.Join(cfg.OutputDir, "meta", "fuchsia.abi")
 	if err := os.MkdirAll(abiDir, os.ModePerm); err != nil {
 		return err
 	}

 	b := make([]byte, 8)
 	binary.LittleEndian.PutUint64(b, abiRevision)

 	path := filepath.Join(abiDir, "abi-revision")
 	if err := os.WriteFile(path, b, os.ModePerm); err != nil {
 		return err
 	}

 	manifest.Paths[abiRevisionKey] = path

 	return nil
 }

 func readABIRevision(manifest *Manifest) (*uint64, error) {
 	abiPath, ok := manifest.Meta()[abiRevisionKey]
 	if !ok {
 		return nil, nil
 	}

 	return ReadABIRevisionFromFile(abiPath)
 }

 func ReadABIRevisionFromFile(abiPath string) (*uint64, error) {
 	f, err := os.Open(abiPath)
 	if err != nil {
 		return nil, err
 	}

 	// The ABI revision file should be exactly 8 bytes.
 	info, err := f.Stat()
 	if err != nil {
 		return nil, err
 	}

 	if info.Size() != 8 {
 		return nil, fmt.Errorf("ABI revision file must be 8 bytes")
 	}

 	abiRevisionBytes, err := io.ReadAll(f)
 	if err != nil {
 		return nil, err
 	}

 	// We should have only read 8 bytes.
 	if len(abiRevisionBytes) != 8 {
 		return nil, fmt.Errorf("Invalid ABI revision")
 	}

 	abiRevision := binary.LittleEndian.Uint64(abiRevisionBytes)

 	return &abiRevision, nil
 }

 // ErrRequiredFileMissing is returned by operations when the operation depends
 // on a file that was not found on disk.
 type ErrRequiredFileMissing struct {
 	Path string
 }

 func (e ErrRequiredFileMissing) Error() string {
 	return fmt.Sprintf("pkg: missing required file: %q", e.Path)
 }

 // RequiredFiles is a list of files that are required before a package can be sealed.
 var RequiredFiles = []string{"meta/contents", "meta/package"}

 // Validate ensures that the package contains the required files.
 func Validate(cfg *Config) error {
 	if InvalidRepositoryCharsPattern(cfg.PkgRepository) {
 		return fmt.Errorf("pkg: invalid package repository \"%v\"", cfg.PkgRepository)
 	}
 	manifest, err := cfg.Manifest()
 	if err != nil {
 		return err
 	}
 	meta := manifest.Meta()

 	for _, f := range RequiredFiles {
 		if _, ok := meta[f]; !ok {
 			return ErrRequiredFileMissing{f}
 		}
 	}

 	return nil
 }

 // Seal archives meta/ into a FAR archive named meta.far.
 func Seal(cfg *Config) (string, error) {
 	manifest, err := cfg.Manifest()
 	if err != nil {
 		return "", err
 	}

 	if err := Validate(cfg); err != nil {
 		return "", err
 	}

 	archive, err := os.Create(cfg.MetaFAR())
 	if err != nil {
 		return "", err
 	}

 	if err := far.Write(archive, manifest.Meta()); err != nil {
 		return "", err
 	}

 	if _, err := archive.Seek(0, io.SeekStart); err != nil {
 		return "", err
 	}
 	return cfg.MetaFAR(), archive.Close()
 }

 // Read the build-time subpackage data and output files and generate the
 // "subpackages" meta file
 func writeSubpackagesMeta(cfg *Config, subpackagesPath string) error {
 	content, err := os.ReadFile(subpackagesPath)
 	if err != nil {
 		return fmt.Errorf("the -subpackages file (%s) could not be read: %s", subpackagesPath, err)
 	}
 	var subpackages []SubpackageInfo
 	if err := json.Unmarshal(content, &subpackages); err != nil {
 		return fmt.Errorf("the -subpackages file (%s) could not be parsed as JSON: %s", subpackagesPath, err)
 	}

 	var meta_subpackages MetaSubpackages
 	meta_subpackages.Version = "1"
 	meta_subpackages.Subpackages = make(map[string]string)

 	for _, subpackage := range subpackages {
 		var name *string
 		if subpackage.Name != nil {
 			name = subpackage.Name
 		} else if subpackage.MetaPackageFile == nil {
 			return fmt.Errorf("format error in the -subpackages file (%s): a subpackage entry requires either a 'name' or a 'meta_package_file'", subpackagesPath)
 		} else {
 			content, err := os.ReadFile(*subpackage.MetaPackageFile)
 			if err != nil {
 				return fmt.Errorf("a subpackage meta package file (%s) could not be read: %s", *subpackage.MetaPackageFile, err)
 			}
 			var packageMeta pkg.Package
 			if err := json.Unmarshal(content, &packageMeta); err != nil {
 				return fmt.Errorf("a subpackage meta package file (%s) could not be parsed as JSON: %s", *subpackage.MetaPackageFile, err)
 			}
 			name = &packageMeta.Name
 		}

 		if _, ok := meta_subpackages.Subpackages[*name]; ok {
 			return fmt.Errorf("duplicate entry in the -subpackages file (%s) for name: %s", subpackagesPath, *name)
 		}

 		// Find the merkle root for the subpackage.
 		packageManifest, err := LoadPackageManifest(subpackage.PackageManifestFile)
 		if err != nil {
 			return fmt.Errorf("a subpackage package manifest (%s) could not be read: %s", subpackage.PackageManifestFile, err)
 		}
 		metaFarIdx := -1
 		for i := range packageManifest.Blobs {
 			if packageManifest.Blobs[i].Path == "meta/" {
 				metaFarIdx = i
 				break
 			}
 		}
 		if metaFarIdx == -1 {
 			return fmt.Errorf("a subpackage package manifest (%s) is missing a meta.far: %s", subpackage.PackageManifestFile, err)
 		}
 		merkle := packageManifest.Blobs[metaFarIdx].Merkle.String()
 		meta_subpackages.Subpackages[*name] = merkle
 	}
 	{
 		content, err := json.MarshalIndent(meta_subpackages, "", "    ")
 		if err != nil {
 			return err
 		}
 		subpackages_dir := filepath.Join(cfg.OutputDir, "meta", "fuchsia.pkg")
 		os.MkdirAll(subpackages_dir, os.ModePerm)
 		subpackagesFilePath := filepath.Join(subpackages_dir, "subpackages")
 		if err := os.WriteFile(subpackagesFilePath, content, 0644); err != nil {
 			return err
 		}

 		manifest, err := cfg.Manifest()
 		if err != nil {
 			return err
 		}
 		manifest.Paths["meta/fuchsia.pkg/subpackages"] = subpackagesFilePath
 	}
 	return nil
 }
	// Copyright 2017 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	package build

	import (
	"bufio"
	"encoding/binary"
	"encoding/json"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"regexp"
	"runtime"
	"sync"

	"go.fuchsia.dev/fuchsia/src/sys/pkg/bin/pm/pkg"
	far "go.fuchsia.dev/fuchsia/src/sys/pkg/lib/far/go"
	"go.fuchsia.dev/fuchsia/src/sys/pkg/lib/merkle"
	)

	const abiRevisionKey string = "meta/fuchsia.abi/abi-revision"

	// invalidRepositoryCharsPattern contains all characters not allowed by the spec in
	// https://fuchsia.dev/fuchsia-src/concepts/packages/package_url#repository
	var InvalidRepositoryCharsPattern = regexp.MustCompile("[^a-z0-9-.]").MatchString

	// Build-time information about a subpackage
	type SubpackageInfo struct {
	// If provided, the subpackage name (relative URI path), relative to the
	// parent package.
	Name *string `json:"name,omitempty"`

	// If a subpackage-specific Name override is not explicitly provided,
	// this field is the path to a JSON serialized pkg.Package object
	// containing the subpackage's declared package_name.
	MetaPackageFile *string `json:"meta_package_file,omitempty"`

	// The path to the package_manifest.json of the subpackage (may not be
	// used by pm tool)
	PackageManifestFile string `json:"package_manifest_file"`
	}

	// subpackages metafile content
	type MetaSubpackages struct {
	Version string `json:"version"`
	Subpackages map[string]string `json:"subpackages"`
	}

	// PackageManifest is the json structure representation of a full package
	// manifest.
	type PackageManifest struct {
	Version string `json:"version"`
	Repository string `json:"repository,omitempty"`
	Package pkg.Package `json:"package"`
	Blobs []PackageBlobInfo `json:"blobs"`
	Subpackages []PackageSubpackageInfo `json:"subpackages,omitempty"`
	}

	// packageManifestMaybeRelative is the json structure representation of a package
	// manifest that may contain file-relative source paths. This is a separate type
	// from PackageManifest so we don't need to touch every use of PackageManifest to
	// avoid writing invalid blob_sources_relative values to disk.
	type packageManifestMaybeRelative struct {
	Version string `json:"version"`
	Repository string `json:"repository,omitempty"`
	Package pkg.Package `json:"package"`
	Blobs []PackageBlobInfo `json:"blobs"`
	Subpackages []PackageSubpackageInfo `json:"subpackages,omitempty"`
	// TODO(https://fxbug.dev/42066050): rename the json field to `paths_relative` since it
	// applies to both blobs and subpackages.
	PathsRelativeTo string `json:"blob_sources_relative"`
	}

	// LoadPackageManifest parses the package manifest for a particular package,
	// resolving file-relative blob source paths before returning if needed.
	func LoadPackageManifest(packageManifestPath string) (*PackageManifest, error) {
	fileContents, err := os.ReadFile(packageManifestPath)
	if err != nil {
	return nil, fmt.Errorf("failed to read %s: %w", packageManifestPath, err)
	}

	rawManifest := &packageManifestMaybeRelative{}
	if err := json.Unmarshal(fileContents, rawManifest); err != nil {
	return nil, fmt.Errorf("failed to unmarshal %s: %w", packageManifestPath, err)
	}

	manifest := &PackageManifest{}
	manifest.Version = rawManifest.Version
	manifest.Repository = rawManifest.Repository
	manifest.Package = rawManifest.Package

	if manifest.Version != "1" {
	return nil, fmt.Errorf("unknown version %q, can't load manifest", manifest.Version)
	}

	// if the manifest has file-relative paths, make them relative to the working directory
	if rawManifest.PathsRelativeTo == "file" {
	basePath := filepath.Dir(packageManifestPath)
	for i := 0; i < len(rawManifest.Blobs); i++ {
	blob := rawManifest.Blobs[i]
	blob.SourcePath = filepath.Join(basePath, blob.SourcePath)
	manifest.Blobs = append(manifest.Blobs, blob)
	}

	for i := 0; i < len(rawManifest.Subpackages); i++ {
	subpackage := rawManifest.Subpackages[i]
	subpackage.ManifestPath = filepath.Join(basePath, subpackage.ManifestPath)
	manifest.Subpackages = append(manifest.Subpackages, subpackage)
	}
	} else {
	manifest.Blobs = rawManifest.Blobs
	manifest.Subpackages = rawManifest.Subpackages
	}

	return manifest, nil
	}

	// Init initializes package metadata in the output directory. A manifest
	// is generated with a name matching the output directory name.
	func Init(cfg *Config) error {
	metadir := filepath.Join(cfg.OutputDir, "meta")
	if err := os.MkdirAll(metadir, os.ModePerm); err != nil {
	return err
	}

	meta := filepath.Join(metadir, "package")
	if _, err := os.Stat(meta); os.IsNotExist(err) {
	f, err := os.Create(meta)
	if err != nil {
	return err
	}

	p, err := cfg.Package()
	if err != nil {
	return err
	}

	err = json.NewEncoder(f).Encode(&p)
	f.Close()
	if err != nil {
	return err
	}
	}
	return nil
	}

	// Update walks the contents of the package and updates the merkle root values
	// within the contents file.
	func Update(cfg *Config) error {
	metadir := filepath.Join(cfg.OutputDir, "meta")
	os.MkdirAll(metadir, os.ModePerm)
	manifest, err := cfg.Manifest()
	if err != nil {
	return err
	}

	if err := writeABIRevision(cfg, manifest); err != nil {
	return err
	}

	contentsPath := filepath.Join(metadir, "contents")
	pkgContents := manifest.Content()

	if cfg.SubpackagesPath != "" {
	if err := writeSubpackagesMeta(cfg, cfg.SubpackagesPath); err != nil {
	return err
	}
	}

	// manifestLines is a channel containing unpacked manifest paths
	var manifestLines = make(chan struct{ src, dest string }, len(pkgContents))
	go func() {
	for dest, src := range pkgContents {
	manifestLines <- struct{ src, dest string }{src, dest}
	}
	close(manifestLines)
	}()

	// contentCollector receives entries to include in contents
	type contentEntry struct {
	path string
	root MerkleRoot
	}
	var contentCollector = make(chan contentEntry, len(pkgContents))
	var errors = make(chan error)

	// w is a group that is done when contentCollector is fully populated
	var w sync.WaitGroup
	for i := runtime.NumCPU(); i > 0; i-- {
	w.Add(1)

	go func() {
	defer w.Done()

	for in := range manifestLines {
	var t merkle.Tree
	cf, err := os.Open(in.src)
	if err != nil {
	errors <- fmt.Errorf("build.Update: open %s for %s: %s", in.src, in.dest, err)
	return
	}
	_, err = t.ReadFrom(bufio.NewReader(cf))
	cf.Close()
	if err != nil {
	errors <- err
	return
	}

	var root MerkleRoot
	copy(root[:], t.Root())
	contentCollector <- contentEntry{in.dest, root}
	}
	}()
	}

	// close the collector channel when all workers are done
	go func() {
	w.Wait()
	close(contentCollector)
	}()

	// collect all results and close done to signal the waiting select
	var done = make(chan struct{})
	contents := MetaContents{}
	go func() {
	for entry := range contentCollector {
	contents[entry.path] = entry.root
	}
	close(done)
	}()

	select {
	case <-done:
	// contents is populated
	case err := <-errors:
	// exit on the first error
	return err
	}

	manifest.Paths["meta/contents"] = contentsPath

	return os.WriteFile(contentsPath,
	[]byte(contents.String()), os.ModePerm)
	}

	func writeABIRevision(cfg Config, manifest Manifest) error {
	// Read the ABI file from the manifest, if it exists.
	manifestABIRevision, err := readABIRevision(manifest)
	if err != nil {
	return err
	}

	if manifestABIRevision == nil && cfg.PkgABIRevision == 0 {
	// FIXME(https://fxbug.dev/42168415): We can stop treating the ABI
	// revision as optional once the ecosystem has migrated to
	// specifying it everywhere.
	//return fmt.Errorf("the Fuchsia SDK version must be specified with either the -api-level or -abi-revision arguments, or manually creating meta/fuchsia.abi/abi-revision in the package directory")
	return nil
	}

	var abiRevision uint64

	if manifestABIRevision != nil {
	if cfg.PkgABIRevision != 0 && *manifestABIRevision != cfg.PkgABIRevision {
	return fmt.Errorf("Manifest ABI revision %x does not match the CLI revision %x", *manifestABIRevision, cfg.PkgABIRevision)
	}

	abiRevision = *manifestABIRevision
	} else {
	abiRevision = cfg.PkgABIRevision
	}

	abiDir := filepath.Join(cfg.OutputDir, "meta", "fuchsia.abi")
	if err := os.MkdirAll(abiDir, os.ModePerm); err != nil {
	return err
	}

	b := make([]byte, 8)
	binary.LittleEndian.PutUint64(b, abiRevision)

	path := filepath.Join(abiDir, "abi-revision")
	if err := os.WriteFile(path, b, os.ModePerm); err != nil {
	return err
	}

	manifest.Paths[abiRevisionKey] = path

	return nil
	}

	func readABIRevision(manifest Manifest) (uint64, error) {
	abiPath, ok := manifest.Meta()[abiRevisionKey]
	if !ok {
	return nil, nil
	}

	return ReadABIRevisionFromFile(abiPath)
	}

	func ReadABIRevisionFromFile(abiPath string) (*uint64, error) {
	f, err := os.Open(abiPath)
	if err != nil {
	return nil, err
	}

	// The ABI revision file should be exactly 8 bytes.
	info, err := f.Stat()
	if err != nil {
	return nil, err
	}

	if info.Size() != 8 {
	return nil, fmt.Errorf("ABI revision file must be 8 bytes")
	}

	abiRevisionBytes, err := io.ReadAll(f)
	if err != nil {
	return nil, err
	}

	// We should have only read 8 bytes.
	if len(abiRevisionBytes) != 8 {
	return nil, fmt.Errorf("Invalid ABI revision")
	}

	abiRevision := binary.LittleEndian.Uint64(abiRevisionBytes)

	return &abiRevision, nil
	}

	// ErrRequiredFileMissing is returned by operations when the operation depends
	// on a file that was not found on disk.
	type ErrRequiredFileMissing struct {
	Path string
	}

	func (e ErrRequiredFileMissing) Error() string {
	return fmt.Sprintf("pkg: missing required file: %q", e.Path)
	}

	// RequiredFiles is a list of files that are required before a package can be sealed.
	var RequiredFiles = []string{"meta/contents", "meta/package"}

	// Validate ensures that the package contains the required files.
	func Validate(cfg *Config) error {
	if InvalidRepositoryCharsPattern(cfg.PkgRepository) {
	return fmt.Errorf("pkg: invalid package repository \"%v\"", cfg.PkgRepository)
	}
	manifest, err := cfg.Manifest()
	if err != nil {
	return err
	}
	meta := manifest.Meta()

	for _, f := range RequiredFiles {
	if _, ok := meta[f]; !ok {
	return ErrRequiredFileMissing{f}
	}
	}

	return nil
	}

	// Seal archives meta/ into a FAR archive named meta.far.
	func Seal(cfg *Config) (string, error) {
	manifest, err := cfg.Manifest()
	if err != nil {
	return "", err
	}

	if err := Validate(cfg); err != nil {
	return "", err
	}

	archive, err := os.Create(cfg.MetaFAR())
	if err != nil {
	return "", err
	}

	if err := far.Write(archive, manifest.Meta()); err != nil {
	return "", err
	}

	if _, err := archive.Seek(0, io.SeekStart); err != nil {
	return "", err
	}
	return cfg.MetaFAR(), archive.Close()
	}

	// Read the build-time subpackage data and output files and generate the
	// "subpackages" meta file
	func writeSubpackagesMeta(cfg *Config, subpackagesPath string) error {
	content, err := os.ReadFile(subpackagesPath)
	if err != nil {
	return fmt.Errorf("the -subpackages file (%s) could not be read: %s", subpackagesPath, err)
	}
	var subpackages []SubpackageInfo
	if err := json.Unmarshal(content, &subpackages); err != nil {
	return fmt.Errorf("the -subpackages file (%s) could not be parsed as JSON: %s", subpackagesPath, err)
	}

	var meta_subpackages MetaSubpackages
	meta_subpackages.Version = "1"
	meta_subpackages.Subpackages = make(map[string]string)

	for _, subpackage := range subpackages {
	var name *string
	if subpackage.Name != nil {
	name = subpackage.Name
	} else if subpackage.MetaPackageFile == nil {
	return fmt.Errorf("format error in the -subpackages file (%s): a subpackage entry requires either a 'name' or a 'meta_package_file'", subpackagesPath)
	} else {
	content, err := os.ReadFile(*subpackage.MetaPackageFile)
	if err != nil {
	return fmt.Errorf("a subpackage meta package file (%s) could not be read: %s", *subpackage.MetaPackageFile, err)
	}
	var packageMeta pkg.Package
	if err := json.Unmarshal(content, &packageMeta); err != nil {
	return fmt.Errorf("a subpackage meta package file (%s) could not be parsed as JSON: %s", *subpackage.MetaPackageFile, err)
	}
	name = &packageMeta.Name
	}

	if _, ok := meta_subpackages.Subpackages[*name]; ok {
	return fmt.Errorf("duplicate entry in the -subpackages file (%s) for name: %s", subpackagesPath, *name)
	}

	// Find the merkle root for the subpackage.
	packageManifest, err := LoadPackageManifest(subpackage.PackageManifestFile)
	if err != nil {
	return fmt.Errorf("a subpackage package manifest (%s) could not be read: %s", subpackage.PackageManifestFile, err)
	}
	metaFarIdx := -1
	for i := range packageManifest.Blobs {
	if packageManifest.Blobs[i].Path == "meta/" {
	metaFarIdx = i
	break
	}
	}
	if metaFarIdx == -1 {
	return fmt.Errorf("a subpackage package manifest (%s) is missing a meta.far: %s", subpackage.PackageManifestFile, err)
	}
	merkle := packageManifest.Blobs[metaFarIdx].Merkle.String()
	meta_subpackages.Subpackages[*name] = merkle
	}
	{
	content, err := json.MarshalIndent(meta_subpackages, "", " ")
	if err != nil {
	return err
	}
	subpackages_dir := filepath.Join(cfg.OutputDir, "meta", "fuchsia.pkg")
	os.MkdirAll(subpackages_dir, os.ModePerm)
	subpackagesFilePath := filepath.Join(subpackages_dir, "subpackages")
	if err := os.WriteFile(subpackagesFilePath, content, 0644); err != nil {
	return err
	}

	manifest, err := cfg.Manifest()
	if err != nil {
	return err
	}
	manifest.Paths["meta/fuchsia.pkg/subpackages"] = subpackagesFilePath
	}
	return nil
	}