Merge lp:~elopio/snappy/cross-compile-debs-merge-failover into lp:~fgimenez/snappy/cross-compile-debs

[Leo Arias]

[Federico Gimenez (fgimenez)]

Nice, thanks!

review: Approve

=== modified file '_integration-tests/README'
--- _integration-tests/README	2015-06-17 15:42:00 +0000
+++ _integration-tests/README	2015-06-26 00:24:26 +0000
@@ -19,4 +19,3 @@
 shell tests) with:
 
 $ go run _integration-test/main.go
-

=== modified file '_integration-tests/main.go'
--- _integration-tests/main.go	2015-06-25 08:57:01 +0000
+++ _integration-tests/main.go	2015-06-26 00:24:26 +0000
@@ -30,17 +30,15 @@
 )
 
 const (
-	baseDir         = "/tmp/snappy-test"
-	debsTestBedPath = "/tmp/snappy-debs"
-	defaultRelease  = "rolling"
-	defaultChannel  = "edge"
-	defaultArch     = "amd64"
-	defaultDist     = "wily"
-	defaultSSHPort  = 22
+	baseDir        = "/tmp/snappy-test"
+	defaultRelease = "rolling"
+	defaultChannel = "edge"
+	defaultArch    = "amd64"
+	defaultSSHPort = 22
 )
 
 var (
-	defaultDebsDir   = filepath.Join(baseDir, "debs")
+	testsDir         = filepath.Join(baseDir, "tests")
 	imageDir         = filepath.Join(baseDir, "image")
 	outputDir        = filepath.Join(baseDir, "output")
 	imageTarget      = filepath.Join(imageDir, "snappy.img")
@@ -52,25 +50,21 @@
 			"--", "-i", imageTarget}...)
 )
 
-func setupAndRunTests(useFlashedImage bool, debsDir, arch, testbedIP string, testbedPort int) {
+func setupAndRunTests(arch, testbedIP string, testbedPort int) {
+	buildTests(arch)
+
 	rootPath := getRootPath()
-	if useFlashedImage {
-		// using the flashed image, so no debs must be installed.
-		debsDir = ""
-	} else if debsDir == defaultDebsDir {
-		buildDebs(rootPath, debsDir, arch)
-	}
 	if testbedIP == "" {
-		createImage(defaultRelease, defaultChannel, getArchForImage())
-		adtRun(rootPath, debsDir, kvmSSHOptions)
+		createImage(defaultRelease, defaultChannel)
+		adtRun(rootPath, kvmSSHOptions)
 	} else {
 		execCommand("ssh-copy-id", "-p", strconv.Itoa(testbedPort), "ubuntu@"+testbedIP)
-		adtRun(rootPath, debsDir, remoteTestbedSSHOptions(testbedIP, testbedPort))
+		adtRun(rootPath, remoteTestbedSSHOptions(testbedIP, testbedPort))
 	}
 }
 
 func execCommand(cmds ...string) {
-	cmd := exec.Command(cmds[0], cmds[1:len(cmds)]...)
+	cmd := exec.Command(cmds[0], cmds[1:]...)
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 	if err := cmd.Run(); err != nil {
@@ -78,59 +72,40 @@
 	}
 }
 
-func buildDebs(rootPath, destDir, arch string) {
-	fmt.Println("Building debs...")
-	prepareTargetDir(destDir)
-	buildCommand := []string{"bzr", "bd", "-v",
-		fmt.Sprintf("--result-dir=%s", destDir),
-		"--split",
-		rootPath,
-		"--",
-	}
-	if arch != defaultArch {
-		archFlag := fmt.Sprintf("-a%s", arch)
-		buildCommand = append(buildCommand, archFlag)
-	}
-	dontSignDebs := []string{"-uc", "-us"}
-	buildCommand = append(buildCommand, dontSignDebs...)
-
-	fmt.Println(buildCommand)
-	execCommand(buildCommand...)
+func buildTests(arch string) {
+	fmt.Println("Building tests")
+	prepareTargetDir(testsDir)
+	if arch != "" {
+		defer os.Setenv("GOARCH", os.Getenv("GOARCH"))
+		os.Setenv("GOARCH", arch)
+	}
+	execCommand("go", "test", "-c", "./_integration-tests/tests")
+	os.Rename("tests.test", "snappy.tests")
 }
 
-func createImage(release, channel, arch string) {
+func createImage(release, channel string) {
 	fmt.Println("Creating image...")
 	prepareTargetDir(imageDir)
 	execCommand(
 		"sudo", "ubuntu-device-flash", "--verbose",
 		"core", release,
 		"-o", imageTarget,
-		fmt.Sprintf("--oem=%s", arch),
 		"--channel", channel,
 		"--developer-mode")
 }
 
-func adtRun(rootPath, debsDir string, testbedOptions []string) {
+func adtRun(rootPath string, testbedOptions []string) {
 	fmt.Println("Calling adt-run...")
 	prepareTargetDir(outputDir)
+
 	cmd := []string{
-		"adt-run", "-B",
+		"adt-run",
+		"-B",
+		"--setup-commands", "touch /run/autopkgtest_no_reboot.stamp",
 		"--override-control", "debian/integration-tests/control",
 		"--built-tree", rootPath,
-		"--output-dir", outputDir}
-
-	if debsDir != "" {
-		debsSetup := []string{
-			"--setup-commands", "touch /run/autopkgtest_no_reboot.stamp",
-			"--setup-commands", "mount -o remount,rw /",
-			"--setup-commands",
-			fmt.Sprintf("dpkg -i %s/*deb", debsTestBedPath),
-			"--setup-commands",
-			"sync; sleep 2; mount -o remount,ro /",
-			fmt.Sprintf("--copy=%s:%s", debsDir, debsTestBedPath)}
-		cmd = append(cmd, debsSetup...)
+		"--output-dir", outputDir,
 	}
-
 	execCommand(append(cmd, testbedOptions...)...)
 }
 
@@ -139,7 +114,8 @@
 		"-H", testbedIP,
 		"-p", strconv.Itoa(testbedPort),
 		"-l", "ubuntu",
-		"-i", filepath.Join(os.Getenv("HOME"), ".ssh", "id_rsa")}
+		"-i", filepath.Join(os.Getenv("HOME"), ".ssh", "id_rsa"),
+		"--reboot"}
 	return append(commonSSHOptions, options...)
 }
 
@@ -159,25 +135,17 @@
 	return dir
 }
 
-func getArchForImage() string {
-	return fmt.Sprintf("generic-%s", defaultArch)
-}
-
 func main() {
 	var (
-		useFlashedImage = flag.Bool("installed-image", false,
-			"Wether we should install the snappy version from the branch or use the one installed on the image")
-		debsDir = flag.String("debs-dir", defaultDebsDir,
-			"Directory with th1e snappy debian packages.")
-		arch = flag.String("arch", defaultArch,
-			"Target architecture (amd64, armhf)")
+		arch = flag.String("arch", "",
+			"Architecture of the test bed. Defaults to use the same architecture as the host.")
 		testbedIP = flag.String("ip", "",
-			"IP of the testbed to run the tests in")
+			"IP of the testbed. If no IP is passed, a virtual machine will be created for the test.")
 		testbedPort = flag.Int("port", defaultSSHPort,
-			"SSH port of the testbed")
+			"SSH port of the testbed. Defaults to use port 22.")
 	)
 
 	flag.Parse()
 
-	setupAndRunTests(*useFlashedImage, *debsDir, *arch, *testbedIP, *testbedPort)
+	setupAndRunTests(*arch, *testbedIP, *testbedPort)
 }

=== modified file '_integration-tests/snappy-selftest'
--- _integration-tests/snappy-selftest	2015-06-16 06:47:24 +0000
+++ _integration-tests/snappy-selftest	2015-06-26 00:24:26 +0000
@@ -4,7 +4,7 @@
 
 MYDIR=$(dirname $0)
 
-. $MYDIR/tests/framework
+. "$MYDIR"/tests/framework
 
 SNAPPY=snappy
 
@@ -15,9 +15,9 @@
     exit 1
 fi
 
-. $MYDIR/tests/settings
+. "$MYDIR"/tests/settings
 
-. $MYDIR/tests/common.sh
+. "$MYDIR"/tests/common.sh
 
 # prepare the environment
 if [ -z "$ADT_REBOOT_MARK" ]; then
@@ -27,7 +27,7 @@
     sudo snappy remove xkcd-webserver 2>&1 || true
 fi
 
