actions: install-deb: Implement action to install local Debian packages

README.md

@@ -41,6 +41,7 @@ Some of the actions provided by debos to customize and produce images are:
 * download: download a single file from the internet
 * filesystem-deploy: deploy a root filesystem to an image previously created
 * image-partition: create an image file, make partitions and format them
+* install-dpkg: install packages and their dependencies from local 'deb' files
 * ostree-commit: create an OSTree commit from rootfs
 * ostree-deploy: deploy an OSTree branch to the image
 * overlay: do a recursive copy of directories or files to the target filesystem

actions/apt_action.go

@@ -28,6 +28,7 @@ package actions
 
 import (
 	"github.com/go-debos/debos"
+	"github.com/go-debos/debos/wrapper"
 )
 
 type AptAction struct {
@@ -44,50 +45,19 @@ func NewAptAction() *AptAction {
 }
 
 func (apt *AptAction) Run(context *debos.DebosContext) error {
-	aptConfig := []string{}
-
-	/* Don't show progress update percentages */
-	aptConfig = append(aptConfig, "-o=quiet::NoUpdate=1")
-
-	aptOptions := []string{"apt-get", "-y"}
-	aptOptions = append(aptOptions, aptConfig...)
-
-	if !apt.Recommends {
-		aptOptions = append(aptOptions, "--no-install-recommends")
-	}
-
-	if apt.Unauthenticated {
-		aptOptions = append(aptOptions, "--allow-unauthenticated")
-	}
-
-	aptOptions = append(aptOptions, "install")
-	aptOptions = append(aptOptions, apt.Packages...)
-
-	c := debos.NewChrootCommandForContext(*context)
-	c.AddEnv("DEBIAN_FRONTEND=noninteractive")
+	aptCommand := wrapper.NewAptCommand(*context, "apt")
 
 	if apt.Update {
-		cmd := []string{"apt-get"}
-		cmd = append(cmd, aptConfig...)
-		cmd = append(cmd, "update")
-
-		err := c.Run("apt", cmd...)
-		if err != nil {
+		if err := aptCommand.Update(); err != nil {
 			return err
 		}
 	}
 
-	err := c.Run("apt", aptOptions...)
-	if err != nil {
+	if err := aptCommand.Install(apt.Packages, apt.Recommends, apt.Unauthenticated); err != nil {
 		return err
 	}
 
-	cmd := []string{"apt-get"}
-	cmd = append(cmd, aptConfig...)
-	cmd = append(cmd, "clean")
-
-	err = c.Run("apt", cmd...)
-	if err != nil {
+	if err := aptCommand.Clean(); err != nil {
 		return err
 	}
 

actions/install_dpkg_action.go

@@ -0,0 +1,180 @@
+/*
+InstallDpkg Action
+
+Install packages from .deb files and their dependencies to the target rootfs
+using 'apt'.
+
+Dependencies will be satisfied first from the `packages` list (i.e. locally
+available packages) and then from the target's configured apt repositories. If
+`deps` is set to false, dependencies will not be installed and an error will be
+thrown. TODO: check this
+
+Attempting to downgrade packages which are already installed is not allowed and
+will throw an error.
+
+ # Yaml syntax:
+ - action: install-dpkg
+   origin: name
+   recommends: bool
+   unauthenticated: bool
+   deps: bool
+   packages:
+     - package_path.deb
+     - *.deb
+
+Mandatory properties:
+
+- packages -- list of package files to install from the filesystem (or named
+origin). Resolves Unix-style glob patterns. If installing from a named origin,
+e.g. the result of a download action, the package path will be automatically
+generated from the origin contents and the `packages` property can be omitted.
+
+Optional properties:
+
+- origin -- reference to named file or directory. Defaults to recipe directory.
+
+- recommends -- boolean indicating if suggested packages will be installed. Defaults to false.
+
+- unauthenticated -- boolean indicating if unauthenticated packages can be installed. Defaults to false.
+
+- update -- boolean indicating if `apt update` will be run. Default 'true'.
+
+Example to install all packages from recipe subdirectory `pkgs/`:
+
+ - action: install-dpkg
+   description: Install Debian packages from local recipe
+   packages:
+     - pkgs/*.deb
+
+Example to install named packages from recipe subdirectory `pkgs/`:
+
+ - action: install-dpkg
+   description: Install Debian packages from local recipe
+   packages:
+     - pkgs/bmap-tools_*_all.deb
+     - pkgs/fakemachine_*_amd64.deb
+
+Example to download and install a package:
+
+ - action: download
+   description: Install Debian package from url
+   url: http://ftp.us.debian.org/debian/pool/main/b/bmap-tools/bmap-tools_3.5-2_all.deb
+   name: bmap-tools-pkg
+
+ - action: install-dpkg
+   description: Install Debian package from url
+   origin: bmap-tools-pkg
+*/
+
+package actions
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/go-debos/debos"
+	"github.com/go-debos/debos/wrapper"
+)
+
+type InstallDpkgAction struct {
+	debos.BaseAction `yaml:",inline"`
+	Recommends       bool
+	Unauthenticated  bool
+	Update           bool
+	Origin           string
+	Packages         []string
+}
+
+func NewInstallDpkgAction() *InstallDpkgAction {
+	a := &InstallDpkgAction{Update: true}
+	return a
+}
+
+func (apt *InstallDpkgAction) Run(context *debos.DebosContext) error {
+	aptCommand := wrapper.NewAptCommand(*context, "install-dpkg")
+
+	/* check if named origin exists or fallback to RecipeDir if no origin set */
+	var origin string = context.RecipeDir
+	if len(apt.Origin) > 0 {
+		var found bool
+		if origin, found = context.Origins[apt.Origin]; !found {
+			return fmt.Errorf("origin %s not found", apt.Origin)
+		}
+	}
+
+	/* create a list of full paths of packages to install: if the origin is a
+	 * single file (e.g download action) then just return that package, otherwise
+	 * append package name to the origin path and glob to create a list of packages.
+	 * In other words, install all packages which are in the origin's directory.
+	 */
+	packages := []string{}
+	file, err := os.Stat(origin)
+	if err != nil {
+		return err
+	}
+
+	if file.IsDir() {
+		if len(apt.Packages) == 0 {
+			return fmt.Errorf("no packages defined")
+		}
+
+		for _, pkg := range apt.Packages {
+			// resolve globs
+			source := path.Join(origin, pkg)
+			matches, err := filepath.Glob(source)
+			if err != nil {
+				return err
+			}
+			if len(matches) == 0 {
+				return fmt.Errorf("file(s) not found after globbing: %s", pkg)
+			}
+
+			packages = append(packages, matches...)
+		}
+	} else {
+		packages = append(packages, origin)
+	}
+
+	/* bind mount each package into rootfs & update the list with the
+	 * path relative to the chroot */
+	for idx, pkg := range packages {
+		// check for duplicates after globbing
+		for j := idx + 1; j < len(packages); j++ {
+			if packages[j] == pkg {
+				return fmt.Errorf("duplicate package found: %s", pkg)
+			}
+		}
+
+		log.Printf("Installing %s", pkg)
+
+		/* Only bind mount the package if the file is outside the rootfs */
+		if strings.HasPrefix(pkg, context.Rootdir) {
+			pkg = strings.TrimPrefix(pkg, context.Rootdir)
+		} else {
+			aptCommand.AddBindMount(pkg, "")
+		}
+
+		/* update pkg list with the complete resolved path */
+		packages[idx] = pkg
+	}
+
+	if apt.Update {
+		if err := aptCommand.Update(); err != nil {
+			return err
+		}
+	}
+
+	if err := aptCommand.Install(packages, apt.Recommends, apt.Unauthenticated); err != nil {
+		return err
+	}
+
+	if err := aptCommand.Clean(); err != nil {
+		return err
+	}
+
+	return nil
+}

actions/recipe.go

@@ -54,6 +54,8 @@ Supported actions
 
 - image-partition -- https://godoc.org/github.com/go-debos/debos/actions#hdr-ImagePartition_Action
 
+- install-dpkg -- https://godoc.org/github.com/go-debos/debos/actions#hdr-InstallDpkg_Action
+
 - ostree-commit -- https://godoc.org/github.com/go-debos/debos/actions#hdr-OstreeCommit_Action
 
 - ostree-deploy -- https://godoc.org/github.com/go-debos/debos/actions#hdr-OstreeDeploy_Action
@@ -133,6 +135,8 @@ func (y *YamlAction) UnmarshalYAML(unmarshal func(interface{}) error) error {
 		y.Action = &OverlayAction{}
 	case "image-partition":
 		y.Action = &ImagePartitionAction{}
+	case "install-dpkg":
+		y.Action = NewInstallDpkgAction()
 	case "filesystem-deploy":
 		y.Action = NewFilesystemDeployAction()
 	case "raw":

actions/recipe_test.go

@@ -54,6 +54,7 @@ actions:
   - action: download
   - action: filesystem-deploy
   - action: image-partition
+  - action: install-dpkg
   - action: ostree-commit
   - action: ostree-deploy
   - action: overlay

wrapper/apt_wrapper.go

@@ -0,0 +1,49 @@
+/* Abstracts the apt command. */
+package wrapper
+
+import (
+	"github.com/go-debos/debos"
+)
+
+type AptCommand struct {
+	Wrapper
+}
+
+func NewAptCommand(context debos.DebosContext, label string) AptCommand {
+	command := "apt-get"
+
+	apt := AptCommand{
+		Wrapper: NewCommandWrapper(context, command, label),
+	}
+
+	apt.AddEnv("DEBIAN_FRONTEND=noninteractive")
+
+	/* Don't show progress update percentages */
+	apt.AppendGlobalArguments("-o=quiet::NoUpdate=1")
+
+	return apt
+}
+
+func (apt AptCommand) Clean() error {
+	return apt.Run("clean")
+}
+
+func (apt AptCommand) Install(packages []string, recommends bool, unauthenticated bool) error {
+	arguments := []string{"install", "--yes"}
+
+	if !recommends {
+		arguments = append(arguments, "--no-install-recommends")
+	}
+
+	if unauthenticated {
+		arguments = append(arguments, "--allow-unauthenticated")
+	}
+
+	arguments = append(arguments, packages...)
+
+	return apt.Run(arguments...)
+}
+
+func (apt AptCommand) Update() error {
+	return apt.Run("update")
+}

wrapper/wrapper.go

@@ -0,0 +1,41 @@
+/* Base class to abstract commonly used commands. */
+package wrapper
+
+import (
+	"github.com/go-debos/debos"
+)
+
+type Wrapper struct {
+	debos.Command
+	command    string
+	globalArgs []string
+	label      string
+}
+
+func NewCommandWrapper(context debos.DebosContext, command string, label string) Wrapper {
+	return Wrapper{
+		Command: debos.NewChrootCommandForContext(context),
+		command: command,
+		label:   label,
+	}
+}
+
+func (cmd *Wrapper) SetCommand(command string) {
+	cmd.command = command
+}
+
+func (cmd *Wrapper) AppendGlobalArguments(args string) {
+	cmd.globalArgs = append(cmd.globalArgs, args)
+}
+
+func (cmd *Wrapper) SetLabel(label string) {
+	cmd.label = label
+}
+
+func (cmd Wrapper) Run(additionalArgs ...string) error {
+	args := []string{cmd.command}
+	args = append(args, cmd.globalArgs...)
+	args = append(args, additionalArgs...)
+
+	return cmd.Command.Run(cmd.label, args...)
+}