src/cmd/cos_dkms/actions/args.go - cos/tools - Git at Google

 package actions

 import (
 	"context"
 	"errors"
 	"fmt"
 	"os"
 	"os/exec"
 	"path"
 	"strings"

 	"cloud.google.com/go/storage"
 	"cos.googlesource.com/cos/tools.git/src/pkg/cos"
 	"cos.googlesource.com/cos/tools.git/src/pkg/dkms"
 	"cos.googlesource.com/cos/tools.git/src/pkg/fs"
 	"cos.googlesource.com/cos/tools.git/src/pkg/gcs"
 	"cos.googlesource.com/cos/tools.git/src/pkg/utils"
 	"github.com/golang/glog"
 	"github.com/spf13/cobra"
 	"google.golang.org/api/option"
 )

 func FetchKernelVersion() (string, error) {
 	kernelVersion := os.Getenv("KERNEL_VERSION")
 	if kernelVersion != "" {
 		return kernelVersion, nil
 	}

 	cmd := exec.Command("uname", "-r")
 	out, err := cmd.CombinedOutput()
 	if err == nil {
 		glog.Info(string(out))
 	} else {
 		glog.Error(string(out))
 		return "", err
 	}
 	return strings.Trim(string(out), "\n"), nil
 }

 // FetchKernelVersionFromHeaders downloads the COS kernel headers for the
 // given build id and board to a temporary directory and reads the kernel
 // release version from include/config/kernel.release.
 func FetchKernelVersionFromHeaders(buildId, board string) (string, error) {
 	ctx := context.Background()
 	client, err := storage.NewClient(ctx, option.WithoutAuthentication())
 	if err != nil {
 		return "", err
 	}

 	prefix := path.Join(buildId, board)
 	downloader := cos.NewGCSDownloader(client, nil, "", prefix, "", "")

 	tmpDir, err := os.MkdirTemp("", "")
 	if err != nil {
 		return "", err
 	}
 	defer os.RemoveAll(tmpDir)

 	glog.Infof("installing kernel headers to determine kernel version")
 	if err := dkms.InstallKernelHeaders(ctx, downloader, tmpDir); err != nil {
 		return "", err
 	}

 	versionPath := path.Join(tmpDir, "include/config/kernel.release")
 	versionBytes, err := os.ReadFile(versionPath)
 	if err != nil {
 		return "", err
 	}
 	version := strings.TrimSpace(string(versionBytes))

 	return version, nil
 }

 func FetchArch() (string, error) {
 	arch := os.Getenv("ARCH")
 	if arch != "" {
 		return arch, nil
 	}

 	cmd := exec.Command("uname", "-m")
 	out, err := cmd.CombinedOutput()
 	if err == nil {
 		glog.Info(string(out))
 	} else {
 		glog.Error(string(out))
 		return "", err
 	}
 	return strings.Trim(string(out), "\n"), nil
 }

 func ParsePackageNameAndVersion(name, version string) (string, string, error) {
 	if name == "" {
 		return "", "", errors.New("must provide a package name and version as <package>/<version>")
 	}

 	parts := strings.Split(name, "/")
 	name = parts[0]
 	if name == "" {
 		return "", "", errors.New("package name must not be empty")
 	}

 	if version == "" {
 		if len(parts) != 2 {
 			return "", "", errors.New("must provide a package and version as <package>/<version>")
 		}

 		version = parts[1]
 		if version == "" {
 			return "", "", errors.New("package version must not be empty")
 		}
 	} else {
 		if len(parts) != 1 {
 			return "", "", errors.New("cannot provide explicit package version and <package>/<version> simultaneously")
 		}
 	}

 	return name, version, nil
 }

 func initPackage(pkg *dkms.Package) error {
 	name, version, err := ParsePackageNameAndVersion(pkg.Name, pkg.Version)
 	if err != nil {
 		return err
 	}
 	pkg.Name = name
 	pkg.Version = version

 	if pkg.KernelVersion == "" {
 		kernelVersion, err := FetchKernelVersion()
 		if err != nil {
 			return fmt.Errorf("could not determine kernel version: %v", err)
 		}
 		pkg.KernelVersion = kernelVersion
 	} else if pkg.KernelVersion == "cos-default" {
 		kernelVersion, err := FetchKernelVersionFromHeaders(pkg.BuildId, pkg.Board)
 		if err != nil {
 			return fmt.Errorf("could not determine kernel version from headers: %v", err)
 		}
 		pkg.KernelVersion = kernelVersion
 	}

 	if pkg.Arch == "" {
 		arch, err := FetchArch()
 		if err != nil {
 			return fmt.Errorf("could not determine arch: %v", err)
 		}
 		pkg.Arch = arch
 	}

 	if pkg.Trees.Source == "" {
 		pkg.Trees.Source = "/usr/src"
 	}

 	if pkg.Trees.Install == "" {
 		pkg.Trees.Install = fmt.Sprintf("/lib/modules/%s", pkg.KernelVersion)
 	}

 	if pkg.Trees.Kernel == "" {
 		pkg.Trees.Kernel = fmt.Sprintf("/lib/modules/%s/build", pkg.KernelVersion)
 	}

 	if pkg.Trees.KernelModules == "" {
 		pkg.Trees.KernelModules = pkg.Trees.Install
 	}

 	if fs.IsDir(pkg.SourceDir()) {
 		config, err := dkms.LoadConfig(pkg)
 		if err != nil {
 			glog.Warningf("error loading dkms config: %v", err)
 		} else {
 			pkg.Config = config
 		}
 	}

 	return nil
 }

 func parseKeyCertPaths(options *dkms.Options) {
 	privateKeyPath := os.Getenv("MODULES_SIGN_KEY")
 	if privateKeyPath == "" {
 		privateKeyPath = "/var/lib/dkms/mok.key"
 	}

 	certificatePath := os.Getenv("MODULES_SIGN_CERT")
 	if certificatePath == "" {
 		certificatePath = "/var/lib/dkms/mok.cert"
 	}

 	options.PrivateKeyPath = privateKeyPath
 	options.CertificatePath = certificatePath
 }

 func FetchLatestCompatiblePackageVersion(pkg *dkms.Package, cache *gcs.GCSBucket) (string, error) {
 	versions, err := dkms.CompatiblePackageVersions(pkg)
 	if err != nil {
 		return "", err
 	}

 	if cache != nil {
 		ctx := context.Background()
 		cachedVersions, err := dkms.CachedCompatiblePackageVersions(ctx, pkg, cache)
 		if err != nil {
 			return "", err
 		}

 		versions = append(versions, cachedVersions...)
 	}

 	if len(versions) == 0 {
 		if cache != nil {
 			return "", fmt.Errorf("could not find any usable versions of the specified package in the local or cache DKMS tree; make sure the package is added first before using --latest")
 		} else {
 			return "", fmt.Errorf("could not find any usable versions of the specified package in the local DKMS tree; make sure the package is added first before using --latest")
 		}
 	}

 	latestVersion := versions[0]
 	for _, version := range versions[1:] {
 		if dkms.CompareVersions(latestVersion, version) < 0 {
 			latestVersion = version
 		}
 	}

 	return latestVersion, nil
 }

 func InitPackage(pkg *dkms.Package, cache *gcs.GCSBucket, latest bool) error {
 	// We need all of the other package fields initialized before we can
 	// determine the latest version of the package, so we fill in a
 	// placeholder value of the version so that the rest of the
 	// initialization works as normal
 	if latest {
 		if pkg.Version != "" {
 			return fmt.Errorf("cannot specify explicit package version (%s) and --latest simultaneously", pkg.Version)
 		}

 		pkg.Version = "placeholder"
 	}

 	if err := initPackage(pkg); err != nil {
 		return err
 	}

 	// After the other fields are initialized, we can get the actual latest
 	// package version.
 	if latest {
 		version, err := FetchLatestCompatiblePackageVersion(pkg, cache)
 		if err != nil {
 			return err
 		}
 		pkg.Version = version
 	}
 	glog.Infof("using package version %s", pkg.Version)

 	return nil
 }

 func InitCache(gcsPath, buildId, board string) (*gcs.GCSBucket, error) {
 	if gcsPath == "" {
 		gcsPath = os.Getenv("GCS_BUCKET")
 	}

 	if gcsPath == "" {
 		return nil, nil
 	}

 	if gcsPath == "cos-default" {
 		bucket := cos.DefaultCOSArtifactsBucket()
 		gcsPath = fmt.Sprintf("gs://%s/%s/%s", bucket, buildId, board)
 	}

 	ctx := context.Background()
 	client, err := storage.NewClient(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create storage client: %v", err)
 	}
 	return gcs.GCSBucketFromPath(client, gcsPath)
 }

 func parsePositionalArgs(args []string, pkg *dkms.Package) error {
 	if len(args) >= 1 {
 		if pkg.Name != "" {
 			return fmt.Errorf("cannot specify package name as both positional argument and flag")
 		}

 		pkg.Name = args[0]
 	}

 	if len(args) >= 2 {
 		if pkg.Trees.Source != "" {
 			return fmt.Errorf("cannot specify source tree as both positional argument and flag")
 		}

 		pkg.Trees.Source = args[1]
 	}

 	if len(args) > 2 {
 		return fmt.Errorf("expected at most 2 positional arguments; received %d", len(args))
 	}

 	return nil
 }

 // InitCOSValues initializes the package values which are specific to COS,
 // namely BuildId and Board.
 func InitCOSValues(pkg *dkms.Package, lsbReleasePath string) {
 	if pkg.BuildId == "" {
 		pkg.BuildId = os.Getenv("BUILD_ID")
 	}

 	if pkg.Board == "" {
 		pkg.Board = os.Getenv("BOARD")
 	}

 	if pkg.BuildId != "" && pkg.Board != "" {
 		return
 	}

 	lsbReleaseVars, err := utils.LoadEnvFromFile("", lsbReleasePath)
 	if err != nil {
 		glog.Warningf("could not read lsb-release file at %s: %v", err)
 	}
 	if pkg.BuildId == "" {
 		pkg.BuildId = lsbReleaseVars["CHROMEOS_RELEASE_VERSION"]
 	}
 	if pkg.Board == "" {
 		pkg.Board = lsbReleaseVars["CHROMEOS_RELEASE_BOARD"]
 	}
 }

 // ParseArgs parses the cobra positional arguments and flags to populate the
 // options, pkg, and RootGCSBucket variables.
 func ParseArgs(cmd *cobra.Command, args []string) error {
 	if err := parsePositionalArgs(args, RootPackage); err != nil {
 		return err
 	}
 	parseKeyCertPaths(RootOptions)

 	InitCOSValues(RootPackage, RootOptions.LSBReleasePath)

 	var err error
 	RootGCSBucket, err = InitCache(RootOptions.GCSBucket, RootPackage.BuildId, RootPackage.Board)
 	if err != nil {
 		return err
 	}

 	if err := InitPackage(RootPackage, RootGCSBucket, RootOptions.Latest); err != nil {
 		return err
 	}

 	glog.V(2).Infof("options: %v", RootOptions)
 	glog.V(2).Infof("package: %v", RootPackage)
 	glog.V(2).Infof("trees: %v", RootTrees)
 	glog.V(2).Infof("gcs bucket: %v", RootGCSBucket)

 	return nil
 }
	package actions

	import (
	"context"
	"errors"
	"fmt"
	"os"
	"os/exec"
	"path"
	"strings"

	"cloud.google.com/go/storage"
	"cos.googlesource.com/cos/tools.git/src/pkg/cos"
	"cos.googlesource.com/cos/tools.git/src/pkg/dkms"
	"cos.googlesource.com/cos/tools.git/src/pkg/fs"
	"cos.googlesource.com/cos/tools.git/src/pkg/gcs"
	"cos.googlesource.com/cos/tools.git/src/pkg/utils"
	"github.com/golang/glog"
	"github.com/spf13/cobra"
	"google.golang.org/api/option"
	)

	func FetchKernelVersion() (string, error) {
	kernelVersion := os.Getenv("KERNEL_VERSION")
	if kernelVersion != "" {
	return kernelVersion, nil
	}

	cmd := exec.Command("uname", "-r")
	out, err := cmd.CombinedOutput()
	if err == nil {
	glog.Info(string(out))
	} else {
	glog.Error(string(out))
	return "", err
	}
	return strings.Trim(string(out), "\n"), nil
	}

	// FetchKernelVersionFromHeaders downloads the COS kernel headers for the
	// given build id and board to a temporary directory and reads the kernel
	// release version from include/config/kernel.release.
	func FetchKernelVersionFromHeaders(buildId, board string) (string, error) {
	ctx := context.Background()
	client, err := storage.NewClient(ctx, option.WithoutAuthentication())
	if err != nil {
	return "", err
	}

	prefix := path.Join(buildId, board)
	downloader := cos.NewGCSDownloader(client, nil, "", prefix, "", "")

	tmpDir, err := os.MkdirTemp("", "")
	if err != nil {
	return "", err
	}
	defer os.RemoveAll(tmpDir)

	glog.Infof("installing kernel headers to determine kernel version")
	if err := dkms.InstallKernelHeaders(ctx, downloader, tmpDir); err != nil {
	return "", err
	}

	versionPath := path.Join(tmpDir, "include/config/kernel.release")
	versionBytes, err := os.ReadFile(versionPath)
	if err != nil {
	return "", err
	}
	version := strings.TrimSpace(string(versionBytes))

	return version, nil
	}

	func FetchArch() (string, error) {
	arch := os.Getenv("ARCH")
	if arch != "" {
	return arch, nil
	}

	cmd := exec.Command("uname", "-m")
	out, err := cmd.CombinedOutput()
	if err == nil {
	glog.Info(string(out))
	} else {
	glog.Error(string(out))
	return "", err
	}
	return strings.Trim(string(out), "\n"), nil
	}

	func ParsePackageNameAndVersion(name, version string) (string, string, error) {
	if name == "" {
	return "", "", errors.New("must provide a package name and version as <package>/<version>")
	}

	parts := strings.Split(name, "/")
	name = parts[0]
	if name == "" {
	return "", "", errors.New("package name must not be empty")
	}

	if version == "" {
	if len(parts) != 2 {
	return "", "", errors.New("must provide a package and version as <package>/<version>")
	}

	version = parts[1]
	if version == "" {
	return "", "", errors.New("package version must not be empty")
	}
	} else {
	if len(parts) != 1 {
	return "", "", errors.New("cannot provide explicit package version and <package>/<version> simultaneously")
	}
	}

	return name, version, nil
	}

	func initPackage(pkg *dkms.Package) error {
	name, version, err := ParsePackageNameAndVersion(pkg.Name, pkg.Version)
	if err != nil {
	return err
	}
	pkg.Name = name
	pkg.Version = version

	if pkg.KernelVersion == "" {
	kernelVersion, err := FetchKernelVersion()
	if err != nil {
	return fmt.Errorf("could not determine kernel version: %v", err)
	}
	pkg.KernelVersion = kernelVersion
	} else if pkg.KernelVersion == "cos-default" {
	kernelVersion, err := FetchKernelVersionFromHeaders(pkg.BuildId, pkg.Board)
	if err != nil {
	return fmt.Errorf("could not determine kernel version from headers: %v", err)
	}
	pkg.KernelVersion = kernelVersion
	}

	if pkg.Arch == "" {
	arch, err := FetchArch()
	if err != nil {
	return fmt.Errorf("could not determine arch: %v", err)
	}
	pkg.Arch = arch
	}

	if pkg.Trees.Source == "" {
	pkg.Trees.Source = "/usr/src"
	}

	if pkg.Trees.Install == "" {
	pkg.Trees.Install = fmt.Sprintf("/lib/modules/%s", pkg.KernelVersion)
	}

	if pkg.Trees.Kernel == "" {
	pkg.Trees.Kernel = fmt.Sprintf("/lib/modules/%s/build", pkg.KernelVersion)
	}

	if pkg.Trees.KernelModules == "" {
	pkg.Trees.KernelModules = pkg.Trees.Install
	}

	if fs.IsDir(pkg.SourceDir()) {
	config, err := dkms.LoadConfig(pkg)
	if err != nil {
	glog.Warningf("error loading dkms config: %v", err)
	} else {
	pkg.Config = config
	}
	}

	return nil
	}

	func parseKeyCertPaths(options *dkms.Options) {
	privateKeyPath := os.Getenv("MODULES_SIGN_KEY")
	if privateKeyPath == "" {
	privateKeyPath = "/var/lib/dkms/mok.key"
	}

	certificatePath := os.Getenv("MODULES_SIGN_CERT")
	if certificatePath == "" {
	certificatePath = "/var/lib/dkms/mok.cert"
	}

	options.PrivateKeyPath = privateKeyPath
	options.CertificatePath = certificatePath
	}

	func FetchLatestCompatiblePackageVersion(pkg dkms.Package, cache gcs.GCSBucket) (string, error) {
	versions, err := dkms.CompatiblePackageVersions(pkg)
	if err != nil {
	return "", err
	}

	if cache != nil {
	ctx := context.Background()
	cachedVersions, err := dkms.CachedCompatiblePackageVersions(ctx, pkg, cache)
	if err != nil {
	return "", err
	}

	versions = append(versions, cachedVersions...)
	}

	if len(versions) == 0 {
	if cache != nil {
	return "", fmt.Errorf("could not find any usable versions of the specified package in the local or cache DKMS tree; make sure the package is added first before using --latest")
	} else {
	return "", fmt.Errorf("could not find any usable versions of the specified package in the local DKMS tree; make sure the package is added first before using --latest")
	}
	}

	latestVersion := versions[0]
	for _, version := range versions[1:] {
	if dkms.CompareVersions(latestVersion, version) < 0 {
	latestVersion = version
	}
	}

	return latestVersion, nil
	}

	func InitPackage(pkg dkms.Package, cache gcs.GCSBucket, latest bool) error {
	// We need all of the other package fields initialized before we can
	// determine the latest version of the package, so we fill in a
	// placeholder value of the version so that the rest of the
	// initialization works as normal
	if latest {
	if pkg.Version != "" {
	return fmt.Errorf("cannot specify explicit package version (%s) and --latest simultaneously", pkg.Version)
	}

	pkg.Version = "placeholder"
	}

	if err := initPackage(pkg); err != nil {
	return err
	}

	// After the other fields are initialized, we can get the actual latest
	// package version.
	if latest {
	version, err := FetchLatestCompatiblePackageVersion(pkg, cache)
	if err != nil {
	return err
	}
	pkg.Version = version
	}
	glog.Infof("using package version %s", pkg.Version)

	return nil
	}

	func InitCache(gcsPath, buildId, board string) (*gcs.GCSBucket, error) {
	if gcsPath == "" {
	gcsPath = os.Getenv("GCS_BUCKET")
	}

	if gcsPath == "" {
	return nil, nil
	}

	if gcsPath == "cos-default" {
	bucket := cos.DefaultCOSArtifactsBucket()
	gcsPath = fmt.Sprintf("gs://%s/%s/%s", bucket, buildId, board)
	}

	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
	return nil, fmt.Errorf("failed to create storage client: %v", err)
	}
	return gcs.GCSBucketFromPath(client, gcsPath)
	}

	func parsePositionalArgs(args []string, pkg *dkms.Package) error {
	if len(args) >= 1 {
	if pkg.Name != "" {
	return fmt.Errorf("cannot specify package name as both positional argument and flag")
	}

	pkg.Name = args[0]
	}

	if len(args) >= 2 {
	if pkg.Trees.Source != "" {
	return fmt.Errorf("cannot specify source tree as both positional argument and flag")
	}

	pkg.Trees.Source = args[1]
	}

	if len(args) > 2 {
	return fmt.Errorf("expected at most 2 positional arguments; received %d", len(args))
	}

	return nil
	}

	// InitCOSValues initializes the package values which are specific to COS,
	// namely BuildId and Board.
	func InitCOSValues(pkg *dkms.Package, lsbReleasePath string) {
	if pkg.BuildId == "" {
	pkg.BuildId = os.Getenv("BUILD_ID")
	}

	if pkg.Board == "" {
	pkg.Board = os.Getenv("BOARD")
	}

	if pkg.BuildId != "" && pkg.Board != "" {
	return
	}

	lsbReleaseVars, err := utils.LoadEnvFromFile("", lsbReleasePath)
	if err != nil {
	glog.Warningf("could not read lsb-release file at %s: %v", err)
	}
	if pkg.BuildId == "" {
	pkg.BuildId = lsbReleaseVars["CHROMEOS_RELEASE_VERSION"]
	}
	if pkg.Board == "" {
	pkg.Board = lsbReleaseVars["CHROMEOS_RELEASE_BOARD"]
	}
	}

	// ParseArgs parses the cobra positional arguments and flags to populate the
	// options, pkg, and RootGCSBucket variables.
	func ParseArgs(cmd *cobra.Command, args []string) error {
	if err := parsePositionalArgs(args, RootPackage); err != nil {
	return err
	}
	parseKeyCertPaths(RootOptions)

	InitCOSValues(RootPackage, RootOptions.LSBReleasePath)

	var err error
	RootGCSBucket, err = InitCache(RootOptions.GCSBucket, RootPackage.BuildId, RootPackage.Board)
	if err != nil {
	return err
	}

	if err := InitPackage(RootPackage, RootGCSBucket, RootOptions.Latest); err != nil {
	return err
	}

	glog.V(2).Infof("options: %v", RootOptions)
	glog.V(2).Infof("package: %v", RootPackage)
	glog.V(2).Infof("trees: %v", RootTrees)
	glog.V(2).Infof("gcs bucket: %v", RootGCSBucket)

	return nil
	}