-for test in $MYDIR/tests/*_test_*[!~#]; do
+for test in "$MYDIR"/tests/*_test_*[!~#]; do
     CURRENT_TEST=$(basename $test)
 
     # after a reboot, skip ahead to the test that triggered it

=== removed file '_integration-tests/tests/80_test_failover'
--- _integration-tests/tests/80_test_failover	2015-06-15 15:36:29 +0000
+++ _integration-tests/tests/80_test_failover	1970-01-01 00:00:00 +0000
@@ -1,48 +0,0 @@
-# Test that we rollback on failed upgrades
-# (needs autopkgtest with a supporting runner).
-
-test() {
-    can_reboot || { echo "SKIP: cannot reboot testbed"; return; }
-
-    # debug
-    version_info
-    boot_info
-
-    if after_reboot; then
-        # reboot: ensure we booted back into original
-        orig_current=$(cat "${ADT_ARTIFACTS}/current")
-        if [ "$orig_current" != "$current" ]; then
-            fail "did not failover to good version (\"$orig_current\" != \"$current\")"
-        fi
-
-        # FIXME: grep log(other partition) for the crash to ensure it
-        #        really worked
-        # FIXME2: reboot again as regression test for #1449904
-
-        # we booted, cleanup the panic for the next tests to work
-        sudo mount -o remount,rw /writable/cache/system
-        sudo rm /writable/cache/system/etc/rc.local
-        return
-    fi
-
-    # fake new available version by doing a current--
-    switch_channel "s/build_number: $current/build_number: $((current-1))/" /etc/system-image/channel.ini
-
-    # we should have something now :)
-    version_info
-
-    [ $avail -gt $current ] || fail "$avail is not newer than $current"
-
-    # save version for post-upgrade test
-    save_version_info $avail $current
-
-    echo "upgrading..."
-    sudo snappy update
-
-    # break the upgrade by inserting a broken rc.local file onto the other
-    # partition
-    sudo mount -o remount,rw /writable/cache/system/
-    printf "#!/bin/sh\nprintf c > /proc/sysrq-trigger" | sudo tee /writable/cache/system/etc/rc.local
-    
-    reboot
-}

=== added file '_integration-tests/tests/common_test.go'
--- _integration-tests/tests/common_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/common_test.go	2015-06-26 00:24:26 +0000
@@ -0,0 +1,74 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"testing"
+
+	. "gopkg.in/check.v1"
+)
+
+type CommonSuite struct{}
+
+// Hook up gocheck into the "go test" runner
+func Test(t *testing.T) { TestingT(t) }
+
+func execCommand(c *C, cmds ...string) string {
+	cmd := exec.Command(cmds[0], cmds[1:len(cmds)]...)
+	output, err := cmd.CombinedOutput()
+	stringOutput := string(output)
+	c.Assert(err, IsNil, Commentf("Error: %v", stringOutput))
+	return stringOutput
+}
+
+func execCommandToFile(c *C, filename string, cmds ...string) {
+	cmd := exec.Command(cmds[0], cmds[1:len(cmds)]...)
+	outfile, err := os.Create(filename)
+	c.Assert(err, IsNil, Commentf("Error creating output file %s", filename))
+
+	defer outfile.Close()
+	cmd.Stdout = outfile
+
+	err = cmd.Run()
+	c.Assert(err, IsNil, Commentf("Error executing command '%v': %v", cmds, err))
+}
+
+func (s *CommonSuite) SetUpSuite(c *C) {
+	execCommand(c, "sudo", "systemctl", "stop", "snappy-autopilot.timer")
+	execCommand(c, "sudo", "systemctl", "disable", "snappy-autopilot.timer")
+}
+
+func (s *CommonSuite) SetUpTest(c *C) {
+	afterReboot := os.Getenv("ADT_REBOOT_MARK")
+
+	if afterReboot == "" {
+		c.Logf("****** Running %s", c.TestName())
+	} else {
+		if afterReboot == c.TestName() {
+			c.Logf("****** Resuming %s after reboot", c.TestName())
+		} else {
+			c.Skip(fmt.Sprintf("****** Skipped %s after reboot caused by %s",
+				c.TestName(), afterReboot))
+		}
+	}
+}

=== added file '_integration-tests/tests/failover_rclocal_crash_test.go'
--- _integration-tests/tests/failover_rclocal_crash_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/failover_rclocal_crash_test.go	2015-06-26 00:24:26 +0000
@@ -0,0 +1,47 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"fmt"
+
+	. "gopkg.in/check.v1"
+)
+
+type rcLocalCrash struct{}
+
+func (rcLocalCrash) set(c *C) {
+	makeWritable(c, baseOtherPath)
+	targetFile := fmt.Sprintf("%s/etc/rc.local", baseOtherPath)
+	execCommand(c, "sudo", "chmod", "a+xw", targetFile)
+	execCommandToFile(c, targetFile,
+		"sudo", "echo", "#!bin/sh\nprintf c > /proc/sysrq-trigger")
+	makeReadonly(c, baseOtherPath)
+}
+
+func (rcLocalCrash) unset(c *C) {
+	makeWritable(c, baseOtherPath)
+	execCommand(c, "sudo", "rm", fmt.Sprintf("%s/etc/rc.local", baseOtherPath))
+	makeReadonly(c, baseOtherPath)
+}
+
+func (s *FailoverSuite) TestRCLocalCrash(c *C) {
+	commonFailoverTest(c, rcLocalCrash{})
+}

=== added file '_integration-tests/tests/failover_systemd_loop_test.go'
--- _integration-tests/tests/failover_systemd_loop_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/failover_systemd_loop_test.go	2015-06-26 00:24:26 +0000
@@ -0,0 +1,114 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"fmt"
+
+	. "gopkg.in/check.v1"
+)
+
+const (
+	deadlockService = `[Unit]
+Before=sysinit.target
+DefaultDependencies=no
+
+[Service]
+Type=oneshot
+ExecStartPre=-/bin/sh -c "echo 'DEBUG: $(date): deadlocked system' >/dev/console"
+ExecStartPre=-/bin/sh -c "echo 'DEBUG: $(date): deadlocked system' >/dev/ttyS0"
+ExecStart=/bin/systemctl start deadlock.service
+RemainAfterExit=yes
+
+[Install]
+RequiredBy=sysinit.target
+`
+	rebootService = `[Unit]
+DefaultDependencies=no
+Description=Hack to force reboot if booting did not finish after 20s
+
+[Service]
+Type=oneshot
+ExecStartPre=/bin/sleep 20
+ExecStart=-/bin/sh -c 'if ! systemctl is-active default.target; then wall "EMERGENCY REBOOT"; reboot -f; fi'
+
+[Install]
+RequiredBy=sysinit.target
+`
+	baseSystemdPath          = "/lib/systemd/system"
+	systemdTargetRequiresDir = "sysinit.target.requires"
+)
+
+type systemdDependencyLoop struct{}
+
+func (systemdDependencyLoop) set(c *C) {
+	installService(c, "deadlock", deadlockService, baseOtherPath)
+	installService(c, "emerg-reboot", rebootService, baseOtherPath)
+}
+
+func (systemdDependencyLoop) unset(c *C) {
+	unInstallService(c, "deadlock", baseOtherPath)
+	unInstallService(c, "emerg-reboot", baseOtherPath)
+}
+
+func installService(c *C, serviceName, serviceCfg, basePath string) {
+	makeWritable(c, basePath)
+
+	// Create service file
+	serviceFile := fmt.Sprintf("%s%s/%s.service", basePath, baseSystemdPath, serviceName)
+	execCommand(c, "sudo", "chmod", "a+w", fmt.Sprintf("%s%s", basePath, baseSystemdPath))
+	execCommandToFile(c, serviceFile, "sudo", "echo", serviceCfg)
+
+	// Create requires directory
+	requiresDirPart := fmt.Sprintf("%s/%s", baseSystemdPath, systemdTargetRequiresDir)
+	requiresDir := fmt.Sprintf("%s%s", basePath, requiresDirPart)
+	execCommand(c, "sudo", "mkdir", "-p", requiresDir)
+
+	// Symlink from the requires dir to the service file (with chroot for being
+	// usable in the other partition)
+	execCommand(c, "sudo", "chroot", basePath, "ln", "-s",
+		fmt.Sprintf("%s/%s.service", baseSystemdPath, serviceName),
+		fmt.Sprintf("%s/%s.service", requiresDirPart, serviceName),
+	)
+
+	makeReadonly(c, basePath)
+}
+
+func unInstallService(c *C, serviceName, basePath string) {
+	makeWritable(c, basePath)
+
+	// Disable the service
+	execCommand(c, "sudo", "chroot", basePath,
+		"systemctl", "disable", fmt.Sprintf("%s.service", serviceName))
+
+	// Remove the service file
+	execCommand(c, "sudo", "rm",
+		fmt.Sprintf("%s%s/%s.service", basePath, baseSystemdPath, serviceName))
+
+	// Remove the requires symlink
+	execCommand(c, "sudo", "rm",
+		fmt.Sprintf("%s%s/%s/%s.service", basePath, baseSystemdPath, systemdTargetRequiresDir, serviceName))
+
+	makeReadonly(c, basePath)
+}
+
+func (s *FailoverSuite) TestSystemdDependencyLoop(c *C) {
+	commonFailoverTest(c, systemdDependencyLoop{})
+}

=== added file '_integration-tests/tests/failover_test.go'
--- _integration-tests/tests/failover_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/failover_test.go	2015-06-26 00:24:26 +0000
@@ -0,0 +1,151 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+
+	. "gopkg.in/check.v1"
+)
+
+type FailoverSuite struct {
+	CommonSuite
+}
+
+var _ = Suite(&FailoverSuite{})
+
+const (
+	baseOtherPath  = "/writable/cache/system"
+	channelCfgFile = "/etc/system-image/channel.ini"
+)
+
+// The types that implement this interface can be used in the test logic
+type failer interface {
+	// Sets the failure conditions
+	set(c *C)
+	// Unsets the failure conditions
+	unset(c *C)
+}
+
+// This is the logic common to all the failover tests. Each of them has define a
+// type implementing the failer interface and call this function with an instance
+// of it
+func commonFailoverTest(c *C, f failer) {
+	currentVersion := getCurrentVersion(c)
+
+	if afterReboot(c) {
+		removeRebootMark(c)
+		f.unset(c)
+		c.Assert(getSavedVersion(c), Equals, currentVersion)
+	} else {
+		switchChannelVersion(c, currentVersion, currentVersion-1)
+		setSavedVersion(c, currentVersion-1)
+
+		callUpdate(c)
+		f.set(c)
+		reboot(c)
+	}
+}
+
+func reboot(c *C) {
+	// This will write the name of the current test as a reboot mark
+	execCommand(c, "sudo", "/tmp/autopkgtest-reboot", c.TestName())
+}
+
+func removeRebootMark(c *C) {
+	err := os.Setenv("ADT_REBOOT_MARK", "")
+	c.Assert(err, IsNil, Commentf("Error unsetting ADT_REBOOT_MARK"))
+}
+
+func afterReboot(c *C) bool {
+	// $ADT_REBOOT_MARK contains the reboot mark, if we have rebooted it'll be the test name
+	return os.Getenv("ADT_REBOOT_MARK") == c.TestName()
+}
+
+func getCurrentVersion(c *C) int {
+	output := execCommand(c, "snappy", "list")
+	pattern := "(?mU)^ubuntu-core (.*)$"
+	re := regexp.MustCompile(pattern)
+	match := re.FindStringSubmatch(output)
+	c.Assert(match, NotNil, Commentf("Version not found in %s", output))
+
+	// match is like "ubuntu-core   2015-06-18 93        ubuntu"
+	items := strings.Fields(match[0])
+	version, err := strconv.Atoi(items[2])
+	c.Assert(err, IsNil, Commentf("Error converting version to int %v", version))
+	return version
+}
+
+func setSavedVersion(c *C, version int) {
+	versionFile := getVersionFile()
+	err := ioutil.WriteFile(versionFile, []byte(strconv.Itoa(version)), 0777)
+	c.Assert(err, IsNil, Commentf("Error writing version file %s with %s", versionFile, version))
+}
+
+func getSavedVersion(c *C) int {
+	versionFile := getVersionFile()
+	contents, err := ioutil.ReadFile(versionFile)
+	c.Assert(err, IsNil, Commentf("Error reading version file %s", versionFile))
+
+	version, err := strconv.Atoi(string(contents))
+	c.Assert(err, IsNil, Commentf("Error converting version %v", contents))
+
+	return version
+}
+
+func getVersionFile() string {
+	return filepath.Join(os.Getenv("ADT_ARTIFACTS"), "version")
+}
+
+func switchChannelVersion(c *C, oldVersion, newVersion int) {
+	targets := []string{"/", baseOtherPath}
+	for _, target := range targets {
+		file := filepath.Join(target, channelCfgFile)
+		if _, err := os.Stat(file); err == nil {
+			makeWritable(c, target)
+			execCommand(c,
+				"sudo", "sed", "-i",
+				fmt.Sprintf(
+					"s/build_number: %d/build_number: %d/g",
+					oldVersion, newVersion),
+				file)
+			makeReadonly(c, target)
+		}
+	}
+}
+
+func callUpdate(c *C) {
+	c.Log("Calling snappy update...")
+	execCommand(c, "sudo", "snappy", "update")
+}
+
+func makeWritable(c *C, path string) {
+	execCommand(c, "sudo", "mount", "-o", "remount,rw", path)
+}
+
+func makeReadonly(c *C, path string) {
+	execCommand(c, "sudo", "mount", "-o", "remount,ro", path)
+}

=== added file '_integration-tests/tests/failover_zero_size_file_test.go'
--- _integration-tests/tests/failover_zero_size_file_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/failover_zero_size_file_test.go	2015-06-26 00:24:26 +0000
@@ -0,0 +1,120 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	. "gopkg.in/check.v1"
+)
+
+const (
+	// TODO: take into account arch for the boot path pattern
+	origBootFilenamePattern    = "boot/%s%s*"
+	origSystemdFilenamePattern = "lib/systemd/%s%s"
+	kernelFilename             = "vmlinuz"
+	initrdFilename             = "initrd"
+	systemdFilename            = "systemd"
+	destFilenamePrefix         = "snappy-selftest-"
+)
+
+type zeroSizeKernel struct{}
+type zeroSizeInitrd struct{}
+type zeroSizeSystemd struct{}
+
+func (zeroSizeKernel) set(c *C) {
+	commonSet(c, origBootFilenamePattern, kernelFilename)
+}
+
+func (zeroSizeKernel) unset(c *C) {
+	commonUnset(c, origBootFilenamePattern, kernelFilename)
+}
+
+func (zeroSizeInitrd) set(c *C) {
+	commonSet(c, origBootFilenamePattern, initrdFilename)
+}
+
+func (zeroSizeInitrd) unset(c *C) {
+	commonUnset(c, origBootFilenamePattern, initrdFilename)
+}
+
+func (zeroSizeSystemd) set(c *C) {
+	commonSet(c, origSystemdFilenamePattern, systemdFilename)
+}
+
+func (zeroSizeSystemd) unset(c *C) {
+	commonUnset(c, origSystemdFilenamePattern, systemdFilename)
+}
+
+func commonSet(c *C, origPattern, filename string) {
+	filenamePattern := fmt.Sprintf(origPattern, "", filename)
+	completePattern := filepath.Join(
+		baseOtherPath,
+		filenamePattern)
+	oldFilename := getSingleFilename(c, completePattern)
+	filenameSuffix := fmt.Sprintf(
+		strings.Replace(origPattern, "*", "", 1), destFilenamePrefix, filepath.Base(oldFilename))
+	newFilename := fmt.Sprintf(
+		"%s/%s", baseOtherPath, filenameSuffix)
+
+	renameFile(c, baseOtherPath, oldFilename, newFilename)
+}
+
+func commonUnset(c *C, origPattern, filename string) {
+	completePattern := filepath.Join(
+		baseOtherPath,
+		fmt.Sprintf(origPattern, destFilenamePrefix, filename))
+	oldFilename := getSingleFilename(c, completePattern)
+	newFilename := strings.Replace(oldFilename, destFilenamePrefix, "", 1)
+
+	renameFile(c, baseOtherPath, oldFilename, newFilename)
+}
+
+func renameFile(c *C, basePath, oldFilename, newFilename string) {
+	makeWritable(c, basePath)
+	execCommand(c, "sudo", "mv", oldFilename, newFilename)
+	execCommand(c, "sudo", "touch", oldFilename)
+	makeReadonly(c, basePath)
+}
+
+func getSingleFilename(c *C, pattern string) string {
+	matches, err := filepath.Glob(pattern)
+
+	c.Assert(err, IsNil, Commentf("Error: %v", err))
+	c.Assert(len(matches), Equals, 1)
+
+	return matches[0]
+}
+
+/*
+func (s *FailoverSuite) TestZeroSizeKernel(c *C) {
+	commonFailoverTest(c, zeroSizeKernel{})
+}
+*/
+
+func (s *FailoverSuite) TestZeroSizeInitrd(c *C) {
+	commonFailoverTest(c, zeroSizeInitrd{})
+}
+
+func (s *FailoverSuite) TestZeroSizeSystemd(c *C) {
+	commonFailoverTest(c, zeroSizeSystemd{})
+}

