Add support for downloading and placing ffu configuration files to the provisioned drive.

PiperOrigin-RevId: 400811866

Author: Fresnel Imaging Team

cli/config/config.go

@@ -57,15 +57,17 @@ const (
 // required to obtain the resources required to install it.
 type distribution struct {
 	os          OperatingSystem
-	name        string // Friendly name: e.g. Corp Windows.
-	label       string // If set, is used to set partition labels.
-	seedServer  string // If set, a seed is obtained from here.
-	seedFile    string // This file is hashed when obtainng a seed.
-	seedDest    string // The relative path where the seed should be written.
+	confStore   string // The relative path where configs are located.
 	ffuDest     string // The relative path where SFU files will be stored.
 	imageServer string // The base image is obtained here.
+	label       string // If set, is used to set partition labels.
+	name        string // Friendly name: e.g. Corp Windows.
+	seedDest    string // The relative path where the seed should be written.
+	seedFile    string // This file is hashed when obtainng a seed.
+	seedServer  string // If set, a seed is obtained from here.
 	images      map[string]string
 	ffus        map[string]string // Contains SFU manifests names.
+	configs     map[string]string // Contains config file names.
 }
 
 // Configuration represents the state of all flags and selections provided
@@ -88,11 +90,11 @@ type Configuration struct {
 func New(cleanup, warning, eject, ffu, update bool, devices []string, os, track, seedServer string) (*Configuration, error) {
 	// Create a partial config using known good values.
 	conf := &Configuration{
-		cleanup:  cleanup,
-		warning:  warning,
-		ffu:      ffu,
-		eject:    eject,
-		update:   update,
+		cleanup: cleanup,
+		warning: warning,
+		ffu:     ffu,
+		eject:   eject,
+		update:  update,
 	}
 	if len(devices) > 0 {
 		if err := conf.addDeviceList(devices); err != nil {
@@ -273,6 +275,16 @@ func (c *Configuration) FFUPath() string {
 	return fmt.Sprintf(`%s/%s/%s`, c.distro.imageServer, c.distro.name, c.track)
 }
 
+// ConfName returns the name of the config file.
+func (c *Configuration) ConfName() string {
+	return c.distro.configs[c.track]
+}
+
+// ConfPath returns the path to the config.
+func (c *Configuration) ConfPath() string {
+	return fmt.Sprintf(`%s/%s/%s`, c.distro.imageServer, c.distro.confStore, c.distro.configs[c.track])
+}
+
 // PowerOff returns whether or not devices should be powered off after write
 // operations.
 func (c *Configuration) PowerOff() bool {

cli/config/config_test.go

@@ -517,6 +517,36 @@ func TestFFUManifest(t *testing.T) {
 	}
 }
 
+func TestYAMLConfig(t *testing.T) {
+	track := `default`
+	distro := distribution{
+		configs: map[string]string{
+			track: "conf.yaml",
+		},
+	}
+	want := "conf.yaml"
+	c := Configuration{track: track, distro: &distro}
+	if got := c.ConfName(); got != want {
+		t.Errorf("YAMLConfig() got: %q, want: %q", got, want)
+	}
+}
+
+func TestYAMLPath(t *testing.T) {
+	track := `default`
+	distro := distribution{
+		imageServer: `https://foo.bar.com`,
+		confStore:   `configs/yaml`,
+		configs: map[string]string{
+			track: "conf.yaml",
+		},
+	}
+	want := "https://foo.bar.com/configs/yaml/conf.yaml"
+	c := Configuration{track: track, distro: &distro}
+	if got := c.ConfPath(); got != want {
+		t.Errorf("YAMLPath() got: %q, want: %q", got, want)
+	}
+}
+
 func TestCleanup(t *testing.T) {
 	want := true
 	c := Configuration{cleanup: want}

cli/installer/installer.go

@@ -87,6 +87,7 @@ var (
 	errUnsupported = errors.New("unsupported")
 	errUser        = errors.New("user detection error")
 	errWipe        = errors.New("device wipe error")
+	errYAML        = errors.New("yaml retrieval error")
 
 	// ErrLabel is made public to that callers can warn on mismatches.
 	ErrLabel = errors.New(`label error`)
@@ -120,6 +121,8 @@ type Configuration interface {
 	SeedFile() string
 	SeedServer() string
 	UpdateOnly() bool
+	ConfName() string
+	ConfPath() string
 }
 
 // Device represents storage.Device.
@@ -269,16 +272,30 @@ func (i *Installer) Retrieve() (err error) {
 		return i.retrieveFile(i.config.ImageFile(), i.config.Image())
 	}
 
-	// Check FFU Path configuration
+	// Check FFU Path configuration.
 	if i.config.FFUPath() == "" {
 		return fmt.Errorf("missing FFU path: %w", errConfig)
 	}
 
-	// Check FFU Manifest configuration
+	// Check FFU Manifest configuration.
 	if i.config.FFUManifest() == "" {
 		return fmt.Errorf("missing FFU manifest: %w", errConfig)
 	}
 
+	// Check for missing conf file name.
+	if i.config.ConfName() == "" {
+		return fmt.Errorf("missing configuration file name: %w", errConfig)
+	}
+
+	// Check conf path configuration.
+	if i.config.ConfPath() == "" {
+		return fmt.Errorf("missing conf file path: %w", errConfig)
+	}
+
+	if err := i.retrieveFile(i.config.ConfName(), i.config.ConfPath()); err != nil {
+		return fmt.Errorf("%w: %v", errYAML, err)
+	}
+
 	if err := i.retrieveFile(i.config.ImageFile(), i.config.Image()); err != nil {
 		return fmt.Errorf("%w: %v", errImage, err)
 	}
@@ -475,7 +492,8 @@ func (i *Installer) DownloadSFU() error {
 	return nil
 }
 
-// PlaceSFU copies SFU files onto provisioned media from the local cache.
+// PlaceSFU copies SFU files and config files onto provisioned media
+// from the local cache.
 func (i *Installer) PlaceSFU(d Device) error {
 	// Find a compatible partition to write the FFU to.
 	logger.V(2).Infof("Searching for FFU %q for a %q partition larger than %v.", d.FriendlyName(), humanize.Bytes(minSFUPartSize), storage.FAT32)
@@ -487,39 +505,46 @@ func (i *Installer) PlaceSFU(d Device) error {
 	if err != nil {
 		return fmt.Errorf("getManifest() returned: %w: %v", errManifest, err)
 	}
+	// Copy SFU files.
 	for ind, sfu := range sfus {
-		// This is done as a separate function call to handle closing
-		// the files through the defer at the end of each iteration
-		// of the loop instead of waiting until the end of the function.
-		func() error {
-			path := filepath.Join(i.cache, sfu.Filename)
-			newPath := filepath.Join(p.MountPoint(), i.config.FFUDest(), sfu.Filename)
-			// Add colon for windows paths if its a drive root.
-			if runtime.GOOS == "windows" && len(p.MountPoint()) < 2 {
-				newPath = filepath.Join(fmt.Sprintf("%s:", p.MountPoint()), i.config.FFUDest(), sfu.Filename)
-			}
-			console.Printf("Copying SFU %d of %d...", ind+1, len(sfus))
-			if err := os.MkdirAll(filepath.Dir(newPath), 0644); err != nil {
-				return fmt.Errorf("failed to create path: %v", err)
-			}
-			source, err := os.Open(path)
-			if err != nil {
-				return fmt.Errorf("%w: couldn't open file(%s) from cache: %v", errPath, path, err)
-			}
-			defer source.Close()
-			destination, err := os.Create(newPath)
-			if err != nil {
-				return fmt.Errorf("%w: couldn't create target file(%s): %v", errFile, path, err)
-			}
-			defer destination.Close()
-			cBytes, err := io.Copy(destination, source)
-			if err != nil {
-				return fmt.Errorf("failed to copy file to %s: %v", newPath, err)
-			}
-			console.Printf("Copied %d bytes", cBytes)
-			return nil
-		}()
+		console.Printf("Copying SFU %d of %d...", ind+1, len(sfus))
+		if err := i.fileCopy(sfu.Filename, i.config.FFUDest(), p); err != nil {
+			return fmt.Errorf("fileCopy() failed for %s to %s: %v", sfu.Filename, i.config.FFUDest(), err)
+		}
+	}
+	// Copy config.
+	console.Printf("Copying %s", i.config.ConfName())
+	if err := i.fileCopy(i.config.ConfName(), i.config.FFUDest(), p); err != nil {
+		return fmt.Errorf("fileCopy() failed for %s to %s: %v", i.config.ConfName(), i.config.FFUDest(), err)
+	}
+	return nil
+}
+
+func (i *Installer) fileCopy(srcFile, dest string, p partition) error {
+	path := filepath.Join(i.cache, srcFile)
+	newPath := filepath.Join(p.MountPoint(), dest, srcFile)
+	// Add colon for windows paths if its a drive root.
+	if runtime.GOOS == "windows" && len(p.MountPoint()) < 2 {
+		newPath = filepath.Join(fmt.Sprintf("%s:", p.MountPoint()), dest, srcFile)
+	}
+	if err := os.MkdirAll(filepath.Dir(newPath), 0744); err != nil {
+		return fmt.Errorf("failed to create path: %v", err)
+	}
+	source, err := os.Open(path)
+	if err != nil {
+		return fmt.Errorf("%w: couldn't open file(%s) from cache: %v", errPath, path, err)
+	}
+	defer source.Close()
+	destination, err := os.Create(newPath)
+	if err != nil {
+		return fmt.Errorf("%w: couldn't create target file(%s): %v", errFile, path, err)
+	}
+	defer destination.Close()
+	cBytes, err := io.Copy(destination, source)
+	if err != nil {
+		return fmt.Errorf("failed to copy file to %s: %v", newPath, err)
 	}
+	console.Printf("Copied %d bytes", cBytes)
 	return nil
 }
 

cli/installer/installer_test.go

@@ -60,6 +60,8 @@ type fakeConfig struct {
 	ffuDest     string
 	ffuPath     string
 	ffuManifest string
+	confName    string
+	confPath    string
 }
 
 func (f *fakeConfig) Dismount() bool {
@@ -118,6 +120,14 @@ func (f *fakeConfig) FFUPath() string {
 	return f.ffuPath
 }
 
+func (f *fakeConfig) ConfName() string {
+	return f.confName
+}
+
+func (f *fakeConfig) ConfPath() string {
+	return f.confPath
+}
+
 func TestNew(t *testing.T) {
 	// Generate a fake config to use with New.
 	c := &fakeConfig{
@@ -238,6 +248,32 @@ func TestRetrieve(t *testing.T) {
 			}},
 			want: errConfig,
 		},
+		{
+			desc: "missing yaml config",
+			installer: &Installer{cache: fakeCache, config: &fakeConfig{
+				image:       `https://foo.bar.com/test_installer.img`,
+				imageFile:   `test_installer.img`,
+				ffuPath:     `https://foo.bar.com/once/OS/stable/`,
+				ffu:         true,
+				ffuManifest: "manifest.json",
+				confName:    "",
+				confPath:    "",
+			}},
+			want: errConfig,
+		},
+		{
+			desc: "missing yaml path",
+			installer: &Installer{cache: fakeCache, config: &fakeConfig{
+				image:       `https://foo.bar.com/test_installer.img`,
+				imageFile:   `test_installer.img`,
+				ffuPath:     `https://foo.bar.com/once/OS/stable/`,
+				ffu:         true,
+				ffuManifest: "manifest.json",
+				confName:    "conf.yaml",
+				confPath:    "",
+			}},
+			want: errConfig,
+		},
 		{
 			desc: "missing ffu manifest",
 			installer: &Installer{cache: fakeCache, config: &fakeConfig{
@@ -268,6 +304,8 @@ func TestRetrieve(t *testing.T) {
 				ffuPath:     `https://foo.bar.com/once/OS/stable/`,
 				ffu:         true,
 				ffuManifest: "manifest.json",
+				confPath:    "https://foo.bar.com/told/conf.yaml",
+				confName:    "conf.yaml",
 			}},
 			download: func(client httpDoer, path string, w io.Writer) error { return nil },
 			want:     nil,
@@ -1289,8 +1327,8 @@ func TestDownloadSFU(t *testing.T) {
 	}
 }
 
-// createFakeSFU is used to create a set of fake SFU files.
-func createFakeSFU(fakeCache string) error {
+// createFakeFiles is used to create a set of fake SFU and conf files.
+func createFakeFiles(fakeCache, yamlName string) error {
 	sfus := fakeReadManifest()
 	for _, sfu := range sfus {
 		path := filepath.Join(fakeCache, sfu.Filename)
@@ -1300,16 +1338,80 @@ func createFakeSFU(fakeCache string) error {
 		}
 		defer f.Close()
 	}
+	path := filepath.Join(fakeCache, yamlName)
+	f, err := os.Create(path)
+	if err != nil {
+		return fmt.Errorf("ioutil.TempFile(%q, %q) returned %w: %v", fakeCache, yamlName, errFile, err)
+	}
+	defer f.Close()
 	return nil
 }
 
+func TestFileCopy(t *testing.T) {
+	// Setup a temp folder.
+	fakeCache, err := ioutil.TempDir("", "")
+	if err != nil {
+		t.Fatalf("ioutil.TempDir('', '') returned %v", err)
+	}
+	if err := createFakeFiles(fakeCache, "config.yaml"); err != nil {
+		t.Fatalf("createFakeFiles() failed: %v", err)
+	}
+	// Temp folders representing file system contents.
+	mount, _, err := fakeFileSystems()
+	if err != nil {
+		t.Fatalf("fakeFileSystems() returned %v", err)
+	}
+	defer os.RemoveAll(mount)
+	tests := []struct {
+		desc      string
+		installer *Installer
+		file      string
+		dest      string
+		part      partition
+		want      error
+	}{
+		{
+			desc:      "successful copy",
+			installer: &Installer{cache: fakeCache},
+			file:      "config.yaml",
+			dest:      `some/dirs`,
+			part:      &fakePartition{mount: mount},
+			want:      nil,
+		},
+		{
+			desc:      "bad path",
+			installer: &Installer{cache: ""},
+			file:      "config.yaml",
+			dest:      "",
+			part:      &fakePartition{mount: mount},
+			want:      errPath,
+		},
+		{
+			desc:      "empty file",
+			installer: &Installer{cache: fakeCache},
+			file:      "",
+			dest:      "",
+			part:      &fakePartition{mount: mount},
+			want:      errFile,
+		},
+	}
+	for _, tt := range tests {
+
+		got := tt.installer.fileCopy(tt.file, tt.dest, tt.part)
+		if !errors.Is(got, tt.want) {
+			t.Errorf("%s: fileCopy() got: %v, want: %v", tt.desc, got, tt.want)
+		}
+	}
+}
+
 func TestPlaceSFU(t *testing.T) {
 	// Setup a temp folder.
 	fakeCache, err := ioutil.TempDir("", "")
 	if err != nil {
 		t.Fatalf("ioutil.TempDir('', '') returned %v", err)
 	}
-	if err := createFakeSFU(fakeCache); err != nil {
+	yamlName := "conf.yaml"
+	if err := createFakeFiles(fakeCache, yamlName); err != nil {
 		t.Fatalf("createFakeSFU(%s) returned: %v", fakeCache, err)
 	}
 
@@ -1323,6 +1425,7 @@ func TestPlaceSFU(t *testing.T) {
 	c := &fakeConfig{
 		track:       "stable",
 		ffuManifest: "manifest.json",
+		confName:    yamlName,
 	}
 	tests := []struct {
 		desc         string