Merge lp:~mvo/snappy/snappy-all-snap2 into lp:~snappy-dev/snappy/snappy-moved-to-github

[Michael Vogt]

This moves the os/kernel into snaps.

[lp:~mvo/snappy/snappy-all-snap2]

667. By Michael Vogt on 2015-09-02

fix activate in the kernel

668. By Michael Vogt on 2015-09-03

re-add utils.go

Unmerged revisions

668. By Michael Vogt on 2015-09-03

re-add utils.go

667. By Michael Vogt on 2015-09-02

fix activate in the kernel

666. By Michael Vogt on 2015-09-02

add {Oem,OsKernel}Snap types

665. By Michael Vogt on 2015-09-02

re-add test hook function

664. By Michael Vogt on 2015-09-02

rename partition to bootloader

663. By Michael Vogt on 2015-09-02

add tests for the new code

662. By Michael Vogt on 2015-09-02

rename PartitionTestSuite->BootloaderTestSuite

661. By Michael Vogt on 2015-09-02

unset snappy_trial_boot

660. By Michael Vogt on 2015-09-02

move partition.go bits into bootloader as we do not care about partitioning at this level anymore

659. By Michael Vogt on 2015-09-01

kill partition.IsNextBootOther

=== renamed directory 'partition' => 'bootloader'
=== modified file 'bootloader/bootloader.go'
--- partition/bootloader.go	2015-07-16 11:07:30 +0000
+++ bootloader/bootloader.go	2015-09-03 08:14:56 +0000
@@ -17,70 +17,40 @@
  *
  */
 
-package partition
+package bootloader
 
 import (
-	"fmt"
-	"os"
-	"path/filepath"
+	"errors"
+	"strings"
+)
 
-	"launchpad.net/snappy/helpers"
+var (
+	// ErrBootloader is returned if the bootloader can not be determined
+	ErrBootloader = errors.New("Unable to determine bootloader")
 )
 
 const (
-	// bootloader variable used to denote which rootfs to boot from
-	bootloaderRootfsVar = "snappy_ab"
-
 	// bootloader variable used to determine if boot was successful.
 	// Set to value of either bootloaderBootmodeTry (when attempting
 	// to boot a new rootfs) or bootloaderBootmodeSuccess (to denote
 	// that the boot of the new rootfs was successful).
 	bootloaderBootmodeVar = "snappy_mode"
 
-	bootloaderTrialBootVar = "snappy_trial_boot"
-
 	// Initial and final values
 	bootloaderBootmodeTry     = "try"
 	bootloaderBootmodeSuccess = "regular"
 
-	// textual description in hardware.yaml for AB systems
-	bootloaderSystemAB = "system-AB"
+	// set by the bootloader itself to "1" and it will be cleared
+	// as the last action of the boot
+	bootloaderTrialBootVar = "snappy_trial_boot"
 )
 
-type bootloaderName string
-
 type bootLoader interface {
-	// Name of the bootloader
-	Name() bootloaderName
-
-	// Switch bootloader configuration so that the "other" root
-	// filesystem partition will be used on next boot.
-	ToggleRootFS(otherRootfs string) error
-
-	// Hook function called before system-image starts downloading
-	// and applying archives that allows files to be copied between
-	// partitions.
-	SyncBootFiles(bootAssets map[string]string) error
-
-	// Install any hardware-specific files that system-image
-	// downloaded.
-	HandleAssets() error
-
 	// Return the value of the specified bootloader variable
 	GetBootVar(name string) (string, error)
 
-	// Return the 1-character name corresponding to the
-	// rootfs that will be used on _next_ boot.
-	//
-	// XXX: Note the distinction between this method and
-	// GetOtherRootFSName(): the latter corresponds to the other
-	// partition, whereas the value returned by this method is
-	// queried directly from the bootloader.
-	GetNextBootRootFSName() (string, error)
-
-	// Update the bootloader configuration to mark the
-	// currently-booted rootfs as having booted successfully.
-	MarkCurrentBootSuccessful(currentRootfs string) error
+	// Set the value of the specified bootloader variable
+	SetBootVar(key, value string) error
 
 	// BootDir returns the (writable) bootloader-specific boot
 	// directory.
@@ -88,16 +58,16 @@
 }
 
 // Factory method that returns a new bootloader for the given partition
-var bootloader = bootloaderImpl
+var new = bootloaderImpl
 