=== renamed file '_integration-tests/tests/snappy_test.go' => '_integration-tests/tests/install_test.go'
--- _integration-tests/tests/snappy_test.go	2015-06-22 23:52:54 +0000
+++ _integration-tests/tests/install_test.go	2015-06-26 00:24:26 +0000
@@ -19,42 +19,24 @@
 
 package tests
 
-import (
-	"os/exec"
-	"testing"
-
-	. "gopkg.in/check.v1"
-)
-
-// Hook up gocheck into the "go test" runner
-func Test(t *testing.T) { TestingT(t) }
+import . "gopkg.in/check.v1"
 
 var _ = Suite(&InstallSuite{})
 
-type InstallSuite struct{}
-
-func (s *InstallSuite) installSnap(c *C, packageName string) string {
-	return s.execCommand(c, "sudo", "snappy", "install", packageName)
-}
-
-func (s *InstallSuite) execCommand(c *C, cmds ...string) string {
-	cmd := exec.Command(cmds[0], cmds[1:len(cmds)]...)
-	output, err := cmd.CombinedOutput()
-	stringOutput := string(output)
-	c.Assert(err, IsNil, Commentf("Error: %v", stringOutput))
-	return stringOutput
-}
-
-func (s *InstallSuite) SetUpSuite(c *C) {
-	s.execCommand(c, "sudo", "systemctl", "stop", "snappy-autopilot.timer")
+type InstallSuite struct {
+	CommonSuite
+}
+
+func installSnap(c *C, packageName string) string {
+	return execCommand(c, "sudo", "snappy", "install", packageName)
 }
 
 func (s *InstallSuite) TearDownTest(c *C) {
-	s.execCommand(c, "sudo", "snappy", "remove", "hello-world")
+	execCommand(c, "sudo", "snappy", "remove", "hello-world")
 }
 
 func (s *InstallSuite) TestInstallSnapMustPrintPackageInformation(c *C) {
-	installOutput := s.installSnap(c, "hello-world")
+	installOutput := installSnap(c, "hello-world")
 
 	expected := "" +
 		"Installing hello-world\n" +
@@ -66,18 +48,19 @@
 }
 
 func (s *InstallSuite) TestCallBinaryFromInstalledSnap(c *C) {
-	s.installSnap(c, "hello-world")
+	installSnap(c, "hello-world")
 
-	echoOutput := s.execCommand(c, "hello-world.echo")
+	echoOutput := execCommand(c, "hello-world.echo")
 
 	c.Assert(echoOutput, Equals, "Hello World!\n")
 }
 
 func (s *InstallSuite) TestInfoMustPrintInstalledPackageInformation(c *C) {
-	s.installSnap(c, "hello-world")
+	installSnap(c, "hello-world")
 
-	infoOutput := s.execCommand(c, "sudo", "snappy", "info")
+	infoOutput := execCommand(c, "snappy", "info")
 
 	expected := "(?ms).*^apps: hello-world\n"
+
 	c.Assert(infoOutput, Matches, expected)
 }

=== modified file 'cmd/snappy/cmd_internal_unpack.go'
--- cmd/snappy/cmd_internal_unpack.go	2015-06-08 13:03:35 +0000
+++ cmd/snappy/cmd_internal_unpack.go	2015-06-26 00:24:26 +0000
@@ -70,7 +70,7 @@
 	return filepath.Join("/etc/", file)
 }
 
-func readUid(user, passwdFile string) (uid int, err error) {
+func readUID(user, passwdFile string) (uid int, err error) {
 	f, err := os.Open(passwdFile)
 	if err != nil {
 		return -1, err
@@ -125,13 +125,13 @@
 	if helpers.ShouldDropPrivs() {
 
 		passFile := passwdFile(rootDir, "passwd")
-		uid, err := readUid(dropPrivsUser, passFile)
+		uid, err := readUID(dropPrivsUser, passFile)
 		if err != nil {
 			return err
 		}
 
 		groupFile := passwdFile(rootDir, "group")
-		gid, err := readUid(dropPrivsUser, groupFile)
+		gid, err := readUID(dropPrivsUser, groupFile)
 		if err != nil {
 			return err
 		}

=== modified file 'cmd/snappy/cmd_low_level_unpack_test.go'
--- cmd/snappy/cmd_low_level_unpack_test.go	2015-06-02 20:46:07 +0000
+++ cmd/snappy/cmd_low_level_unpack_test.go	2015-06-26 00:24:26 +0000
@@ -42,7 +42,7 @@
 clickpkg:x:101:104::/nonexistent:/bin/false
 `)
 
-	uid, err := readUid("clickpkg", f.Name())
+	uid, err := readUID("clickpkg", f.Name())
 	c.Assert(err, IsNil)
 	c.Assert(uid, Equals, 101)
 }
@@ -53,7 +53,7 @@
 clickpkg:x:104:
 `)
 
-	gid, err := readUid("clickpkg", f.Name())
+	gid, err := readUID("clickpkg", f.Name())
 	c.Assert(err, IsNil)
 	c.Assert(gid, Equals, 104)
 }
@@ -66,7 +66,7 @@
 `)
 	defer os.Remove(f.Name())
 
-	uid, err := readUid("clickpkg", f.Name())
+	uid, err := readUID("clickpkg", f.Name())
 	c.Assert(err, IsNil)
 	c.Assert(uid, Equals, 102)
 }
@@ -77,7 +77,7 @@
 clickpkg:x:
 `)
 
-	_, err := readUid("clickpkg", f.Name())
+	_, err := readUID("clickpkg", f.Name())
 	c.Assert(err, NotNil)
 }
 
@@ -86,6 +86,6 @@
 daemon:
 `)
 
-	_, err := readUid("clickpkg", f.Name())
+	_, err := readUID("clickpkg", f.Name())
 	c.Assert(err, NotNil)
 }

=== modified file 'debian/control'
--- debian/control	2015-06-16 15:06:45 +0000
+++ debian/control	2015-06-26 00:24:26 +0000
@@ -51,10 +51,3 @@
 Built-Using: ${misc:Built-Using}
 Description: Tool to interact with Ubuntu Core Snappy.
  Manage an Ubuntu system with snappy.
-
-Package: ubuntu-snappy-tests
-Architecture: any
-Depends: ubuntu-snappy-cli (= ${binary:Version}),
-         ${misc:Depends}
-Description: snappy selftests
- Installs snappy selftests binary

=== modified file 'debian/integration-tests/control'
--- debian/integration-tests/control	2015-06-16 04:52:54 +0000
+++ debian/integration-tests/control	2015-06-26 00:24:26 +0000
@@ -1,4 +1,4 @@
-Test-Command: snappy.test -gocheck.vv -test.outputdir=$ADT_ARTIFACTS
+Test-Command: ./snappy.tests -gocheck.vv -test.outputdir=$ADT_ARTIFACTS
 Restrictions: allow-stderr
 Depends: ubuntu-snappy-tests
 

=== modified file 'debian/rules'
--- debian/rules	2015-06-17 12:02:30 +0000
+++ debian/rules	2015-06-26 00:24:26 +0000
@@ -4,7 +4,6 @@
 #export DH_VERBOSE=1
 export DH_OPTIONS
 export DH_GOPKG := launchpad.net/snappy
-DH_BUILDDIR = obj-$(shell dpkg-architecture -qDEB_HOST_GNU_TYPE)
 
 %:
 	dh $@ --buildsystem=golang --with=golang --fail-missing --with systemd
@@ -51,11 +50,6 @@
 		-pubuntu-snappy \
 		snappy-autopilot.service
 
-override_dh_auto_build:
-	dh_auto_build
-	GOPATH=$$PWD/$(DH_BUILDDIR) go test -c ./_integration-tests/tests
-	mv tests.test $$PWD/$(DH_BUILDDIR)/bin/snappy.test
-
 override_dh_auto_install:
 	dh_auto_install -O--buildsystem=golang
 	# Making the packages private

=== removed file 'debian/ubuntu-snappy-tests.install'
--- debian/ubuntu-snappy-tests.install	2015-06-13 18:10:49 +0000
+++ debian/ubuntu-snappy-tests.install	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-/usr/bin/snappy.test

=== modified file 'helpers/touch.go'
--- helpers/touch.go	2015-05-15 13:33:27 +0000
+++ helpers/touch.go	2015-06-26 00:24:26 +0000
@@ -38,6 +38,8 @@
 	"unsafe"
 )
 
+// ErrNotAbsPath is returned when an absolute path is needed but the received
+// path is not.
 var ErrNotAbsPath = errors.New("not an absolute path")
 
 // UpdateTimestamp updates the timestamp of the file at pathname. It does not

=== added file 'partition/assets.go'
--- partition/assets.go	1970-01-01 00:00:00 +0000
+++ partition/assets.go	2015-06-26 00:24:26 +0000
@@ -0,0 +1,87 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package partition
+
+import (
+	"errors"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"gopkg.in/yaml.v2"
+)
+
+// Representation of the yaml in the hardwareSpecFile
+type hardwareSpecType struct {
+	Kernel          string         `yaml:"kernel"`
+	Initrd          string         `yaml:"initrd"`
+	DtbDir          string         `yaml:"dtbs"`
+	PartitionLayout string         `yaml:"partition-layout"`
+	Bootloader      bootloaderName `yaml:"bootloader"`
+}
+
+var (
+	// ErrNoHardwareYaml is returned when no hardware yaml is found in
+	// the update, this means that there is nothing to process with regards
+	// to device parts.
+	ErrNoHardwareYaml = errors.New("no hardware.yaml")
+
+	// Declarative specification of the type of system which specifies such
+	// details as:
+	//
+	// - the location of initrd+kernel within the system-image archive.
+	// - the location of hardware-specific .dtb files within the
+	//   system-image archive.
+	// - the type of bootloader that should be used for this system.
+	// - expected system partition layout (single or dual rootfs's).
+	hardwareSpecFileReal = filepath.Join(cacheDir, "hardware.yaml")
+
+	// useful to override in the tests
+	hardwareSpecFile = hardwareSpecFileReal
+
+	// Directory that _may_ get automatically created on unpack that
+	// contains updated hardware-specific boot assets (such as initrd,
+	// kernel)
+	assetsDir = filepath.Join(cacheDir, "assets")
+
+	// Directory that _may_ get automatically created on unpack that
+	// contains updated hardware-specific assets that require flashing
+	// to the disk (such as uBoot, MLO)
+	flashAssetsDir = filepath.Join(cacheDir, "flashtool-assets")
+)
+
+func readHardwareSpec() (*hardwareSpecType, error) {
+	var h hardwareSpecType
+
+	data, err := ioutil.ReadFile(hardwareSpecFile)
+	// if hardware.yaml does not exist it just means that there was no
+	// device part in the update.
+	if os.IsNotExist(err) {
+		return nil, ErrNoHardwareYaml
+	} else if err != nil {
+		return nil, err
+	}
+
+	if err := yaml.Unmarshal([]byte(data), &h); err != nil {
+		return nil, err
+	}
+
+	return &h, nil
+}

=== added file 'partition/assets_test.go'
--- partition/assets_test.go	1970-01-01 00:00:00 +0000
+++ partition/assets_test.go	2015-06-26 00:24:26 +0000
@@ -0,0 +1,36 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package partition
+
+import (
+	. "gopkg.in/check.v1"
+)
+
+func (s *PartitionTestSuite) TestHardwareSpec(c *C) {
+
+	hardwareSpecFile = makeHardwareYaml(c, "")
+	hw, err := readHardwareSpec()
+	c.Assert(err, IsNil)
+	c.Assert(hw.Kernel, Equals, "assets/vmlinuz")
+	c.Assert(hw.Initrd, Equals, "assets/initrd.img")
+	c.Assert(hw.DtbDir, Equals, "assets/dtbs")
+	c.Assert(hw.PartitionLayout, Equals, bootloaderSystemAB)
+	c.Assert(hw.Bootloader, Equals, bootloaderNameUboot)
+}

=== modified file 'partition/bootloader.go'
--- partition/bootloader.go	2015-06-09 17:43:20 +0000
+++ partition/bootloader.go	2015-06-26 00:24:26 +0000
@@ -45,7 +45,7 @@
 
 	// Switch bootloader configuration so that the "other" root
 	// filesystem partition will be used on next boot.
-	ToggleRootFS() error
+	ToggleRootFS(otherRootfs string) error
 
 	// Hook function called before system-image starts downloading
 	// and applying archives that allows files to be copied between
@@ -60,14 +60,6 @@
 	GetBootVar(name string) (string, error)
 
 	// Return the 1-character name corresponding to the
-	// rootfs currently being used.
-	GetRootFSName() string
-
-	// Return the 1-character name corresponding to the
-	// other rootfs.
-	GetOtherRootFSName() string
-
-	// Return the 1-character name corresponding to the
 	// rootfs that will be used on _next_ boot.
 	//
 	// XXX: Note the distinction between this method and
@@ -78,7 +70,7 @@
 
 	// Update the bootloader configuration to mark the
 	// currently-booted rootfs as having booted successfully.
-	MarkCurrentBootSuccessful() error
+	MarkCurrentBootSuccessful(currentRootfs string) error
 
 	// Return the additional required chroot bind mounts for this bootloader
 	AdditionalBindMounts() []string
@@ -88,15 +80,6 @@
 	BootDir() string
 }
 
-type bootloaderType struct {
-	partition *Partition
-
-	// each rootfs partition has a corresponding u-boot directory named
-	// from the last character of the partition name ('a' or 'b').
-	currentRootfs string
-	otherRootfs   string
-}
-
 // Factory method that returns a new bootloader for the given partition
 var bootloader = bootloaderImpl
 
@@ -115,46 +98,13 @@
 	return nil, ErrBootloader
 }
 
-func newBootLoader(partition *Partition) *bootloaderType {
-	b := new(bootloaderType)
-
-	b.partition = partition
-
-	currentLabel := partition.rootPartition().name
-
-	// FIXME: is this the right thing to do? i.e. what should we do
-	//        on a single partition system?
-	if partition.otherRootPartition() == nil {
-		return nil
-	}
-	otherLabel := partition.otherRootPartition().name
-
-	b.currentRootfs = string(currentLabel[len(currentLabel)-1])
-	b.otherRootfs = string(otherLabel[len(otherLabel)-1])
-
-	return b
-}
-
-// Return true if the next boot will use the other rootfs
-// partition.
-func isNextBootOther(bootloader bootLoader) bool {
-	value, err := bootloader.GetBootVar(bootloaderBootmodeVar)
-	if err != nil {
-		return false
-	}
-
-	if value != bootloaderBootmodeTry {
-		return false
-	}
-
-	fsname, err := bootloader.GetNextBootRootFSName()
-	if err != nil {
-		return false
-	}
-
-	if fsname == bootloader.GetOtherRootFSName() {
-		return true
-	}
-
-	return false
+// BootloaderDir returns the full path to the (mounted and writable)
+// bootloader-specific boot directory.
+func BootloaderDir() string {
+	b, err := bootloader(nil)
+	if err != nil {
+		return ""
+	}
+
+	return b.BootDir()
 }

=== modified file 'partition/bootloader_grub.go'
--- partition/bootloader_grub.go	2015-06-09 17:22:59 +0000
+++ partition/bootloader_grub.go	2015-06-26 00:24:26 +0000
@@ -49,7 +49,6 @@
 )
 
 type grub struct {
-	*bootloaderType
 }
 
 const bootloaderNameGrub bootloaderName = "grub"
@@ -59,13 +58,8 @@
 	if !helpers.FileExists(bootloaderGrubConfigFile) || !helpers.FileExists(bootloaderGrubUpdateCmd) {
 		return nil
 	}
-	b := newBootLoader(partition)
-	if b == nil {
-		return nil
-	}
-	g := &grub{bootloaderType: b}
 
-	return g
+	return &grub{}
 }
 
 func (g *grub) Name() bootloaderName {
@@ -77,10 +71,10 @@
 // Approach:
 //
 // Update the grub configuration.
-func (g *grub) ToggleRootFS() (err error) {
+func (g *grub) ToggleRootFS(otherRootfs string) (err error) {
 
 	// create the grub config
-	if err := runInChroot(g.partition.MountTarget(), bootloaderGrubUpdateCmd); err != nil {
+	if err := runInChroot(mountTarget, bootloaderGrubUpdateCmd); err != nil {
 		return err
 	}
 
@@ -91,7 +85,7 @@
 	// Record the partition that will be used for next boot. This
 	// isn't necessary for correct operation under grub, but allows
 	// us to query the next boot device easily.
-	return g.setBootVar(bootloaderRootfsVar, g.otherRootfs)
+	return g.setBootVar(bootloaderRootfsVar, otherRootfs)
 }
 
 func (g *grub) GetBootVar(name string) (value string, err error) {
@@ -127,22 +121,14 @@
 	return g.GetBootVar(bootloaderRootfsVar)
 }
 
-func (g *grub) GetRootFSName() string {
-	return g.currentRootfs
-}
-
-func (g *grub) GetOtherRootFSName() string {
-	return g.otherRootfs
-}
-
-func (g *grub) MarkCurrentBootSuccessful() (err error) {
+func (g *grub) MarkCurrentBootSuccessful(currentRootfs string) (err error) {
 	// Clear the variable set by grub on boot to denote a good
 	// boot.
 	if err := g.unsetBootVar(bootloaderGrubTrialBootVar); err != nil {
 		return err
 	}
 
-	if err := g.setBootVar(bootloaderRootfsVar, g.currentRootfs); err != nil {
+	if err := g.setBootVar(bootloaderRootfsVar, currentRootfs); err != nil {
 		return err
 	}
 

=== modified file 'partition/bootloader_grub_test.go'
--- partition/bootloader_grub_test.go	2015-06-09 17:43:20 +0000
+++ partition/bootloader_grub_test.go	2015-06-26 00:24:26 +0000
@@ -63,15 +63,6 @@
 	c.Assert(g.Name(), Equals, bootloaderNameGrub)
 }
 
-func (s *PartitionTestSuite) TestNewGrubSinglePartition(c *C) {
-	runLsblk = mockRunLsblkSingleRootSnappy
-	s.makeFakeGrubEnv(c)
-
-	partition := New()
-	g := newGrub(partition)
-	c.Assert(g, IsNil)
-}
-
 type singleCommand []string
 
 var allCommands = []singleCommand{}
@@ -88,14 +79,14 @@
 	partition := New()
 	g := newGrub(partition)
 	c.Assert(g, NotNil)
-	err := g.ToggleRootFS()
+	err := g.ToggleRootFS("b")
 	c.Assert(err, IsNil)
 
 	// this is always called
-	mp := singleCommand{"/bin/mountpoint", "/writable/cache/system"}
+	mp := singleCommand{"/bin/mountpoint", mountTarget}
 	c.Assert(allCommands[0], DeepEquals, mp)
 
-	expectedGrubUpdate := singleCommand{"/usr/sbin/chroot", "/writable/cache/system", bootloaderGrubUpdateCmd}
+	expectedGrubUpdate := singleCommand{"/usr/sbin/chroot", mountTarget, bootloaderGrubUpdateCmd}
 	c.Assert(allCommands[1], DeepEquals, expectedGrubUpdate)
 
 	expectedGrubSet := singleCommand{bootloaderGrubEnvCmd, bootloaderGrubEnvFile, "set", "snappy_mode=try"}
@@ -141,11 +132,11 @@
 	partition := New()
 	g := newGrub(partition)
 	c.Assert(g, NotNil)
-	err := g.MarkCurrentBootSuccessful()
+	err := g.MarkCurrentBootSuccessful("a")
 	c.Assert(err, IsNil)
 
 	// this is always called
-	mp := singleCommand{"/bin/mountpoint", "/writable/cache/system"}
+	mp := singleCommand{"/bin/mountpoint", mountTarget}
 	c.Assert(allCommands[0], DeepEquals, mp)
 
 	expectedGrubSet := singleCommand{bootloaderGrubEnvCmd, bootloaderGrubEnvFile, "unset", "snappy_trial_boot"}

=== modified file 'partition/bootloader_uboot.go'
--- partition/bootloader_uboot.go	2015-06-09 17:22:59 +0000
+++ partition/bootloader_uboot.go	2015-06-26 00:24:26 +0000
@@ -58,8 +58,6 @@
 const bootloaderNameUboot bootloaderName = "u-boot"
 
 type uboot struct {
-	*bootloaderType
-
 	// full path to rootfs-specific assets on boot partition
 	currentBootPath string
 	otherBootPath   string
@@ -78,13 +76,13 @@
 		return nil
 	}
 
-	b := newBootLoader(partition)
-	if b == nil {
-		return nil
-	}
-	u := uboot{bootloaderType: b}
-	u.currentBootPath = filepath.Join(bootloaderUbootDir, u.currentRootfs)
-	u.otherBootPath = filepath.Join(bootloaderUbootDir, u.otherRootfs)
+	u := uboot{}
+
+	currentRootfs := partition.rootPartition().shortName
+	u.currentBootPath = filepath.Join(bootloaderUbootDir, currentRootfs)
+
+	otherRootfs := partition.otherRootPartition().shortName
+	u.otherBootPath = filepath.Join(bootloaderUbootDir, otherRootfs)
 
 	return &u
 }
@@ -103,7 +101,7 @@
 // - Copy the "other" rootfs's kernel+initrd to the boot partition,
 //   renaming them in the process to ensure the next boot uses the
 //   correct versions.
-func (u *uboot) ToggleRootFS() (err error) {
+func (u *uboot) ToggleRootFS(otherRootfs string) (err error) {
 
 	// If the file exists, update it. Otherwise create it.
 	//
@@ -112,7 +110,7 @@
 	// recreate to allow the system to boot!
 	changes := []configFileChange{
 		configFileChange{Name: bootloaderRootfsVar,
-			Value: string(u.otherRootfs),
+			Value: string(otherRootfs),
 		},
 		configFileChange{Name: bootloaderBootmodeVar,
 			Value: bootloaderBootmodeTry,
@@ -142,14 +140,6 @@
 	return value, nil
 }
 
-func (u *uboot) GetRootFSName() string {
-	return u.currentRootfs
-}
-
-func (u *uboot) GetOtherRootFSName() string {
-	return u.otherRootfs
-}
-
 // FIXME: put into utils package
 func readLines(path string) (lines []string, err error) {
 
@@ -200,13 +190,13 @@
 	return file.Sync()
 }
 
-func (u *uboot) MarkCurrentBootSuccessful() (err error) {
+func (u *uboot) MarkCurrentBootSuccessful(currentRootfs string) (err error) {
 	changes := []configFileChange{
 		configFileChange{Name: bootloaderBootmodeVar,
 			Value: bootloaderBootmodeSuccess,
 		},
 		configFileChange{Name: bootloaderRootfsVar,
-			Value: string(u.currentRootfs),
+			Value: string(currentRootfs),
 		},
 	}
 
@@ -227,14 +217,18 @@
 func (u *uboot) HandleAssets() (err error) {
 	// check if we have anything, if there is no hardware yaml, there is nothing
 	// to process.
-	hardware, err := u.partition.hardwareSpec()
+	hardware, err := readHardwareSpec()
 	if err == ErrNoHardwareYaml {
 		return nil
 	} else if err != nil {
 		return err
 	}
-	// ensure to remove the file once we are done
-	defer os.Remove(u.partition.hardwareSpecFile)
+	// ensure to remove the file once we are done (and all was good)
+	defer func() {
+		if err == nil {
+			os.Remove(hardwareSpecFile)
+		}
+	}()
 
 	// validate bootloader
 	if hardware.Bootloader != u.Name() {
@@ -244,8 +238,9 @@
 			hardware.Bootloader)
 	}
 
-	// validate partition layout
-	if u.partition.dualRootPartitions() && hardware.PartitionLayout != bootloaderSystemAB {
+	// validate partition layout, we ONLY support bootloaderSystemAB
+	// currently
+	if hardware.PartitionLayout != bootloaderSystemAB {
 		return fmt.Errorf("hardware spec requires dual root partitions")
 	}
 
@@ -263,7 +258,7 @@
 		}
 
 		// expand path
-		path := filepath.Join(u.partition.cacheDir(), file)
+		path := filepath.Join(cacheDir, file)
 
 		if !helpers.FileExists(path) {
 			return fmt.Errorf("can not find file %s", path)
@@ -281,7 +276,7 @@
 	//       fully speced
 
 	// install .dtb files
-	dtbSrcDir := filepath.Join(u.partition.cacheDir(), hardware.DtbDir)
+	dtbSrcDir := filepath.Join(cacheDir, hardware.DtbDir)
 	if helpers.FileExists(dtbSrcDir) {
 		// ensure we cleanup the source dir
 		defer os.RemoveAll(dtbSrcDir)
@@ -303,8 +298,6 @@
 		}
 	}
 
-	flashAssetsDir := u.partition.flashAssetsDir()
-
 	if helpers.FileExists(flashAssetsDir) {
 		// FIXME: we don't currently do anything with the
 		// MLO + uImage files since they are not specified in

=== modified file 'partition/bootloader_uboot_test.go'
--- partition/bootloader_uboot_test.go	2015-06-12 05:23:40 +0000
+++ partition/bootloader_uboot_test.go	2015-06-26 00:24:26 +0000
@@ -89,15 +89,6 @@
 	c.Assert(u.Name(), Equals, bootloaderNameUboot)
 }
 
-func (s *PartitionTestSuite) TestNewUbootSinglePartition(c *C) {
-	runLsblk = mockRunLsblkSingleRootSnappy
-	s.makeFakeUbootEnv(c)
-
-	partition := New()
-	u := newUboot(partition)
-	c.Assert(u, IsNil)
-}
-
 func (s *PartitionTestSuite) TestUbootGetBootVar(c *C) {
 	s.makeFakeUbootEnv(c)
 
@@ -111,7 +102,7 @@
 	c.Assert(nextBoot, Equals, "a")
 
 	// ensure that nextBootIsOther works too
-	c.Assert(isNextBootOther(u), Equals, false)
+	c.Assert(partition.IsNextBootOther(), Equals, false)
 }
 
 func (s *PartitionTestSuite) TestUbootToggleRootFS(c *C) {
@@ -121,7 +112,7 @@
 	u := newUboot(partition)
 	c.Assert(u, NotNil)
 
-	err := u.ToggleRootFS()
+	err := u.ToggleRootFS("b")
 	c.Assert(err, IsNil)
 
 	nextBoot, err := u.GetBootVar(bootloaderRootfsVar)
@@ -129,7 +120,7 @@
 	c.Assert(nextBoot, Equals, "b")
 
 	// ensure that nextBootIsOther works too
-	c.Assert(isNextBootOther(u), Equals, true)
+	c.Assert(partition.IsNextBootOther(), Equals, true)
 }
 
 func (s *PartitionTestSuite) TestUbootGetEnvVar(c *C) {
@@ -158,7 +149,7 @@
 
 func makeMockAssetsDir(c *C) {
 	for _, f := range []string{"assets/vmlinuz", "assets/initrd.img", "assets/dtbs/foo.dtb", "assets/dtbs/bar.dtb"} {
-		p := filepath.Join(defaultCacheDir, f)
+		p := filepath.Join(cacheDir, f)
 		os.MkdirAll(filepath.Dir(p), 0755)
 		err := ioutil.WriteFile(p, []byte(f), 0644)
 		c.Assert(err, IsNil)
@@ -172,8 +163,8 @@
 	c.Assert(err, IsNil)
 
 	// mock the hardwareYaml and the cacheDir
-	p.hardwareSpecFile = makeHardwareYaml(c, "")
-	defaultCacheDir = c.MkDir()
+	hardwareSpecFile = makeHardwareYaml(c, "")
+	cacheDir = c.MkDir()
 
 	// create mock assets/
 	makeMockAssetsDir(c)
@@ -192,8 +183,8 @@
 	}
 
 	// ensure nothing left behind
-	c.Assert(helpers.FileExists(filepath.Join(defaultCacheDir, "assets")), Equals, false)
-	c.Assert(helpers.FileExists(p.hardwareSpecFile), Equals, false)
+	c.Assert(helpers.FileExists(filepath.Join(cacheDir, "assets")), Equals, false)
+	c.Assert(helpers.FileExists(hardwareSpecFile), Equals, false)
 }
 
 func (s *PartitionTestSuite) TestHandleAssetsVerifyBootloader(c *C) {
@@ -203,7 +194,8 @@
 	c.Assert(err, IsNil)
 
 	// mock the hardwareYaml and the cacheDir
-	p.hardwareSpecFile = makeHardwareYaml(c, "bootloader: grub")
+	hardwareSpecFile = makeHardwareYaml(c, "bootloader: grub")
+	cacheDir = c.MkDir()
 
 	err = bootloader.HandleAssets()
 	c.Assert(err, NotNil)
@@ -216,18 +208,16 @@
 	c.Assert(err, IsNil)
 
 	// mock the hardwareYaml and the cacheDir
-	p.hardwareSpecFile = makeHardwareYaml(c, `
+	hardwareSpecFile = makeHardwareYaml(c, `
 bootloader: u-boot
 partition-layout: inplace
 `)