-func bootloaderImpl(p *Partition) (bootLoader, error) {
+func bootloaderImpl() (bootLoader, error) {
 	// try uboot
-	if uboot := newUboot(p); uboot != nil {
+	if uboot := newUboot(); uboot != nil {
 		return uboot, nil
 	}
 
 	// no, try grub
-	if grub := newGrub(p); grub != nil {
+	if grub := newGrub(); grub != nil {
 		return grub, nil
 	}
 
@@ -105,196 +75,62 @@
 	return nil, ErrBootloader
 }
 
-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
-
-	// full path to rootfs-specific assets on boot partition
-	currentBootPath string
-	otherBootPath   string
-
-	// FIXME: this should /boot if possible
-	// the dir that the bootloader lives in (e.g. /boot/uboot)
-	bootloaderDir string
-}
-
-func newBootLoader(partition *Partition, bootloaderDir string) *bootloaderType {
-	// 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
-	}
-
-	// full label of the system {system-a,system-b}
-	currentLabel := partition.rootPartition().name
-	otherLabel := partition.otherRootPartition().name
-
-	// single letter description of the rootfs {a,b}
-	currentRootfs := string(currentLabel[len(currentLabel)-1])
-	otherRootfs := string(otherLabel[len(otherLabel)-1])
-
-	return &bootloaderType{
-		partition: partition,
-
-		currentRootfs: currentRootfs,
-		otherRootfs:   otherRootfs,
-
-		// the paths that the kernel/initramfs are loaded, e.g.
-		// /boot/uboot/a
-		currentBootPath: filepath.Join(bootloaderDir, currentRootfs),
-		otherBootPath:   filepath.Join(bootloaderDir, otherRootfs),
-
-		// the base bootloader dir, e.g. /boot/uboot or /boot/grub
-		bootloaderDir: bootloaderDir,
-	}
-}
-
-// FIXME:
-// - populate kernel if missing
-func (b *bootloaderType) SyncBootFiles(bootAssets map[string]string) (err error) {
-	for src, dst := range bootAssets {
-		if err := helpers.CopyIfDifferent(src, filepath.Join(b.bootloaderDir, dst)); err != nil {
-			return err
-		}
-	}
-
-	srcDir := b.currentBootPath
-	destDir := b.otherBootPath
-
-	// ensure they exist
-	for _, dir := range []string{srcDir, destDir} {
-		if err := os.MkdirAll(dir, 0755); err != nil {
-			return err
-		}
-
-	}
-	return helpers.RSyncWithDelete(srcDir, destDir)
-}
-
-// FIXME:
-// - if this fails it will never be re-tried because the "other" patition
-//   is updated to revision-N in /etc/system-image/channel.ini
-//   so the system only downloads from revision-N onwards even though the
-//   complete update was not applied (i.e. kernel missing)
-func (b *bootloaderType) HandleAssets() (err error) {
-	// check if we have anything, if there is no hardware yaml, there is nothing
-	// to process.
-	hardware, err := readHardwareSpec()
-	if err == ErrNoHardwareYaml {
-		return nil
-	} else if err != nil {
-		return err
-	}
-	// ensure to remove the file if there are no errors
-	defer func() {
-		if err == nil {
-			os.Remove(hardwareSpecFile)
-		}
-	}()
-
-	/*
-		// validate bootloader
-		if hardware.Bootloader != b.Name() {
-			return fmt.Errorf(
-				"bootloader is of type %s but hardware spec requires %s",
-				b.Name(),
-				hardware.Bootloader)
-		}
-	*/
-
-	// validate partition layout
-	if b.partition.dualRootPartitions() && hardware.PartitionLayout != bootloaderSystemAB {
-		return fmt.Errorf("hardware spec requires dual root partitions")
-	}
-
-	// ensure we have the destdir
-	destDir := b.otherBootPath
-	if err := os.MkdirAll(destDir, dirMode); err != nil {
-		return err
-	}
-
-	// install kernel+initrd
-	for _, file := range []string{hardware.Kernel, hardware.Initrd} {
-
-		if file == "" {
-			continue
-		}
-
-		// expand path
-		path := filepath.Join(cacheDir, file)
-
-		if !helpers.FileExists(path) {
-			return fmt.Errorf("can not find file %s", path)
-		}
-
-		// ensure we remove the dir later
-		defer func() {
-			if err == nil {
-				os.RemoveAll(filepath.Dir(path))
-			}
-		}()
-
-		if err := runCommand("/bin/cp", path, destDir); err != nil {
-			return err
-		}
-	}
-
-	// TODO: look at the OEM package for dtb changes too once that is
-	//       fully speced
-
-	// install .dtb files
-	dtbSrcDir := filepath.Join(cacheDir, hardware.DtbDir)
-	// ensure there is a DtbDir specified
-	if hardware.DtbDir != "" && helpers.FileExists(dtbSrcDir) {
-		// ensure we cleanup the source dir
-		defer func() {
-			if err == nil {
-				os.RemoveAll(dtbSrcDir)
-			}
-		}()
-
-		dtbDestDir := filepath.Join(destDir, "dtbs")
-		if err := os.MkdirAll(dtbDestDir, dirMode); err != nil {
-			return err
-		}
-
-		files, err := filepath.Glob(filepath.Join(dtbSrcDir, "*"))
+// MarkBootSuccessful marks the boot as successful
+func MarkBootSuccessful() (err error) {
+	bootloader, err := new()
+	if err != nil {
+		return err
+	}
+
+	// FIXME: these vars should be applied all in a single run
+	for _, k := range []string{"snappy_os", "snappy_kernel"} {
+		value, err := bootloader.GetBootVar(k)
 		if err != nil {
 			return err
 		}
 
-		for _, file := range files {
-			if err := runCommand("/bin/cp", file, dtbDestDir); err != nil {
-				return err
-			}
-		}
-	}
-
-	if helpers.FileExists(flashAssetsDir) {
-		// FIXME: we don't currently do anything with the
-		// MLO + uImage files since they are not specified in
-		// the hardware spec. So for now, just remove them.
-
-		if err := os.RemoveAll(flashAssetsDir); err != nil {
+		// FIXME: a bit ugly
+		newKey := strings.Replace(k, "snappy_", "snappy_good_", -1)
+		if err := bootloader.SetBootVar(newKey, value); err != nil {
 			return err
 		}
-	}
-
-	return err
+
+	}
+
+	if err := bootloader.SetBootVar("snappy_mode", "regular"); err != nil {
+		return err
+	}
+
+	return bootloader.SetBootVar("snappy_trial_boot", "0")
 }
 
-// BootloaderDir returns the full path to the (mounted and writable)
+// Dir returns the full path to the (mounted and writable)
 // bootloader-specific boot directory.
-func BootloaderDir() string {
-	if helpers.FileExists(bootloaderUbootDir) {
-		return bootloaderUbootDir
-	} else if helpers.FileExists(bootloaderGrubDir) {
-		return bootloaderGrubDir
-	}
-
-	return ""
+func Dir() string {
+	bootloader, err := new()
+	if err != nil {
+		return ""
+	}
+
+	return bootloader.BootDir()
+}
+
+// SetBootVar sets a boot variable
+func SetBootVar(key, value string) error {
+	bootloader, err := new()
+	if err != nil {
+		return err
+	}
+
+	return bootloader.SetBootVar(key, value)
+}
+
+// GetBootVar sets a boot variable
+func GetBootVar(key string) (string, error) {
+	bootloader, err := new()
+	if err != nil {
+		return "", err
+	}
+
+	return bootloader.GetBootVar(key)
 }
 
=== modified file 'bootloader/bootloader_grub.go'
--- partition/bootloader_grub.go	2015-07-23 11:54:14 +0000
+++ bootloader/bootloader_grub.go	2015-09-03 08:14:56 +0000
@@ -17,7 +17,7 @@
  *
  */
 
-package partition
+package bootloader
 
 import (
 	"fmt"
@@ -45,45 +45,15 @@
 )
 
 type grub struct {
-	bootloaderType
 }
 
-const bootloaderNameGrub bootloaderName = "grub"
-
 // newGrub create a new Grub bootloader object
-func newGrub(partition *Partition) bootLoader {
+func newGrub() bootLoader {
 	if !helpers.FileExists(bootloaderGrubConfigFile) {
 		return nil
 	}
 
-	b := newBootLoader(partition, bootloaderGrubDir)
-	if b == nil {
-		return nil
-	}
-	g := grub{bootloaderType: *b}
-
-	return &g
-}
-
-func (g *grub) Name() bootloaderName {
-	return bootloaderNameGrub
-}
-
-// ToggleRootFS make the Grub bootloader switch rootfs's.
-//
-// Approach:
-//
-// Update the grub configuration.
-func (g *grub) ToggleRootFS(otherRootfs string) (err error) {
-
-	if err := g.setBootVar(bootloaderBootmodeVar, bootloaderBootmodeTry); err != nil {
-		return err
-	}
-
-	// 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, otherRootfs)
+	return &grub{}
 }
 
 func (g *grub) GetBootVar(name string) (value string, err error) {
@@ -103,7 +73,7 @@
 	return cfg.Get("", name)
 }
 
-func (g *grub) setBootVar(name, value string) (err error) {
+func (g *grub) SetBootVar(name, value string) (err error) {
 	// note that strings are not quoted since because
 	// RunCommand() does not use a shell and thus adding quotes
 	// stores them in the environment file (which is not desirable)
@@ -111,23 +81,6 @@
 	return runCommand(bootloaderGrubEnvCmd, bootloaderGrubEnvFile, "set", arg)
 }
 
-func (g *grub) GetNextBootRootFSName() (label string, err error) {
-	return g.GetBootVar(bootloaderRootfsVar)
-}
-
-func (g *grub) MarkCurrentBootSuccessful(currentRootfs string) (err error) {
-	// Clear the variable set on boot to denote a good boot.
-	if err := g.setBootVar(bootloaderTrialBootVar, "0"); err != nil {
-		return err
-	}
-
-	if err := g.setBootVar(bootloaderRootfsVar, currentRootfs); err != nil {
-		return err
-	}
-
-	return g.setBootVar(bootloaderBootmodeVar, bootloaderBootmodeSuccess)
-}
-
 func (g *grub) BootDir() string {
 	return bootloaderGrubDir
 }
 
=== modified file 'bootloader/bootloader_grub_test.go'
--- partition/bootloader_grub_test.go	2015-07-23 11:54:14 +0000
+++ bootloader/bootloader_grub_test.go	2015-09-03 08:14:56 +0000
@@ -17,15 +17,13 @@
  *
  */
 
-package partition
+package bootloader
 
 import (
 	"fmt"
 	"io/ioutil"
 	"os"
-	"path/filepath"
-
-	"launchpad.net/snappy/helpers"
+	"strings"
 
 	. "gopkg.in/check.v1"
 )
@@ -35,7 +33,21 @@
 	c.Assert(err, IsNil)
 }
 
-func (s *PartitionTestSuite) makeFakeGrubEnv(c *C) {
+type singleCommand []string
+
+var allCommands = []singleCommand{}
+
+func mockRunCommandWithCapture(args ...string) (err error) {
+	allCommands = append(allCommands, args)
+	return nil
+}
+
+func mockGrubEditenvList(cmd ...string) (string, error) {
+	mockGrubEditenvOutput := fmt.Sprintf("%s=regular", bootloaderBootmodeVar)
+	return mockGrubEditenvOutput, nil
+}
+
+func (s *BootloaderTestSuite) makeFakeGrubEnv(c *C) {
 	// create bootloader
 	err := os.MkdirAll(bootloaderGrubDir, 0755)
 	c.Assert(err, IsNil)
@@ -48,135 +60,48 @@
 	runCommand = mockRunCommandWithCapture
 }
 
-func (s *PartitionTestSuite) TestNewGrubNoGrubReturnsNil(c *C) {
+func (s *BootloaderTestSuite) TestNewGrubNoGrubReturnsNil(c *C) {
 	bootloaderGrubConfigFile = "no-such-dir"
 
-	partition := New()
-	g := newGrub(partition)
+	g := newGrub()
 	c.Assert(g, IsNil)
 }
 
-func (s *PartitionTestSuite) TestNewGrub(c *C) {
-	s.makeFakeGrubEnv(c)
-
-	partition := New()
-	g := newGrub(partition)
-	c.Assert(g, NotNil)
-	c.Assert(g.Name(), Equals, bootloaderNameGrub)
-}
-
-type singleCommand []string
-
-var allCommands = []singleCommand{}
-
-func mockRunCommandWithCapture(args ...string) (err error) {
-	allCommands = append(allCommands, args)
-	return nil
-}
-
-func (s *PartitionTestSuite) TestToggleRootFS(c *C) {
-	s.makeFakeGrubEnv(c)
-	allCommands = []singleCommand{}
-
-	partition := New()
-	g := newGrub(partition)
-	c.Assert(g, NotNil)
-	err := g.ToggleRootFS("b")
-	c.Assert(err, IsNil)
-
-	// this is always called
-	mp := singleCommand{"/bin/mountpoint", mountTarget}
-	c.Assert(allCommands[0], DeepEquals, mp)
-
-	expectedGrubSet := singleCommand{bootloaderGrubEnvCmd, bootloaderGrubEnvFile, "set", "snappy_mode=try"}
-	c.Assert(allCommands[1], DeepEquals, expectedGrubSet)
-
-	// the https://developer.ubuntu.com/en/snappy/porting guide says
-	// we always use the short names
-	expectedGrubSet = singleCommand{bootloaderGrubEnvCmd, bootloaderGrubEnvFile, "set", "snappy_ab=b"}
-	c.Assert(allCommands[2], DeepEquals, expectedGrubSet)
-
-	c.Assert(len(allCommands), Equals, 3)
-}
-
-func mockGrubEditenvList(cmd ...string) (string, error) {
-	mockGrubEditenvOutput := fmt.Sprintf("%s=regular", bootloaderBootmodeVar)
-	return mockGrubEditenvOutput, nil
-}
-
-func (s *PartitionTestSuite) TestGetBootVer(c *C) {
+func (s *BootloaderTestSuite) TestNewGrub(c *C) {
+	s.makeFakeGrubEnv(c)
+
+	g := newGrub()
+	c.Assert(g, NotNil)
+}
+
+func (s *BootloaderTestSuite) TestGetBootVer(c *C) {
 	s.makeFakeGrubEnv(c)
 	runCommandWithStdout = mockGrubEditenvList
 
-	partition := New()
-	g := newGrub(partition)
+	g := newGrub()
 
 	v, err := g.GetBootVar(bootloaderBootmodeVar)
 	c.Assert(err, IsNil)
 	c.Assert(v, Equals, "regular")
 }
 
-func (s *PartitionTestSuite) TestGetBootloaderWithGrub(c *C) {
-	s.makeFakeGrubEnv(c)
-	p := New()
-	bootloader, err := bootloader(p)
-	c.Assert(err, IsNil)
-	c.Assert(bootloader.Name(), Equals, bootloaderNameGrub)
-}
-
-func (s *PartitionTestSuite) TestGrubMarkCurrentBootSuccessful(c *C) {
-	s.makeFakeGrubEnv(c)
-	allCommands = []singleCommand{}
-
-	partition := New()
-	g := newGrub(partition)
-	c.Assert(g, NotNil)
-	err := g.MarkCurrentBootSuccessful("a")
-	c.Assert(err, IsNil)
-
-	// this is always called
-	mp := singleCommand{"/bin/mountpoint", mountTarget}
-	c.Assert(allCommands[0], DeepEquals, mp)
-
-	expectedGrubSet := singleCommand{bootloaderGrubEnvCmd, bootloaderGrubEnvFile, "set", "snappy_trial_boot=0"}
-
-	c.Assert(allCommands[1], DeepEquals, expectedGrubSet)
-
-	expectedGrubSet2 := singleCommand{bootloaderGrubEnvCmd, bootloaderGrubEnvFile, "set", "snappy_ab=a"}
-
-	c.Assert(allCommands[2], DeepEquals, expectedGrubSet2)
-
-	expectedGrubSet3 := singleCommand{bootloaderGrubEnvCmd, bootloaderGrubEnvFile, "set", "snappy_mode=regular"}
-
-	c.Assert(allCommands[3], DeepEquals, expectedGrubSet3)
-
-}
-
-func (s *PartitionTestSuite) TestSyncBootFilesWithAssets(c *C) {
-	err := os.MkdirAll(bootloaderGrubDir, 0755)
-	c.Assert(err, IsNil)
-
-	runCommand = mockRunCommand
-	b := grub{
-		bootloaderType{
-			currentBootPath: c.MkDir(),
-			otherBootPath:   c.MkDir(),
-			bootloaderDir:   c.MkDir(),
-		},
-	}
-
-	bootfile := filepath.Join(c.MkDir(), "bootfile")
-	err = ioutil.WriteFile(bootfile, []byte(bootfile), 0644)
-	c.Assert(err, IsNil)
-
-	bootassets := map[string]string{
-		bootfile: filepath.Base(bootfile),
-	}
-
-	err = b.SyncBootFiles(bootassets)
-	c.Assert(err, IsNil)
-
-	dst := filepath.Join(b.bootloaderDir, bootassets[bootfile])
-	c.Check(helpers.FileExists(dst), Equals, true)
-	c.Check(helpers.FilesAreEqual(bootfile, dst), Equals, true)
+func (s *BootloaderTestSuite) TestSetBootVer(c *C) {
+	s.makeFakeGrubEnv(c)
+	runCommandWithStdout = mockGrubEditenvList
+
+	g := newGrub()
+
+	err := g.SetBootVar("snappy_os", "123")
+	c.Assert(err, IsNil)
+
+	expectedGrubSet := singleCommand{bootloaderGrubEnvCmd, bootloaderGrubEnvFile, "set", "snappy_os=123"}
+	c.Assert(allCommands[0], DeepEquals, expectedGrubSet)
+	c.Assert(allCommands, HasLen, 1)
+}
+
+func (s *BootloaderTestSuite) TestGrubBootdir(c *C) {
+	s.makeFakeGrubEnv(c)
+
+	g := newGrub()
+	c.Assert(strings.HasSuffix(g.BootDir(), "/boot/grub"), Equals, true)
 }
 
=== renamed file 'partition/partition_test.go' => 'bootloader/bootloader_test.go'
--- partition/partition_test.go	2015-07-16 11:07:30 +0000
+++ bootloader/bootloader_test.go	2015-09-03 08:14:56 +0000
@@ -17,14 +17,11 @@
  *
  */
 
-package partition
+package bootloader
 
 import (
-	"errors"
-	"io/ioutil"
 	"os"
 	"path/filepath"
-	"strings"
 	"testing"
 
 	. "gopkg.in/check.v1"
@@ -34,22 +31,14 @@
 func Test(t *testing.T) { TestingT(t) }
 
 // partition specific testsuite
-type PartitionTestSuite struct {
+type BootloaderTestSuite struct {
 	tempdir string
 }
 
-var _ = Suite(&PartitionTestSuite{})
-
-func mockRunCommand(args ...string) (err error) {
-	return err
-}
-
-func (s *PartitionTestSuite) SetUpTest(c *C) {
+var _ = Suite(&BootloaderTestSuite{})
+
+func (s *BootloaderTestSuite) 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")
@@ -58,23 +47,15 @@
 
 	// and uboot
 	bootloaderUbootDir = filepath.Join(s.tempdir, "boot", "uboot")
-	bootloaderUbootConfigFile = filepath.Join(bootloaderUbootDir, "uEnv.txt")
-	bootloaderUbootEnvFile = filepath.Join(bootloaderUbootDir, "uEnv.txt")
 	bootloaderUbootFwEnvFile = filepath.Join(bootloaderUbootDir, "uboot.env")
-	bootloaderUbootStampFile = filepath.Join(bootloaderUbootDir, "snappy-stamp.txt")
-
-	c.Assert(mounts, DeepEquals, mountEntryArray(nil))
 }
 
-func (s *PartitionTestSuite) TearDownTest(c *C) {
+func (s *BootloaderTestSuite) TearDownTest(c *C) {
 	os.RemoveAll(s.tempdir)
 
 	// always restore what we might have mocked away
 	runCommand = runCommandImpl
-	bootloader = bootloaderImpl
-	cacheDir = cacheDirReal
-	hardwareSpecFile = hardwareSpecFileReal
-	mountTarget = mountTargetReal
+	new = bootloaderImpl
 
 	// grub vars
 	bootloaderGrubConfigFile = bootloaderGrubConfigFileReal
@@ -82,369 +63,101 @@
 
 	// uboot vars
 	bootloaderUbootDir = bootloaderUbootDirReal
-	bootloaderUbootConfigFile = bootloaderUbootConfigFileReal
-	bootloaderUbootEnvFile = bootloaderUbootEnvFileReal
-	bootloaderUbootStampFile = bootloaderUbootStampFileReal
-
-	c.Assert(mounts, DeepEquals, mountEntryArray(nil))
-}
-
-func makeHardwareYaml(c *C, hardwareYaml string) (outPath string) {
-	tmp, err := ioutil.TempFile(c.MkDir(), "hw-")
-	c.Assert(err, IsNil)
-	defer tmp.Close()
-
-	if hardwareYaml == "" {
-		hardwareYaml = `
-kernel: assets/vmlinuz
-initrd: assets/initrd.img
-dtbs: assets/dtbs
-partition-layout: system-AB
-bootloader: u-boot
-`
-	}
-	_, err = tmp.Write([]byte(hardwareYaml))
-	c.Assert(err, IsNil)
-
-	return tmp.Name()
-}
-
-func mockRunLsblkDualSnappy() (output []string, err error) {
-	dualData := `
-NAME="sda" LABEL="" PKNAME="" MOUNTPOINT=""
-NAME="sda1" LABEL="" PKNAME="sda" MOUNTPOINT=""
-NAME="sda2" LABEL="system-boot" PKNAME="sda" MOUNTPOINT="/boot/efi"
-NAME="sda3" LABEL="system-a" PKNAME="sda" MOUNTPOINT="/"
-NAME="sda4" LABEL="system-b" PKNAME="sda" MOUNTPOINT=""
-NAME="sda5" LABEL="writable" PKNAME="sda" MOUNTPOINT="/writable"
-NAME="sr0" LABEL="" PKNAME="" MOUNTPOINT=""
-`
-	return strings.Split(dualData, "\n"), err
-}
-
-func (s *PartitionTestSuite) TestSnappyDualRoot(c *C) {
-	p := New()
-	c.Assert(p.dualRootPartitions(), Equals, true)
-	c.Assert(p.singleRootPartition(), Equals, false)
-
-	rootPartitions := p.rootPartitions()
-	c.Assert(rootPartitions[0].name, Equals, "system-a")
-	c.Assert(rootPartitions[0].device, Equals, "/dev/sda3")
-	c.Assert(rootPartitions[0].parentName, Equals, "/dev/sda")
-	c.Assert(rootPartitions[1].name, Equals, "system-b")
-	c.Assert(rootPartitions[1].device, Equals, "/dev/sda4")
-	c.Assert(rootPartitions[1].parentName, Equals, "/dev/sda")
-
-	wp := p.writablePartition()
-	c.Assert(wp.name, Equals, "writable")
-	c.Assert(wp.device, Equals, "/dev/sda5")
-	c.Assert(wp.parentName, Equals, "/dev/sda")
-
-	boot := p.bootPartition()
-	c.Assert(boot.name, Equals, "system-boot")
-	c.Assert(boot.device, Equals, "/dev/sda2")
-	c.Assert(boot.parentName, Equals, "/dev/sda")
-
-	root := p.rootPartition()
-	c.Assert(root.name, Equals, "system-a")
-	c.Assert(root.device, Equals, "/dev/sda3")
-	c.Assert(root.parentName, Equals, "/dev/sda")
-
-	other := p.otherRootPartition()
-	c.Assert(other.name, Equals, "system-b")
-	c.Assert(other.device, Equals, "/dev/sda4")
-	c.Assert(other.parentName, Equals, "/dev/sda")
-}
-
-func (s *PartitionTestSuite) TestRunWithOtherDualParitionRO(c *C) {
-	p := New()
-	reportedRoot := ""
-	err := p.RunWithOther(RO, func(otherRoot string) (err error) {
-		reportedRoot = otherRoot
-		return nil
-	})
-	c.Assert(err, IsNil)
-	c.Assert(reportedRoot, Equals, mountTarget)
-}
-
-func (s *PartitionTestSuite) TestRunWithOtherDualParitionRWFuncErr(c *C) {
-	c.Assert(mounts, DeepEquals, mountEntryArray(nil))
-
-	runCommand = mockRunCommand
-
-	p := New()
-	err := p.RunWithOther(RW, func(otherRoot string) (err error) {
-		return errors.New("canary")
-	})
-
-	// ensure we actually got the right error
-	c.Assert(err, NotNil)
-	c.Assert(err.Error(), Equals, "canary")
-
-	// ensure cleanup happend
-
-	// FIXME: mounts are global
-	expected := mountEntry{
-		source:    "/dev/sda4",
-		target:    mountTarget,
-		options:   "",
-		bindMount: false,
-	}
-
-	// At program exit, "other" should still be mounted
-	c.Assert(mounts, DeepEquals, mountEntryArray{expected})
-
-	undoMounts(false)
-
-	c.Assert(mounts, DeepEquals, mountEntryArray(nil))
-}
-
-func (s *PartitionTestSuite) TestRunWithOtherSingleParitionRO(c *C) {
-	runLsblk = mockRunLsblkSingleRootSnappy
-	p := New()
-	err := p.RunWithOther(RO, func(otherRoot string) (err error) {
-		return nil
-	})
-	c.Assert(err, Equals, ErrNoDualPartition)
-}
-
-func mockRunLsblkSingleRootSnappy() (output []string, err error) {
-	dualData := `
-NAME="sda" LABEL="" PKNAME="" MOUNTPOINT=""
-NAME="sda1" LABEL="" PKNAME="sda" MOUNTPOINT=""
-NAME="sda2" LABEL="system-boot" PKNAME="sda" MOUNTPOINT=""
-NAME="sda3" LABEL="system-a" PKNAME="sda" MOUNTPOINT="/"
-NAME="sda5" LABEL="writable" PKNAME="sda" MOUNTPOINT="/writable"
-`
-	return strings.Split(dualData, "\n"), err
-}
-func (s *PartitionTestSuite) TestSnappySingleRoot(c *C) {
-	runLsblk = mockRunLsblkSingleRootSnappy
-
-	p := New()
-	c.Assert(p.dualRootPartitions(), Equals, false)
-	c.Assert(p.singleRootPartition(), Equals, true)
-
-	root := p.rootPartition()
-	c.Assert(root.name, Equals, "system-a")
-	c.Assert(root.device, Equals, "/dev/sda3")
-	c.Assert(root.parentName, Equals, "/dev/sda")
-
-	other := p.otherRootPartition()
-	c.Assert(other, IsNil)
-
-	rootPartitions := p.rootPartitions()
-	c.Assert(&rootPartitions[0], DeepEquals, root)
-}
-
-func (s *PartitionTestSuite) TestMountUnmountTracking(c *C) {
-	runCommand = mockRunCommand
-
-	p := New()
-	c.Assert(p, NotNil)
-
-	p.mountOtherRootfs(false)
-	expected := mountEntry{
-		source:    "/dev/sda4",
-		target:    mountTarget,
-		options:   "",
-		bindMount: false,
-	}
-
-	c.Assert(mounts, DeepEquals, mountEntryArray{expected})
-
-	p.unmountOtherRootfs()
-	c.Assert(mounts, DeepEquals, mountEntryArray(nil))
-}
-
-func (s *PartitionTestSuite) TestUnmountRequiredFilesystems(c *C) {
-	runCommand = mockRunCommand
-	s.makeFakeGrubEnv(c)
-
-	p := New()
-	c.Assert(c, NotNil)
-
-	p.bindmountRequiredFilesystems()
-	c.Assert(mounts, DeepEquals, mountEntryArray{
-		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},
-
-		// Required to allow grub inside the chroot to access
-		// the "current" rootfs outside the chroot (used
-		// to generate the grub menuitems).
-		mountEntry{source: "/",
-			target:  mountTarget + mountTarget,
-			options: "bind,ro", bindMount: true},
-	})
-	p.unmountRequiredFilesystems()
-	c.Assert(mounts, DeepEquals, mountEntryArray(nil))
-}
-
-func (s *PartitionTestSuite) TestUndoMounts(c *C) {
-	runCommand = mockRunCommand
-
-	p := New()
-	c.Assert(c, NotNil)
-
-	err := p.remountOther(RW)
-	c.Assert(err, IsNil)
-
-	p.bindmountRequiredFilesystems()
-	c.Assert(mounts, DeepEquals, mountEntryArray{
-
-		mountEntry{source: "/dev/sda4", target: mountTarget,
-			options: "", bindMount: false},
-
-		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:  mountTarget + mountTarget,
-			options: "bind,ro", bindMount: true},
-	})
-
-	// should leave non-bind mounts
-	undoMounts(true)
-
-	c.Assert(mounts, DeepEquals, mountEntryArray{
-		mountEntry{
-			source:    "/dev/sda4",
-			target:    mountTarget,
-			options:   "",
-			bindMount: false,
-		},
-	})
-
-	// should unmount everything
-	undoMounts(false)
-
-	c.Assert(mounts, DeepEquals, mountEntryArray(nil))
-}
-
-func mockRunLsblkNoSnappy() (output []string, err error) {
-	dualData := `
-NAME="sda" LABEL="" PKNAME="" MOUNTPOINT=""
-NAME="sda1" LABEL="meep" PKNAME="sda" MOUNTPOINT="/"
-NAME="sr0" LABEL="" PKNAME="" MOUNTPOINT=""
-`
-	return strings.Split(dualData, "\n"), err
-}
-
-func (s *PartitionTestSuite) TestSnappyNoSnappyPartitions(c *C) {
-	runLsblk = mockRunLsblkNoSnappy
-
-	p := New()
-	err := p.getPartitionDetails()
-	c.Assert(err, Equals, ErrPartitionDetection)
-
-	c.Assert(p.dualRootPartitions(), Equals, false)
-	c.Assert(p.singleRootPartition(), Equals, false)
-
-	c.Assert(p.rootPartition(), IsNil)
-	c.Assert(p.bootPartition(), IsNil)
-	c.Assert(p.writablePartition(), IsNil)
-	c.Assert(p.otherRootPartition(), IsNil)
 }
 
 // mock bootloader for the tests
 type mockBootloader struct {
-	ToggleRootFSCalled              bool
-	HandleAssetsCalled              bool
-	MarkCurrentBootSuccessfulCalled bool
-	SyncBootFilesCalled             bool
+	bootvars map[string]string
 }
 
-func (b *mockBootloader) Name() bootloaderName {
-	return "mocky"
-}
-func (b *mockBootloader) ToggleRootFS(otherRootfs string) error {
-	b.ToggleRootFSCalled = true
-	return nil
-}
-func (b *mockBootloader) SyncBootFiles(bootAssets map[string]string) error {
-	b.SyncBootFilesCalled = true
-	return nil
-}
-func (b *mockBootloader) HandleAssets() error {
-	b.HandleAssetsCalled = true
-	return nil
-}
 func (b *mockBootloader) GetBootVar(name string) (string, error) {
-	return "", nil
-}
-func (b *mockBootloader) GetNextBootRootFSName() (string, error) {
-	return "", nil
-}
-func (b *mockBootloader) MarkCurrentBootSuccessful(currentRootfs string) error {
-	b.MarkCurrentBootSuccessfulCalled = true
+	return b.bootvars[name], nil
+}
+func (b *mockBootloader) SetBootVar(key, value string) error {
+	b.bootvars[key] = value
 	return nil
 }
 func (b *mockBootloader) BootDir() string {
-	return ""
-}
-
-func (s *PartitionTestSuite) TestToggleBootloaderRootfs(c *C) {
-	runCommand = mockRunCommand
-	b := &mockBootloader{}
-	bootloader = func(p *Partition) (bootLoader, error) {
-		return b, nil
-	}
-
-	p := New()
-	c.Assert(c, NotNil)
-
-	err := p.toggleBootloaderRootfs()
-	c.Assert(err, IsNil)
-	c.Assert(b.ToggleRootFSCalled, Equals, true)
-	c.Assert(b.HandleAssetsCalled, Equals, true)
-
-	p.unmountOtherRootfs()
-	c.Assert(mounts, DeepEquals, mountEntryArray(nil))
-}
-
-func (s *PartitionTestSuite) TestMarkBootSuccessful(c *C) {
-	runCommand = mockRunCommand
-	b := &mockBootloader{}
-	bootloader = func(p *Partition) (bootLoader, error) {
-		return b, nil
-	}
-
-	p := New()
-	c.Assert(c, NotNil)
-
-	err := p.MarkBootSuccessful()
-	c.Assert(err, IsNil)
-	c.Assert(b.MarkCurrentBootSuccessfulCalled, Equals, true)
-}
-
-func (s *PartitionTestSuite) TestSyncBootFiles(c *C) {
-	runCommand = mockRunCommand
-	b := &mockBootloader{}
-	bootloader = func(p *Partition) (bootLoader, error) {
-		return b, nil
-	}
-
-	p := New()
-	c.Assert(c, NotNil)
-
-	err := p.SyncBootloaderFiles(nil)
-	c.Assert(err, IsNil)
-	c.Assert(b.SyncBootFilesCalled, Equals, true)
+	return "/boot/mock"
+}
+
+func mockRunCommand(args ...string) (err error) {
+	return err
+}
+
+func (s *BootloaderTestSuite) TestMarkBootSuccessful(c *C) {
+	runCommand = mockRunCommand
+	b := &mockBootloader{
+		bootvars: map[string]string{
+			"snappy_os":     "os1",
+			"snappy_kernel": "k1",
+		},
+	}
+	new = func() (bootLoader, error) {
+		return b, nil
+	}
+
+	err := MarkBootSuccessful()
+	c.Assert(err, IsNil)
+	c.Assert(b.bootvars["snappy_good_os"], Equals, "os1")
+	c.Assert(b.bootvars["snappy_good_kernel"], Equals, "k1")
+	c.Assert(b.bootvars["snappy_mode"], Equals, "regular")
+	c.Assert(b.bootvars["snappy_trial_boot"], Equals, "0")
+}
+
+func (s *BootloaderTestSuite) TestSetBootVar(c *C) {
+	runCommand = mockRunCommand
+	b := &mockBootloader{
+		bootvars: map[string]string{},
+	}
+	new = func() (bootLoader, error) {
+		return b, nil
+	}
+
+	err := SetBootVar("foo", "bar")
+	c.Assert(err, IsNil)
+	c.Assert(b.bootvars["foo"], Equals, "bar")
+}
+
+func (s *BootloaderTestSuite) TestGetBootVar(c *C) {
+	runCommand = mockRunCommand
+	b := &mockBootloader{
+		bootvars: map[string]string{"baz": "foobar"},
+	}
+	new = func() (bootLoader, error) {
+		return b, nil
+	}
+
+	v, err := GetBootVar("baz")
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, "foobar")
+}
+
+func (s *BootloaderTestSuite) TestGetBootDir(c *C) {
+	runCommand = mockRunCommand
+	b := &mockBootloader{
+		bootvars: map[string]string{"baz": "foobar"},
+	}
+	new = func() (bootLoader, error) {
+		return b, nil
+	}
+
+	d := Dir()
+	c.Assert(d, Equals, "/boot/mock")
+}
+
+func (s *BootloaderTestSuite) TestBootloaderIsGrub(c *C) {
+	s.makeFakeGrubEnv(c)
+
+	g, err := new()
+	c.Assert(err, IsNil)
+	c.Assert(g, FitsTypeOf, &grub{})
+}
+
+func (s *BootloaderTestSuite) TestBootloaderIsUboot(c *C) {
+	s.makeFakeUbootEnv(c)
+
+	u, err := new()
+	c.Assert(err, IsNil)
+	c.Assert(u, FitsTypeOf, &uboot{})
 }
 
=== modified file 'bootloader/bootloader_uboot.go'
--- partition/bootloader_uboot.go	2015-07-24 12:00:01 +0000
+++ bootloader/bootloader_uboot.go	2015-09-03 08:14:56 +0000
@@ -17,252 +17,61 @@
  *
  */
 
-package partition
+package bootloader
 
 import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"os"
-	"strings"
-
 	"launchpad.net/snappy/helpers"
 
-	"github.com/mvo5/goconfigparser"
 	"github.com/mvo5/uboot-go/uenv"
 )
 
 const (
-	bootloaderUbootDirReal        = "/boot/uboot"
-	bootloaderUbootConfigFileReal = "/boot/uboot/uEnv.txt"
-
-	// File created by u-boot itself when
-	// bootloaderBootmodeTry == "try" which the
-	// successfully booted system must remove to flag to u-boot that
-	// this partition is "good".
-	bootloaderUbootStampFileReal = "/boot/uboot/snappy-stamp.txt"
-
-	// DEPRECATED:
-	bootloaderUbootEnvFileReal = "/boot/uboot/snappy-system.txt"
-
-	// the real uboot env
+	bootloaderUbootDirReal       = "/boot/uboot"
 	bootloaderUbootFwEnvFileReal = "/boot/uboot/uboot.env"
 )
 
 // var to make it testable
 var (
-	bootloaderUbootDir        = bootloaderUbootDirReal
-	bootloaderUbootConfigFile = bootloaderUbootConfigFileReal
-	bootloaderUbootStampFile  = bootloaderUbootStampFileReal
-	bootloaderUbootEnvFile    = bootloaderUbootEnvFileReal
-	bootloaderUbootFwEnvFile  = bootloaderUbootFwEnvFileReal
-
-	atomicWriteFile = helpers.AtomicWriteFile
+	bootloaderUbootDir       = bootloaderUbootDirReal
+	bootloaderUbootFwEnvFile = bootloaderUbootFwEnvFileReal
 )
 
-const bootloaderNameUboot bootloaderName = "u-boot"
-
 type uboot struct {
-	bootloaderType
-}
-
-// Stores a Name and a Value to be added as a name=value pair in a file.
-// TODO convert to map
-type configFileChange struct {
-	Name  string
-	Value string
-}
-
-var setBootVar = func(name, value string) error { return nil }
-var getBootVar = func(name string) (string, error) { return "", nil }
+}
 
 // newUboot create a new Uboot bootloader object
-func newUboot(partition *Partition) bootLoader {
-	if !helpers.FileExists(bootloaderUbootConfigFile) {
-		return nil
-	}
-
-	b := newBootLoader(partition, bootloaderUbootDir)
-	if b == nil {
-		return nil
-	}
-	u := uboot{bootloaderType: *b}
-
-	if helpers.FileExists(bootloaderUbootFwEnvFile) {
-		setBootVar = setBootVarFwEnv
-		getBootVar = getBootVarFwEnv
-	} else {
-		setBootVar = setBootVarLegacy
-		getBootVar = getBootVarLegacy
-	}
-
-	return &u
-}
-
-func (u *uboot) Name() bootloaderName {
-	return bootloaderNameUboot
-}
-
-func (u *uboot) ToggleRootFS(otherRootfs string) (err error) {
-	if err := setBootVar(bootloaderRootfsVar, string(otherRootfs)); err != nil {
-		return err
-	}
-
-	return setBootVar(bootloaderBootmodeVar, bootloaderBootmodeTry)
-}
-
-func getBootVarLegacy(name string) (value string, err error) {
-	cfg := goconfigparser.New()
-	cfg.AllowNoSectionHeader = true
-	if err := cfg.ReadFile(bootloaderUbootEnvFile); err != nil {
-		return "", nil
-	}
-
-	return cfg.Get("", name)
-}
-
-func setBootVarLegacy(name, value string) error {
-	curVal, err := getBootVarLegacy(name)
-	if err == nil && curVal == value {
-		return nil
-	}
-
-	changes := []configFileChange{
-		configFileChange{
-			Name:  name,
-			Value: value,
-		},
-	}
-
-	return modifyNameValueFile(bootloaderUbootEnvFile, changes)
-}
-
-func setBootVarFwEnv(name, value string) error {
+func newUboot() bootLoader {
+	if !helpers.FileExists(bootloaderUbootFwEnvFile) {
+		return nil
+	}
+
+	return &uboot{}
+}
+
+func (u *uboot) GetBootVar(name string) (value string, err error) {
+	env, err := uenv.Open(bootloaderUbootFwEnvFile)
+	if err != nil {
+		return "", err
+	}
+
+	return env.Get(name), nil
+}
+
+func (u *uboot) SetBootVar(key, value string) error {
 	env, err := uenv.Open(bootloaderUbootFwEnvFile)
 	if err != nil {
 		return err
 	}
 
 	// already set, nothing to do
-	if env.Get(name) == value {
+	if env.Get(key) == value {
 		return nil
 	}
 
-	env.Set(name, value)
+	env.Set(key, value)
 	return env.Save()
 }
 
-func getBootVarFwEnv(name string) (string, error) {
-	env, err := uenv.Open(bootloaderUbootFwEnvFile)
-	if err != nil {
-		return "", err
-	}
-
-	return env.Get(name), nil
-}
-
-func (u *uboot) GetBootVar(name string) (value string, err error) {
-	return getBootVar(name)
-}
-
-func (u *uboot) GetNextBootRootFSName() (label string, err error) {
-	value, err := u.GetBootVar(bootloaderRootfsVar)
-	if err != nil {
-		// should never happen
-		return "", err
-	}
-
-	return value, nil
-}
-
-// FIXME: this is super similar to grub now, refactor to extract the
-//        common code
-func (u *uboot) MarkCurrentBootSuccessful(currentRootfs string) error {
-	// Clear the variable set on boot to denote a good boot.
-	if err := setBootVar(bootloaderTrialBootVar, "0"); err != nil {
-		return err
-	}
-
-	if err := setBootVar(bootloaderRootfsVar, currentRootfs); err != nil {
-		return err
-	}
-
-	if err := setBootVar(bootloaderBootmodeVar, bootloaderBootmodeSuccess); err != nil {
-		return err
-	}
-
-	// legacy support, does not error if the file is not there
-	return os.RemoveAll(bootloaderUbootStampFile)
-}
-
 func (u *uboot) BootDir() string {
 	return bootloaderUbootDir
 }
-
-// Rewrite the specified file, applying the specified set of changes.
-// Lines not in the changes slice are left alone.
-// If the original file does not contain any of the name entries (from
-// the corresponding configFileChange objects), those entries are
-// appended to the file.
-//
-// FIXME: put into utils package
-// FIXME: improve logic
-func modifyNameValueFile(path string, changes []configFileChange) error {
-	var updated []configFileChange
-
-	// we won't write to a file if we don't need to.
-	updateNeeded := false
-
-	file, err := os.Open(path)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-
-	buf := bytes.NewBuffer(nil)
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		line := scanner.Text()
-		for _, change := range changes {
-			if strings.HasPrefix(line, fmt.Sprintf("%s=", change.Name)) {
-				value := strings.SplitN(line, "=", 2)[1]
-				// updated is used later to see if you had the originally requested
-				// value.
-				updated = append(updated, change)
-				if value != change.Value {
-					line = fmt.Sprintf("%s=%s", change.Name, change.Value)
-					updateNeeded = true
-				}
-			}
-		}
-		if _, err := fmt.Fprintln(buf, line); err != nil {
-			return err
-		}
-	}
-
-	for _, change := range changes {
-		got := false
-		for _, update := range updated {
-			if update.Name == change.Name {
-				got = true
-				break
-			}
-		}
-
-		if !got {
-			updateNeeded = true
-
-			// name/value pair did not exist in original
-			// file, so append
-			if _, err := fmt.Fprintf(buf, "%s=%s\n", change.Name, change.Value); err != nil {
-				return err
-			}
-		}
-	}
-
-	if updateNeeded {
-		return atomicWriteFile(path, buf.Bytes(), 0644)
-	}
-
-	return nil
-}
 
=== modified file 'bootloader/bootloader_uboot_test.go'
--- partition/bootloader_uboot_test.go	2015-07-24 11:58:04 +0000
+++ bootloader/bootloader_uboot_test.go	2015-09-03 08:14:56 +0000
@@ -17,17 +17,14 @@
  *
  */
 
-package partition
+package bootloader
 
 import (
-	"io/ioutil"
 	"os"
-	"path/filepath"
 	"strings"
 	"time"
 
 	. "gopkg.in/check.v1"
-	"launchpad.net/snappy/helpers"
 
 	"github.com/mvo5/uboot-go/uenv"
 )
@@ -66,319 +63,84 @@
 snappy_boot=if test "${snappy_mode}" = "try"; then if test -e mmc ${bootpart} ${snappy_stamp}; then if test "${snappy_ab}" = "a"; then setenv snappy_ab "b"; else setenv snappy_ab "a"; fi; else fatwrite mmc ${mmcdev}:${mmcpart} 0x0 ${snappy_stamp} 0; fi; fi; run loadfiles; setenv mmcroot /dev/disk/by-label/system-${snappy_ab} ${snappy_cmdline}; run mmcargs; bootz ${loadaddr} ${initrd_addr}:${initrd_size} ${fdtaddr}
 `
 
-func (s *PartitionTestSuite) makeFakeUbootEnv(c *C) {
+func (s *BootloaderTestSuite) makeFakeUbootEnv(c *C) {
 	err := os.MkdirAll(bootloaderUbootDir, 0755)
 	c.Assert(err, IsNil)
 
-	// this file just needs to exist
-	err = ioutil.WriteFile(bootloaderUbootConfigFile, []byte(""), 0644)
+	env, err := uenv.Create(bootloaderUbootFwEnvFile, 4096)
 	c.Assert(err, IsNil)
-
-	// this file needs specific data
-	err = ioutil.WriteFile(bootloaderUbootEnvFile, []byte(fakeUbootEnvData), 0644)
+	env.Set("snappy_ab", "a")
+	env.Set("snappy_mode", "regular")
+	err = env.Save()
 	c.Assert(err, IsNil)
 }
 
-func (s *PartitionTestSuite) TestNewUbootNoUbootReturnsNil(c *C) {
-	partition := New()
-	u := newUboot(partition)
+func (s *BootloaderTestSuite) TestNewUbootNoUbootReturnsNil(c *C) {
+	u := newUboot()
 	c.Assert(u, IsNil)
 }
 
-func (s *PartitionTestSuite) TestNewUboot(c *C) {
-	s.makeFakeUbootEnv(c)
-
-	partition := New()
-	u := newUboot(partition)
-	c.Assert(u, NotNil)
-	c.Assert(u.Name(), Equals, bootloaderNameUboot)
-}
-
-func (s *PartitionTestSuite) TestUbootGetBootVar(c *C) {
-	s.makeFakeUbootEnv(c)
-
-	partition := New()
-	u := newUboot(partition)
-
-	nextBoot, err := u.GetBootVar(bootloaderRootfsVar)
-	c.Assert(err, IsNil)
-	// the https://developer.ubuntu.com/en/snappy/porting guide says
-	// we always use the short names
-	c.Assert(nextBoot, Equals, "a")
-
-	// ensure that nextBootIsOther works too
-	c.Assert(partition.IsNextBootOther(), Equals, false)
-}
-
-func (s *PartitionTestSuite) TestUbootToggleRootFS(c *C) {
-	s.makeFakeUbootEnv(c)
-
-	partition := New()
-	u := newUboot(partition)
-	c.Assert(u, NotNil)
-
-	err := u.ToggleRootFS("b")
-	c.Assert(err, IsNil)
-
-	nextBoot, err := u.GetBootVar(bootloaderRootfsVar)
-	c.Assert(err, IsNil)
-	c.Assert(nextBoot, Equals, "b")
-
-	// ensure that nextBootIsOther works too
-	c.Assert(partition.IsNextBootOther(), Equals, true)
-}
-
-func (s *PartitionTestSuite) TestUbootGetEnvVar(c *C) {
-	s.makeFakeUbootEnv(c)
-
-	partition := New()
-	u := newUboot(partition)
+func (s *BootloaderTestSuite) TestNewUboot(c *C) {
+	s.makeFakeUbootEnv(c)
+
+	u := newUboot()
+	c.Assert(u, NotNil)
+}
+
+func (s *BootloaderTestSuite) TestUbootGetEnvVar(c *C) {
+	s.makeFakeUbootEnv(c)
+
+	u := newUboot()
 	c.Assert(u, NotNil)
 
 	v, err := u.GetBootVar(bootloaderBootmodeVar)
 	c.Assert(err, IsNil)
 	c.Assert(v, Equals, "regular")
 
-	v, err = u.GetBootVar(bootloaderRootfsVar)
+	v, err = u.GetBootVar("snappy_ab")
 	c.Assert(err, IsNil)
 	c.Assert(v, Equals, "a")
 }
 
-func (s *PartitionTestSuite) TestGetBootloaderWithUboot(c *C) {
-	s.makeFakeUbootEnv(c)
-	p := New()
-	bootloader, err := bootloader(p)
-	c.Assert(err, IsNil)
-	c.Assert(bootloader.Name(), Equals, bootloaderNameUboot)
-}
-
-func makeMockAssetsDir(c *C) {
-	for _, f := range []string{"assets/vmlinuz", "assets/initrd.img", "assets/dtbs/foo.dtb", "assets/dtbs/bar.dtb"} {
-		p := filepath.Join(cacheDir, f)
-		os.MkdirAll(filepath.Dir(p), 0755)
-		err := ioutil.WriteFile(p, []byte(f), 0644)
-		c.Assert(err, IsNil)
-	}
-}
-
-func (s *PartitionTestSuite) TestHandleAssets(c *C) {
-	s.makeFakeUbootEnv(c)
-	p := New()
-	bootloader, err := bootloader(p)
-	c.Assert(err, IsNil)
-
-	// mock the hardwareYaml and the cacheDir
-	hardwareSpecFile = makeHardwareYaml(c, "")
-	cacheDir = c.MkDir()
-
-	// create mock assets/
-	makeMockAssetsDir(c)
-
-	// run the handle assets code
-	err = bootloader.HandleAssets()
-	c.Assert(err, IsNil)
-
-	// ensure the files are where we expect them
-	otherBootPath := bootloader.(*uboot).otherBootPath
-	for _, f := range []string{"vmlinuz", "initrd.img", "dtbs/foo.dtb", "dtbs/bar.dtb"} {
-		content, err := ioutil.ReadFile(filepath.Join(otherBootPath, f))
-		c.Assert(err, IsNil)
-		// match content
-		c.Assert(strings.HasSuffix(string(content), f), Equals, true)
-	}
-
-	// ensure nothing left behind
-	c.Assert(helpers.FileExists(filepath.Join(cacheDir, "assets")), Equals, false)
-	c.Assert(helpers.FileExists(hardwareSpecFile), Equals, false)
-}
-
-func (s *PartitionTestSuite) TestHandleAssetsVerifyBootloader(c *C) {
-	s.makeFakeUbootEnv(c)
-	p := New()
-	bootloader, err := bootloader(p)
-	c.Assert(err, IsNil)
-
-	// mock the hardwareYaml and the cacheDir
-	hardwareSpecFile = makeHardwareYaml(c, "bootloader: grub")
-	cacheDir = c.MkDir()
-
-	err = bootloader.HandleAssets()
-	c.Assert(err, NotNil)
-}
-
-func (s *PartitionTestSuite) TestHandleAssetsFailVerifyPartitionLayout(c *C) {
-	s.makeFakeUbootEnv(c)
-	p := New()
-	bootloader, err := bootloader(p)
-	c.Assert(err, IsNil)
-
-	// mock the hardwareYaml and the cacheDir
-	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)
-	hardwareSpecFile = filepath.Join(c.MkDir(), "non-existent.yaml")
-
-	p := New()
-	bootloader, err := bootloader(p)
-	c.Assert(err, IsNil)
-
-	c.Assert(bootloader.HandleAssets(), IsNil)
-}
-
-func (s *PartitionTestSuite) TestHandleAssetsBadHardwareYaml(c *C) {
-	s.makeFakeUbootEnv(c)
-	p := New()
-	bootloader, err := bootloader(p)
-	c.Assert(err, IsNil)
-
-	hardwareSpecFile = makeHardwareYaml(c, `
-bootloader u-boot
-`)
-
-	c.Assert(bootloader.HandleAssets(), NotNil)
-}
-
-func (s *PartitionTestSuite) TestUbootMarkCurrentBootSuccessful(c *C) {
-	s.makeFakeUbootEnv(c)
-
-	// To simulate what uboot does for a "try" mode boot, create a
-	// stamp file. uboot will expect this file to be removed by
-	// "snappy booted" if the system boots successfully. If this
-	// file exists when uboot starts, it will know that the previous
-	// boot failed, and will therefore toggle to the other rootfs.
-	err := ioutil.WriteFile(bootloaderUbootStampFile, []byte(""), 0640)
-	c.Assert(err, IsNil)
-	c.Assert(helpers.FileExists(bootloaderUbootStampFile), Equals, true)
-
-	partition := New()
-	u := newUboot(partition)
-	c.Assert(u, NotNil)
-
-	// 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("b")
-	c.Assert(err, IsNil)
-
-	c.Assert(helpers.FileExists(bootloaderUbootEnvFile), Equals, true)
-	bytes, err := ioutil.ReadFile(bootloaderUbootEnvFile)
-	c.Assert(err, IsNil)
-	c.Assert(strings.Contains(string(bytes), "snappy_mode=try"), Equals, true)
-	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("b")
-	c.Assert(err, IsNil)
-
-	c.Assert(helpers.FileExists(bootloaderUbootStampFile), Equals, false)
-	c.Assert(helpers.FileExists(bootloaderUbootEnvFile), Equals, true)
-
-	bytes, err = ioutil.ReadFile(bootloaderUbootEnvFile)
-	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=b"), Equals, true)
-}
-
-func (s *PartitionTestSuite) TestNoWriteNotNeeded(c *C) {
-	s.makeFakeUbootEnv(c)
-
-	atomiCall := false
-	atomicWriteFile = func(a string, b []byte, c os.FileMode) error {
-		atomiCall = true
-		return helpers.AtomicWriteFile(a, b, c)
-	}
-
-	partition := New()
-	u := newUboot(partition)
-	c.Assert(u, NotNil)
-
-	c.Check(u.MarkCurrentBootSuccessful("a"), IsNil)
-	c.Assert(atomiCall, Equals, false)
-}
-
-func (s *PartitionTestSuite) TestWriteDueToMissingValues(c *C) {
-	s.makeFakeUbootEnv(c)
-
-	// this file needs specific data
-	c.Assert(ioutil.WriteFile(bootloaderUbootEnvFile, []byte(""), 0644), IsNil)
-
-	atomiCall := false
-	atomicWriteFile = func(a string, b []byte, c os.FileMode) error {
-		atomiCall = true
-		return helpers.AtomicWriteFile(a, b, c)
-	}
-
-	partition := New()
-	u := newUboot(partition)
-	c.Assert(u, NotNil)
-
-	c.Check(u.MarkCurrentBootSuccessful("a"), IsNil)
-	c.Assert(atomiCall, Equals, true)
-
-	bytes, err := ioutil.ReadFile(bootloaderUbootEnvFile)
-	c.Assert(err, IsNil)
-	c.Check(strings.Contains(string(bytes), "snappy_mode=try"), Equals, false)
-	c.Check(strings.Contains(string(bytes), "snappy_mode=regular"), Equals, true)
-	c.Check(strings.Contains(string(bytes), "snappy_ab=a"), Equals, true)
-}
-
-func (s *PartitionTestSuite) TestUbootMarkCurrentBootSuccessfulFwEnv(c *C) {
-	s.makeFakeUbootEnv(c)
-
-	env, err := uenv.Create(bootloaderUbootFwEnvFile, 4096)
-	c.Assert(err, IsNil)
-	env.Set("snappy_ab", "b")
-	env.Set("snappy_mode", "try")
-	env.Set("snappy_trial_boot", "1")
-	err = env.Save()
-	c.Assert(err, IsNil)
-
-	partition := New()
-	u := newUboot(partition)
-	c.Assert(u, NotNil)
-
-	err = u.MarkCurrentBootSuccessful("b")
-	c.Assert(err, IsNil)
-
-	env, err = uenv.Open(bootloaderUbootFwEnvFile)
-	c.Assert(err, IsNil)
-	c.Assert(env.String(), Equals, "snappy_ab=b\nsnappy_mode=regular\nsnappy_trial_boot=0\n")
-}
-
-func (s *PartitionTestSuite) TestUbootSetEnvNoUselessWrites(c *C) {
-	s.makeFakeUbootEnv(c)
-
-	env, err := uenv.Create(bootloaderUbootFwEnvFile, 4096)
-	c.Assert(err, IsNil)
-	env.Set("snappy_ab", "b")
-	env.Set("snappy_mode", "regular")
-	err = env.Save()
-	c.Assert(err, IsNil)
+func (s *BootloaderTestSuite) TestUbootSetEnvVar(c *C) {
+	s.makeFakeUbootEnv(c)
+
+	u := newUboot()
+	c.Assert(u, NotNil)
+
+	err := u.SetBootVar("snappy_os", "123")
+	c.Assert(err, IsNil)
+
+	v, err := u.GetBootVar("snappy_os")
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, "123")
+}
+
+func (s *BootloaderTestSuite) TestUbootSetEnvNoUselessWrites(c *C) {
+	s.makeFakeUbootEnv(c)
 
 	st, err := os.Stat(bootloaderUbootFwEnvFile)
 	c.Assert(err, IsNil)
 	time.Sleep(100 * time.Millisecond)
 
-	partition := New()
-	u := newUboot(partition)
+	u := newUboot()
 	c.Assert(u, NotNil)
 
-	err = setBootVar(bootloaderRootfsVar, "b")
+	err = u.SetBootVar("snappy_ab", "a")
 	c.Assert(err, IsNil)
 
-	env, err = uenv.Open(bootloaderUbootFwEnvFile)
+	env, err := uenv.Open(bootloaderUbootFwEnvFile)
 	c.Assert(err, IsNil)
-	c.Assert(env.String(), Equals, "snappy_ab=b\nsnappy_mode=regular\n")
+	c.Assert(env.String(), Equals, "snappy_ab=a\nsnappy_mode=regular\n")
 
 	st2, err := os.Stat(bootloaderUbootFwEnvFile)
 	c.Assert(err, IsNil)
 	c.Assert(st.ModTime(), Equals, st2.ModTime())
 }
+
+func (s *BootloaderTestSuite) TestUbootBootdir(c *C) {
+	s.makeFakeUbootEnv(c)
+
+	u := newUboot()
+	c.Assert(strings.HasSuffix(u.BootDir(), "/boot/uboot"), Equals, true)
+}
 
=== added file 'bootloader/utils.go'
--- bootloader/utils.go	1970-01-01 00:00:00 +0000
+++ bootloader/utils.go	2015-09-03 08:14:56 +0000
@@ -0,0 +1,63 @@
+// -*- 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 bootloader
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+// FIXME: would it make sense to differenciate between launch errors and
+//        exit code? (i.e. something like (returnCode, error) ?)
+func runCommandImpl(args ...string) (err error) {
+	if len(args) == 0 {
+		return errors.New("no command specified")
+	}
+
+	if out, err := exec.Command(args[0], args[1:]...).CombinedOutput(); err != nil {
+		cmdline := strings.Join(args, " ")
+		return fmt.Errorf("Failed to run command '%s': %s (%s)",
+			cmdline, out, err)
+	}
+	return nil
+}
+
+// Run the command specified by args
+// This is a var instead of a function to making mocking in the tests easier
+var runCommand = runCommandImpl
+
+// Run command specified by args and return the output
+func runCommandWithStdoutImpl(args ...string) (output string, err error) {
+	if len(args) == 0 {
+		return "", errors.New("no command specified")
+	}
+
+	bytes, err := exec.Command(args[0], args[1:]...).Output()
+	if err != nil {
+		return "", err
+	}
+
+	return string(bytes), err
+}
+
+// This is a var instead of a function to making mocking in the tests easier
+var runCommandWithStdout = runCommandWithStdoutImpl
 
=== added file 'bootloader/utils_test.go'
--- bootloader/utils_test.go	1970-01-01 00:00:00 +0000
+++ bootloader/utils_test.go	2015-09-03 08:14:56 +0000
@@ -0,0 +1,47 @@
+// -*- 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 bootloader
+
+import (
+	. "gopkg.in/check.v1"
+)
+
+type UtilsTestSuite struct {
+}
+
+var _ = Suite(&UtilsTestSuite{})
+
+func (s *UtilsTestSuite) SetUpTest(c *C) {
+}
+
+func (s *UtilsTestSuite) TestRunCommand(c *C) {
+	err := runCommandImpl("false")
+	c.Assert(err, NotNil)
+
+	err = runCommandImpl("no-such-command")
+	c.Assert(err, NotNil)
+}
+
+func (s *UtilsTestSuite) TestRunCommandWithStdout(c *C) {
+	runCommandWithStdout = runCommandWithStdoutImpl
+	output, err := runCommandWithStdout("sh", "-c", "printf 'foo\nbar'")
+	c.Assert(err, IsNil)
+	c.Assert(output, DeepEquals, "foo\nbar")
+}
 
=== modified file 'cmd/snappy/cmd_booted.go'
--- cmd/snappy/cmd_booted.go	2015-06-15 07:38:57 +0000
+++ cmd/snappy/cmd_booted.go	2015-09-03 08:14:56 +0000
@@ -20,9 +20,8 @@
 package main
 
 import (
+	"launchpad.net/snappy/bootloader"
 	"launchpad.net/snappy/logger"
-	"launchpad.net/snappy/pkg"
-	"launchpad.net/snappy/snappy"
 )
 
 type cmdBooted struct {
@@ -43,10 +42,5 @@
 }
 
 func (x *cmdBooted) doBooted() error {
-	parts, err := snappy.ActiveSnapsByType(pkg.TypeCore)
-	if err != nil {
-		return err
-	}
-
-	return parts[0].(*snappy.SystemImagePart).MarkBootSuccessful()
+	return bootloader.MarkBootSuccessful()
 }
 
=== modified file 'gen-coverage.sh'
--- gen-coverage.sh	2015-06-09 13:02:49 +0000
+++ gen-coverage.sh	2015-09-03 08:14:56 +0000
@@ -10,8 +10,8 @@
 
 (cd snappy &&
         $GOPATH/bin/gocov test | $GOPATH/bin/gocov-html > $OUTPUTDIR/cov-snappy.html)
-(cd partition &&
-        $GOPATH/bin/gocov test | $GOPATH/bin/gocov-html > $OUTPUTDIR/cov-partition.html)
+(cd bootloader &&
+        $GOPATH/bin/gocov test | $GOPATH/bin/gocov-html > $OUTPUTDIR/cov-bootloader.html)
 (cd logger &&
         $GOPATH/bin/gocov test | $GOPATH/bin/gocov-html > $OUTPUTDIR/cov-logger.html)
 (cd helpers &&
 
=== removed file 'partition/assets.go'
--- partition/assets.go	2015-06-11 13:08:19 +0000
+++ partition/assets.go	1970-01-01 00:00:00 +0000
@@ -1,87 +0,0 @@
-// -*- 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
-}
 
=== removed file 'partition/assets_test.go'
--- partition/assets_test.go	2015-06-11 07:06:21 +0000
+++ partition/assets_test.go	1970-01-01 00:00:00 +0000
@@ -1,36 +0,0 @@
-// -*- 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)
-}
 
=== removed file 'partition/dirs.go'
--- partition/dirs.go	2015-06-11 08:05:14 +0000
+++ partition/dirs.go	1970-01-01 00:00:00 +0000
@@ -1,41 +0,0 @@
-// -*- 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
-)
 
=== removed file 'partition/mount.go'
--- partition/mount.go	2015-06-11 13:08:19 +0000
+++ partition/mount.go	1970-01-01 00:00:00 +0000
@@ -1,153 +0,0 @@
-// -*- 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
-}
 
=== removed file 'partition/mount_test.go'
--- partition/mount_test.go	2015-06-11 08:15:22 +0000
+++ partition/mount_test.go	1970-01-01 00:00:00 +0000
@@ -1,64 +0,0 @@
-// -*- 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})
-}
 
=== removed file 'partition/partition.go'
--- partition/partition.go	2015-07-15 07:53:43 +0000
+++ partition/partition.go	1970-01-01 00:00:00 +0000
@@ -1,622 +0,0 @@
-// -*- 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 manipulate snappy disk partitions
-package partition
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"os/signal"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"sync"
-	"syscall"
-
-	"launchpad.net/snappy/logger"
-)
-
-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
-	ErrBootloader = errors.New("Unable to determine bootloader")
-
-	// ErrPartitionDetection is returned if the partition type can not
-	// be detected
-	ErrPartitionDetection = errors.New("Failed to detect system type")
-
-	// ErrNoDualPartition is returned if you try to use a dual
-	// partition feature on a single partition
-	ErrNoDualPartition = errors.New("No dual partition")
-)
-
-// Interface provides the interface to interact with a partition
-type Interface interface {
-	ToggleNextBoot() error
-
-	MarkBootSuccessful() error
-	// FIXME: could we make SyncBootloaderFiles part of ToogleBootloader
-	//        to expose even less implementation details?
-	SyncBootloaderFiles(bootAssets map[string]string) error
-	IsNextBootOther() bool
-
-	// run the function f with the otherRoot mounted
-	RunWithOther(rw MountOption, f func(otherRoot string) (err error)) (err error)
-}
-
-// Partition is the type to interact with the partition
-type Partition struct {
-	// all partitions
-	partitions []blockDevice
-
-	// just root partitions
-	roots []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
-
-	// full path to disk device (for example "/dev/sda")
-	parentName string
-
-	// mountpoint (or nil if not mounted)
-	mountpoint string
-}
-
-var once sync.Once
-
-func init() {
-	once.Do(setupSignalHandler)
-}
-
-func signalHandler(sig os.Signal) {
-	err := undoMounts(false)
-	if err != nil {
-		logger.Noticef("Failed to unmount: %v", err)
-	}
-}
-
-func setupSignalHandler() {
-	ch := make(chan os.Signal, 1)
-
-	// add the signals we care about
-	signal.Notify(ch, os.Interrupt)
-	signal.Notify(ch, syscall.SIGTERM)
-
-	go func() {
-		// block waiting for a signal
-		sig := <-ch
-
-		// handle it
-		signalHandler(sig)
-		os.Exit(1)
-	}()
-}
-
-// Returns a list of root filesystem partition labels
-func rootPartitionLabels() []string {
-	return []string{rootfsAlabel, rootfsBlabel}
-}
-
-// Returns a list of all recognised partition labels
-func allPartitionLabels() []string {
-	var labels []string
-
-	labels = rootPartitionLabels()
-	labels = append(labels, bootPartitionLabel)
-	labels = append(labels, writablePartitionLabel)
-
-	return labels
-}
-
-var runLsblk = func() (out []string, err error) {
-	output, err := runCommandWithStdout(
-		"/bin/lsblk",
-		"--ascii",
-		"--output=NAME,LABEL,PKNAME,MOUNTPOINT",
-		"--pairs")
-	if err != nil {
-		return out, err
-	}
-
-	return strings.Split(output, "\n"), nil
-}
-
-// Determine details of the recognised disk partitions
-// available on the system via lsblk
-func loadPartitionDetails() (partitions []blockDevice, err error) {
-	recognised := allPartitionLabels()
-
-	lines, err := runLsblk()
-	if err != nil {
-		return partitions, err
-	}
-	pattern := regexp.MustCompile(`(?:[^\s"]|"(?:[^"])*")+`)
-
-	for _, line := range lines {
-		fields := make(map[string]string)
-
-		// split the line into 'NAME="quoted value"' fields
-		matches := pattern.FindAllString(line, -1)
-
-		for _, match := range matches {
-			tmp := strings.Split(match, "=")
-			name := tmp[0]
-
-			// remove quotes
-			value := strings.Trim(tmp[1], "\"")
-
-			// store
-			fields[name] = value
-		}
-
-		// Look for expected partition labels
-		name, ok := fields["LABEL"]
-		if !ok {
-			continue
-		}
-
-		if name == "" || name == "\"\"" {
-			continue
-		}
-
-		pos := stringInSlice(recognised, name)
-		if pos < 0 {
-			// ignore unrecognised partitions
-			continue
-		}
-
-		// reconstruct full path to disk partition device
-		device := fmt.Sprintf("/dev/%s", fields["NAME"])
-
-		// FIXME: we should have a way to mock the "/dev" dir
-		//        or we skip this test lsblk never returns non-existing
-		//        devices
-		/*
-			if err := FileExists(device); err != nil {
-				continue
-			}
-		*/
-		// reconstruct full path to entire disk device
-		disk := fmt.Sprintf("/dev/%s", fields["PKNAME"])
-
-		// FIXME: we should have a way to mock the "/dev" dir
-		//        or we skip this test lsblk never returns non-existing
-		//        files
-		/*
-			if err := FileExists(disk); err != nil {
-				continue
-			}
-		*/
-		shortName := string(name[len(name)-1])
-		bd := blockDevice{
-			name:       fields["LABEL"],
-			shortName:  shortName,
-			device:     device,
-			mountpoint: fields["MOUNTPOINT"],
-			parentName: disk,
-		}
-
-		partitions = append(partitions, bd)
-	}
-
-	return partitions, nil
-}
-
-// New creates a new partition type
-func New() *Partition {
-	p := new(Partition)
-
-	p.getPartitionDetails()
-
-	return p
-}
-
-// RunWithOther mount the other rootfs partition, execute the
-// specified function and unmount "other" before returning. If "other"
-// is mounted read-write, /proc, /sys and /dev will also be
-// bind-mounted at the time the specified function is called.
-func (p *Partition) RunWithOther(option MountOption, f func(otherRoot string) (err error)) (err error) {
-	dual := p.dualRootPartitions()
-
-	if !dual {
-		return ErrNoDualPartition
-	}
-
-	if option == RW {
-		if err := p.remountOther(RW); err != nil {
-			return err
-		}
-
-		defer func() {
-			// we can't reuse err here as this will override
-			// the error value we got from calling "f()"
-			derr := p.remountOther(RO)
-			if derr != nil && err == nil {
-				err = derr
-			}
-		}()
-
-		if err := p.bindmountRequiredFilesystems(); err != nil {
-			return err
-		}
-
-		defer func() {
-			// we can't reuse err here as this will override
-			// the error value we got from calling "f()"
-			derr := p.unmountRequiredFilesystems()
-			if derr != nil && err == nil {
-				err = derr
-			}
-		}()
-	}
-
-	err = f(mountTarget)
-	return err
-}
-
-// SyncBootloaderFiles syncs the bootloader files
-//
-//  We need this code solve the following scenario:
-//
-//  1. start with: /boot/a/k1, /boot/b/k1
-//  2. upgrade with new kernel k2: /boot/a/k1, /boot/b/k2
-//  3. reboot into b, running with /boot/b/k2
-//  4. new update without a changed kernel, system-a updated
-//
-//  6. reboot to system-a with /boot/a/k1 (WRONG!)
-//  But it should be system-a with /boot/a/k2 it was just not part of
-//  the s-i delta as we already got it. So as step (5) above we do the
-//  SyncBootloaderFiles that  copies /boot/b/k2 -> /boot/a/
-//  (and that is ok because we know /boot/b/k2 works)
-//
-func (p *Partition) SyncBootloaderFiles(bootAssets map[string]string) (err error) {
-	bootloader, err := bootloader(p)
-	if err != nil {
-		return err
-	}
-
-	return bootloader.SyncBootFiles(bootAssets)
-}
-
-// ToggleNextBoot toggles the roofs that should be used on the next boot
-func (p *Partition) ToggleNextBoot() (err error) {
-	if p.dualRootPartitions() {
-		return p.toggleBootloaderRootfs()
-	}
-	return err
-}
-
-// MarkBootSuccessful marks the boot as successful
-func (p *Partition) MarkBootSuccessful() (err error) {
-	bootloader, err := bootloader(p)
-	if err != nil {
-		return err
-	}
-
-	currentRootfs := p.rootPartition().shortName
-	return bootloader.MarkCurrentBootSuccessful(currentRootfs)
-}
-
-// IsNextBootOther return true if the next boot will use the other rootfs
-// partition.
-func (p *Partition) IsNextBootOther() bool {
-	bootloader, err := bootloader(p)
-	if err != nil {
-		return false
-	}
-
-	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) {
-	p.partitions, err = loadPartitionDetails()
-	if err != nil {
-		return err
-	}
-
-	if !p.dualRootPartitions() && !p.singleRootPartition() {
-		return ErrPartitionDetection
-	}
-
-	if p.dualRootPartitions() {
-		// XXX: this will soon be handled automatically at boot by
-		// initramfs-tools-ubuntu-core.
-		return p.ensureOtherMountedRO()
-	}
-
-	return err
-}
-
-// Return array of blockDevices representing available root partitions
-func (p *Partition) rootPartitions() (roots []blockDevice) {
-	for _, part := range p.partitions {
-		pos := stringInSlice(rootPartitionLabels(), part.name)
-		if pos >= 0 {
-			roots = append(roots, part)
-		}
-	}
-
-	return roots
-}
-
-// Return true if system has dual root partitions configured in the
-// expected manner for a snappy system.
-func (p *Partition) dualRootPartitions() bool {
-	return len(p.rootPartitions()) == 2
-}
-
-// Return true if system has a single root partition configured in the
-// expected manner for a snappy system.
-func (p *Partition) singleRootPartition() bool {
-	return len(p.rootPartitions()) == 1
-}
-
-// Return pointer to blockDevice representing writable partition
-func (p *Partition) writablePartition() (result *blockDevice) {
-	for _, part := range p.partitions {
-		if part.name == writablePartitionLabel {
-			return &part
-		}
-	}
-
-	return nil
-}
-
-// Return pointer to blockDevice representing boot partition (if any)
-func (p *Partition) bootPartition() (result *blockDevice) {
-	for _, part := range p.partitions {
-		if part.name == bootPartitionLabel {
-			return &part
-		}
-	}
-
-	return nil
-}
-
-// Return pointer to blockDevice representing currently mounted root
-// filesystem
-func (p *Partition) rootPartition() (result *blockDevice) {
-	for _, part := range p.rootPartitions() {
-		if part.mountpoint == "/" {
-			return &part
-		}
-	}
-
-	return nil
-}
-
-// Return pointer to blockDevice representing the "other" root
-// filesystem (which is not currently mounted)
-func (p *Partition) otherRootPartition() (result *blockDevice) {
-	for _, part := range p.rootPartitions() {
-		if part.mountpoint != "/" {
-			return &part
-		}
-	}
-
-	return nil
-}
-
-// Mount the "other" root filesystem
-func (p *Partition) mountOtherRootfs(readOnly bool) (err error) {
-	var other *blockDevice
-
-	if err := os.MkdirAll(mountTarget, dirMode); err != nil {
-		return err
-	}
-
-	other = p.otherRootPartition()
-
-	m := mountEntry{source: other.device, target: mountTarget}
-
-	if readOnly {
-		m.options = "ro"
-		err = mountAndAddToGlobalMountList(m)
-	} else {
-		err = fsck(m.source)
-		if err != nil {
-			return err
-		}
-		err = mountAndAddToGlobalMountList(m)
-	}
-
-	return err
-}
-
-// Create a read-only bindmount of the currently-mounted rootfs at the
-// specified mountpoint location (which must already exist).
-func (p *Partition) bindmountThisRootfsRO(target string) (err error) {
-	return mountAndAddToGlobalMountList(mountEntry{source: "/",
-		target:    target,
-		options:   "bind,ro",
-		bindMount: true})
-}
-
-// Ensure the other partition is mounted read-only.
-func (p *Partition) ensureOtherMountedRO() (err error) {
-	if err = runCommand("/bin/mountpoint", mountTarget); err == nil {
-		// already mounted
-		return err
-	}
-
-	return p.mountOtherRootfs(true)
-}
-
-// Remount the already-mounted other partition. Whether the mount
-// should become writable is specified by the writable argument.
-//
-// XXX: Note that in the case where writable=true, this isn't a simple
-// toggle - if the partition is already mounted read-only, it needs to
-// be unmounted, fsck(8)'d, then (re-)mounted read-write.
-func (p *Partition) remountOther(option MountOption) (err error) {
-	other := p.otherRootPartition()
-
-	if option == RW {
-		// r/o -> r/w: initially r/o, so no need to fsck before
-		// switching to r/w.
-		err = p.unmountOtherRootfs()
-		if err != nil {
-			return err
-		}
-
-		err = fsck(other.device)
-		if err != nil {
-			return err
-		}
-
-		return mountAndAddToGlobalMountList(mountEntry{
-			source: other.device,
-			target: mountTarget})
-	}
-	// r/w -> r/o: no fsck required.
-	return mount(other.device, mountTarget, "remount,ro")
-}
-
-func (p *Partition) unmountOtherRootfs() (err error) {
-	return unmountAndRemoveFromGlobalMountList(mountTarget)
-}
-
-// The bootloader requires a few filesystems to be mounted when
-// run from within a chroot.
-func (p *Partition) bindmountRequiredFilesystems() (err error) {
-
-	// we always requires these
-	requiredChrootMounts := []string{"/dev", "/proc", "/sys"}
-
-	// if there is a boot partition we also bind-mount it
-	boot := p.bootPartition()
-	if boot != nil && boot.mountpoint != "" {
-		requiredChrootMounts = append(requiredChrootMounts, boot.mountpoint)
-	}
-
-	for _, fs := range requiredChrootMounts {
-		target := filepath.Join(mountTarget, fs)
-
-		err := mountAndAddToGlobalMountList(mountEntry{source: fs,
-			target:    target,
-			options:   "bind",
-			bindMount: true})
-		if err != nil {
-			return err
-		}
-	}
-
-	// 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(mountTarget, mountTarget)
-
-	// FIXME: we should really remove this after the unmount
-
-	if err = os.MkdirAll(targetInChroot, dirMode); err != nil {
-		return err
-	}
-
-	return p.bindmountThisRootfsRO(targetInChroot)
-}
-
-// Undo the effects of BindmountRequiredFilesystems()
-func (p *Partition) unmountRequiredFilesystems() (err error) {
-	if err = undoMounts(true); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (p *Partition) toggleBootloaderRootfs() (err error) {
-
-	if !p.dualRootPartitions() {
-		return errors.New("System is not dual root")
-	}
-
-	bootloader, err := bootloader(p)
-	if err != nil {
-		return err
-	}
-
-	// ensure we have updated kernels etc
-	if err := bootloader.HandleAssets(); err != nil {
-		return err
-	}
-
-	otherRootfs := p.otherRootPartition().shortName
-	return bootloader.ToggleRootFS(otherRootfs)
-}
-
-// 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()
-}
 
=== removed file 'partition/utils.go'
--- partition/utils.go	2015-07-08 10:21:02 +0000
+++ partition/utils.go	1970-01-01 00:00:00 +0000
@@ -1,82 +0,0 @@
-// -*- 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"
-	"fmt"
-	"os/exec"
-	"strings"
-)
-
-// FIXME: would it make sense to differenciate between launch errors and
-//        exit code? (i.e. something like (returnCode, error) ?)
-func runCommandImpl(args ...string) (err error) {
-	if len(args) == 0 {
-		return errors.New("no command specified")
-	}
-
-	if out, err := exec.Command(args[0], args[1:]...).CombinedOutput(); err != nil {
-		cmdline := strings.Join(args, " ")
-		return fmt.Errorf("Failed to run command '%s': %s (%s)",
-			cmdline, out, err)
-	}
-	return nil
-}
-
-// Run the command specified by args
-// This is a var instead of a function to making mocking in the tests easier
-var runCommand = runCommandImpl
-
-// Run command specified by args and return the output
-func runCommandWithStdoutImpl(args ...string) (output string, err error) {
-	if len(args) == 0 {
-		return "", errors.New("no command specified")
-	}
-
-	bytes, err := exec.Command(args[0], args[1:]...).Output()
-	if err != nil {
-		return "", err
-	}
-
-	return string(bytes), err
-}
-
-// 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
-}
 
=== removed file 'partition/utils_test.go'
--- partition/utils_test.go	2015-06-02 20:46:07 +0000
+++ partition/utils_test.go	1970-01-01 00:00:00 +0000
@@ -1,47 +0,0 @@
-// -*- 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"
-)
-
-type UtilsTestSuite struct {
-}
-
-var _ = Suite(&UtilsTestSuite{})
-
-func (s *UtilsTestSuite) SetUpTest(c *C) {
-}
-
-func (s *UtilsTestSuite) TestRunCommand(c *C) {
-	err := runCommandImpl("false")
-	c.Assert(err, NotNil)
-
-	err = runCommandImpl("no-such-command")
-	c.Assert(err, NotNil)
-}
-
-func (s *UtilsTestSuite) TestRunCommandWithStdout(c *C) {
-	runCommandWithStdout = runCommandWithStdoutImpl
-	output, err := runCommandWithStdout("sh", "-c", "printf 'foo\nbar'")
-	c.Assert(err, IsNil)
-	c.Assert(output, DeepEquals, "foo\nbar")
-}
 
=== modified file 'pkg/types.go'
--- pkg/types.go	2015-05-19 19:34:13 +0000
+++ pkg/types.go	2015-09-03 08:14:56 +0000
@@ -34,6 +34,8 @@
 	TypeCore      Type = "core"
 	TypeFramework Type = "framework"
 	TypeOem       Type = "oem"
+	TypeOS        Type = "os"
+	TypeKernel    Type = "kernel"
 )
 
 // MarshalJSON returns *m as the JSON encoding of m.
 
=== modified file 'snappy/click.go'
--- snappy/click.go	2015-08-19 15:21:16 +0000
+++ snappy/click.go	2015-09-03 08:14:56 +0000
@@ -718,7 +718,8 @@
 	if err != nil {
 		return "", err
 	}
-	defer part.deb.Close()
+	// FIXME: NewSnapPartFromSnapFile is ugly that it needs this close
+	defer part.debClose()
 
 	return part.Install(inter, flags)
 }
 
=== modified file 'snappy/dirs.go'
--- snappy/dirs.go	2015-06-30 12:36:00 +0000
+++ snappy/dirs.go	2015-09-03 08:14:56 +0000
@@ -27,6 +27,8 @@
 
 	snapAppsDir      string
 	snapOemDir       string
+	snapOsDir        string
+	snapKernelDir    string
 	snapDataDir      string
 	snapDataHomeGlob string
 	snapAppArmorDir  string
@@ -53,6 +55,8 @@
 
 	snapAppsDir = filepath.Join(rootdir, "/apps")
 	snapOemDir = filepath.Join(rootdir, "/oem")
+	snapOsDir = filepath.Join(rootdir, "/os")
+	snapKernelDir = filepath.Join(rootdir, "/kernel")
 	snapDataDir = filepath.Join(rootdir, "/var/lib/apps")
 	snapDataHomeGlob = filepath.Join(rootdir, "/home/*/apps/")
 	snapAppArmorDir = filepath.Join(rootdir, "/var/lib/apparmor/clicks")
 
=== modified file 'snappy/install.go'
--- snappy/install.go	2015-06-11 09:38:18 +0000
+++ snappy/install.go	2015-09-03 08:14:56 +0000
@@ -24,8 +24,8 @@
 	"os"
 	"sort"
 
+	"launchpad.net/snappy/bootloader"
 	"launchpad.net/snappy/logger"
-	"launchpad.net/snappy/partition"
 	"launchpad.net/snappy/progress"
 	"launchpad.net/snappy/provisioning"
 )
@@ -97,7 +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
-		if provisioning.InDeveloperMode(partition.BootloaderDir()) {
+		if provisioning.InDeveloperMode(bootloader.Dir()) {
 			flags |= AllowUnauthenticated
 		}
 
 
=== modified file 'snappy/install_test.go'
--- snappy/install_test.go	2015-06-29 20:21:38 +0000
+++ snappy/install_test.go	2015-09-03 08:14:56 +0000
@@ -30,7 +30,6 @@
 	"path/filepath"
 
 	. "gopkg.in/check.v1"
-	"launchpad.net/snappy/partition"
 	"launchpad.net/snappy/progress"
 )
 
@@ -172,94 +171,3 @@
 	_, err = Install("hello-app.potato", 0, ag)
 	c.Assert(err, ErrorMatches, ".*"+ErrPackageNameAlreadyInstalled.Error())
 }
-
-func (s *SnapTestSuite) TestUpdate(c *C) {
-	snapPackagev1 := makeTestSnapPackage(c, "name: foo\nversion: 1\nvendor: foo")
-	name, err := Install(snapPackagev1, AllowUnauthenticated|DoInstallGC, &progress.NullProgress{})
-	c.Assert(err, IsNil)
-	c.Assert(name, Equals, "foo")
-
-	snapPackagev2 := makeTestSnapPackage(c, "name: foo\nversion: 2\nvendor: foo")
-
-	snapR, err := os.Open(snapPackagev2)
-	c.Assert(err, IsNil)
-	defer snapR.Close()
-
-	// details
-	var dlURL, iconURL string
-	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/details/foo":
-			io.WriteString(w, `{
-"package_name": "foo",
-"version": "2",
-"origin": "sideload",
-"anon_download_url": "`+dlURL+`",
-"icon_url": "`+iconURL+`"
-}`)
-		case "/dl":
-			snapR.Seek(0, 0)
-			io.Copy(w, snapR)
-		case "/icon":
-			fmt.Fprintf(w, "")
-		default:
-			panic("unexpected url path: " + r.URL.Path)
-		}
-	}))
-	c.Assert(mockServer, NotNil)
-	defer mockServer.Close()
-
-	dlURL = mockServer.URL + "/dl"
-	iconURL = mockServer.URL + "/icon"
-
-	storeDetailsURI, err = url.Parse(mockServer.URL + "/details/")
-	c.Assert(err, IsNil)
-
-	// bulk
-	mockServer = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		io.WriteString(w, `[{
-	"package_name": "foo",
-	"version": "2",
-	"origin": "sideload",
-	"anon_download_url": "`+dlURL+`",
-	"icon_url": "`+iconURL+`"
-}]`)
-	}))
-
-	storeBulkURI, err = url.Parse(mockServer.URL)
-	c.Assert(err, IsNil)
-
-	c.Assert(mockServer, NotNil)
-	defer mockServer.Close()
-
-	// system image
-	newPartition = func() (p partition.Interface) {
-		return new(MockPartition)
-	}
-	defer func() { newPartition = newPartitionImpl }()
-
-	tempdir := c.MkDir()
-	systemImageRoot = tempdir
-
-	makeFakeSystemImageChannelConfig(c, filepath.Join(tempdir, systemImageChannelConfig), "1")
-	// setup fake /other partition
-	makeFakeSystemImageChannelConfig(c, filepath.Join(tempdir, "other", systemImageChannelConfig), "2")
-
-	siServer := runMockSystemImageWebServer()
-	defer siServer.Close()
-
-	mockServer = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		io.WriteString(w, fmt.Sprintf(mockSystemImageIndexJSONTemplate, "1"))
-	}))
-	c.Assert(mockServer, NotNil)
-	defer mockServer.Close()
-
-	systemImageServer = mockServer.URL
-
-	// the test
-	updates, err := Update(0, &progress.NullProgress{})
-	c.Assert(err, IsNil)
-	c.Assert(updates, HasLen, 1)
-	c.Check(updates[0].Name(), Equals, "foo")
-	c.Check(updates[0].Version(), Equals, "2")
-}
 
=== added file 'snappy/kernel.go'
--- snappy/kernel.go	1970-01-01 00:00:00 +0000
+++ snappy/kernel.go	2015-09-03 08:14:56 +0000
@@ -0,0 +1,103 @@
+// -*- 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 snappy
+
+import (
+	"os"
+	"path/filepath"
+
+	"launchpad.net/snappy/bootloader"
+	"launchpad.net/snappy/helpers"
+)
+
+type KernelSnap struct {
+	SnapPart
+}
+
+func (s *KernelSnap) NeedsReboot() bool {
+	snappyKernel, _ := bootloader.GetBootVar("snappy_kernel")
+	if !s.IsActive() && snappyKernel == s.Version() {
+		return true
+	}
+
+	return false
+}
+
+/*
+func (s *KernelSnap) dir() string {
+	fullName := s.SnapPart.m.qualifiedName(s.origin)
+	return filepath.Join(snapKernelDir, fullName, s.m.Version)
+}
+*/
+
+func (s *KernelSnap) activate(inhibitHooks bool, inter interacter) error {
+	if err := s.SnapPart.activate(inhibitHooks, inter); err != nil {
+		return err
+	}
+
+	if err := bootloader.SetBootVar("snappy_kernel", s.Version()); err != nil {
+		return err
+	}
+
+	return bootloader.SetBootVar("snappy_mode", "try")
+}
+
+func unpackKernel(s *SnapPart) error {
+	// FIXME: do we need the globalRootDir here?
+	if err := s.deb.Unpack(s.basedir); err != nil {
+		return err
+	}
+
+	// FIXME: create special unpack that diverts kernel/initrd/dtbs
+	//        to the right place, this will currently copy the files
+	//        (duplicate data)
+	bootdir := bootloader.Dir()
+	if err := os.MkdirAll(filepath.Join(bootdir, s.Version()), 0755); err != nil {
+		return err
+	}
+	if s.m.Kernel != "" {
+		src := filepath.Join(s.basedir, s.m.Kernel)
+		dst := filepath.Join(bootdir, s.Version(), normalizeKernelInitrdName(s.m.Kernel))
+		if err := helpers.CopyFile(src, dst, helpers.CopyFlagDefault); err != nil {
+			return err
+		}
+	}
+	if s.m.Initrd != "" {
+		src := filepath.Join(s.basedir, s.m.Initrd)
+		dst := filepath.Join(bootdir, s.Version(), normalizeKernelInitrdName(s.m.Initrd))
+		if err := helpers.CopyFile(src, dst, helpers.CopyFlagDefault); err != nil {
+			return err
+		}
+	}
+	if s.m.Dtbs != "" {
+		src := filepath.Join(s.basedir, s.m.Dtbs)
+		dst := filepath.Join(bootdir, s.Version(), s.m.Dtbs)
+		// FIXME: a simple "cp -a" is what we need here
+		if err := helpers.RSyncWithDelete(src, dst); err != nil {
+			return err
+		}
+	}
+
+	if err := bootloader.SetBootVar("snappy_kernel", s.Version()); err != nil {
+		return err
+	}
+
+	return bootloader.SetBootVar("snappy_mode", "trial")
+}
 
=== modified file 'snappy/oem.go'
--- snappy/oem.go	2015-07-01 14:48:33 +0000
+++ snappy/oem.go	2015-09-03 08:14:56 +0000
@@ -291,3 +291,14 @@
 
 	return nil
 }
+
+type OemSnap struct {
+	SnapPart
+}
+
+/*
+func (s *OemSnap) dir() string {
+	fullName := s.SnapPart.m.qualifiedName(s.origin)
+	return filepath.Join(snapOemDir, fullName, s.m.Version)
+}
+*/
 
=== added file 'snappy/os.go'
--- snappy/os.go	1970-01-01 00:00:00 +0000
+++ snappy/os.go	2015-09-03 08:14:56 +0000
@@ -0,0 +1,68 @@
+// -*- 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 snappy
+
+import (
+	"launchpad.net/snappy/bootloader"
+)
+
+type OsSnap struct {
+	SnapPart
+}
+
+func (s *OsSnap) NeedsReboot() bool {
+	snappyOS, _ := bootloader.GetBootVar("snappy_os")
+	if !s.IsActive() && snappyOS == s.Version() {
+		return true
+	}
+
+	return false
+}
+
+/*
+func (s *OsSnap) dir() string {
+	fullName := s.SnapPart.m.qualifiedName(s.origin)
+	return filepath.Join(snapOsDir, fullName, s.m.Version)
+}
+*/
+
+func (s *OsSnap) activate(inhibitHooks bool, inter interacter) error {
+	if err := s.SnapPart.activate(inhibitHooks, inter); err != nil {
+		return err
+	}
+	if err := bootloader.SetBootVar("snappy_os", s.Version()); err != nil {
+		return err
+	}
+
+	return bootloader.SetBootVar("snappy_mode", "try")
+}
+
+func unpackOS(s *SnapPart) error {
+	// FIXME: do we need the globalRootDir here?
+	if err := s.deb.Unpack(s.basedir); err != nil {
+		return err
+	}
+
+	if err := bootloader.SetBootVar("snappy_os", s.Version()); err != nil {
+		return err
+	}
+
+	return bootloader.SetBootVar("snappy_mode", "trial")
+}
 
=== modified file 'snappy/parts.go'
--- snappy/parts.go	2015-07-23 11:05:37 +0000
+++ snappy/parts.go	2015-09-03 08:14:56 +0000
@@ -134,14 +134,10 @@
 	m := new(MetaRepository)
 	m.all = []Repository{}
 
-	if repo := NewSystemImageRepository(); repo != nil {
-		m.all = append(m.all, repo)
-	}
-	if repo := NewLocalSnapRepository(snapAppsDir); repo != nil {
-		m.all = append(m.all, repo)
-	}
-	if repo := NewLocalSnapRepository(snapOemDir); repo != nil {
-		m.all = append(m.all, repo)
+	for _, d := range []string{snapAppsDir, snapOemDir, snapOsDir, snapKernelDir} {
+		if repo := NewLocalSnapRepository(d); repo != nil {
+			m.all = append(m.all, repo)
+		}
 	}
 
 	return m
 
=== modified file 'snappy/purge.go'
--- snappy/purge.go	2015-05-29 12:08:46 +0000
+++ snappy/purge.go	2015-09-03 08:14:56 +0000
@@ -47,7 +47,7 @@
 
 	purgeActive := flags&DoPurgeActive != 0
 
-	var active []*SnapPart
+	var active []Snap
 
 	for _, datadir := range datadirs {
 		yamlPath := filepath.Join(snapAppsDir, datadir.QualifiedName(), datadir.Version, "meta", "package.yaml")
 
=== modified file 'snappy/purge_test.go'
--- snappy/purge_test.go	2015-06-09 19:11:54 +0000
+++ snappy/purge_test.go	2015-09-03 08:14:56 +0000
@@ -57,7 +57,7 @@
 	c.Check(inter.notified, HasLen, 0)
 }
 
-func (s *purgeSuite) mkpkg(c *C, args ...string) (dataDir string, part *SnapPart) {
+func (s *purgeSuite) mkpkg(c *C, args ...string) (dataDir string, part Snap) {
 	version := "1.10"
 	extra := ""
 	switch len(args) {
 
=== modified file 'snappy/snapp.go'
--- snappy/snapp.go	2015-08-19 15:21:16 +0000
+++ snappy/snapp.go	2015-09-03 08:14:56 +0000
@@ -38,6 +38,7 @@
 
 	"gopkg.in/yaml.v2"
 
+	"launchpad.net/snappy/bootloader"
 	"launchpad.net/snappy/clickdeb"
 	"launchpad.net/snappy/helpers"
 	"launchpad.net/snappy/logger"
@@ -198,6 +199,16 @@
 	return nil
 }
 
+type Snap interface {
+	Part
+	activate(inhibitHooks bool, inter interacter) error
+	deactivate(inhibitHooks bool, inter interacter) error
+	remove(inter interacter) error
+	dir() string
+	ServiceYamls() []ServiceYaml
+	debClose() error
+}
+
 // TODO split into payloads per package type composing the common
 // elements for all snaps.
 type packageYaml struct {
@@ -228,6 +239,11 @@
 
 	ExplicitLicenseAgreement bool   `yaml:"explicit-license-agreement,omitempty"`
 	LicenseVersion           string `yaml:"license-version,omitempty"`
+
+	// FIXME: move into a special kernel struct
+	Kernel string `yaml:"kernel,omitempty"`
+	Initrd string `yaml:"initrd,omitempty"`
+	Dtbs   string `yaml:"dtbs,omitempty"`
 }
 
 type remoteSnap struct {
@@ -362,6 +378,12 @@
 	return m.Name + "." + origin
 }
 
+// noramlizeAssetName transforms like "vmlinuz-4.1.0" -> "vmlinuz"
+func normalizeKernelInitrdName(name string) string {
+	name = filepath.Base(name)
+	return strings.SplitN(name, "-", 2)[0]
+}
+
 func (m *packageYaml) checkForNameClashes() error {
 	d := make(map[string]struct{})
 	for _, bin := range m.Binaries {
@@ -528,7 +550,7 @@
 }
 
 // NewInstalledSnapPart returns a new SnapPart from the given yamlPath
-func NewInstalledSnapPart(yamlPath, origin string) (*SnapPart, error) {
+func NewInstalledSnapPart(yamlPath, origin string) (Snap, error) {
 	m, err := parsePackageYamlFile(yamlPath)
 	if err != nil {
 		return nil, err
@@ -546,7 +568,7 @@
 // NewSnapPartFromSnapFile loads a snap from the given (clickdeb) snap file.
 // Caller should call Close on the clickdeb.
 // TODO: expose that Close.
-func NewSnapPartFromSnapFile(snapFile string, origin string, unauthOk bool) (*SnapPart, error) {
+func NewSnapPartFromSnapFile(snapFile string, origin string, unauthOk bool) (Snap, error) {
 	if err := clickdeb.Verify(snapFile, unauthOk); err != nil {
 		return nil, err
 	}
@@ -566,10 +588,15 @@
 		return nil, err
 	}
 
+	// FIMXE: move all into {App,Kernel,Os}Snap.dir()
 	targetDir := snapAppsDir
-	// the "oem" parts are special
-	if m.Type == pkg.TypeOem {
+	switch m.Type {
+	case pkg.TypeOem:
 		targetDir = snapOemDir
+	case pkg.TypeOS:
+		targetDir = snapOsDir
+	case pkg.TypeKernel:
+		targetDir = snapKernelDir
 	}
 
 	if origin == sideloadedOrigin {
@@ -579,12 +606,22 @@
 	fullName := m.qualifiedName(origin)
 	instDir := filepath.Join(targetDir, fullName, m.Version)
 
-	return &SnapPart{
+	baseSnap := &SnapPart{
 		basedir: instDir,
 		origin:  origin,
 		m:       m,
 		deb:     d,
-	}, nil
+	}
+	switch m.Type {
+	case pkg.TypeOem:
+		return &OemSnap{SnapPart: *baseSnap}, nil
+	case pkg.TypeOS:
+		return &OsSnap{SnapPart: *baseSnap}, nil
+	case pkg.TypeKernel:
+		return &KernelSnap{SnapPart: *baseSnap}, nil
+	}
+
+	return baseSnap, nil
 }
 
 // NewSnapPartFromYaml returns a new SnapPart from the given *packageYaml at yamlPath
@@ -650,6 +687,10 @@
 	return part, nil
 }
 
+func (s *SnapPart) dir() string {
+	return s.basedir
+}
+
 // Type returns the type of the SnapPart (app, oem, ...)
 func (s *SnapPart) Type() pkg.Type {
 	if s.m.Type != "" {
@@ -665,6 +706,11 @@
 	return s.m.Name
 }
 
+// FIXME: super ugly
+func (s *SnapPart) debClose() error {
+	return s.deb.Close()
+}
+
 // Version returns the version
 func (s *SnapPart) Version() string {
 	if s.basedir != "" {
@@ -802,7 +848,7 @@
 	fullName := QualifiedName(s)
 	dataDir := filepath.Join(snapDataDir, fullName, s.Version())
 
-	var oldPart *SnapPart
+	var oldPart Snap
 	if currentActiveDir, _ := filepath.EvalSymlinks(filepath.Join(s.basedir, "..", "current")); currentActiveDir != "" {
 		oldPart, err = NewInstalledSnapPart(filepath.Join(currentActiveDir, "meta", "package.yaml"), s.origin)
 		if err != nil {
@@ -824,10 +870,21 @@
 		}
 	}()
 
-	// we need to call the external helper so that we can reliable drop
-	// privs
-	if err := s.deb.UnpackWithDropPrivs(s.basedir, globalRootDir); err != nil {
-		return "", err
+	// FIXME: so ugly, what we need is
+	// "dynamic dispatch of overridden methods" which go makes hard
+	switch s.Type() {
+	case pkg.TypeOS:
+		if err := unpackOS(s); err != nil {
+			return "", err
+		}
+	case pkg.TypeKernel:
+		if err := unpackKernel(s); err != nil {
+			return "", err
+		}
+	default:
+		if err := s.deb.UnpackWithDropPrivs(s.basedir, globalRootDir); err != nil {
+			return "", err
+		}
 	}
 
 	// legacy, the hooks (e.g. apparmor) need this. Once we converted
@@ -1128,6 +1185,14 @@
 
 // NeedsReboot returns true if the snap becomes active on the next reboot
 func (s *SnapPart) NeedsReboot() bool {
+	// FIXME: needs to become SnapKernel
+	if s.m.Type == pkg.TypeKernel {
+		snappyKernel, _ := bootloader.GetBootVar("snappy_kernel")
+		if !s.IsActive() && snappyKernel == s.Version() {
+			return true
+		}
+	}
+
 	return false
 }
 
@@ -1266,10 +1331,10 @@
 }
 
 // RefreshDependentsSecurity refreshes the security policies of dependent snaps
-func (s *SnapPart) RefreshDependentsSecurity(oldPart *SnapPart, inter interacter) (err error) {
+func (s *SnapPart) RefreshDependentsSecurity(oldPart Snap, inter interacter) (err error) {
 	oldBaseDir := ""
 	if oldPart != nil {
-		oldBaseDir = oldPart.basedir
+		oldBaseDir = oldPart.(*SnapPart).basedir
 	}
 	upPol, upTpl := policy.AppArmorDelta(oldBaseDir, s.basedir, s.Name()+"_")
 
@@ -1878,7 +1943,7 @@
 // The returned environment contains additional SNAP_* variables that
 // are required when calling a meta/hook/ script and that will override
 // any already existing SNAP_* variables in os.Environment()
-func makeSnapHookEnv(part *SnapPart) (env []string) {
+func makeSnapHookEnv(part Snap) (env []string) {
 	desc := struct {
 		AppName     string
 		AppArch     string
@@ -1889,7 +1954,7 @@
 	}{
 		part.Name(),
 		helpers.UbuntuArchitecture(),
-		part.basedir,
+		part.dir(),
 		part.Version(),
 		QualifiedName(part),
 		part.Origin(),
 
=== modified file 'snappy/snapp_test.go'
--- snappy/snapp_test.go	2015-07-23 11:05:37 +0000
+++ snappy/snapp_test.go	2015-09-03 08:14:56 +0000
@@ -29,10 +29,10 @@
 	"os"
 	"path/filepath"
 	"strings"
+	"testing"
 
 	"launchpad.net/snappy/clickdeb"
 	"launchpad.net/snappy/helpers"
-	"launchpad.net/snappy/partition"
 	"launchpad.net/snappy/pkg"
 	"launchpad.net/snappy/policy"
 	"launchpad.net/snappy/release"
@@ -41,6 +41,9 @@
 	. "gopkg.in/check.v1"
 )
 
+// Hook up check.v1 into the "go test" runner
+func Test(t *testing.T) { TestingT(t) }
+
 type SnapTestSuite struct {
 	tempdir   string
 	clickhook string
@@ -54,9 +57,6 @@
 	aaClickHookCmd = "/bin/true"
 	s.secbase = policy.SecBase
 	s.tempdir = c.MkDir()
-	newPartition = func() (p partition.Interface) {
-		return new(MockPartition)
-	}
 
 	SetRootDir(s.tempdir)
 	policy.SecBase = filepath.Join(s.tempdir, "security")
@@ -96,9 +96,6 @@
 	c.Assert(err, IsNil)
 
 	runScFilterGen = mockRunScFilterGen
-
-	// ensure we do not look at the system
-	systemImageRoot = s.tempdir
 }
 
 func (s *SnapTestSuite) TearDownTest(c *C) {
@@ -153,11 +150,11 @@
 	c.Assert(services[0].Name, Equals, "svc1")
 
 	// ensure we get valid Date()
-	st, err := os.Stat(snap.basedir)
+	st, err := os.Stat(snap.dir())
 	c.Assert(err, IsNil)
 	c.Assert(snap.Date(), Equals, st.ModTime())
 
-	c.Assert(snap.basedir, Equals, filepath.Join(s.tempdir, "apps", helloAppComposedName, "1.10"))
+	c.Assert(snap.dir(), Equals, filepath.Join(s.tempdir, "apps", helloAppComposedName, "1.10"))
 	c.Assert(snap.InstalledSize(), Not(Equals), -1)
 }
 
@@ -827,11 +824,11 @@
 	c.Assert(services[1].Description, Equals, "Service #2")
 
 	// ensure we get valid Date()
-	st, err := os.Stat(snap.basedir)
+	st, err := os.Stat(snap.dir())
 	c.Assert(err, IsNil)
 	c.Assert(snap.Date(), Equals, st.ModTime())
 
-	c.Assert(snap.basedir, Equals, filepath.Join(s.tempdir, "apps", helloAppComposedName, "1.10"))
+	c.Assert(snap.dir(), Equals, filepath.Join(s.tempdir, "apps", helloAppComposedName, "1.10"))
 	c.Assert(snap.InstalledSize(), Not(Equals), -1)
 }
 
 
=== removed file 'snappy/systemimage.go'
--- snappy/systemimage.go	2015-07-24 12:03:30 +0000
+++ snappy/systemimage.go	1970-01-01 00:00:00 +0000
@@ -1,518 +0,0 @@
-// -*- 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 snappy
-
-import (
-	"crypto/sha512"
-	"encoding/hex"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/mvo5/goconfigparser"
-
-	"launchpad.net/snappy/coreconfig"
-	"launchpad.net/snappy/helpers"
-	"launchpad.net/snappy/logger"
-	"launchpad.net/snappy/partition"
-	"launchpad.net/snappy/pkg"
-	"launchpad.net/snappy/progress"
-	"launchpad.net/snappy/provisioning"
-)
-
-const (
-	systemImagePartName   = "ubuntu-core"
-	systemImagePartOrigin = "ubuntu"
-	systemImagePartVendor = "Canonical Ltd."
-
-	// location of the channel config on the filesystem.
-	//
-	// This file specifies the s-i version installed on the rootfs
-	// and hence s-i updates this file on every update applied to
-	// the rootfs (by unpacking file "version-$version.tar.xz").
-	systemImageChannelConfig = "/etc/system-image/config.d/01_channel.ini"
-
-	// location of the client config.
-	//
-	// The full path to this file needs to be passed to
-	// systemImageCli when querying a different rootfs.
-	systemImageClientConfig = "/etc/system-image/config.d/00_default.ini"
-)
-
-var (
-	// the system-image-cli binary
-	systemImageCli = "system-image-cli"
-)
-
-// This is the root directory of the filesystem. Its only useful to
-// change when writing tests
-var systemImageRoot = "/"
-
-// will replace newPartition() to return a mockPartition
-var newPartition = newPartitionImpl
-
-func newPartitionImpl() (p partition.Interface) {
-	return partition.New()
-}
-
-// SystemImagePart represents a "core" snap that is managed via the SystemImage
-// client
-type SystemImagePart struct {
-	version        string
-	versionDetails string
-	channelName    string
-	lastUpdate     time.Time
-
-	isInstalled bool
-	isActive    bool
-
-	updateSize int64
-
-	partition partition.Interface
-}
-
-// Type returns pkg.TypeCore for this snap
-func (s *SystemImagePart) Type() pkg.Type {
-	return pkg.TypeCore
-}
-
-// Name returns the name
-func (s *SystemImagePart) Name() string {
-	return systemImagePartName
-}
-
-// Origin returns the origin ("ubuntu")
-func (s *SystemImagePart) Origin() string {
-	return systemImagePartOrigin
-}
-
-// Vendor returns the vendor ("Canonical Ltd.")
-func (s *SystemImagePart) Vendor() string {
-	return systemImagePartVendor
-}
-
-// Version returns the version
-func (s *SystemImagePart) Version() string {
-	return s.version
-}
-
-// Description returns the description
-func (s *SystemImagePart) Description() string {
-	return "ubuntu-core description"
-}
-
-// Hash returns the hash
-func (s *SystemImagePart) Hash() string {
-	hasher := sha512.New()
-	hasher.Write([]byte(s.versionDetails))
-	hexdigest := hex.EncodeToString(hasher.Sum(nil))
-
-	return hexdigest
-}
-
-// IsActive returns true if the snap is active
-func (s *SystemImagePart) IsActive() bool {
-	return s.isActive
-}
-
-// IsInstalled returns true if the snap is installed
-func (s *SystemImagePart) IsInstalled() bool {
-	return s.isInstalled
-}
-
-// InstalledSize returns the size of the installed snap
-func (s *SystemImagePart) InstalledSize() int64 {
-	return -1
-}
-
-// DownloadSize returns the dowload size
-func (s *SystemImagePart) DownloadSize() int64 {
-	return s.updateSize
-}
-
-// Date returns the last update date
-func (s *SystemImagePart) Date() time.Time {
-	return s.lastUpdate
-}
-
-// SetActive sets the snap active
-func (s *SystemImagePart) SetActive(pb progress.Meter) (err error) {
-	isNextBootOther := s.partition.IsNextBootOther()
-	// active and no switch scheduled -> nothing to do
-	if s.IsActive() && !isNextBootOther {
-		return nil
-	}
-	// not currently active but switch scheduled already -> nothing to do
-	if !s.IsActive() && isNextBootOther {
-		return nil
-	}
-
-	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(bootloaderDir()) {
-		return "", ErrSideLoaded
-	}
-
-	if pb != nil {
-		// ensure the progress finishes when we are done
-		defer func() {
-			pb.Finished()
-		}()
-	}
-
-	// Ensure there is always a kernel + initrd to boot with, even
-	// if the update does not provide new versions.
-	if s.needsBootAssetSync() {
-		if pb != nil {
-			pb.Notify("Syncing boot files")
-		}
-		err = s.partition.SyncBootloaderFiles(bootAssetFilePaths())
-		if err != nil {
-			return "", err
-		}
-	}
-
-	// find out what config file to use, the other partition may be
-	// empty so we need to fallback to the current one if it is
-	configFile := systemImageClientConfig
-	err = s.partition.RunWithOther(partition.RO, func(otherRoot string) (err error) {
-		// XXX: Note that systemImageDownloadUpdate() requires
-		// the s-i _client_ config file whereas otherIsEmpty()
-		// checks the s-i _channel_ config file.
-		otherConfigFile := filepath.Join(systemImageRoot, otherRoot, systemImageClientConfig)
-		if !otherIsEmpty(otherRoot) && helpers.FileExists(otherConfigFile) {
-			configFile = otherConfigFile
-		}
-
-		// NOTE: we need to pass the config dir here
-		configDir := filepath.Dir(configFile)
-		return systemImageDownloadUpdate(configDir, pb)
-	})
-	if err != nil {
-		return "", err
-	}
-
-	// Check that the final system state is as expected.
-	if err = s.verifyUpgradeWasApplied(); err != nil {
-		return "", err
-	}
-
-	// XXX: ToggleNextBoot() calls handleAssets() (but not SyncBootloader
-	//      files :/) - handleAssets() may copy kernel/initramfs to the
-	//      sync mounted /boot/uboot, so its very slow, tell the user
-	//      at least that something is going on
-	if pb != nil {
-		pb.Notify("Updating boot files")
-	}
-	if err = s.partition.ToggleNextBoot(); err != nil {
-		return "", err
-	}
-	return systemImagePartName, nil
-}
-
-// Ensure the expected version update was applied to the expected partition.
-func (s *SystemImagePart) verifyUpgradeWasApplied() error {
-	// The upgrade has now been applied, so check that the expected
-	// update was applied by comparing "self" (which is the newest
-	// system-image revision with that installed on the other
-	// partition.
-
-	// Determine the latest installed part.
-	latestPart := makeOtherPart(s.partition)
-	if latestPart == nil {
-		// If there is no other part, this system must be a
-		// single rootfs one, so re-query current to find the
-		// latest installed part.
-		latestPart = makeCurrentPart(s.partition)
-	}
-
-	if latestPart == nil {
-		return &ErrUpgradeVerificationFailed{
-			msg: "could not find latest installed partition",
-		}
-	}
-
-	if s.version != latestPart.Version() {
-		return &ErrUpgradeVerificationFailed{
-			msg: fmt.Sprintf("found %q but expected %q", latestPart.Version(), s.version),
-		}
-	}
-
-	return nil
-}
-
-// Uninstall can not be used for "core" snaps
-func (s *SystemImagePart) Uninstall(progress.Meter) error {
-	return ErrPackageNotRemovable
-}
-
-// Config is used to to configure the snap
-func (s *SystemImagePart) Config(configuration []byte) (newConfig string, err error) {
-	if cfg := string(configuration); cfg != "" {
-		return coreconfig.Set(cfg)
-	}
-
-	return coreconfig.Get()
-}
-
-// NeedsReboot returns true if the snap becomes active on the next reboot
-func (s *SystemImagePart) NeedsReboot() bool {
-
-	if !s.IsActive() && s.partition.IsNextBootOther() {
-		return true
-	}
-
-	return false
-}
-
-// MarkBootSuccessful marks the *currently* booted rootfs as "good"
-// (it booted :)
-// Note: Not part of the Part interface.
-func (s *SystemImagePart) MarkBootSuccessful() (err error) {
-
-	return s.partition.MarkBootSuccessful()
-}
-
-// Channel returns the system-image-server channel used
-func (s *SystemImagePart) Channel() string {
-	return s.channelName
-}
-
-// Icon returns the icon path
-func (s *SystemImagePart) Icon() string {
-	return ""
-}
-
-// Frameworks returns the list of frameworks needed by the snap
-func (s *SystemImagePart) Frameworks() ([]string, error) {
-	// system image parts can't depend on frameworks.
-	return nil, nil
-}
-
-// SystemImageRepository is the type used for the system-image-server
-type SystemImageRepository struct {
-	partition partition.Interface
-}
-
-// NewSystemImageRepository returns a new SystemImageRepository
-func NewSystemImageRepository() *SystemImageRepository {
-	return &SystemImageRepository{partition: newPartition()}
-}
-
-func makePartFromSystemImageConfigFile(p partition.Interface, channelIniPath string, isActive bool) (part Part, err error) {
-	cfg := goconfigparser.New()
-	f, err := os.Open(channelIniPath)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-	err = cfg.Read(f)
-	if err != nil {
-		logger.Noticef("Can not parse config %q: %v", channelIniPath, err)
-		return nil, err
-	}
-	st, err := os.Stat(channelIniPath)
-	if err != nil {
-		logger.Noticef("Can not stat %q: %v", channelIniPath, err)
-		return nil, err
-	}
-
-	currentBuildNumber, err := cfg.Get("service", "build_number")
-	versionDetails, err := cfg.Get("service", "version_detail")
-	channelName, err := cfg.Get("service", "channel")
-	return &SystemImagePart{
-		isActive:       isActive,
-		isInstalled:    true,
-		version:        currentBuildNumber,
-		versionDetails: versionDetails,
-		channelName:    channelName,
-		lastUpdate:     st.ModTime(),
-		partition:      p}, err
-}
-
-// Returns the part associated with the current rootfs
-func makeCurrentPart(p partition.Interface) Part {
-	configFile := filepath.Join(systemImageRoot, systemImageChannelConfig)
-	part, err := makePartFromSystemImageConfigFile(p, configFile, true)
-	if err != nil {
-		return nil
-	}
-	return part
-}
-
-// otherIsEmpty returns true if the rootfs path specified should be
-// considered empty.
-//
-// Note that the rootfs _may_ not actually be strictly empty, but it
-// must be considered empty if it is incomplete.
-//
-// This function encapsulates the heuristics to determine if the rootfs
-// is complete.
-func otherIsEmpty(root string) bool {
-	configFile := filepath.Join(systemImageRoot, root, systemImageChannelConfig)
-
-	st, err := os.Stat(configFile)
-
-	if err == nil && st.Size() > 0 {
-		// the channel config file exists and has a "reasonable"
-		// size. The upgrade therefore completed successfully,
-		// so consider the rootfs complete.
-		return false
-	}
-
-	// The upgrader pre-creates the s-i channel config file as a
-	// zero-sized file when "other" is first provisioned.
-	//
-	// So if this file either does not exist, or has a size of zero
-	// (indicating the upgrader failed to complete the s-i unpack on
-	// a previous boot [which would have made configFile >0 bytes]),
-	// the other partition is considered empty.
-
-	return true
-}
-
-// Returns the part associated with the other rootfs (if any)
-func makeOtherPart(p partition.Interface) Part {
-	var part Part
-	err := p.RunWithOther(partition.RO, func(otherRoot string) (err error) {
-		if otherIsEmpty(otherRoot) {
-			return nil
-		}
-
-		configFile := filepath.Join(systemImageRoot, otherRoot, systemImageChannelConfig)
-		part, err = makePartFromSystemImageConfigFile(p, configFile, false)
-		if err != nil {
-			logger.Noticef("Can not make system-image part for %q: %v", configFile, err)
-		}
-		return err
-	})
-	if err == partition.ErrNoDualPartition {
-		return nil
-	}
-	return part
-}
-
-// Description describes the repository
-func (s *SystemImageRepository) Description() string {
-	return "SystemImageRepository"
-}
-
-// Search searches the SystemImageRepository for the given terms
-func (s *SystemImageRepository) Search(terms string) (versions []Part, err error) {
-	if strings.Contains(terms, systemImagePartName) {
-		part := makeCurrentPart(s.partition)
-		versions = append(versions, part)
-	}
-	return versions, err
-}
-
-// Details returns details for the given snap
-func (s *SystemImageRepository) Details(snapName string) (versions []Part, err error) {
-	if snapName == systemImagePartName {
-		part := makeCurrentPart(s.partition)
-		versions = append(versions, part)
-	}
-	return versions, err
-}
-
-// Updates returns the available updates
-func (s *SystemImageRepository) Updates() (parts []Part, err error) {
-	configFile := filepath.Join(systemImageRoot, systemImageChannelConfig)
-	updateStatus, err := systemImageClientCheckForUpdates(configFile)
-
-	current := makeCurrentPart(s.partition)
-	// no VersionCompare here because the channel provides a "order" and
-	// that may go backwards when switching channels(?)
-	if current.Version() != updateStatus.targetVersion {
-		parts = append(parts, &SystemImagePart{
-			version:        updateStatus.targetVersion,
-			versionDetails: updateStatus.targetVersionDetails,
-			lastUpdate:     updateStatus.lastUpdate,
-			updateSize:     updateStatus.updateSize,
-			channelName:    current.(*SystemImagePart).channelName,
-			partition:      s.partition})
-	}
-
-	return parts, err
-}
-
-// Installed returns the installed snaps from this repository
-func (s *SystemImageRepository) Installed() (parts []Part, err error) {
-	// current partition
-	curr := makeCurrentPart(s.partition)
-	if curr != nil {
-		parts = append(parts, curr)
-	}
-
-	// other partition
-	other := makeOtherPart(s.partition)
-	if other != nil {
-		parts = append(parts, other)
-	}
-
-	return parts, err
-}
-
-// needsSync determines if syncing boot assets is required
-func (s *SystemImagePart) needsBootAssetSync() bool {
-	// current partition
-	curr := makeCurrentPart(s.partition)
-	if curr == nil {
-		// this should never ever happen
-		panic("current part does not exist")
-	}
-
-	// other partition
-	other := makeOtherPart(s.partition)
-	if other == nil {
-		return true
-	}
-
-	// the idea here is that a channel change on the other
-	// partition always triggers a full image download so
-	// there is no need for syncing the assets (because the
-	// kernel is included in the full image already)
-	//
-	// FIXME: its not entirely clear if this is true, there
-	// is no mechanism to switch channels right now and all
-	// the tests always switch both partitions
-	if curr.Channel() != other.Channel() {
-		return false
-	}
-
-	// if the other version is already a higher version number
-	// than the current one it means all the kernel updates
-	// has happend already and we do not need to sync the
-	// bootloader files, see:
-	// https://bugs.launchpad.net/snappy/+bug/1474125
-	return VersionCompare(curr.Version(), other.Version()) > 0
-}
 
=== removed file 'snappy/systemimage_native.go'
--- snappy/systemimage_native.go	2015-07-02 20:57:18 +0000
+++ snappy/systemimage_native.go	1970-01-01 00:00:00 +0000
@@ -1,211 +0,0 @@
-// -*- 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 snappy
-
-import (
-	"bufio"
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"os/exec"
-	"path"
-	"strings"
-	"time"
-
-	"github.com/mvo5/goconfigparser"
-
-	"launchpad.net/snappy/helpers"
-	"launchpad.net/snappy/progress"
-)
-
-var systemImageServer = "https://system-image.ubuntu.com/"
-
-type updateStatus struct {
-	targetVersion        string
-	targetVersionDetails string
-	updateSize           int64
-	lastUpdate           time.Time
-}
-
-type channelImage struct {
-	Descripton     string              `json:"description,omitempty"`
-	Type           string              `json:"type, omitempty"`
-	Version        int                 `json:"version, omitempty"`
-	VersionDetails string              `json:"version_detail, omitempty"`
-	Files          []channelImageFiles `json:"files"`
-}
-
-type channelImageFiles struct {
-	Size int64 `json:"size"`
-}
-
-type channelImageGlobal struct {
-	GeneratedAt string `json:"generated_at"`
-}
-
-type channelJSON struct {
-	Global channelImageGlobal `json:"global"`
-	Images []channelImage     `json:"images"`
-}
-
-func systemImageClientCheckForUpdates(configFile string) (us updateStatus, err error) {
-	cfg := goconfigparser.New()
-	if err := cfg.ReadFile(configFile); err != nil {
-		return us, err
-	}
-	channel, _ := cfg.Get("service", "channel")
-	device, _ := cfg.Get("service", "device")
-
-	indexURL := systemImageServer + "/" + path.Join(channel, device, "index.json")
-
-	resp, err := http.Get(indexURL)
-	if err != nil {
-		return us, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		return us, fmt.Errorf("systemImageDbusProxy: unexpected http statusCode %v for %s", resp.StatusCode, indexURL)
-	}
-
-	// and decode json
-	var channelData channelJSON
-	dec := json.NewDecoder(resp.Body)
-	if err := dec.Decode(&channelData); err != nil {
-		return us, err
-	}
-
-	// global property
-	us.lastUpdate, _ = time.Parse("Mon Jan 2 15:04:05 MST 2006", channelData.Global.GeneratedAt)
-
-	// FIXME: find latest image of type "full" here
-	latestImage := channelData.Images[len(channelData.Images)-1]
-	us.targetVersion = fmt.Sprintf("%d", latestImage.Version)
-	us.targetVersionDetails = latestImage.VersionDetails
-
-	// FIXME: this is not accurate right now as it does not take
-	//        the deltas into account
-	for _, f := range latestImage.Files {
-		us.updateSize += f.Size
-	}
-
-	return us, nil
-}
-
-type genericJSON struct {
-	Type    string  `json:"type, omitempty"`
-	Message string  `json:"msg, omitempty"`
-	Now     float64 `json:"now, omitempty"`
-	Total   float64 `json:"total, omitempty"`
-}
-
-func parseSIProgress(pb progress.Meter, stdout io.Reader) error {
-	if pb == nil {
-		pb = &progress.NullProgress{}
-	}
-
-	scanner := bufio.NewScanner(stdout)
-	// s-i is funny, total changes during the runs
-	total := 0.0
-	pb.Start("ubuntu-core", 100)
-
-	for scanner.Scan() {
-		if os.Getenv("SNAPPY_DEBUG") != "" {
-			fmt.Println(scanner.Text())
-		}
-
-		jsonStream := strings.NewReader(scanner.Text())
-		dec := json.NewDecoder(jsonStream)
-		var genericData genericJSON
-		if err := dec.Decode(&genericData); err != nil {
-			// we ignore invalid json here and continue
-			// the parsing if s-i-cli or ubuntu-core-upgrader
-			// output something unexpected (like stray debug
-			// output or whatnot)
-			continue
-		}
-
-		switch {
-		case genericData.Type == "spinner":
-			pb.Spin(genericData.Message)
-		case genericData.Type == "error":
-			return fmt.Errorf("error from %s: %s", systemImageCli, genericData.Message)
-		case genericData.Type == "progress":
-			if total != genericData.Total {
-				total = genericData.Total
-				pb.SetTotal(total)
-			}
-			pb.Set(genericData.Now)
-		}
-	}
-	// ugly: avoid Spin() artifacts
-	pb.Notify("\nApply done")
-
-	if err := scanner.Err(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func systemImageDownloadUpdate(configDir string, pb progress.Meter) (err error) {
-	cmd := exec.Command(systemImageCli, "--progress", "json", "-C", configDir)
-
-	// collect progress over stdout pipe if we want progress
-	var stdout io.Reader
-	stdout, err = cmd.StdoutPipe()
-	if err != nil {
-		return err
-	}
-
-	// collect error message (traceback etc in a separate goroutine)
-	stderr, err := cmd.StderrPipe()
-	if err != nil {
-		return err
-	}
-	stderrCh := make(chan []byte)
-	go func() {
-		stderrContent, _ := ioutil.ReadAll(stderr)
-		stderrCh <- stderrContent
-	}()
-
-	// run it
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-
-	// and parse progress synchronously
-	if err := parseSIProgress(pb, stdout); err != nil {
-		return err
-	}
-
-	// we need to read all of stderr *before* calling cmd.Wait() to avoid
-	// a race, see docs for "os/exec:func (*Cmd) StdoutPipe"
-	stderrContent := <-stderrCh
-	if err := cmd.Wait(); err != nil {
-		retCode, _ := helpers.ExitCode(err)
-		return fmt.Errorf("%s failed with return code %v: %s", systemImageCli, retCode, string(stderrContent))
-	}
-
-	return err
-}
 
=== removed file 'snappy/systemimage_native_test.go'
--- snappy/systemimage_native_test.go	2015-06-02 20:46:07 +0000
+++ snappy/systemimage_native_test.go	1970-01-01 00:00:00 +0000
@@ -1,123 +0,0 @@
-// -*- 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 snappy
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"path/filepath"
-	"time"
-
-	. "gopkg.in/check.v1"
-)
-
-/* acquired via:
-   curl https://system-image.ubuntu.com/ubuntu-core/devel/generic_armhf/index.json
-*/
-const mockSystemImageIndexJSONTemplate = `{
-    "global": {
-        "generated_at": "Thu Feb 19 18:26:23 UTC 2015"
-    },
-    "images": [
-        {
-            "description": ",version=1",
-            "files": [
-                {
-                    "checksum": "3869be55a95db880862fe3dc3f5d643101736f674e9970a2099a883bd2bd2367",
-                    "order": 0,
-                    "path": "/pool/ubuntu-3f8ef532557aaec57264565b9948734bfe01f2a39886c816b0f69ae19e25f903.tar.xz",
-                    "signature": "/pool/ubuntu-3f8ef532557aaec57264565b9948734bfe01f2a39886c816b0f69ae19e25f903.tar.xz.asc",
-                    "size": 71081252
-                },
-                {
-                    "checksum": "f1a5ae7b4264e045ad58710a427168c02732e29130e5619dd2a82bbc8781b7c0",
-                    "order": 1,
-                    "path": "/pool/device-bf0a49e75a3deb99855f186906f17d7668e2dcc3a0b38f5feade3e6f7c75e9b8.tar.xz",
-                    "signature": "/pool/device-bf0a49e75a3deb99855f186906f17d7668e2dcc3a0b38f5feade3e6f7c75e9b8.tar.xz.asc",
-                    "size": 52589508
-                },
-                {
-                    "checksum": "a84fb49b505a797e1ddd6811d8cf79b5fe2a021198cd221e022318026dfb5417",
-                    "order": 2,
-                    "path": "/ubuntu-core/devel/generic_armhf/version-1.tar.xz",
-                    "signature": "/ubuntu-core/devel/generic_armhf/version-1.tar.xz.asc",
-                    "size": 328
-                }
-            ],
-            "type": "full",
-            "version": 1,
-            "version_detail": ",version=1"
-        },
-        {
-            "description": ",version=2",
-            "files": [
-                {
-                    "checksum": "8be1d2c82a6d785089de91febf70aa7aa790c23fae4f2e02c5dc4dfc343d005a",
-                    "order": 0,
-                    "path": "/pool/ubuntu-0e6f7a24f941a2fbe27c922b5158da9ab177afaa851c28c002a22f4166f3ec01.tar.xz",
-                    "signature": "/pool/ubuntu-0e6f7a24f941a2fbe27c922b5158da9ab177afaa851c28c002a22f4166f3ec01.tar.xz.asc",
-                    "size": 70576648
-                },
-                {
-                    "checksum": "f1a5ae7b4264e045ad58710a427168c02732e29130e5619dd2a82bbc8781b7c0",
-                    "order": 1,
-                    "path": "/pool/device-bf0a49e75a3deb99855f186906f17d7668e2dcc3a0b38f5feade3e6f7c75e9b8.tar.xz",
-                    "signature": "/pool/device-bf0a49e75a3deb99855f186906f17d7668e2dcc3a0b38f5feade3e6f7c75e9b8.tar.xz.asc",
-                    "size": 52589508
-                },
-                {
-                    "checksum": "242f0198b4bd0b63c943e7ff7eb46889753c725cb5b127a7bb76600bcecee544",
-                    "order": 2,
-                    "path": "/ubuntu-core/devel/generic_armhf/version-2.tar.xz",
-                    "signature": "/ubuntu-core/devel/generic_armhf/version-2.tar.xz.asc",
-                    "size": 332
-                }
-            ],
-            "type": "full",
-            "version": %s,
-            "version_detail": ",version=2"
-        }
-    ]
-}`
-
-var mockSystemImageIndexJSON = fmt.Sprintf(mockSystemImageIndexJSONTemplate, "2")
-
-func runMockSystemImageWebServer() *httptest.Server {
-	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		io.WriteString(w, mockSystemImageIndexJSON)
-	}))
-	if mockServer == nil {
-		return nil
-	}
-	systemImageServer = mockServer.URL
-	return mockServer
-}
-
-func (s *SITestSuite) TestCheckForUpdates(c *C) {
-	mockConfigFile := filepath.Join(c.MkDir(), "channel.init")
-	makeFakeSystemImageChannelConfig(c, mockConfigFile, "1")
-	updateStatus, err := systemImageClientCheckForUpdates(mockConfigFile)
-	c.Assert(err, IsNil)
-	c.Assert(updateStatus.targetVersion, Equals, "2")
-	c.Assert(updateStatus.targetVersionDetails, Equals, ",version=2")
-	c.Assert(updateStatus.lastUpdate, Equals, time.Date(2015, 02, 19, 18, 26, 23, 0, time.UTC))
-}
 
=== removed file 'snappy/systemimage_test.go'
--- snappy/systemimage_test.go	2015-07-15 07:53:43 +0000
+++ snappy/systemimage_test.go	1970-01-01 00:00:00 +0000
@@ -1,486 +0,0 @@
-// -*- 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 snappy
-
-import (
-	"fmt"
-	"io/ioutil"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"launchpad.net/snappy/partition"
-	"launchpad.net/snappy/provisioning"
-
-	. "gopkg.in/check.v1"
-)
-
-// Hook up check.v1 into the "go test" runner
-func Test(t *testing.T) { TestingT(t) }
-
-type SITestSuite struct {
-	systemImage              *SystemImageRepository
-	mockSystemImageWebServer *httptest.Server
-}
-
-var _ = Suite(&SITestSuite{})
-
-func (s *SITestSuite) SetUpTest(c *C) {
-	newPartition = func() (p partition.Interface) {
-		return new(MockPartition)
-	}
-
-	s.systemImage = NewSystemImageRepository()
-	c.Assert(s, NotNil)
-	// setup alternative root for system image
-	tempdir := c.MkDir()
-	systemImageRoot = tempdir
-
-	makeFakeSystemImageChannelConfig(c, filepath.Join(tempdir, systemImageChannelConfig), "1")
-	// setup fake /other partition
-	makeFakeSystemImageChannelConfig(c, filepath.Join(tempdir, "other", systemImageChannelConfig), "0")
-
-	// run test webserver instead of talking to the real one
-	//
-	// The mock webserver versions  "1" and "2"
-	s.mockSystemImageWebServer = runMockSystemImageWebServer()
-	c.Assert(s.mockSystemImageWebServer, NotNil)
-
-	// create mock system-image-cli
-	systemImageCli = makeMockSystemImageCli(c, tempdir)
-}
-
-func (s *SITestSuite) TearDownTest(c *C) {
-	s.mockSystemImageWebServer.Close()
-	systemImageRoot = "/"
-	bootloaderDir = bootloaderDirImpl
-}
-
-func makeMockSystemImageCli(c *C, tempdir string) string {
-	s := `#!/bin/sh
-
-printf '{"type": "progress", "now": 20, "total":100}\n'
-printf '{"type": "progress", "now": 40, "total":100}\n'
-printf '{"type": "progress", "now": 60, "total":100}\n'
-printf '{"type": "progress", "now": 80, "total":100}\n'
-printf '{"type": "progress", "now": 100, "total":100}\n'
-printf '{"type": "spinner", "msg": "Applying"}\n'
-`
-	mockScript := filepath.Join(tempdir, "system-image-cli")
-	err := ioutil.WriteFile(mockScript, []byte(s), 0755)
-	c.Assert(err, IsNil)
-
-	return mockScript
-}
-
-func makeFakeSystemImageChannelConfig(c *C, cfgPath, buildNumber string) {
-	os.MkdirAll(filepath.Dir(cfgPath), 0775)
-	f, err := os.OpenFile(cfgPath, os.O_CREATE|os.O_RDWR, 0664)
-	c.Assert(err, IsNil)
-	defer f.Close()
-	f.Write([]byte(fmt.Sprintf(`
-[service]
-base: system-image.ubuntu.com
-http_port: 80
-https_port: 443
-channel: ubuntu-core/devel-proposed
-device: generic_amd64
-build_number: %s
-version_detail: ubuntu=20141206,raw-device=20141206,version=77
-`, buildNumber)))
-}
-
-func (s *SITestSuite) TestTestInstalled(c *C) {
-	// whats installed
-	parts, err := s.systemImage.Installed()
-	c.Assert(err, IsNil)
-	// we have one active and one inactive
-	c.Assert(parts, HasLen, 2)
-	c.Assert(parts[0].Name(), Equals, systemImagePartName)
-	c.Assert(parts[0].Origin(), Equals, systemImagePartOrigin)
-	c.Assert(parts[0].Vendor(), Equals, systemImagePartVendor)
-	c.Assert(parts[0].Version(), Equals, "1")
-	c.Assert(parts[0].Hash(), Equals, "e09c13f68fccef3b2fe0f5c8ff5c61acf2173b170b1f2a3646487147690b0970ef6f2c555d7bcb072035f29ee4ea66a6df7f6bb320d358d3a7d78a0c37a8a549")
-	c.Assert(parts[0].IsActive(), Equals, true)
-	c.Assert(parts[0].Channel(), Equals, "ubuntu-core/devel-proposed")
-
-	// second partition is not active and has a different version
-	c.Assert(parts[1].IsActive(), Equals, false)
-	c.Assert(parts[1].Version(), Equals, "0")
-}
-
-func (s *SITestSuite) TestUpdateNoUpdate(c *C) {
-	mockSystemImageIndexJSON = fmt.Sprintf(mockSystemImageIndexJSONTemplate, "1")
-	parts, err := s.systemImage.Updates()
-	c.Assert(err, IsNil)
-	c.Assert(parts, HasLen, 0)
-}
-
-func (s *SITestSuite) TestUpdateHasUpdate(c *C) {
-	// add a update
-	mockSystemImageIndexJSON = fmt.Sprintf(mockSystemImageIndexJSONTemplate, "2")
-	parts, err := s.systemImage.Updates()
-	c.Assert(err, IsNil)
-	c.Assert(parts, HasLen, 1)
-	c.Assert(parts[0].Name(), Equals, "ubuntu-core")
-	c.Assert(parts[0].Version(), Equals, "2")
-	c.Assert(parts[0].DownloadSize(), Equals, int64(123166488))
-}
-
-type MockPartition struct {
-	toggleNextBootCalled      bool
-	markBootSuccessfulCalled  bool
-	syncBootloaderFilesCalled bool
-}
-
-func (p *MockPartition) ToggleNextBoot() error {
-	p.toggleNextBootCalled = true
-	return nil
-}
-
-func (p *MockPartition) MarkBootSuccessful() error {
-	p.markBootSuccessfulCalled = true
-	return nil
-}
-func (p *MockPartition) SyncBootloaderFiles(map[string]string) error {
-	p.syncBootloaderFilesCalled = true
-	return nil
-}
-func (p *MockPartition) IsNextBootOther() bool {
-	return false
-}
-
-func (p *MockPartition) RunWithOther(option partition.MountOption, f func(otherRoot string) (err error)) (err error) {
-	return f("/other")
-}
-
-// used by GetBootLoaderDir(), used to test sideload logic.
-var tempBootDir string
-
-func (p *MockPartition) BootloaderDir() string {
-	return tempBootDir
-}
-
-func (s *SITestSuite) TestSystemImagePartInstallUpdatesPartition(c *C) {
-	// FIXME: ideally we would change the version to "2" as a side-effect
-	// of calling sp.Install() we need to update it because the
-	// sp.Install() will verify that it got applied
-	makeFakeSystemImageChannelConfig(c, filepath.Join(systemImageRoot, "other", systemImageChannelConfig), "2")
-
-	// add a update
-	mockSystemImageIndexJSON = fmt.Sprintf(mockSystemImageIndexJSONTemplate, "2")
-	parts, err := s.systemImage.Updates()
-	c.Assert(err, IsNil)
-
-	sp := parts[0].(*SystemImagePart)
-	mockPartition := MockPartition{}
-	sp.partition = &mockPartition
-
-	pb := &MockProgressMeter{}
-	// do the install
-	_, err = sp.Install(pb, 0)
-	c.Assert(err, IsNil)
-	c.Assert(mockPartition.toggleNextBootCalled, Equals, true)
-	c.Assert(pb.total, Equals, 100.0)
-	c.Assert(pb.spin, Equals, true)
-	c.Assert(pb.spinMsg, Equals, "Applying")
-	c.Assert(pb.finished, Equals, true)
-	c.Assert(pb.progress, DeepEquals, []float64{20.0, 40.0, 60.0, 80.0, 100.0})
-}
-
-func (s *SITestSuite) TestSystemImagePartInstallUpdatesBroken(c *C) {
-	// fake a broken upgrade
-	scriptContent := `#!/bin/sh
-printf '{"type": "error", "msg": "some error msg"}\n'