-
 	err = bootloader.HandleAssets()
 	c.Assert(err, NotNil)
 }
 
 func (s *PartitionTestSuite) TestHandleAssetsNoHardwareYaml(c *C) {
 	s.makeFakeUbootEnv(c)
-	defaultCacheDir = c.MkDir()
 
 	p := New()
 	bootloader, err := bootloader(p)
@@ -242,7 +232,7 @@
 	bootloader, err := bootloader(p)
 	c.Assert(err, IsNil)
 
-	p.hardwareSpecFile = makeHardwareYaml(c, `
+	hardwareSpecFile = makeHardwareYaml(c, `
 bootloader u-boot
 `)
 
@@ -268,7 +258,7 @@
 	// enter "try" mode so that we check to ensure that snappy
 	// correctly modifies the snappy_mode variable from "try" to
 	// "regular" to denote a good boot.
-	err = u.ToggleRootFS()
+	err = u.ToggleRootFS("b")
 	c.Assert(err, IsNil)
 
 	c.Assert(helpers.FileExists(bootloaderUbootEnvFile), Equals, true)
@@ -278,7 +268,7 @@
 	c.Assert(strings.Contains(string(bytes), "snappy_mode=regular"), Equals, false)
 	c.Assert(strings.Contains(string(bytes), "snappy_ab=b"), Equals, true)
 
-	err = u.MarkCurrentBootSuccessful()
+	err = u.MarkCurrentBootSuccessful("b")
 	c.Assert(err, IsNil)
 
 	c.Assert(helpers.FileExists(bootloaderUbootStampFile), Equals, false)
@@ -288,7 +278,7 @@
 	c.Assert(err, IsNil)
 	c.Assert(strings.Contains(string(bytes), "snappy_mode=try"), Equals, false)
 	c.Assert(strings.Contains(string(bytes), "snappy_mode=regular"), Equals, true)
-	c.Assert(strings.Contains(string(bytes), "snappy_ab=a"), Equals, true)
+	c.Assert(strings.Contains(string(bytes), "snappy_ab=b"), Equals, true)
 }
 
 func (s *PartitionTestSuite) TestNoWriteNotNeeded(c *C) {
@@ -301,7 +291,7 @@
 	u := newUboot(partition)
 	c.Assert(u, NotNil)
 
-	c.Check(u.MarkCurrentBootSuccessful(), IsNil)
+	c.Check(u.MarkCurrentBootSuccessful("a"), IsNil)
 	c.Assert(atomiCall, Equals, false)
 }
 
@@ -318,7 +308,7 @@
 	u := newUboot(partition)
 	c.Assert(u, NotNil)
 
-	c.Check(u.MarkCurrentBootSuccessful(), IsNil)
+	c.Check(u.MarkCurrentBootSuccessful("a"), IsNil)
 	c.Assert(atomiCall, Equals, true)
 
 	bytes, err := ioutil.ReadFile(bootloaderUbootEnvFile)

=== added file 'partition/dirs.go'
--- partition/dirs.go	1970-01-01 00:00:00 +0000
+++ partition/dirs.go	2015-06-26 00:24:26 +0000
@@ -0,0 +1,41 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package partition
+
+import (
+	"path/filepath"
+)
+
+// The full path to the cache directory, which is used as a
+// scratch pad, for downloading new images to and bind mounting the
+// rootfs.
+const cacheDirReal = "/writable/cache"
+
+var (
+	// useful for overwriting in the tests
+	cacheDir = cacheDirReal
+
+	// Directory to mount writable root filesystem below the cache
+	// diretory.
+	mountTargetReal = filepath.Join(cacheDir, "system")
+
+	// useful to override in tests
+	mountTarget = mountTargetReal
+)

=== added file 'partition/mount.go'
--- partition/mount.go	1970-01-01 00:00:00 +0000
+++ partition/mount.go	2015-06-26 00:24:26 +0000
@@ -0,0 +1,153 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package partition
+
+import (
+	"fmt"
+	"sort"
+)
+
+// MountOption represents how the partition should be mounted, currently
+// RO (read-only) and RW (read-write) are supported
+type MountOption int
+
+const (
+	// RO mounts the partition read-only
+	RO MountOption = iota
+	// RW mounts the partition read-only
+	RW
+)
+
+// mountEntry represents a mount this package has created.
+type mountEntry struct {
+	source string
+	target string
+
+	options string
+
+	// true if target refers to a bind mount. We could derive this
+	// from options, but this field saves the effort.
+	bindMount bool
+}
+
+// mountEntryArray represents an array of mountEntry objects.
+type mountEntryArray []mountEntry
+
+// current mounts that this package has created.
+var mounts mountEntryArray
+
+// Len is part of the sort interface, required to allow sort to work
+// with an array of Mount objects.
+func (mounts mountEntryArray) Len() int {
+	return len(mounts)
+}
+
+// Less is part of the sort interface, required to allow sort to work
+// with an array of Mount objects.
+func (mounts mountEntryArray) Less(i, j int) bool {
+	return mounts[i].target < mounts[j].target
+}
+
+// Swap is part of the sort interface, required to allow sort to work
+// with an array of Mount objects.
+func (mounts mountEntryArray) Swap(i, j int) {
+	mounts[i], mounts[j] = mounts[j], mounts[i]
+}
+
+// removeMountByTarget removes the Mount specified by the target from
+// the global mounts array.
+func removeMountByTarget(mnts mountEntryArray, target string) (results mountEntryArray) {
+
+	for _, m := range mnts {
+		if m.target != target {
+			results = append(results, m)
+		}
+	}
+
+	return results
+}
+
+// undoMounts unmounts all mounts this package has mounted optionally
+// only unmounting bind mounts and leaving all remaining mounts.
+func undoMounts(bindMountsOnly bool) error {
+
+	mountsCopy := make(mountEntryArray, len(mounts), cap(mounts))
+	copy(mountsCopy, mounts)
+
+	// reverse sort to ensure unmounts are handled in the correct
+	// order.
+	sort.Sort(sort.Reverse(mountsCopy))
+
+	// Iterate backwards since we want a reverse-sorted list of
+	// mounts to ensure we can unmount in order.
+	for _, mount := range mountsCopy {
+		if bindMountsOnly && !mount.bindMount {
+			continue
+		}
+
+		if err := unmountAndRemoveFromGlobalMountList(mount.target); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// FIXME: use syscall.Mount() here
+func mount(source, target, options string) (err error) {
+	var args []string
+
+	args = append(args, "/bin/mount")
+	if options != "" {
+		args = append(args, fmt.Sprintf("-o%s", options))
+	}
+
+	args = append(args, source)
+	args = append(args, target)
+
+	return runCommand(args...)
+}
+
+// Mount the given directory and add it to the global mounts slice
+func mountAndAddToGlobalMountList(m mountEntry) (err error) {
+
+	err = mount(m.source, m.target, m.options)
+	if err == nil {
+		mounts = append(mounts, m)
+	}
+
+	return err
+}
+
+// Unmount the given directory and remove it from the global "mounts" slice
+func unmountAndRemoveFromGlobalMountList(target string) (err error) {
+	err = runCommand("/bin/umount", target)
+	if err != nil {
+		return err
+
+	}
+
+	results := removeMountByTarget(mounts, target)
+
+	// Update global
+	mounts = results
+
+	return nil
+}

=== added file 'partition/mount_test.go'
--- partition/mount_test.go	1970-01-01 00:00:00 +0000
+++ partition/mount_test.go	2015-06-26 00:24:26 +0000
@@ -0,0 +1,64 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package partition
+
+import (
+	. "gopkg.in/check.v1"
+)
+
+func (s *PartitionTestSuite) TestMountEntryArray(c *C) {
+	mea := mountEntryArray{}
+
+	c.Assert(mea.Len(), Equals, 0)
+
+	me := mountEntry{source: "/dev",
+		target:    "/dev",
+		options:   "bind",
+		bindMount: true}
+
+	mea = append(mea, me)
+	c.Assert(mea.Len(), Equals, 1)
+
+	me = mountEntry{source: "/foo",
+		target:    "/foo",
+		options:   "",
+		bindMount: false}
+
+	mea = append(mea, me)
+	c.Assert(mea.Len(), Equals, 2)
+
+	c.Assert(mea.Less(0, 1), Equals, true)
+	c.Assert(mea.Less(1, 0), Equals, false)
+
+	mea.Swap(0, 1)
+	c.Assert(mea.Less(0, 1), Equals, false)
+	c.Assert(mea.Less(1, 0), Equals, true)
+
+	results := removeMountByTarget(mea, "invalid")
+
+	// No change expected
+	c.Assert(results, DeepEquals, mea)
+
+	results = removeMountByTarget(mea, "/dev")
+
+	c.Assert(len(results), Equals, 1)
+	c.Assert(results[0], Equals, mountEntry{source: "/foo",
+		target: "/foo", options: "", bindMount: false})
+}

=== modified file 'partition/partition.go'
--- partition/partition.go	2015-06-09 17:43:20 +0000
+++ partition/partition.go	2015-06-26 00:24:26 +0000
@@ -23,50 +23,37 @@
 import (
 	"errors"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"os/signal"
 	"path/filepath"
 	"regexp"
-	"sort"
 	"strings"
+	"sync"
 	"syscall"
 
-	"gopkg.in/yaml.v2"
-
 	"launchpad.net/snappy/logger"
 )
 
-var signalHandlerRegistered = false
-
-// Name of writable user data partition label as created by
-// ubuntu-device-flash(1).
-const writablePartitionLabel = "writable"
-
-// Name of primary root filesystem partition label as created by
-// ubuntu-device-flash(1).
-const rootfsAlabel = "system-a"
-
-// Name of primary root filesystem partition label as created by
-// ubuntu-device-flash(1). Note that this partition will
-// only be present if this is an A/B upgrade system.
-const rootfsBlabel = "system-b"
-
-// name of boot partition label as created by ubuntu-device-flash(1).
-const bootPartitionLabel = "system-boot"
-
-// its useful to override this in tests
-const realDefaultCacheDir = "/writable/cache"
-
-// FIXME: Should query system-image-cli (see bug LP:#1380574).
-var defaultCacheDir = realDefaultCacheDir
-
-// Directory to mount writable root filesystem below the cache
-// diretory.
-const mountTarget = "system"
-
-// File creation mode used when any directories are created
-const dirMode = 0750
+const (
+	// Name of writable user data partition label as created by
+	// ubuntu-device-flash(1).
+	writablePartitionLabel = "writable"
+
+	// Name of primary root filesystem partition label as created by
+	// ubuntu-device-flash(1).
+	rootfsAlabel = "system-a"
+
+	// Name of primary root filesystem partition label as created by
+	// ubuntu-device-flash(1). Note that this partition will
+	// only be present if this is an A/B upgrade system.
+	rootfsBlabel = "system-b"
+
+	// name of boot partition label as created by ubuntu-device-flash(1).
+	bootPartitionLabel = "system-boot"
+
+	// File creation mode used when any directories are created
+	dirMode = 0750
+)
 
 var (
 	// ErrBootloader is returned if the bootloader can not be determined
@@ -79,41 +66,6 @@
 	// ErrNoDualPartition is returned if you try to use a dual
 	// partition feature on a single partition
 	ErrNoDualPartition = errors.New("No dual partition")
-
-	// ErrNoHardwareYaml is returned when no hardware yaml is found in
-	// the update, this means that there is nothing to process with regards
-	// to device parts.
-	ErrNoHardwareYaml = errors.New("no hardware.yaml")
-)
-
-// Declarative specification of the type of system which specifies such
-// details as:
-//
-// - the location of initrd+kernel within the system-image archive.
-// - the location of hardware-specific .dtb files within the
-//   system-image archive.
-// - the type of bootloader that should be used for this system.
-// - expected system partition layout (single or dual rootfs's).
-const hardwareSpecFile = "hardware.yaml"
-
-// Directory that _may_ get automatically created on unpack that
-// contains updated hardware-specific boot assets (such as initrd, kernel)
-const assetsDir = "assets"
-
-// Directory that _may_ get automatically created on unpack that
-// contains updated hardware-specific assets that require flashing
-// to the disk (such as uBoot, MLO)
-const flashAssetsDir = "flashtool-assets"
-
-// MountOption represents how the partition should be mounted, currently
-// RO (read-only) and RW (read-write) are supported
-type MountOption int
-
-const (
-	// RO mounts the partition read-only
-	RO MountOption = iota
-	// RW mounts the partition read-only
-	RW
 )
 
 // Interface provides the interface to interact with a partition
@@ -128,29 +80,7 @@
 
 	// run the function f with the otherRoot mounted
 	RunWithOther(rw MountOption, f func(otherRoot string) (err error)) (err error)
-
-	// Returns the full path to the (mounted and writable)
-	// bootloader-specific boot directory.
-	BootloaderDir() string
-}
-
-// mountEntry represents a mount this package has created.
-type mountEntry struct {
-	source string
-	target string
-
-	options string
-
-	// true if target refers to a bind mount. We could derive this
-	// from options, but this field saves the effort.
-	bindMount bool
-}
-
-// mountEntryArray represents an array of mountEntry objects.
-type mountEntryArray []mountEntry
-
-// current mounts that this package has created.
-var mounts mountEntryArray
+}
 
 // Partition is the type to interact with the partition
 type Partition struct {
@@ -159,14 +89,15 @@
 
 	// just root partitions
 	roots []string
-
-	hardwareSpecFile string
 }
 
 type blockDevice struct {
 	// label for partition
 	name string
 
+	// the last char of the partition label
+	shortName string
+
 	// full path to device on which partition exists
 	// (for example "/dev/sda3")
 	device string
@@ -178,77 +109,10 @@
 	mountpoint string
 }
 
-// Representation of HARDWARE_SPEC_FILE
-type hardwareSpecType struct {
-	Kernel          string         `yaml:"kernel"`
-	Initrd          string         `yaml:"initrd"`
-	DtbDir          string         `yaml:"dtbs"`
-	PartitionLayout string         `yaml:"partition-layout"`
-	Bootloader      bootloaderName `yaml:"bootloader"`
-}
-
-// Len is part of the sort interface, required to allow sort to work
-// with an array of Mount objects.
-func (mounts mountEntryArray) Len() int {
-	return len(mounts)
-}
-
-// Less is part of the sort interface, required to allow sort to work
-// with an array of Mount objects.
-func (mounts mountEntryArray) Less(i, j int) bool {
-	return mounts[i].target < mounts[j].target
-}
-
-// Swap is part of the sort interface, required to allow sort to work
-// with an array of Mount objects.
-func (mounts mountEntryArray) Swap(i, j int) {
-	mounts[i], mounts[j] = mounts[j], mounts[i]
-}
-
-// removeMountByTarget removes the Mount specified by the target from
-// the global mounts array.
-func removeMountByTarget(mnts mountEntryArray, target string) (results mountEntryArray) {
-
-	for _, m := range mnts {
-		if m.target != target {
-			results = append(results, m)
-		}
-	}
-
-	return results
-}
+var once sync.Once
 
 func init() {
-	if !signalHandlerRegistered {
-		setupSignalHandler()
-		signalHandlerRegistered = true
-	}
-}
-
-// undoMounts unmounts all mounts this package has mounted optionally
-// only unmounting bind mounts and leaving all remaining mounts.
-func undoMounts(bindMountsOnly bool) error {
-
-	mountsCopy := make(mountEntryArray, len(mounts), cap(mounts))
-	copy(mountsCopy, mounts)
-
-	// reverse sort to ensure unmounts are handled in the correct
-	// order.
-	sort.Sort(sort.Reverse(mountsCopy))
-
-	// Iterate backwards since we want a reverse-sorted list of
-	// mounts to ensure we can unmount in order.
-	for _, mount := range mountsCopy {
-		if bindMountsOnly && !mount.bindMount {
-			continue
-		}
-
-		if err := unmountAndRemoveFromGlobalMountList(mount.target); err != nil {
-			return err
-		}
-	}
-
-	return nil
+	once.Do(setupSignalHandler)
 }
 
 func signalHandler(sig os.Signal) {
@@ -291,66 +155,6 @@
 	return labels
 }
 
-func mount(source, target, options string) (err error) {
-	var args []string
-
-	args = append(args, "/bin/mount")
-	if options != "" {
-		args = append(args, fmt.Sprintf("-o%s", options))
-	}
-
-	args = append(args, source)
-	args = append(args, target)
-
-	return runCommand(args...)
-}
-
-// Mount the given directory and add it to the global mounts slice
-func mountAndAddToGlobalMountList(m mountEntry) (err error) {
-
-	err = mount(m.source, m.target, m.options)
-	if err == nil {
-		mounts = append(mounts, m)
-	}
-
-	return err
-}
-
-// Unmount the given directory and remove it from the global "mounts" slice
-func unmountAndRemoveFromGlobalMountList(target string) (err error) {
-	err = runCommand("/bin/umount", target)
-	if err != nil {
-		return err
-
-	}
-
-	results := removeMountByTarget(mounts, target)
-
-	// Update global
-	mounts = results
-
-	return nil
-}
-
-// Run fsck(8) on specified device.
-func fsck(device string) (err error) {
-	return runCommand(
-		"/sbin/fsck",
-		"-M", // Paranoia - don't fsck if already mounted
-		"-av", device)
-}
-
-// Returns the position of the string in the given slice or -1 if its not found
-func stringInSlice(slice []string, value string) int {
-	for i, s := range slice {
-		if s == value {
-			return i
-		}
-	}
-
-	return -1
-}
-
 var runLsblk = func() (out []string, err error) {
 	output, err := runCommandWithStdout(
 		"/bin/lsblk",
@@ -430,8 +234,10 @@
 				continue
 			}
 		*/
+		shortName := string(name[len(name)-1])
 		bd := blockDevice{
 			name:       fields["LABEL"],
+			shortName:  shortName,
 			device:     device,
 			mountpoint: fields["MOUNTPOINT"],
 			parentName: disk,
@@ -443,20 +249,11 @@
 	return partitions, nil
 }
 
-var makeDirectory = func(path string, mode os.FileMode) error {
-	return os.MkdirAll(path, mode)
-}
-
-func (p *Partition) makeMountPoint() (err error) {
-	return makeDirectory(p.MountTarget(), dirMode)
-}
-
 // New creates a new partition type
 func New() *Partition {
 	p := new(Partition)
 
 	p.getPartitionDetails()
-	p.hardwareSpecFile = filepath.Join(p.cacheDir(), hardwareSpecFile)
 
 	return p
 }
@@ -500,7 +297,7 @@
 		}()
 	}
 
-	err = f(p.MountTarget())
+	err = f(mountTarget)
 	return err
 }
 
@@ -529,7 +326,8 @@
 		return err
 	}
 
-	return bootloader.MarkCurrentBootSuccessful()
+	currentRootfs := p.rootPartition().shortName
+	return bootloader.MarkCurrentBootSuccessful(currentRootfs)
 }
 
 // IsNextBootOther return true if the next boot will use the other rootfs
@@ -539,48 +337,27 @@
 	if err != nil {
 		return false
 	}
-	return isNextBootOther(bootloader)
-}
-
-// Returns the full path to the cache directory, which is used as a
-// scratch pad, for downloading new images to and bind mounting the
-// rootfs.
-func (p *Partition) cacheDir() string {
-	return defaultCacheDir
-}
-
-func (p *Partition) hardwareSpec() (hardwareSpecType, error) {
-	h := hardwareSpecType{}
-
-	data, err := ioutil.ReadFile(p.hardwareSpecFile)
-	// if hardware.yaml does not exist it just means that there was no
-	// device part in the update.
-	if os.IsNotExist(err) {
-		return h, ErrNoHardwareYaml
-	} else if err != nil {
-		return h, err
-	}
-
-	if err := yaml.Unmarshal([]byte(data), &h); err != nil {
-		return h, err
-	}
-
-	return h, nil
-}
-
-// Return full path to the main assets directory
-func (p *Partition) assetsDir() string {
-	return filepath.Join(p.cacheDir(), assetsDir)
-}
-
-// Return the full path to the hardware-specific flash assets directory.
-func (p *Partition) flashAssetsDir() string {
-	return filepath.Join(p.cacheDir(), flashAssetsDir)
-}
-
-// MountTarget gets the full path to the mount target directory
-func (p *Partition) MountTarget() string {
-	return filepath.Join(p.cacheDir(), mountTarget)
+
+	value, err := bootloader.GetBootVar(bootloaderBootmodeVar)
+	if err != nil {
+		return false
+	}
+
+	if value != bootloaderBootmodeTry {
+		return false
+	}
+
+	fsname, err := bootloader.GetNextBootRootFSName()
+	if err != nil {
+		return false
+	}
+
+	otherRootfs := p.otherRootPartition().shortName
+	if fsname == otherRootfs {
+		return true
+	}
+
+	return false
 }
 
 func (p *Partition) getPartitionDetails() (err error) {
@@ -676,11 +453,13 @@
 func (p *Partition) mountOtherRootfs(readOnly bool) (err error) {
 	var other *blockDevice
 
-	p.makeMountPoint()
+	if err := os.MkdirAll(mountTarget, dirMode); err != nil {
+		return err
+	}
 
 	other = p.otherRootPartition()
 
-	m := mountEntry{source: other.device, target: p.MountTarget()}
+	m := mountEntry{source: other.device, target: mountTarget}
 
 	if readOnly {
 		m.options = "ro"
@@ -707,9 +486,7 @@
 
 // Ensure the other partition is mounted read-only.
 func (p *Partition) ensureOtherMountedRO() (err error) {
-	mountpoint := p.MountTarget()
-
-	if err = runCommand("/bin/mountpoint", mountpoint); err == nil {
+	if err = runCommand("/bin/mountpoint", mountTarget); err == nil {
 		// already mounted
 		return err
 	}
@@ -741,14 +518,14 @@
 
 		return mountAndAddToGlobalMountList(mountEntry{
 			source: other.device,
-			target: p.MountTarget()})
+			target: mountTarget})
 	}
 	// r/w -> r/o: no fsck required.
-	return mount(other.device, p.MountTarget(), "remount,ro")
+	return mount(other.device, mountTarget, "remount,ro")
 }
 
 func (p *Partition) unmountOtherRootfs() (err error) {
-	return unmountAndRemoveFromGlobalMountList(p.MountTarget())
+	return unmountAndRemoveFromGlobalMountList(mountTarget)
 }
 
 // The bootloader requires a few filesystems to be mounted when
@@ -773,7 +550,7 @@
 	}
 
 	for _, fs := range requiredChrootMounts {
-		target := filepath.Join(p.MountTarget(), fs)
+		target := filepath.Join(mountTarget, fs)
 
 		err := mountAndAddToGlobalMountList(mountEntry{source: fs,
 			target:    target,
@@ -787,11 +564,11 @@
 	// Grub also requires access to both rootfs's when run from
 	// within a chroot (to allow it to create menu entries for
 	// both), so bindmount the real rootfs.
-	targetInChroot := filepath.Join(p.MountTarget(), p.MountTarget())
+	targetInChroot := filepath.Join(mountTarget, mountTarget)
 
 	// FIXME: we should really remove this after the unmount
 
-	if err = makeDirectory(targetInChroot, dirMode); err != nil {
+	if err = os.MkdirAll(targetInChroot, dirMode); err != nil {
 		return err
 	}
 
@@ -822,7 +599,8 @@
 	//      wrong given that handleAssets may fails and we will
 	//      knowingly boot into a broken system
 	err = p.RunWithOther(RW, func(otherRoot string) (err error) {
-		return bootloader.ToggleRootFS()
+		otherRootfs := p.otherRootPartition().shortName
+		return bootloader.ToggleRootFS(otherRootfs)
 	})
 
 	if err != nil {
@@ -831,14 +609,3 @@
 
 	return bootloader.HandleAssets()
 }
-
-// BootloaderDir returns the full path to the (mounted and writable)
-// bootloader-specific boot directory.
-func (p *Partition) BootloaderDir() string {
-	bootloader, err := bootloader(p)
-	if err != nil {
-		return ""
-	}
-
-	return bootloader.BootDir()
-}

=== modified file 'partition/partition_test.go'
--- partition/partition_test.go	2015-06-09 17:43:20 +0000
+++ partition/partition_test.go	2015-06-26 00:24:26 +0000
@@ -44,14 +44,13 @@
 	return err
 }
 
-func mockMakeDirectory(path string, mode os.FileMode) error {
-	return nil
-}
-
 func (s *PartitionTestSuite) SetUpTest(c *C) {
 	s.tempdir = c.MkDir()
 	runLsblk = mockRunLsblkDualSnappy
 
+	// custom mount target
+	mountTarget = c.MkDir()
+
 	// setup fake paths for grub
 	bootloaderGrubDir = filepath.Join(s.tempdir, "boot", "grub")
 	bootloaderGrubConfigFile = filepath.Join(bootloaderGrubDir, "grub.cfg")
@@ -72,8 +71,10 @@
 
 	// always restore what we might have mocked away
 	runCommand = runCommandImpl
-	defaultCacheDir = realDefaultCacheDir
 	bootloader = bootloaderImpl
+	cacheDir = cacheDirReal
+	hardwareSpecFile = hardwareSpecFileReal
+	mountTarget = mountTargetReal
 
 	// grub vars
 	bootloaderGrubConfigFile = bootloaderGrubConfigFileReal
@@ -109,20 +110,6 @@
 	return tmp.Name()
 }
 
-func (s *PartitionTestSuite) TestHardwareSpec(c *C) {
-	p := New()
-	c.Assert(p, NotNil)
-
-	p.hardwareSpecFile = makeHardwareYaml(c, "")
-	hw, err := p.hardwareSpec()
-	c.Assert(err, IsNil)
-	c.Assert(hw.Kernel, Equals, "assets/vmlinuz")
-	c.Assert(hw.Initrd, Equals, "assets/initrd.img")
-	c.Assert(hw.DtbDir, Equals, "assets/dtbs")
-	c.Assert(hw.PartitionLayout, Equals, bootloaderSystemAB)
-	c.Assert(hw.Bootloader, Equals, bootloaderNameUboot)
-}
-
 func mockRunLsblkDualSnappy() (output []string, err error) {
 	dualData := `
 NAME="sda" LABEL="" PKNAME="" MOUNTPOINT=""
@@ -136,46 +123,6 @@
 	return strings.Split(dualData, "\n"), err
 }
 
-func (s *PartitionTestSuite) TestMountEntryArray(c *C) {
-	mea := mountEntryArray{}
-
-	c.Assert(mea.Len(), Equals, 0)
-
-	me := mountEntry{source: "/dev",
-		target:    "/dev",
-		options:   "bind",
-		bindMount: true}
-
-	mea = append(mea, me)
-	c.Assert(mea.Len(), Equals, 1)
-
-	me = mountEntry{source: "/foo",
-		target:    "/foo",
-		options:   "",
-		bindMount: false}
-
-	mea = append(mea, me)
-	c.Assert(mea.Len(), Equals, 2)
-
-	c.Assert(mea.Less(0, 1), Equals, true)
-	c.Assert(mea.Less(1, 0), Equals, false)
-
-	mea.Swap(0, 1)
-	c.Assert(mea.Less(0, 1), Equals, false)
-	c.Assert(mea.Less(1, 0), Equals, true)
-
-	results := removeMountByTarget(mea, "invalid")
-
-	// No change expected
-	c.Assert(results, DeepEquals, mea)
-
-	results = removeMountByTarget(mea, "/dev")
-
-	c.Assert(len(results), Equals, 1)
-	c.Assert(results[0], Equals, mountEntry{source: "/foo",
-		target: "/foo", options: "", bindMount: false})
-}
-
 func (s *PartitionTestSuite) TestSnappyDualRoot(c *C) {
 	p := New()
 	c.Assert(p.dualRootPartitions(), Equals, true)
@@ -218,14 +165,13 @@
 		return nil
 	})
 	c.Assert(err, IsNil)
-	c.Assert(reportedRoot, Equals, (&Partition{}).MountTarget())
+	c.Assert(reportedRoot, Equals, mountTarget)
 }
 
 func (s *PartitionTestSuite) TestRunWithOtherDualParitionRWFuncErr(c *C) {
 	c.Assert(mounts, DeepEquals, mountEntryArray(nil))
 
 	runCommand = mockRunCommand
-	makeDirectory = mockMakeDirectory
 
 	p := New()
 	err := p.RunWithOther(RW, func(otherRoot string) (err error) {
@@ -239,8 +185,12 @@
 	// ensure cleanup happend
 
 	// FIXME: mounts are global
-	expected := mountEntry{source: "/dev/sda4",
-		target: "/writable/cache/system", options: "", bindMount: false}
+	expected := mountEntry{
+		source:    "/dev/sda4",
+		target:    mountTarget,
+		options:   "",
+		bindMount: false,
+	}
 
 	// At program exit, "other" should still be mounted
 	c.Assert(mounts, DeepEquals, mountEntryArray{expected})
@@ -295,8 +245,12 @@
 	c.Assert(p, NotNil)
 
 	p.mountOtherRootfs(false)
-	expected := mountEntry{source: "/dev/sda4",
-		target: "/writable/cache/system", options: "", bindMount: false}
+	expected := mountEntry{
+		source:    "/dev/sda4",
+		target:    mountTarget,
+		options:   "",
+		bindMount: false,
+	}
 
 	c.Assert(mounts, DeepEquals, mountEntryArray{expected})
 
@@ -313,26 +267,26 @@
 
 	p.bindmountRequiredFilesystems()
 	c.Assert(mounts, DeepEquals, mountEntryArray{
-		mountEntry{source: "/dev", target: p.MountTarget() + "/dev",
-			options: "bind", bindMount: true},
-
-		mountEntry{source: "/proc", target: p.MountTarget() + "/proc",
-			options: "bind", bindMount: true},
-
-		mountEntry{source: "/sys", target: p.MountTarget() + "/sys",
-			options: "bind", bindMount: true},
-		mountEntry{source: "/boot/efi", target: p.MountTarget() + "/boot/efi",
+		mountEntry{source: "/dev", target: mountTarget + "/dev",
+			options: "bind", bindMount: true},
+
+		mountEntry{source: "/proc", target: mountTarget + "/proc",
+			options: "bind", bindMount: true},
+
+		mountEntry{source: "/sys", target: mountTarget + "/sys",
+			options: "bind", bindMount: true},
+		mountEntry{source: "/boot/efi", target: mountTarget + "/boot/efi",
 			options: "bind", bindMount: true},
 
 		// this comes from the grub bootloader via AdditionalBindMounts
-		mountEntry{source: "/boot/grub", target: p.MountTarget() + "/boot/grub",
+		mountEntry{source: "/boot/grub", target: mountTarget + "/boot/grub",
 			options: "bind", bindMount: true},
 
 		// Required to allow grub inside the chroot to access
 		// the "current" rootfs outside the chroot (used
 		// to generate the grub menuitems).
 		mountEntry{source: "/",
-			target:  p.MountTarget() + p.MountTarget(),
+			target:  mountTarget + mountTarget,
 			options: "bind,ro", bindMount: true},
 	})
 	p.unmountRequiredFilesystems()
@@ -351,23 +305,23 @@
 	p.bindmountRequiredFilesystems()
 	c.Assert(mounts, DeepEquals, mountEntryArray{
 
-		mountEntry{source: "/dev/sda4", target: "/writable/cache/system",
+		mountEntry{source: "/dev/sda4", target: mountTarget,
 			options: "", bindMount: false},
 
-		mountEntry{source: "/dev", target: p.MountTarget() + "/dev",
-			options: "bind", bindMount: true},
-
-		mountEntry{source: "/proc", target: p.MountTarget() + "/proc",
-			options: "bind", bindMount: true},
-
-		mountEntry{source: "/sys", target: p.MountTarget() + "/sys",
-			options: "bind", bindMount: true},
-
-		mountEntry{source: "/boot/efi", target: p.MountTarget() + "/boot/efi",
+		mountEntry{source: "/dev", target: mountTarget + "/dev",
+			options: "bind", bindMount: true},
+
+		mountEntry{source: "/proc", target: mountTarget + "/proc",
+			options: "bind", bindMount: true},
+
+		mountEntry{source: "/sys", target: mountTarget + "/sys",
+			options: "bind", bindMount: true},
+
+		mountEntry{source: "/boot/efi", target: mountTarget + "/boot/efi",
 			options: "bind", bindMount: true},
 
 		mountEntry{source: "/",
-			target:  p.MountTarget() + p.MountTarget(),
+			target:  mountTarget + mountTarget,
 			options: "bind,ro", bindMount: true},
 	})
 
@@ -375,8 +329,12 @@
 	undoMounts(true)
 
 	c.Assert(mounts, DeepEquals, mountEntryArray{
-		mountEntry{source: "/dev/sda4", target: "/writable/cache/system",
-			options: "", bindMount: false},
+		mountEntry{
+			source:    "/dev/sda4",
+			target:    mountTarget,
+			options:   "",
+			bindMount: false,
+		},
 	})
 
 	// should unmount everything
@@ -421,7 +379,7 @@
 func (b *mockBootloader) Name() bootloaderName {
 	return "mocky"
 }
-func (b *mockBootloader) ToggleRootFS() error {
+func (b *mockBootloader) ToggleRootFS(otherRootfs string) error {
 	b.ToggleRootFSCalled = true
 	return nil
 }
@@ -436,16 +394,10 @@
 func (b *mockBootloader) GetBootVar(name string) (string, error) {
 	return "", nil
 }
-func (b *mockBootloader) GetRootFSName() string {
-	return ""
-}
-func (b *mockBootloader) GetOtherRootFSName() string {
-	return ""
-}
 func (b *mockBootloader) GetNextBootRootFSName() (string, error) {
 	return "", nil
 }
-func (b *mockBootloader) MarkCurrentBootSuccessful() error {
+func (b *mockBootloader) MarkCurrentBootSuccessful(currentRootfs string) error {
 	b.MarkCurrentBootSuccessfulCalled = true
 	return nil
 }

=== modified file 'partition/utils.go'
--- partition/utils.go	2015-05-19 14:09:19 +0000
+++ partition/utils.go	2015-06-26 00:24:26 +0000
@@ -69,3 +69,22 @@
 
 // This is a var instead of a function to making mocking in the tests easier
 var runCommandWithStdout = runCommandWithStdoutImpl
+
+// Run fsck(8) on specified device.
+func fsck(device string) (err error) {
+	return runCommand(
+		"/sbin/fsck",
+		"-M", // Paranoia - don't fsck if already mounted
+		"-av", device)
+}
+
+// Returns the position of the string in the given slice or -1 if its not found
+func stringInSlice(slice []string, value string) int {
+	for i, s := range slice {
+		if s == value {
+			return i
+		}
+	}
+
+	return -1
+}

=== modified file 'snappy/errors.go'
--- snappy/errors.go	2015-06-04 22:21:51 +0000
+++ snappy/errors.go	2015-06-26 00:24:26 +0000
@@ -140,6 +140,8 @@
 
 	// ErrInvalidSeccompPolicy is returned when policy-version and policy-vender are not set together
 	ErrInvalidSeccompPolicy = errors.New("policy-version and policy-vendor must be specified together")
+	// ErrNoSeccompPolicy is returned when an expected seccomp policy is not provided.
+	ErrNoSeccompPolicy = errors.New("no seccomp policy provided")
 )
 
 // ErrArchitectureNotSupported is returned when trying to install a snappy package that

=== modified file 'snappy/install.go'
--- snappy/install.go	2015-06-11 06:33:42 +0000
+++ snappy/install.go	2015-06-26 00:24:26 +0000
@@ -25,6 +25,7 @@
 	"sort"
 
 	"launchpad.net/snappy/logger"
+	"launchpad.net/snappy/partition"
 	"launchpad.net/snappy/progress"
 	"launchpad.net/snappy/provisioning"
 )
@@ -96,8 +97,7 @@
 		// FIXME: this is terrible, we really need a single
 		//        bootloader dir like /boot or /boot/loader
 		//        instead of having to query the partition code
-		p := newPartition()
-		if provisioning.InDeveloperMode(p.BootloaderDir()) {
+		if provisioning.InDeveloperMode(partition.BootloaderDir()) {
 			flags |= AllowUnauthenticated
 		}
 

=== modified file 'snappy/security.go'
--- snappy/security.go	2015-06-02 16:31:01 +0000
+++ snappy/security.go	2015-06-26 00:24:26 +0000
@@ -151,6 +151,11 @@
 	syscalls := []string{}
 
 	if sd.SecurityOverride != nil {
+		if sd.SecurityOverride.Seccomp == "" {
+			logger.Noticef("No seccomp policy found")
+			return nil, ErrNoSeccompPolicy
+		}
+
 		fn := filepath.Join(baseDir, sd.SecurityOverride.Seccomp)
 		var s securitySeccompOverride
 		err := readSeccompOverride(fn, &s)

=== modified file 'snappy/security_test.go'
--- snappy/security_test.go	2015-06-08 16:26:25 +0000
+++ snappy/security_test.go	2015-06-26 00:24:26 +0000
@@ -58,6 +58,13 @@
 	c.Assert(string(content), Equals, expected)
 }
 
+func (a *SecurityTestSuite) TestSnappyNoSeccompOverrideEntry(c *C) {
+	sd := SecurityDefinitions{SecurityOverride: &SecurityOverrideDefinition{}}
+
+	_, err := generateSeccompPolicy(c.MkDir(), "appName", sd)
+	c.Assert(err, Equals, ErrNoSeccompPolicy)
+}
+
 // no special security settings generate the default
 func (a *SecurityTestSuite) TestSnappyHandleApparmorSecurityDefault(c *C) {
 	sec := &SecurityDefinitions{}

=== modified file 'snappy/systemimage.go'
--- snappy/systemimage.go	2015-06-10 13:38:01 +0000
+++ snappy/systemimage.go	2015-06-26 00:24:26 +0000
@@ -169,9 +169,16 @@
 	return s.partition.ToggleNextBoot()
 }
 
+// override in tests
+var bootloaderDir = bootloaderDirImpl
+
+func bootloaderDirImpl() string {
+	return partition.BootloaderDir()
+}
+
 // Install installs the snap
 func (s *SystemImagePart) Install(pb progress.Meter, flags InstallFlags) (name string, err error) {
-	if provisioning.IsSideLoaded(s.partition.BootloaderDir()) {
+	if provisioning.IsSideLoaded(bootloaderDir()) {
 		return "", ErrSideLoaded
 	}
 

=== modified file 'snappy/systemimage_test.go'
--- snappy/systemimage_test.go	2015-06-09 17:43:20 +0000
+++ snappy/systemimage_test.go	2015-06-26 00:24:26 +0000
@@ -28,7 +28,7 @@
 	"strings"
 	"testing"
 
-	partition "launchpad.net/snappy/partition"
+	"launchpad.net/snappy/partition"
 	"launchpad.net/snappy/provisioning"
 
 	. "gopkg.in/check.v1"
@@ -72,6 +72,7 @@
 func (s *SITestSuite) TearDownTest(c *C) {
 	s.mockSystemImageWebServer.Close()
 	systemImageRoot = "/"
+	bootloaderDir = bootloaderDirImpl
 }
 
 func makeMockSystemImageCli(c *C, tempdir string) string {
@@ -390,18 +391,16 @@
   device-part: /some/path/file.tgz
   developer-mode: true
 `
-	tempBootDir, err = ioutil.TempDir("", "")
-	c.Assert(err, IsNil)
-
+	tempBootDir := c.MkDir()
 	parts, err := s.systemImage.Updates()
 
 	sp := parts[0].(*SystemImagePart)
 	mockPartition := MockPartition{}
 	sp.partition = &mockPartition
 
-	bootDir := sp.partition.BootloaderDir()
+	bootloaderDir = func() string { return tempBootDir }
 
-	sideLoaded := filepath.Join(bootDir, provisioning.InstallYamlFile)
+	sideLoaded := filepath.Join(tempBootDir, provisioning.InstallYamlFile)
 
 	err = os.MkdirAll(filepath.Dir(sideLoaded), 0775)
 	c.Assert(err, IsNil)
@@ -414,7 +413,4 @@
 	// Ensure the install fails if the system is sideloaded
 	_, err = sp.Install(pb, 0)
 	c.Assert(err, Equals, ErrSideLoaded)
-
-	os.Remove(tempBootDir)
-	tempBootDir = ""
 }