Merge lp:~snappy-dev/snappy/snappy-moved-to-github into lp:snappy/15.04

[Michael Vogt]

Merge trunk fixes.

Update 15.04 from trunk to bring in the husks^Wlightweight improvements from for the rest API

[lp:~snappy-dev/snappy/snappy-moved-to-github]

760. By John Lenton on 2015-10-12

Lightweights didn't consider "current" in the datadir, which is now a thing. Fixed that. by chipaca approved by mvo

761. By John Lenton on 2015-10-12

Only run service commands on active parts. by chipaca approved by mvo

762. By John Lenton on 2015-10-12

Don't let people sideload over things that are installed; it breaks stuff. by chipaca approved by mvo

[John Lenton (chipaca)]

... studiously ignoring this mp until a few more branches land...

[lp:~snappy-dev/snappy/snappy-moved-to-github]

763. By John Lenton on 2015-10-12

Ignore toplevel DEBIAN in build. by chipaca approved by mvo

764. By John Lenton on 2015-10-12

Switch socket to be a named unix socket, /run/snapd.socket. by chipaca approved by mvo

765. By John Lenton on 2015-10-12

Include store id in /1.0 response. by chipaca approved by mvo

[John Lenton (chipaca)]

review: Approve

=== added directory '_integration-tests/data/snaps/basic-binaries'
=== added directory '_integration-tests/data/snaps/basic-binaries/bin'
=== added file '_integration-tests/data/snaps/basic-binaries/bin/echo'
--- _integration-tests/data/snaps/basic-binaries/bin/echo	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic-binaries/bin/echo	2015-10-12 09:23:01 +0000
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+echo "From basic-binaries snap"

=== added directory '_integration-tests/data/snaps/basic-binaries/meta'
=== added file '_integration-tests/data/snaps/basic-binaries/meta/package.yaml'
--- _integration-tests/data/snaps/basic-binaries/meta/package.yaml	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic-binaries/meta/package.yaml	2015-10-12 09:23:01 +0000
@@ -0,0 +1,6 @@
+name: basic-binaries
+version: 1.0
+vendor: Snappy Developers <[e-mail]>
+icon: meta/snappy64.png
+binaries:
+ - name: bin/echo

=== added file '_integration-tests/data/snaps/basic-binaries/meta/readme.md'
--- _integration-tests/data/snaps/basic-binaries/meta/readme.md	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic-binaries/meta/readme.md	2015-10-12 09:23:01 +0000
@@ -0,0 +1,3 @@
+Basic Binary snap
+
+A basic snap with binary entries

=== added file '_integration-tests/data/snaps/basic-binaries/meta/snappy64.png'
Binary files _integration-tests/data/snaps/basic-binaries/meta/snappy64.png	1970-01-01 00:00:00 +0000 and _integration-tests/data/snaps/basic-binaries/meta/snappy64.png	2015-10-12 09:23:01 +0000 differ
=== added directory '_integration-tests/data/snaps/dev-kmsg'
=== added directory '_integration-tests/data/snaps/dev-kmsg/bin'
=== added file '_integration-tests/data/snaps/dev-kmsg/bin/reader'
--- _integration-tests/data/snaps/dev-kmsg/bin/reader	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/dev-kmsg/bin/reader	2015-10-12 09:23:01 +0000
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+dd if=/dev/kmsg iflag=nonblock
\ No newline at end of file

=== added directory '_integration-tests/data/snaps/dev-kmsg/meta'
=== added file '_integration-tests/data/snaps/dev-kmsg/meta/package.yaml'
--- _integration-tests/data/snaps/dev-kmsg/meta/package.yaml	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/dev-kmsg/meta/package.yaml	2015-10-12 09:23:01 +0000
@@ -0,0 +1,6 @@
+name: dev-kmsg
+version: 1.0
+vendor: Snappy Developers <[e-mail]>
+icon: meta/snappy64.png
+binaries:
+ - name: bin/reader

=== added file '_integration-tests/data/snaps/dev-kmsg/meta/readme.md'
--- _integration-tests/data/snaps/dev-kmsg/meta/readme.md	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/dev-kmsg/meta/readme.md	2015-10-12 09:23:01 +0000
@@ -0,0 +1,5 @@
+dev-kmsg snap
+
+This simple snap provides a binary to read and output real raw
+data from /dev/kmsg using dd. For it to work it needs that hw
+to be assigned before being run.

=== added file '_integration-tests/data/snaps/dev-kmsg/meta/snappy64.png'
Binary files _integration-tests/data/snaps/dev-kmsg/meta/snappy64.png	1970-01-01 00:00:00 +0000 and _integration-tests/data/snaps/dev-kmsg/meta/snappy64.png	2015-10-12 09:23:01 +0000 differ
=== added file '_integration-tests/tests/activate_test.go'
--- _integration-tests/tests/activate_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/activate_test.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,84 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"os"
+
+	"gopkg.in/check.v1"
+
+	"launchpad.net/snappy/_integration-tests/testutils/build"
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
+)
+
+const (
+	activateSnapName    = "basic-binaries"
+	activateBinName     = activateSnapName + ".echo"
+	activateEchoOutput  = "From basic-binaries snap\n"
+	baseActivatePattern = "(?msU).*" + activateSnapName + `\s*.*\s*.*sideload`
+	activatedPattern    = baseActivatePattern + `\*\s*\n.*`
+	deActivatedPattern  = baseActivatePattern + `\s*\n.*`
+)
+
+var _ = check.Suite(&activateSuite{})
+
+type activateSuite struct {
+	common.SnappySuite
+	snapPath string
+}
+
+func (s *activateSuite) SetUpSuite(c *check.C) {
+	s.SnappySuite.SetUpSuite(c)
+	var err error
+	s.snapPath, err = build.LocalSnap(c, activateSnapName)
+	c.Assert(err, check.IsNil)
+	common.InstallSnap(c, s.snapPath)
+}
+
+func (s *activateSuite) TearDownSuite(c *check.C) {
+	os.Remove(s.snapPath)
+	common.RemoveSnap(c, activateSnapName)
+}
+
+func (s *activateSuite) TestDeactivateRemovesBinary(c *check.C) {
+	cli.ExecCommand(c, "sudo", "snappy", "deactivate", activateSnapName)
+	defer cli.ExecCommand(c, "sudo", "snappy", "activate", activateSnapName)
+	output, err := cli.ExecCommandErr(activateBinName)
+
+	c.Assert(err, check.NotNil)
+	c.Assert(output, check.Not(check.Equals), activateEchoOutput)
+
+	list := cli.ExecCommand(c, "snappy", "list", "-v")
+
+	c.Assert(list, check.Matches, deActivatedPattern)
+}
+
+func (s *activateSuite) TestActivateBringsBinaryBack(c *check.C) {
+	cli.ExecCommand(c, "sudo", "snappy", "deactivate", activateSnapName)
+	cli.ExecCommand(c, "sudo", "snappy", "activate", activateSnapName)
+	output := cli.ExecCommand(c, activateBinName)
+
+	c.Assert(output, check.Equals, activateEchoOutput)
+
+	list := cli.ExecCommand(c, "snappy", "list", "-v")
+
+	c.Assert(list, check.Matches, activatedPattern)
+}

=== modified file '_integration-tests/tests/apt_test.go'
--- _integration-tests/tests/apt_test.go	2015-07-28 04:03:52 +0000
+++ _integration-tests/tests/apt_test.go	2015-10-12 09:23:01 +0000
@@ -20,19 +20,20 @@
 package tests
 
 import (
-	. "launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
 
-	check "gopkg.in/check.v1"
+	"gopkg.in/check.v1"
 )
 
 var _ = check.Suite(&aptSuite{})
 
 type aptSuite struct {
-	SnappySuite
+	common.SnappySuite
 }
 
 func (s *aptSuite) TestAptGetMustPrintError(c *check.C) {
-	aptOutput := ExecCommand(c, "apt-get", "update")
+	aptOutput := cli.ExecCommand(c, "apt-get", "update")
 
 	expected := "Ubuntu Core does not use apt-get, see 'snappy --help'!\n"
 	c.Assert(aptOutput, check.Equals, expected)

=== added file '_integration-tests/tests/config_test.go'
--- _integration-tests/tests/config_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/config_test.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,114 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"io/ioutil"
+	"os"
+	"strings"
+
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
+
+	"gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&configSuite{})
+
+type configSuite struct {
+	common.SnappySuite
+	backConfig string
+}
+
+func (s *configSuite) SetUpTest(c *check.C) {
+	s.SnappySuite.SetUpTest(c)
+	s.backConfig = currentConfig(c)
+}
+
+func (s *configSuite) TearDownTest(c *check.C) {
+	s.SnappySuite.TearDownTest(c)
+	s.setConfig(c, s.backConfig)
+}
+
+func (s *configSuite) TestModprobe(c *check.C) {
+	s.doTest(c, `modprobe: blacklist floppy`)
+}
+
+func (s *configSuite) TestPPP(c *check.C) {
+	s.doTest(c, `network:
+      ppp:
+      - name: chap-secrets
+        content: secret`)
+}
+
+func (s *configSuite) TestWatchdog(c *check.C) {
+	s.doTest(c, `watchdog:
+      startup: |
+        run_watchdog=0
+        run_wd_keepalive=0
+        watchdog_module="none"`)
+}
+
+func (s *configSuite) TestNetworkInterfaces(c *check.C) {
+	s.doTest(c, `network:
+      interfaces:
+      - name: eth0
+        content: config`)
+}
+
+func (s *configSuite) doTest(c *check.C, targetCfg string) {
+	config := configString(targetCfg)
+
+	err := s.setConfig(c, config)
+	c.Assert(err, check.IsNil)
+
+	actualConfig := currentConfig(c)
+
+	// we admit any characters after a new line, this is needed because the reuse
+	// of the config yaml string in the regex pattern, after setting a configuration
+	// option any other sibling options can appear before the one set when displaying
+	// the configuration (for instance, network-interfaces is always shown before
+	// network-ppp)
+	configPattern := "(?Usm).*" + strings.Replace(targetCfg, "\n", "\n.*", -1) + ".*"
+	c.Assert(actualConfig, check.Matches, configPattern)
+}
+
+func (s *configSuite) setConfig(c *check.C, config string) (err error) {
+	configFile, err := ioutil.TempFile("", "snappy-cfg")
+	defer func() { configFile.Close(); os.Remove(configFile.Name()) }()
+	if err != nil {
+		return
+	}
+	_, err = configFile.Write([]byte(config))
+
+	cli.ExecCommand(c, "sudo", "snappy", "config", "ubuntu-core", configFile.Name())
+
+	return
+}
+
+func currentConfig(c *check.C) string {
+	return cli.ExecCommand(c, "sudo", "snappy", "config", "ubuntu-core")
+}
+
+func configString(cfg string) string {
+	return `config:
+  ubuntu-core:
+    ` + cfg
+}

=== added file '_integration-tests/tests/examples_test.go'
--- _integration-tests/tests/examples_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/examples_test.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,72 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"net/http"
+
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/wait"
+
+	"gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&webserverExampleSuite{})
+
+type webserverExampleSuite struct {
+	common.SnappySuite
+}
+
+func (s *webserverExampleSuite) TestNetworkingServiceMustBeStarted(c *check.C) {
+	baseAppName := "xkcd-webserver"
+	appName := baseAppName + ".canonical"
+	common.InstallSnap(c, appName)
+	defer common.RemoveSnap(c, appName)
+
+	err := wait.ForServerOnPort(c, 80)
+	c.Assert(err, check.IsNil)
+
+	resp, err := http.Get("http://localhost")
+	c.Assert(err, check.IsNil)
+	c.Check(resp.Status, check.Equals, "200 OK")
+	c.Assert(resp.Proto, check.Equals, "HTTP/1.0")
+}
+
+var _ = check.Suite(&frameworkExampleSuite{})
+
+type frameworkExampleSuite struct {
+	common.SnappySuite
+}
+
+func (s *frameworkExampleSuite) TestFrameworkClient(c *check.C) {
+	common.InstallSnap(c, "hello-dbus-fwk.canonical")
+	defer common.RemoveSnap(c, "hello-dbus-fwk.canonical")
+
+	common.InstallSnap(c, "hello-dbus-app.canonical")
+	defer common.RemoveSnap(c, "hello-dbus-app.canonical")
+
+	output := cli.ExecCommand(c, "hello-dbus-app.client")
+
+	expected := "PASS\n"
+
+	c.Assert(output, check.Equals, expected,
+		check.Commentf("Expected output %s not found, %s", expected, output))
+}

=== modified file '_integration-tests/tests/failover_rclocal_crash_test.go'
--- _integration-tests/tests/failover_rclocal_crash_test.go	2015-09-09 06:56:19 +0000
+++ _integration-tests/tests/failover_rclocal_crash_test.go	2015-10-12 09:23:01 +0000
@@ -22,26 +22,29 @@
 import (
 	"fmt"
 
-	. "launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/partition"
 
-	check "gopkg.in/check.v1"
+	"gopkg.in/check.v1"
 )
 
 type rcLocalCrash struct{}
 
 func (rcLocalCrash) set(c *check.C) {
-	MakeWritable(c, BaseAltPartitionPath)
-	defer MakeReadonly(c, BaseAltPartitionPath)
-	targetFile := fmt.Sprintf("%s/etc/rc.local", BaseAltPartitionPath)
-	ExecCommand(c, "sudo", "chmod", "a+xw", targetFile)
-	ExecCommandToFile(c, targetFile,
+	partition.MakeWritable(c, common.BaseAltPartitionPath)
+	defer partition.MakeReadonly(c, common.BaseAltPartitionPath)
+	targetFile := fmt.Sprintf("%s/etc/rc.local", common.BaseAltPartitionPath)
+	cli.ExecCommand(c, "sudo", "chmod", "a+xw", targetFile)
+
+	cli.ExecCommandToFile(c, targetFile,
 		"sudo", "echo", "#!bin/sh\nprintf c > /proc/sysrq-trigger")
 }
 
 func (rcLocalCrash) unset(c *check.C) {
-	MakeWritable(c, BaseAltPartitionPath)
-	defer MakeReadonly(c, BaseAltPartitionPath)
-	ExecCommand(c, "sudo", "rm", fmt.Sprintf("%s/etc/rc.local", BaseAltPartitionPath))
+	partition.MakeWritable(c, common.BaseAltPartitionPath)
+	defer partition.MakeReadonly(c, common.BaseAltPartitionPath)
+	cli.ExecCommand(c, "sudo", "rm", fmt.Sprintf("%s/etc/rc.local", common.BaseAltPartitionPath))
 }
 
 /*

=== modified file '_integration-tests/tests/failover_systemd_loop_test.go'
--- _integration-tests/tests/failover_systemd_loop_test.go	2015-07-30 16:22:30 +0000
+++ _integration-tests/tests/failover_systemd_loop_test.go	2015-10-12 09:23:01 +0000
@@ -22,9 +22,11 @@
 import (
 	"fmt"
 
-	. "launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/partition"
 
-	check "gopkg.in/check.v1"
+	"gopkg.in/check.v1"
 )
 
 const (
@@ -61,51 +63,51 @@
 type systemdDependencyLoop struct{}
 
 func (systemdDependencyLoop) set(c *check.C) {
-	installService(c, "deadlock", deadlockService, BaseAltPartitionPath)
-	installService(c, "emerg-reboot", rebootService, BaseAltPartitionPath)
+	installService(c, "deadlock", deadlockService, common.BaseAltPartitionPath)
+	installService(c, "emerg-reboot", rebootService, common.BaseAltPartitionPath)
 }
 
 func (systemdDependencyLoop) unset(c *check.C) {
-	unInstallService(c, "deadlock", BaseAltPartitionPath)
-	unInstallService(c, "emerg-reboot", BaseAltPartitionPath)
+	unInstallService(c, "deadlock", common.BaseAltPartitionPath)
+	unInstallService(c, "emerg-reboot", common.BaseAltPartitionPath)
 }
 
 func installService(c *check.C, serviceName, serviceCfg, basePath string) {
-	MakeWritable(c, basePath)
-	defer MakeReadonly(c, basePath)
+	partition.MakeWritable(c, basePath)
+	defer partition.MakeReadonly(c, basePath)
 
 	// Create service file
 	serviceFile := fmt.Sprintf("%s%s/%s.service", basePath, baseSystemdPath, serviceName)
-	ExecCommand(c, "sudo", "chmod", "a+w", fmt.Sprintf("%s%s", basePath, baseSystemdPath))
-	ExecCommandToFile(c, serviceFile, "sudo", "echo", serviceCfg)
+	cli.ExecCommand(c, "sudo", "chmod", "a+w", fmt.Sprintf("%s%s", basePath, baseSystemdPath))
+	cli.ExecCommandToFile(c, serviceFile, "sudo", "echo", serviceCfg)
 
 	// Create requires directory
 	requiresDirPart := fmt.Sprintf("%s/%s", baseSystemdPath, systemdTargetRequiresDir)
 	requiresDir := fmt.Sprintf("%s%s", basePath, requiresDirPart)
-	ExecCommand(c, "sudo", "mkdir", "-p", requiresDir)
+	cli.ExecCommand(c, "sudo", "mkdir", "-p", requiresDir)
 
 	// Symlink from the requires dir to the service file (with chroot for being
 	// usable in the other partition)
-	ExecCommand(c, "sudo", "chroot", basePath, "ln", "-s",
+	cli.ExecCommand(c, "sudo", "chroot", basePath, "ln", "-s",
 		fmt.Sprintf("%s/%s.service", baseSystemdPath, serviceName),
 		fmt.Sprintf("%s/%s.service", requiresDirPart, serviceName),
 	)
 }
 
 func unInstallService(c *check.C, serviceName, basePath string) {
-	MakeWritable(c, basePath)
-	defer MakeReadonly(c, basePath)
+	partition.MakeWritable(c, basePath)
+	defer partition.MakeReadonly(c, basePath)
 
 	// Disable the service
-	ExecCommand(c, "sudo", "chroot", basePath,
+	cli.ExecCommand(c, "sudo", "chroot", basePath,
 		"systemctl", "disable", fmt.Sprintf("%s.service", serviceName))
 
 	// Remove the service file
-	ExecCommand(c, "sudo", "rm",
+	cli.ExecCommand(c, "sudo", "rm",
 		fmt.Sprintf("%s%s/%s.service", basePath, baseSystemdPath, serviceName))
 
 	// Remove the requires symlink
-	ExecCommand(c, "sudo", "rm",
+	cli.ExecCommand(c, "sudo", "rm",
 		fmt.Sprintf("%s%s/%s/%s.service", basePath, baseSystemdPath, systemdTargetRequiresDir, serviceName))
 }
 

=== modified file '_integration-tests/tests/failover_test.go'
--- _integration-tests/tests/failover_test.go	2015-07-28 04:03:52 +0000
+++ _integration-tests/tests/failover_test.go	2015-10-12 09:23:01 +0000
@@ -20,15 +20,15 @@
 package tests
 
 import (
-	check "gopkg.in/check.v1"
+	"gopkg.in/check.v1"
 
-	. "launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
 )
 
 var _ = check.Suite(&failoverSuite{})
 
 type failoverSuite struct {
-	SnappySuite
+	common.SnappySuite
 }
 
 // The types that implement this interface can be used in the test logic
@@ -43,16 +43,16 @@
 // type implementing the failer interface and call this function with an instance
 // of it
 func commonFailoverTest(c *check.C, f failer) {
-	currentVersion := GetCurrentUbuntuCoreVersion(c)
+	currentVersion := common.GetCurrentUbuntuCoreVersion(c)
 
-	if AfterReboot(c) {
-		RemoveRebootMark(c)
+	if common.AfterReboot(c) {
+		common.RemoveRebootMark(c)
 		f.unset(c)
-		c.Assert(GetSavedVersion(c), check.Equals, currentVersion)
+		c.Assert(common.GetSavedVersion(c), check.Equals, currentVersion)
 	} else {
-		SetSavedVersion(c, currentVersion-1)
-		CallFakeUpdate(c)
+		common.SetSavedVersion(c, currentVersion-1)
+		common.CallFakeUpdate(c)
 		f.set(c)
-		Reboot(c)
+		common.Reboot(c)
 	}
 }

=== modified file '_integration-tests/tests/failover_zero_size_file_test.go'
--- _integration-tests/tests/failover_zero_size_file_test.go	2015-09-25 14:35:29 +0000
+++ _integration-tests/tests/failover_zero_size_file_test.go	2015-10-12 09:23:01 +0000
@@ -25,7 +25,8 @@
 	"path/filepath"
 	"strings"
 
-	. "launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
 	"launchpad.net/snappy/_integration-tests/testutils/partition"
 
 	"gopkg.in/check.v1"
@@ -45,11 +46,11 @@
 type zeroSizeSystemd struct{}
 
 func (zeroSizeKernel) set(c *check.C) {
-	commonSet(c, BaseAltPartitionPath, origBootFilenamePattern, kernelFilename)
+	commonSet(c, common.BaseAltPartitionPath, origBootFilenamePattern, kernelFilename)
 }
 
 func (zeroSizeKernel) unset(c *check.C) {
-	commonUnset(c, BaseAltPartitionPath, origBootFilenamePattern, kernelFilename)
+	commonUnset(c, common.BaseAltPartitionPath, origBootFilenamePattern, kernelFilename)
 }
 
 func (zeroSizeInitrd) set(c *check.C) {
@@ -71,11 +72,11 @@
 }
 
 func (zeroSizeSystemd) set(c *check.C) {
-	commonSet(c, BaseAltPartitionPath, origSystemdFilenamePattern, systemdFilename)
+	commonSet(c, common.BaseAltPartitionPath, origSystemdFilenamePattern, systemdFilename)
 }
 
 func (zeroSizeSystemd) unset(c *check.C) {
-	commonUnset(c, BaseAltPartitionPath, origSystemdFilenamePattern, systemdFilename)
+	commonUnset(c, common.BaseAltPartitionPath, origSystemdFilenamePattern, systemdFilename)
 }
 
 func commonSet(c *check.C, baseOtherPath, origPattern, filename string) {
@@ -105,17 +106,17 @@
 func renameFile(c *check.C, basePath, oldFilename, newFilename string, keepOld bool) {
 	// Only need to make writable and revert for BaseAltPartitionPath,
 	// kernel files' boot directory is writable
-	if basePath == BaseAltPartitionPath {
-		MakeWritable(c, basePath)
-		defer MakeReadonly(c, basePath)
+	if basePath == common.BaseAltPartitionPath {
+		partition.MakeWritable(c, basePath)
+		defer partition.MakeReadonly(c, basePath)
 	}
 
-	ExecCommand(c, "sudo", "mv", oldFilename, newFilename)
+	cli.ExecCommand(c, "sudo", "mv", oldFilename, newFilename)
 
 	if keepOld {
-		ExecCommand(c, "sudo", "touch", oldFilename)
+		cli.ExecCommand(c, "sudo", "touch", oldFilename)
 		mode := getFileMode(c, newFilename)
-		ExecCommand(c, "sudo", "chmod", fmt.Sprintf("%o", mode), oldFilename)
+		cli.ExecCommand(c, "sudo", "chmod", fmt.Sprintf("%o", mode), oldFilename)
 	}
 }
 

=== added file '_integration-tests/tests/hwAssign_test.go'
--- _integration-tests/tests/hwAssign_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/hwAssign_test.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,106 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+
+	"launchpad.net/snappy/_integration-tests/testutils/build"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
+
+	"gopkg.in/check.v1"
+)
+
+const (
+	snapName          = "dev-kmsg"
+	binName           = snapName + ".reader"
+	installedSnapName = snapName + ".sideload"
+	hwName            = "/dev/kmsg"
+	hwAssignError     = "dd: failed to open ‘" + hwName + "’: Permission denied\n"
+)
+
+var _ = check.Suite(&hwAssignSuite{})
+
+type hwAssignSuite struct {
+	common.SnappySuite
+	snapPath string
+}
+
+func (s *hwAssignSuite) SetUpTest(c *check.C) {
+	s.SnappySuite.SetUpTest(c)
+	var err error
+	s.snapPath, err = build.LocalSnap(c, snapName)
+	c.Assert(err, check.IsNil)
+	common.InstallSnap(c, s.snapPath)
+}
+
+func (s *hwAssignSuite) TearDownTest(c *check.C) {
+	s.SnappySuite.TearDownTest(c)
+	os.Remove(s.snapPath)
+	common.RemoveSnap(c, snapName)
+}
+
+func (s *hwAssignSuite) TestErrorWithoutHwAssign(c *check.C) {
+	cmd := exec.Command(binName)
+	output, err := cmd.CombinedOutput()
+
+	c.Assert(err, check.NotNil)
+	c.Assert(string(output), check.Equals, hwAssignError)
+}
+
+func (s *hwAssignSuite) TestSuccessAfterHwAssign(c *check.C) {
+	assign(c, snapName, hwName)
+	defer unassign(c, snapName, hwName)
+
+	cmd := exec.Command(binName)
+	output, _ := cmd.CombinedOutput()
+
+	c.Assert(string(output), check.Not(check.Equals), hwAssignError)
+}
+
+func (s *hwAssignSuite) TestErrorAfterHwUnAssign(c *check.C) {
+	assign(c, snapName, hwName)
+	unassign(c, snapName, hwName)
+
+	cmd := exec.Command(binName)
+	output, err := cmd.CombinedOutput()
+
+	c.Assert(err, check.NotNil)
+	c.Assert(string(output), check.Equals, hwAssignError)
+}
+
+func assign(c *check.C, snap, hw string) {
+	cmd := exec.Command("sudo", "snappy", "hw-assign", installedSnapName, hwName)
+	output, err := cmd.CombinedOutput()
+	c.Assert(err, check.IsNil)
+	c.Assert(string(output), check.Equals,
+		fmt.Sprintf("'%s' is now allowed to access '%s'\n", installedSnapName, hwName))
+}
+
+func unassign(c *check.C, snap, hw string) {
+	cmd := exec.Command("sudo", "snappy", "hw-unassign", installedSnapName, hwName)
+	output, err := cmd.CombinedOutput()
+	c.Assert(err, check.IsNil)
+	c.Assert(string(output), check.Equals,
+		fmt.Sprintf("'%s' is no longer allowed to access '%s'\n", installedSnapName, hwName))
+
+}

=== modified file '_integration-tests/tests/info_test.go'
--- _integration-tests/tests/info_test.go	2015-07-31 07:55:33 +0000
+++ _integration-tests/tests/info_test.go	2015-10-12 09:23:01 +0000
@@ -21,55 +21,60 @@
 
 import (
 	"fmt"
-
-	. "launchpad.net/snappy/_integration-tests/testutils/common"
-
-	check "gopkg.in/check.v1"
+	"os"
+
+	"launchpad.net/snappy/_integration-tests/testutils/build"
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
+
+	"gopkg.in/check.v1"
 )
 
 var _ = check.Suite(&infoSuite{})
 
 type infoSuite struct {
-	SnappySuite
+	common.SnappySuite
 }
 
 func (s *infoSuite) TestInfoMustPrintReleaseAndChannel(c *check.C) {
 	// skip test when having a remote testbed (we can't know which the
 	// release and channels are)
-	if Cfg.RemoteTestbed {
+	if common.Cfg.RemoteTestbed {
 		c.Skip(fmt.Sprintf(
 			"Skipping %s while testing in remote testbed",
 			c.TestName()))
 	}
 
-	infoOutput := ExecCommand(c, "snappy", "info")
+	infoOutput := cli.ExecCommand(c, "snappy", "info")
 
 	expected := "(?ms)" +
-		fmt.Sprintf("^release: ubuntu-core/%s/%s\n", Cfg.Release, Cfg.Channel) +
+		fmt.Sprintf("^release: ubuntu-core/%s/%s\n", common.Cfg.Release, common.Cfg.Channel) +
 		".*"
 
 	c.Assert(infoOutput, check.Matches, expected)
 }
 
 func (s *infoSuite) TestInfoMustPrintInstalledApps(c *check.C) {
-	InstallSnap(c, "hello-world")
-	s.AddCleanup(func() {
-		RemoveSnap(c, "hello-world")
-	})
-	infoOutput := ExecCommand(c, "snappy", "info")
+	snapPath, err := build.LocalSnap(c, build.BasicSnapName)
+	defer os.Remove(snapPath)
+	c.Assert(err, check.IsNil)
+	common.InstallSnap(c, snapPath)
+	defer common.RemoveSnap(c, build.BasicSnapName)
+
+	infoOutput := cli.ExecCommand(c, "snappy", "info")
 
 	expected := "(?ms)" +
 		".*" +
-		"^apps: .*hello-world.*\n"
+		"^apps: .*" + build.BasicSnapName + "\\.sideload.*\n"
 	c.Assert(infoOutput, check.Matches, expected)
 }
 
 func (s *infoSuite) TestInfoMustPrintInstalledFrameworks(c *check.C) {
-	InstallSnap(c, "hello-dbus-fwk.canonical")
+	common.InstallSnap(c, "hello-dbus-fwk.canonical")
 	s.AddCleanup(func() {
-		RemoveSnap(c, "hello-dbus-fwk.canonical")
+		common.RemoveSnap(c, "hello-dbus-fwk.canonical")
 	})
-	infoOutput := ExecCommand(c, "snappy", "info")
+	infoOutput := cli.ExecCommand(c, "snappy", "info")
 
 	expected := "(?ms)" +
 		".*" +

=== modified file '_integration-tests/tests/installApp_test.go'
--- _integration-tests/tests/installApp_test.go	2015-09-24 19:51:26 +0000
+++ _integration-tests/tests/installApp_test.go	2015-10-12 09:23:01 +0000
@@ -20,13 +20,12 @@
 package tests
 
 import (
-	"net/http"
 	"os/exec"
 
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
 	"launchpad.net/snappy/_integration-tests/testutils/common"
-	"launchpad.net/snappy/_integration-tests/testutils/wait"
 
-	check "gopkg.in/check.v1"
+	"gopkg.in/check.v1"
 )
 
 var _ = check.Suite(&installAppSuite{})
@@ -57,7 +56,7 @@
 		common.RemoveSnap(c, "hello-world")
 	})
 
-	echoOutput := common.ExecCommand(c, "hello-world.echo")
+	echoOutput := cli.ExecCommand(c, "hello-world.echo")
 
 	c.Assert(echoOutput, check.Equals, "Hello World!\n")
 }
@@ -83,35 +82,6 @@
 	c.Assert(string(echoOutput), check.Matches, expected)
 }
 
-func (s *installAppSuite) TestInfoMustPrintInstalledPackageInformation(c *check.C) {
-	common.InstallSnap(c, "hello-world")
-	s.AddCleanup(func() {
-		common.RemoveSnap(c, "hello-world")
-	})
-
-	infoOutput := common.ExecCommand(c, "snappy", "info")
-
-	expected := "(?ms).*^apps: hello-world.canonical\n"
-	c.Assert(infoOutput, check.Matches, expected)
-}
-
-func (s *installAppSuite) TestAppNetworkingServiceMustBeStarted(c *check.C) {
-	baseAppName := "xkcd-webserver"
-	appName := baseAppName + ".canonical"
-	common.InstallSnap(c, appName)
-	s.AddCleanup(func() {
-		common.RemoveSnap(c, appName)
-	})
-
-	err := wait.ForServerOnPort(c, 80)
-	c.Assert(err, check.IsNil)
-
-	resp, err := http.Get("http://localhost")
-	c.Assert(err, check.IsNil)
-	c.Check(resp.Status, check.Equals, "200 OK")
-	c.Assert(resp.Proto, check.Equals, "HTTP/1.0")
-}
-
 func (s *installAppSuite) TestInstallUnexistingAppMustPrintError(c *check.C) {
 	cmd := exec.Command("sudo", "snappy", "install", "unexisting.canonical")
 	output, err := cmd.CombinedOutput()

=== renamed file '_integration-tests/tests/helloDbus_test.go' => '_integration-tests/tests/installFramework_test.go'
--- _integration-tests/tests/helloDbus_test.go	2015-09-11 08:47:39 +0000
+++ _integration-tests/tests/installFramework_test.go	2015-10-12 09:23:01 +0000
@@ -25,23 +25,22 @@
 	"gopkg.in/check.v1"
 )
 
-var _ = check.Suite(&helloDbusSuite{})
+var _ = check.Suite(&installFrameworkSuite{})
 
-type helloDbusSuite struct {
+type installFrameworkSuite struct {
 	common.SnappySuite
 }
 
-func (s *helloDbusSuite) TestCmdOutput(c *check.C) {
-	common.InstallSnap(c, "hello-dbus-fwk.canonical")
+func (s *installFrameworkSuite) TestInstallFrameworkMustPrintPackageInformation(c *check.C) {
+	installOutput := common.InstallSnap(c, "hello-dbus-fwk.canonical")
 	defer common.RemoveSnap(c, "hello-dbus-fwk.canonical")
 
-	common.InstallSnap(c, "hello-dbus-app.canonical")
-	defer common.RemoveSnap(c, "hello-dbus-app.canonical")
-
-	output := common.ExecCommand(c, "hello-dbus-app.client")
-
-	expected := "PASS\n"
-
-	c.Assert(output, check.Equals, expected,
-		check.Commentf("Expected output %s not found, %s", expected, output))
+	expected := "(?ms)" +
+		"Installing hello-dbus-fwk.canonical\n" +
+		"Name +Date +Version +Developer \n" +
+		".*" +
+		"^hello-dbus-fwk +.* +.* +canonical \n" +
+		".*"
+
+	c.Assert(installOutput, check.Matches, expected)
 }

=== modified file '_integration-tests/tests/list_test.go'
--- _integration-tests/tests/list_test.go	2015-07-28 04:03:52 +0000
+++ _integration-tests/tests/list_test.go	2015-10-12 09:23:01 +0000
@@ -23,16 +23,17 @@
 	"fmt"
 	"os"
 
-	. "launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
 
 	"github.com/mvo5/goconfigparser"
-	check "gopkg.in/check.v1"
+	"gopkg.in/check.v1"
 )
 
 var _ = check.Suite(&listSuite{})
 
 type listSuite struct {
-	SnappySuite
+	common.SnappySuite
 }
 
 func getVersionFromConfig(c *check.C) string {
@@ -51,7 +52,7 @@
 }
 
 func (s *listSuite) TestListMustPrintCoreVersion(c *check.C) {
-	listOutput := ExecCommand(c, "snappy", "list")
+	listOutput := cli.ExecCommand(c, "snappy", "list")
 
 	expected := "(?ms)" +
 		"Name +Date +Version +Developer *\n" +
@@ -62,12 +63,12 @@
 }
 
 func (s *listSuite) TestListMustPrintAppVersion(c *check.C) {
-	InstallSnap(c, "hello-world")
+	common.InstallSnap(c, "hello-world")
 	s.AddCleanup(func() {
-		RemoveSnap(c, "hello-world")
+		common.RemoveSnap(c, "hello-world")
 	})
 
-	listOutput := ExecCommand(c, "snappy", "list")
+	listOutput := cli.ExecCommand(c, "snappy", "list")
 	expected := "(?ms)" +
 		"Name +Date +Version +Developer *\n" +
 		".*" +

=== modified file '_integration-tests/tests/rollback_test.go'
--- _integration-tests/tests/rollback_test.go	2015-07-30 09:07:31 +0000
+++ _integration-tests/tests/rollback_test.go	2015-10-12 09:23:01 +0000
@@ -22,32 +22,38 @@
 import (
 	"strconv"
 
-	. "launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/partition"
+	"launchpad.net/snappy/_integration-tests/testutils/wait"
 
-	check "gopkg.in/check.v1"
+	"gopkg.in/check.v1"
 )
 
 var _ = check.Suite(&rollbackSuite{})
 
 type rollbackSuite struct {
-	SnappySuite
+	common.SnappySuite
 }
 
 func (s *rollbackSuite) TestRollbackMustRebootToOtherVersion(c *check.C) {
-	if BeforeReboot() {
-		CallFakeUpdate(c)
-		Reboot(c)
-	} else if CheckRebootMark(c.TestName()) {
-		RemoveRebootMark(c)
-		currentVersion := GetCurrentUbuntuCoreVersion(c)
-		c.Assert(currentVersion > GetSavedVersion(c), check.Equals, true)
-		ExecCommand(c, "sudo", "snappy", "rollback", "ubuntu-core",
-			strconv.Itoa(GetSavedVersion(c)))
-		SetSavedVersion(c, currentVersion)
-		RebootWithMark(c, c.TestName()+"-rollback")
-	} else if CheckRebootMark(c.TestName() + "-rollback") {
-		RemoveRebootMark(c)
+	if common.BeforeReboot() {
+		common.CallFakeUpdate(c)
+		common.Reboot(c)
+	} else if common.CheckRebootMark(c.TestName()) {
+		common.RemoveRebootMark(c)
+		// Workaround for bug https://bugs.launchpad.net/snappy/+bug/1498293
+		// TODO remove once the bug is fixed. --elopio - 2015-09-30
+		wait.ForFunction(c, "regular", partition.Mode)
+		currentVersion := common.GetCurrentUbuntuCoreVersion(c)
+		c.Assert(currentVersion > common.GetSavedVersion(c), check.Equals, true)
+		cli.ExecCommand(c, "sudo", "snappy", "rollback", "ubuntu-core",
+			strconv.Itoa(common.GetSavedVersion(c)))
+		common.SetSavedVersion(c, currentVersion)
+		common.RebootWithMark(c, c.TestName()+"-rollback")
+	} else if common.CheckRebootMark(c.TestName() + "-rollback") {
+		common.RemoveRebootMark(c)
 		c.Assert(
-			GetCurrentUbuntuCoreVersion(c) < GetSavedVersion(c), check.Equals, true)
+			common.GetCurrentUbuntuCoreVersion(c) < common.GetSavedVersion(c), check.Equals, true)
 	}
 }

=== modified file '_integration-tests/tests/search_test.go'
--- _integration-tests/tests/search_test.go	2015-07-28 04:03:52 +0000
+++ _integration-tests/tests/search_test.go	2015-10-12 09:23:01 +0000
@@ -20,19 +20,20 @@
 package tests
 
 import (
-	. "launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
 
-	. "gopkg.in/check.v1"
+	"gopkg.in/check.v1"
 )
 
-var _ = Suite(&searchSuite{})
+var _ = check.Suite(&searchSuite{})
 
 type searchSuite struct {
-	SnappySuite
+	common.SnappySuite
 }
 
-func (s *searchSuite) TestSearchFrameworkMustPrintMatch(c *C) {
-	searchOutput := ExecCommand(c, "snappy", "search", "hello-dbus-fwk")
+func (s *searchSuite) TestSearchFrameworkMustPrintMatch(c *check.C) {
+	searchOutput := cli.ExecCommand(c, "snappy", "search", "hello-dbus-fwk")
 
 	expected := "(?ms)" +
 		"Name +Version +Summary *\n" +
@@ -40,5 +41,5 @@
 		"^hello-dbus-fwk +.* +hello-dbus-fwk *\n" +
 		".*"
 
-	c.Assert(searchOutput, Matches, expected)
+	c.Assert(searchOutput, check.Matches, expected)
 }

=== renamed file '_integration-tests/tests/installFramework_test.go' => '_integration-tests/tests/service_test.go'
--- _integration-tests/tests/installFramework_test.go	2015-09-03 10:46:21 +0000
+++ _integration-tests/tests/service_test.go	2015-10-12 09:23:01 +0000
@@ -23,39 +23,40 @@
 	"fmt"
 	"regexp"
 
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
 	"launchpad.net/snappy/_integration-tests/testutils/common"
 	"launchpad.net/snappy/_integration-tests/testutils/wait"
 
-	check "gopkg.in/check.v1"
+	"gopkg.in/check.v1"
 )
 
-var _ = check.Suite(&installFrameworkSuite{})
+var _ = check.Suite(&serviceSuite{})
 
-type installFrameworkSuite struct {
+type serviceSuite struct {
 	common.SnappySuite
 }
 
-func (s *installFrameworkSuite) TearDownTest(c *check.C) {
+func (s *serviceSuite) TearDownTest(c *check.C) {
 	if !common.NeedsReboot() && common.CheckRebootMark("") {
-		common.RemoveSnap(c, "docker")
+		common.RemoveSnap(c, "hello-dbus-fwk.canonical")
 	}
 	// run cleanup last
 	s.SnappySuite.TearDownTest(c)
 }
 
-func isDockerServiceRunning(c *check.C) bool {
-	dockerVersion := common.GetCurrentVersion(c, "docker")
-	dockerService := fmt.Sprintf("docker_docker-daemon_%s.service", dockerVersion)
+func isServiceRunning(c *check.C) bool {
+	packageVersion := common.GetCurrentVersion(c, "hello-dbus-fwk")
+	service := fmt.Sprintf("hello-dbus-fwk_srv_%s.service", packageVersion)
 
-	err := wait.ForActiveService(c, dockerService)
+	err := wait.ForActiveService(c, service)
 	c.Assert(err, check.IsNil)
 
-	statusOutput := common.ExecCommand(
+	statusOutput := cli.ExecCommand(
 		c, "systemctl", "status",
-		dockerService)
+		service)
 
 	expected := "(?ms)" +
-		".* docker_docker-daemon_.*\\.service .*\n" +
+		".* hello-dbus-fwk_srv_.*\\.service .*\n" +
 		".*Loaded: loaded .*\n" +
 		".*Active: active \\(running\\) .*\n" +
 		".*"
@@ -65,30 +66,29 @@
 	return matched
 }
 
-func (s *installFrameworkSuite) TestInstallFrameworkMustPrintPackageInformation(c *check.C) {
-	installOutput := common.InstallSnap(c, "docker")
-
-	expected := "(?ms)" +
-		"Installing docker\n" +
-		"Name +Date +Version +Developer \n" +
-		".*" +
-		"^docker +.* +.* +canonical \n" +
-		".*"
-
-	c.Assert(installOutput, check.Matches, expected)
-}
-
-func (s *installFrameworkSuite) TestInstalledFrameworkServiceMustBeStarted(c *check.C) {
-	common.InstallSnap(c, "docker")
-	c.Assert(isDockerServiceRunning(c), check.Equals, true)
-}
-
-func (s *installFrameworkSuite) TestFrameworkServiceMustBeStartedAfterReboot(c *check.C) {
-	if common.BeforeReboot() {
-		common.InstallSnap(c, "docker")
-		common.Reboot(c)
-	} else if common.AfterReboot(c) {
-		common.RemoveRebootMark(c)
-		c.Assert(isDockerServiceRunning(c), check.Equals, true)
+func (s *serviceSuite) TestInstalledServiceMustBeStarted(c *check.C) {
+	common.InstallSnap(c, "hello-dbus-fwk.canonical")
+
+	c.Assert(isServiceRunning(c), check.Equals, true)
+}
+
+func (s *serviceSuite) TestServiceMustBeStartedAfterReboot(c *check.C) {
+	if common.BeforeReboot() {
+		common.InstallSnap(c, "hello-dbus-fwk.canonical")
+		common.Reboot(c)
+	} else if common.AfterReboot(c) {
+		common.RemoveRebootMark(c)
+		c.Assert(isServiceRunning(c), check.Equals, true)
+	}
+}
+
+func (s *serviceSuite) TestServiceMustBeStartedAfterUpdate(c *check.C) {
+	if common.BeforeReboot() {
+		common.InstallSnap(c, "hello-dbus-fwk.canonical")
+		common.CallFakeUpdate(c)
+		common.Reboot(c)
+	} else if common.AfterReboot(c) {
+		common.RemoveRebootMark(c)
+		c.Assert(isServiceRunning(c), check.Equals, true)
 	}
 }

=== modified file '_integration-tests/tests/snapd_1_0_packages_test.go'
--- _integration-tests/tests/snapd_1_0_packages_test.go	2015-09-28 11:39:16 +0000
+++ _integration-tests/tests/snapd_1_0_packages_test.go	2015-10-12 09:23:01 +0000
@@ -23,6 +23,7 @@
 	"os"
 
 	"launchpad.net/snappy/_integration-tests/testutils/build"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
 
 	"gopkg.in/check.v1"
 )
@@ -70,6 +71,7 @@
 func (s *snapd10PackagesTestSuite) TearDownTest(c *check.C) {
 	s.snapdTestSuite.TearDownTest(c)
 	os.Remove(s.snapPath)
+	common.RemoveSnap(c, build.BasicSnapName)
 }
 
 func (s *snapd10PackagesTestSuite) resource() string {

=== added file '_integration-tests/tests/snapd_1_0_test.go'
--- _integration-tests/tests/snapd_1_0_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/snapd_1_0_test.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,41 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import "gopkg.in/check.v1"
+
+var _ = check.Suite(&snapd10TestSuite{})
+
+type snapd10TestSuite struct {
+	snapdTestSuite
+}
+
+func (s *snapd10TestSuite) TestResource(c *check.C) {
+	exerciseAPI(c, s)
+}
+
+func (s *snapd10TestSuite) resource() string {
+	return baseURL + "/1.0"
+}
+
+func (s *snapd10TestSuite) getInteractions() apiInteractions {
+	return []apiInteraction{{
+		responsePattern: `(?U){"result":{"api_compat":"0","default_channel":".*","flavor":".*","release":".*"},"status":"OK","status_code":200,"type":"sync"}`}}
+}

=== modified file '_integration-tests/tests/ubuntuFan_test.go'
--- _integration-tests/tests/ubuntuFan_test.go	2015-09-24 21:06:01 +0000
+++ _integration-tests/tests/ubuntuFan_test.go	2015-10-12 09:23:01 +0000
@@ -25,6 +25,7 @@
 	"os/exec"
 	"strings"
 
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
 	"launchpad.net/snappy/_integration-tests/testutils/common"
 	"launchpad.net/snappy/_integration-tests/testutils/wait"
 
@@ -75,7 +76,7 @@
 }
 
 func (s *fanTestSuite) TestFanCommandCreatesFanBridge(c *check.C) {
-	output := common.ExecCommand(c, "ifconfig")
+	output := cli.ExecCommand(c, "ifconfig")
 
 	expectedPattern := fmt.Sprintf("(?msi).*%s.*%s.*", s.fanName(), s.bridgeIP)
 
@@ -89,7 +90,7 @@
 	s.configureDockerToUseBridge(c)
 	defer s.removeBridgeFromDockerConf(c)
 
-	output := common.ExecCommand(c, "docker", "run", "-t", baseContainer, "ifconfig")
+	output := cli.ExecCommand(c, "docker", "run", "-t", baseContainer, "ifconfig")
 
 	expectedIP := strings.TrimRight(s.bridgeIP, ".1") + ".2"
 	expectedPattern := fmt.Sprintf("(?ms).*inet addr:%s.*", expectedIP)
@@ -105,12 +106,12 @@
 	defer s.removeBridgeFromDockerConf(c)
 
 	// spin up first container
-	common.ExecCommand(c, "docker", "run", "-d", "-t", baseContainer)
+	cli.ExecCommand(c, "docker", "run", "-d", "-t", baseContainer)
 	// the first assigned IP in the fan will end with ".2"
 	firstIPAddr := strings.TrimRight(s.bridgeIP, ".1") + ".2"
 
 	// ping from a second container
-	output := common.ExecCommand(c, "docker", "run", "-t", baseContainer, "ping", firstIPAddr, "-c", "1")
+	output := cli.ExecCommand(c, "docker", "run", "-t", baseContainer, "ping", firstIPAddr, "-c", "1")
 
 	expectedPattern := "(?ms).*1 packets transmitted, 1 packets received, 0% packet loss.*"
 
@@ -142,14 +143,14 @@
 }
 
 func (s *fanTestSuite) fanCtl(c *check.C, cmd string) string {
-	return common.ExecCommand(c,
+	return cli.ExecCommand(c,
 		"sudo", "fanctl", cmd, firstOverlaySegment+".0.0.0/8", s.subjectIP+"/16")
 }
 
 func (s *fanTestSuite) configureDockerToUseBridge(c *check.C) {
 	cfgFile := dockerCfgFile(c)
 
-	common.ExecCommand(c, "sudo", "sed", "-i",
+	cli.ExecCommand(c, "sudo", "sed", "-i",
 		fmt.Sprintf(`s/DOCKER_OPTIONS=\"\"/DOCKER_OPTIONS=\"%s\"/`, s.dockerOptions()),
 		cfgFile)
 
@@ -159,7 +160,7 @@
 func (s *fanTestSuite) removeBridgeFromDockerConf(c *check.C) {
 	cfgFile := dockerCfgFile(c)
 
-	common.ExecCommand(c, "sudo", "sed", "-i",
+	cli.ExecCommand(c, "sudo", "sed", "-i",
 		`s/DOCKER_OPTIONS=\".*\"/DOCKER_OPTIONS=\"\"/`,
 		cfgFile)
 
@@ -175,7 +176,7 @@
 	dockerVersion := common.GetCurrentVersion(c, "docker")
 	dockerService := fmt.Sprintf("docker_docker-daemon_%s.service", dockerVersion)
 
-	common.ExecCommand(c, "sudo", "systemctl", "restart", dockerService)
+	cli.ExecCommand(c, "sudo", "systemctl", "restart", dockerService)
 
 	// we need to wait until the socket is ready, an active systemctl status is not enough
 	err := wait.ForCommand(c, `(?ms).*docker\.sock\s.*`, "ls", "/run")
@@ -199,7 +200,7 @@
 	err := wait.ForActiveService(c, dockerService)
 	c.Assert(err, check.IsNil)
 
-	common.ExecCommand(c, "docker", "pull", baseContainer)
+	cli.ExecCommand(c, "docker", "pull", baseContainer)
 }
 
 func tearDownDocker(c *check.C) {

=== modified file '_integration-tests/tests/update_test.go'
--- _integration-tests/tests/update_test.go	2015-09-10 15:55:23 +0000
+++ _integration-tests/tests/update_test.go	2015-10-12 09:23:01 +0000
@@ -23,7 +23,7 @@
 	"io/ioutil"
 	"path"
 
-	. "launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
 	"launchpad.net/snappy/_integration-tests/testutils/partition"
 
 	"gopkg.in/check.v1"
@@ -32,7 +32,7 @@
 var _ = check.Suite(&updateSuite{})
 
 type updateSuite struct {
-	SnappySuite
+	common.SnappySuite
 }
 
 func (s *updateSuite) assertBootDirContents(c *check.C) {
@@ -62,17 +62,17 @@
 // modified to fake an update. If there is a version available, the image will
 // be up-to-date after running this test.
 func (s *updateSuite) TestUpdateToSameReleaseAndChannel(c *check.C) {
-	if BeforeReboot() {
-		updateOutput := CallFakeUpdate(c)
+	if common.BeforeReboot() {
+		updateOutput := common.CallFakeUpdate(c)
 		expected := "(?ms)" +
 			".*" +
 			"^Reboot to use .*ubuntu-core.\n"
 		c.Assert(updateOutput, check.Matches, expected)
 		s.assertBootDirContents(c)
-		Reboot(c)
-	} else if AfterReboot(c) {
-		RemoveRebootMark(c)
-		c.Assert(GetCurrentUbuntuCoreVersion(c) > GetSavedVersion(c),
+		common.Reboot(c)
+	} else if common.AfterReboot(c) {
+		common.RemoveRebootMark(c)
+		c.Assert(common.GetCurrentUbuntuCoreVersion(c) > common.GetSavedVersion(c),
 			check.Equals, true)
 	}
 }

=== modified file '_integration-tests/tests/writablePaths_test.go'
--- _integration-tests/tests/writablePaths_test.go	2015-07-28 04:03:52 +0000
+++ _integration-tests/tests/writablePaths_test.go	2015-10-12 09:23:01 +0000
@@ -27,9 +27,9 @@
 	"path/filepath"
 	"strings"
 
-	. "launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/common"
 
-	check "gopkg.in/check.v1"
+	"gopkg.in/check.v1"
 )
 
 const writablePathsListFile = "/etc/system-image/writable-paths"
@@ -37,7 +37,7 @@
 var _ = check.Suite(&writablePathsSuite{})
 
 type writablePathsSuite struct {
-	SnappySuite
+	common.SnappySuite
 }
 
 var IsWritable check.Checker = &isWritable{}

=== modified file '_integration-tests/testutils/autopkgtest/autopkgtest_test.go'
--- _integration-tests/testutils/autopkgtest/autopkgtest_test.go	2015-08-31 10:09:21 +0000
+++ _integration-tests/testutils/autopkgtest/autopkgtest_test.go	2015-10-12 09:23:01 +0000
@@ -192,7 +192,7 @@
 }
 
 func adtrunLocalCmd(controlFile, sourceCodePath, outputDir, imgPath string) string {
-	options := fmt.Sprintf("--- ssh -s /usr/share/autopkgtest/ssh-setup/snappy -- -i %s", imgPath)
+	options := fmt.Sprintf("--- ssh -s /usr/share/autopkgtest/ssh-setup/snappy -- -b -i %s", imgPath)
 	return adtrunCommonCmd(controlFile, sourceCodePath, outputDir, options)
 }
 

=== modified file '_integration-tests/testutils/autopkgtest/ssh.go'
--- _integration-tests/testutils/autopkgtest/ssh.go	2015-08-31 10:09:21 +0000
+++ _integration-tests/testutils/autopkgtest/ssh.go	2015-10-12 09:23:01 +0000
@@ -33,7 +33,7 @@
 
 func kvmSSHOptions(imagePath string) string {
 	return fmt.Sprint(commonSSHOptions,
-		"-s /usr/share/autopkgtest/ssh-setup/snappy -- -i ", imagePath)
+		"-s /usr/share/autopkgtest/ssh-setup/snappy -- -b -i ", imagePath)
 }
 
 func remoteTestbedSSHOptions(testbedIP string, testbedPort int) string {

=== modified file '_integration-tests/testutils/build/snap.go'
--- _integration-tests/testutils/build/snap.go	2015-09-28 10:35:06 +0000
+++ _integration-tests/testutils/build/snap.go	2015-10-12 09:23:01 +0000
@@ -24,7 +24,7 @@
 	"path/filepath"
 
 	"gopkg.in/check.v1"
-	"launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
 )
 
 const (
@@ -42,11 +42,11 @@
 
 var (
 	// dependency aliasing
-	commonExecCommand = common.ExecCommand
+	cliExecCommand = cli.ExecCommand
 )
 
 func buildSnap(c *check.C, snapPath string) string {
-	return commonExecCommand(c, "snappy", "build", snapPath, "-o", snapPath)
+	return cliExecCommand(c, "snappy", "build", snapPath, "-o", snapPath)
 }
 
 // LocalSnap issues the command to build a snap and returns the path of the generated file

=== modified file '_integration-tests/testutils/build/snap_test.go'
--- _integration-tests/testutils/build/snap_test.go	2015-09-28 10:44:44 +0000
+++ _integration-tests/testutils/build/snap_test.go	2015-10-12 09:23:01 +0000
@@ -37,13 +37,13 @@
 var _ = check.Suite(&snapBuildTestSuite{})
 
 func (s *snapBuildTestSuite) SetUpSuite(c *check.C) {
-	s.backExecCommand = commonExecCommand
-	commonExecCommand = s.fakeExecCommand
+	s.backExecCommand = cliExecCommand
+	cliExecCommand = s.fakeExecCommand
 	s.defaultSnapName = "mySnapName"
 }
 
 func (s *snapBuildTestSuite) TearDownSuite(c *check.C) {
-	commonExecCommand = s.backExecCommand
+	cliExecCommand = s.backExecCommand
 }
 
 func (s *snapBuildTestSuite) SetUpTest(c *check.C) {

=== added directory '_integration-tests/testutils/cli'
=== added file '_integration-tests/testutils/cli/cli.go'
--- _integration-tests/testutils/cli/cli.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/cli/cli.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,64 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package cli
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	"gopkg.in/check.v1"
+)
+
+var execCommand = exec.Command
+
+// ExecCommand executes a shell command and returns a string with the output
+// of the command. In case of error, it will fail the test.
+func ExecCommand(c *check.C, cmds ...string) string {
+	output, err := ExecCommandErr(cmds...)
+	c.Assert(err, check.IsNil, check.Commentf("Error: %v", output))
+	return output
+}
+
+// ExecCommandToFile executes a shell command and saves the output of the
+// command to a file. In case of error, it will fail the test.
+func ExecCommandToFile(c *check.C, filename string, cmds ...string) {
+	cmd := execCommand(cmds[0], cmds[1:]...)
+	outfile, err := os.Create(filename)
+	c.Assert(err, check.IsNil, check.Commentf("Error creating output file %s", filename))
+
+	defer outfile.Close()
+	cmd.Stdout = outfile
+
+	err = cmd.Run()
+	c.Assert(err, check.IsNil, check.Commentf("Error executing command '%v': %v", cmds, err))
+}
+
+// ExecCommandErr executes a shell command and returns a string with the output
+// of the command and eventually the obtained error
+func ExecCommandErr(cmds ...string) (output string, err error) {
+	fmt.Println(strings.Join(cmds, " "))
+	cmd := execCommand(cmds[0], cmds[1:]...)
+	outputByte, err := cmd.CombinedOutput()
+	output = string(outputByte)
+	fmt.Print(output)
+	return
+}

=== added file '_integration-tests/testutils/cli/cli_test.go'
--- _integration-tests/testutils/cli/cli_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/cli/cli_test.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,113 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package cli
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"testing"
+
+	"gopkg.in/check.v1"
+)
+
+const execOutput = "myoutput"
+
+// Hook up check.v1 into the "go test" runner
+func Test(t *testing.T) { check.TestingT(t) }
+
+type cliTestSuite struct {
+	backExecCommand func(string, ...string) *exec.Cmd
+	helperProcess   string
+}
+
+var _ = check.Suite(&cliTestSuite{})
+
+func (s *cliTestSuite) SetUpSuite(c *check.C) {
+	s.backExecCommand = execCommand
+	execCommand = s.fakeExecCommand
+}
+
+func (s *cliTestSuite) TearDownSuite(c *check.C) {
+	execCommand = s.backExecCommand
+}
+
+func (s *cliTestSuite) SetUpTest(c *check.C) {
+	s.helperProcess = "TestHelperProcess"
+}
+
+func (s *cliTestSuite) fakeExecCommand(command string, args ...string) *exec.Cmd {
+	cs := []string{"-check.f=cliTestSuite." + s.helperProcess, "--", command}
+	cs = append(cs, args...)
+	cmd := exec.Command(os.Args[0], cs...)
+	cmd.Env = []string{"GO_WANT_HELPER_PROCESS=1"}
+	return cmd
+}
+
+func (s *cliTestSuite) TestHelperProcess(c *check.C) {
+	baseHelperProcess(0)
+}
+
+func (s *cliTestSuite) TestHelperProcessErr(c *check.C) {
+	baseHelperProcess(1)
+}
+
+func baseHelperProcess(exitValue int) {
+	if os.Getenv("GO_WANT_HELPER_PROCESS") != "1" {
+		return
+	}
+	fmt.Fprintf(os.Stdout, execOutput)
+	os.Exit(exitValue)
+}
+
+func (s *cliTestSuite) TestExecCommand(c *check.C) {
+	actualOutput := ExecCommand(c, "mycmd")
+
+	c.Assert(actualOutput, check.Equals, execOutput)
+}
+
+func (s *cliTestSuite) TestExecCommandToFile(c *check.C) {
+	outputFile, err := ioutil.TempFile("", "snappy-exec")
+	c.Assert(err, check.IsNil)
+	outputFile.Close()
+	defer os.Remove(outputFile.Name())
+
+	ExecCommandToFile(c, outputFile.Name(), "mycmd")
+
+	actualFileContents, err := ioutil.ReadFile(outputFile.Name())
+	c.Assert(err, check.IsNil)
+	c.Assert(string(actualFileContents), check.Equals, execOutput)
+}
+
+func (s *cliTestSuite) TestExecCommandErr(c *check.C) {
+	actualOutput, err := ExecCommandErr("mycmd")
+
+	c.Assert(actualOutput, check.Equals, execOutput)
+	c.Assert(err, check.IsNil)
+}
+
+func (s *cliTestSuite) TestExecCommandErrWithError(c *check.C) {
+	s.helperProcess = "TestHelperProcessErr"
+	actualOutput, err := ExecCommandErr("mycmd")
+
+	c.Assert(actualOutput, check.Equals, execOutput)
+	c.Assert(err, check.NotNil)
+}

=== modified file '_integration-tests/testutils/common/common.go'
--- _integration-tests/testutils/common/common.go	2015-09-28 14:42:52 +0000
+++ _integration-tests/testutils/common/common.go	2015-10-12 09:23:01 +0000
@@ -23,7 +23,6 @@
 	"fmt"
 	"io/ioutil"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"regexp"
 	"strconv"
@@ -31,7 +30,9 @@
 
 	"gopkg.in/check.v1"
 
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
 	"launchpad.net/snappy/_integration-tests/testutils/config"
+	"launchpad.net/snappy/_integration-tests/testutils/partition"
 )
 
 const (
@@ -54,8 +55,8 @@
 // SetUpSuite disables the snappy autopilot. It will run before all the
 // integration suites.
 func (s *SnappySuite) SetUpSuite(c *check.C) {
-	ExecCommand(c, "sudo", "systemctl", "stop", "snappy-autopilot.timer")
-	ExecCommand(c, "sudo", "systemctl", "disable", "snappy-autopilot.timer")
+	cli.ExecCommand(c, "sudo", "systemctl", "stop", "snappy-autopilot.timer")
+	cli.ExecCommand(c, "sudo", "systemctl", "disable", "snappy-autopilot.timer")
 	var err error
 	Cfg, err = config.ReadConfig(
 		"_integration-tests/data/output/testconfig.json")
@@ -66,7 +67,7 @@
 			switchSystemImageConf(c, Cfg.TargetRelease, Cfg.TargetChannel, "0")
 			// Always use the installed snappy because we are updating from an old
 			// image, so we should not use the snappy from the branch.
-			output := ExecCommand(c, "sudo", "/usr/bin/snappy", "update")
+			output := cli.ExecCommand(c, "sudo", "/usr/bin/snappy", "update")
 			if output != "" {
 				RebootWithMark(c, "setupsuite-update")
 			}
@@ -77,7 +78,7 @@
 		Cfg.Update = false
 		Cfg.Write()
 		if Cfg.Rollback {
-			ExecCommand(c, "sudo", "snappy", "rollback", "ubuntu-core")
+			cli.ExecCommand(c, "sudo", "snappy", "rollback", "ubuntu-core")
 			RebootWithMark(c, "setupsuite-rollback")
 		}
 	} else if CheckRebootMark("setupsuite-rollback") {
@@ -127,11 +128,11 @@
 		m[channelCfgOtherBackupFile()] = BaseAltPartitionPath
 		for backup, target := range m {
 			if _, err := os.Stat(backup); err == nil {
-				MakeWritable(c, target)
-				defer MakeReadonly(c, target)
+				partition.MakeWritable(c, target)
+				defer partition.MakeReadonly(c, target)
 				original := filepath.Join(target, channelCfgFile)
 				c.Logf("Restoring %s...", original)
-				ExecCommand(c, "sudo", "mv", backup, original)
+				cli.ExecCommand(c, "sudo", "mv", backup, original)
 			}
 		}
 	}
@@ -153,8 +154,8 @@
 	for _, target := range targets {
 		file := filepath.Join(target, channelCfgFile)
 		if _, err := os.Stat(file); err == nil {
-			MakeWritable(c, target)
-			defer MakeReadonly(c, target)
+			partition.MakeWritable(c, target)
+			defer partition.MakeReadonly(c, target)
 			replaceSystemImageValues(c, file, release, channel, version)
 		}
 	}
@@ -169,12 +170,12 @@
 	}
 	for value, regex := range replaceRegex {
 		if value != "" {
-			ExecCommand(c,
+			cli.ExecCommand(c,
 				"sudo", "sed", "-i", fmt.Sprintf(regex, value), file)
 		}
 	}
 	// Leave the new file in the test log.
-	ExecCommand(c, "cat", file)
+	cli.ExecCommand(c, "cat", file)
 }
 
 func channelCfgBackupFile() string {
@@ -185,35 +186,9 @@
 	return filepath.Join(os.Getenv("ADT_ARTIFACTS"), "channel.ini.other")
 }
 
-// ExecCommand executes a shell command and returns a string with the output
-// of the command. In case of error, it will fail the test.
-func ExecCommand(c *check.C, cmds ...string) string {
-	fmt.Println(strings.Join(cmds, " "))
-	cmd := exec.Command(cmds[0], cmds[1:len(cmds)]...)
-	output, err := cmd.CombinedOutput()
-	stringOutput := string(output)
-	fmt.Print(stringOutput)
-	c.Assert(err, check.IsNil, check.Commentf("Error: %v", stringOutput))
-	return stringOutput
-}
-
-// ExecCommandToFile executes a shell command and saves the output of the
-// command to a file. In case of error, it will fail the test.
-func ExecCommandToFile(c *check.C, filename string, cmds ...string) {
-	cmd := exec.Command(cmds[0], cmds[1:len(cmds)]...)
-	outfile, err := os.Create(filename)
-	c.Assert(err, check.IsNil, check.Commentf("Error creating output file %s", filename))
-
-	defer outfile.Close()
-	cmd.Stdout = outfile
-
-	err = cmd.Run()
-	c.Assert(err, check.IsNil, check.Commentf("Error executing command '%v': %v", cmds, err))
-}
-
 // GetCurrentVersion returns the version of the installed and active package.
 func GetCurrentVersion(c *check.C, packageName string) string {
-	output := ExecCommand(c, "snappy", "list")
+	output := cli.ExecCommand(c, "snappy", "list")
 	pattern := "(?mU)^" + packageName + " +(.*)$"
 	re := regexp.MustCompile(pattern)
 	match := re.FindStringSubmatch(string(output))
@@ -237,7 +212,7 @@
 func CallFakeUpdate(c *check.C) string {
 	c.Log("Preparing fake and calling update.")
 	fakeAvailableUpdate(c)
-	return ExecCommand(c, "sudo", "snappy", "update")
+	return cli.ExecCommand(c, "sudo", "snappy", "update")
 }
 
 func fakeAvailableUpdate(c *check.C) {
@@ -254,25 +229,15 @@
 	for target, backup := range m {
 		file := filepath.Join(target, channelCfgFile)
 		if _, err := os.Stat(file); err == nil {
-			MakeWritable(c, target)
-			defer MakeReadonly(c, target)
+			partition.MakeWritable(c, target)
+			defer partition.MakeReadonly(c, target)
 			// Back up the file. It will be restored during the test tear down.
-			ExecCommand(c, "cp", file, backup)
+			cli.ExecCommand(c, "cp", file, backup)
 			replaceSystemImageValues(c, file, "", "", strconv.Itoa(newVersion))
 		}
 	}
 }
 
-// MakeWritable remounts a path with read and write permissions.
-func MakeWritable(c *check.C, path string) {
-	ExecCommand(c, "sudo", "mount", "-o", "remount,rw", path)
-}
-
-// MakeReadonly remounts a path with only read permissions.
-func MakeReadonly(c *check.C, path string) {
-	ExecCommand(c, "sudo", "mount", "-o", "remount,ro", path)
-}
-
 // Reboot requests a reboot using the test name as the mark.
 func Reboot(c *check.C) {
 	RebootWithMark(c, c.TestName())
@@ -346,10 +311,10 @@
 
 // InstallSnap executes the required command to install the specified snap
 func InstallSnap(c *check.C, packageName string) string {
-	return ExecCommand(c, "sudo", "snappy", "install", packageName, "--allow-unauthenticated")
+	return cli.ExecCommand(c, "sudo", "snappy", "install", packageName, "--allow-unauthenticated")
 }
 
 // RemoveSnap executes the required command to remove the specified snap
 func RemoveSnap(c *check.C, packageName string) string {
-	return ExecCommand(c, "sudo", "snappy", "remove", packageName)
+	return cli.ExecCommand(c, "sudo", "snappy", "remove", packageName)
 }

=== modified file '_integration-tests/testutils/common/info.go'
--- _integration-tests/testutils/common/info.go	2015-09-24 21:06:01 +0000
+++ _integration-tests/testutils/common/info.go	2015-10-12 09:23:01 +0000
@@ -24,10 +24,11 @@
 	"strings"
 
 	"gopkg.in/check.v1"
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
 )
 
 // dependency aliasing
-var execCommand = ExecCommand
+var execCommand = cli.ExecCommand
 
 // Release returns the release of the current snappy image
 func Release(c *check.C) string {

=== modified file '_integration-tests/testutils/partition/bootloader.go'
--- _integration-tests/testutils/partition/bootloader.go	2015-09-13 02:52:52 +0000
+++ _integration-tests/testutils/partition/bootloader.go	2015-10-12 09:23:01 +0000
@@ -69,7 +69,7 @@
 // config file. For uboot systems the boot config file does not change, so that
 // we take the other partition in that case
 func NextBootPartition() (partition string, err error) {
-	m, err := mode()
+	m, err := Mode()
 	if err != nil {
 		return
 	}
@@ -96,7 +96,8 @@
 	return
 }
 
-func mode() (mode string, err error) {
+// Mode returns the current bootloader mode, regular or try.
+func Mode() (mode string, err error) {
 	return confValue("snappy_mode")
 }
 
@@ -144,7 +145,7 @@
 	if err != nil {
 		return
 	}
-	m, err := mode()
+	m, err := Mode()
 	if err != nil {
 		return
 	}

=== modified file '_integration-tests/testutils/partition/bootloader_test.go'
--- _integration-tests/testutils/partition/bootloader_test.go	2015-09-13 02:55:08 +0000
+++ _integration-tests/testutils/partition/bootloader_test.go	2015-10-12 09:23:01 +0000
@@ -244,7 +244,7 @@
 		return "test-system", nil
 	}
 
-	mode, err := mode()
+	mode, err := Mode()
 
 	c.Assert(err, check.IsNil, check.Commentf("Unexpected error %v", err))
 	c.Assert(mode, check.Equals, "test_mode", check.Commentf("Wrong mode"))

=== added file '_integration-tests/testutils/partition/partition.go'
--- _integration-tests/testutils/partition/partition.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/partition/partition.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,89 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package partition
+
+import (
+	"bufio"
+	"fmt"
+	"regexp"
+	"strings"
+
+	"gopkg.in/check.v1"
+
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
+	"launchpad.net/snappy/_integration-tests/testutils/wait"
+)
+
+const (
+	// beginning of the string returned by lsof -V when the partition
+	// is not being used, in this case the exit status of lsof is 1
+	lsofNotUsed = "lsof: no file system use located"
+	// custom pattern to be returned by the check functions
+	lsofNotBeingWritten = "volume-is-idle"
+)
+
+var (
+	execCommand     = cli.ExecCommandErr
+	waitForFunction = wait.ForFunction
+)
+
+// MakeWritable remounts a path with read and write permissions.
+func MakeWritable(c *check.C, path string) (err error) {
+	return commonMount(c, path, "remount,rw")
+}
+
+// MakeReadonly remounts a path with only read permissions.
+func MakeReadonly(c *check.C, path string) (err error) {
+	return commonMount(c, path, "remount,ro")
+}
+
+func commonMount(c *check.C, path, mountOption string) (err error) {
+	err = waitForFunction(c, lsofNotBeingWritten, checkPathBusyFunc(path))
+
+	if err != nil {
+		return
+	}
+
+	execCommand("sudo", "mount", "-o", mountOption, path)
+	return
+}
+
+func checkPathBusyFunc(path string) func() (string, error) {
+	return func() (result string, err error) {
+		// lsof exit status is 1 for unused partitions
+		var info string
+		if info, err = execCommand("lsof", "-V", path); err != nil {
+			// check if the output matches lsofNotUsed
+			if !strings.HasPrefix(info, lsofNotUsed) {
+				return info, err
+			}
+		}
+		reader := strings.NewReader(info)
+		scanner := bufio.NewScanner(reader)
+		for scanner.Scan() {
+			fields := strings.Fields(scanner.Text())
+			if match, _ := regexp.MatchString("^[0-9]+w$", fields[3]); match {
+				fmt.Printf("match! %s", fields[3])
+				return fields[3], nil
+			}
+		}
+		return lsofNotBeingWritten, nil
+	}
+}

=== added file '_integration-tests/testutils/partition/partition_test.go'
--- _integration-tests/testutils/partition/partition_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/partition/partition_test.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,170 @@
+// -*- 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"
+	"strings"
+
+	"gopkg.in/check.v1"
+)
+
+const (
+	path        = "mypath"
+	writableCmd = "sudo mount -o remount,rw " + path
+	readonlyCmd = "sudo mount -o remount,ro " + path
+	waitCmd     = lsofNotBeingWritten
+)
+
+type partitionTestSuite struct {
+	execCalls           map[string]int
+	waitCalls           map[string]int
+	execOutput          string
+	execError           bool
+	backExecCommand     func(...string) (string, error)
+	backWaitForFunction func(*check.C, string, func() (string, error)) error
+	waitError           bool
+}
+
+var _ = check.Suite(&partitionTestSuite{})
+
+func (s *partitionTestSuite) SetUpSuite(c *check.C) {
+	s.backExecCommand = execCommand
+	s.backWaitForFunction = waitForFunction
+	execCommand = s.fakeExecCommand
+	waitForFunction = s.fakeWaitForFunction
+}
+
+func (s *partitionTestSuite) TearDownSuite(c *check.C) {
+	execCommand = s.backExecCommand
+	waitForFunction = s.backWaitForFunction
+}
+
+func (s *partitionTestSuite) SetUpTest(c *check.C) {
+	s.execCalls = make(map[string]int)
+	s.waitCalls = make(map[string]int)
+	s.waitError = false
+	s.execOutput = ""
+	s.execError = false
+}
+
+func (s *partitionTestSuite) fakeExecCommand(args ...string) (output string, err error) {
+	s.execCalls[strings.Join(args, " ")]++
+
+	if s.execError {
+		err = fmt.Errorf("Exec error!")
+	}
+
+	return s.execOutput, err
+}
+
+func (s *partitionTestSuite) fakeWaitForFunction(c *check.C, pattern string, f func() (string, error)) (err error) {
+	s.waitCalls[pattern]++
+
+	if s.waitError {
+		err = fmt.Errorf("Wait error!")
+	}
+
+	return
+}
+
+func (s *partitionTestSuite) TestMakeWritableCallsExecCommand(c *check.C) {
+	err := MakeWritable(c, path)
+
+	c.Assert(err, check.IsNil)
+	c.Assert(s.execCalls[writableCmd], check.Equals, 1)
+}
+
+func (s *partitionTestSuite) TestMakeWritableWaitsForIdlePartition(c *check.C) {
+	err := MakeWritable(c, path)
+
+	c.Assert(err, check.IsNil)
+	c.Assert(s.waitCalls[waitCmd], check.Equals, 1)
+}
+
+func (s *partitionTestSuite) TestMakeWritableReturnsWaitError(c *check.C) {
+	s.waitError = true
+	err := MakeWritable(c, path)
+
+	c.Assert(err, check.NotNil)
+	c.Assert(s.waitCalls[waitCmd], check.Equals, 1)
+	c.Assert(s.execCalls[writableCmd], check.Equals, 0)
+}
+
+func (s *partitionTestSuite) TestMakeReadOnlyCallsExecCommand(c *check.C) {
+	err := MakeReadonly(c, path)
+
+	c.Assert(err, check.IsNil)
+	c.Assert(s.execCalls[readonlyCmd], check.Equals, 1)
+}
+
+func (s *partitionTestSuite) TestMakeReadonlyWaitsForIdlePartition(c *check.C) {
+	err := MakeReadonly(c, path)
+
+	c.Assert(err, check.IsNil)
+	c.Assert(s.waitCalls[waitCmd], check.Equals, 1)
+}
+
+func (s *partitionTestSuite) TestMakeReadonlyReturnsWaitError(c *check.C) {
+	s.waitError = true
+	err := MakeReadonly(c, path)
+
+	c.Assert(err, check.NotNil)
+	c.Assert(s.waitCalls[waitCmd], check.Equals, 1)
+	c.Assert(s.execCalls[readonlyCmd], check.Equals, 0)
+}
+
+func (s *partitionTestSuite) TestCheckPartitionBusyFunc(c *check.C) {
+	testCases := []struct {
+		execCommandOutput string
+		expected          string
+	}{
+		{`prg  4827 user  mem    REG    8,2      3339 10354893 /usr/share/prg
+prg  4827 user   15w   REG    8,2    197132 12452026 /home/user/prg`, "15w"},
+		{`prg  4827 user  mem    REG    8,2      3339 10354893 /usr/share/prg
+prg  4827 user   15w   REG    8,2    197132 12452026 /home/user/prg
+prg  4827 user   1w   REG    8,2    197132 12452026 /home/user/prg`, "15w"},
+		{`prg  4827 user  mem    REG    8,2      3339 10354893 /usr/share/prg`, lsofNotBeingWritten},
+		{`prg  4827 user  cwd    REG    8,2      3339 10354893 /usr/share/prg`, lsofNotBeingWritten},
+	}
+
+	for _, testCase := range testCases {
+		s.execOutput = testCase.execCommandOutput
+		f := checkPathBusyFunc(path)
+
+		actual, err := f()
+		c.Check(err, check.IsNil)
+		c.Check(actual, check.Equals, testCase.expected,
+			check.Commentf("input text %s, expected output %s, obtained %s",
+				testCase.execCommandOutput, testCase.expected, actual))
+	}
+}
+
+func (s *partitionTestSuite) TestCheckPartitionBusyFuncReturnsErrorOnLsofError(c *check.C) {
+	s.execOutput = "not a lsof common output on not used partitions"
+	s.execError = true
+
+	f := checkPathBusyFunc(path)
+
+	actual, err := f()
+
+	c.Check(err, check.NotNil)
+	c.Check(actual, check.Equals, s.execOutput)
+}

=== modified file '_integration-tests/testutils/runner/runner.go'
--- _integration-tests/testutils/runner/runner.go	2015-08-12 15:50:33 +0000
+++ _integration-tests/testutils/runner/runner.go	2015-10-12 09:23:01 +0000
@@ -25,7 +25,7 @@
 	"strings"
 	"testing"
 
-	check "gopkg.in/check.v1"
+	"gopkg.in/check.v1"
 )
 
 var (

=== modified file '_integration-tests/testutils/wait/wait.go'
--- _integration-tests/testutils/wait/wait.go	2015-09-28 10:54:40 +0000
+++ _integration-tests/testutils/wait/wait.go	2015-10-12 09:23:01 +0000
@@ -24,14 +24,14 @@
 	"regexp"
 	"time"
 
-	check "gopkg.in/check.v1"
+	"gopkg.in/check.v1"
 
-	"launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/cli"
 )
 
 var (
 	// dependency aliasing
-	execCommand = common.ExecCommand
+	execCommand = cli.ExecCommand
 	// ForCommand dep alias
 	ForCommand = forCommand
 	// ForFunction dep alias

=== added file 'cmd/snappy/cmd_activate.go'
--- cmd/snappy/cmd_activate.go	1970-01-01 00:00:00 +0000
+++ cmd/snappy/cmd_activate.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,60 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package main
+
+import (
+	"launchpad.net/snappy/i18n"
+	"launchpad.net/snappy/logger"
+	"launchpad.net/snappy/progress"
+	"launchpad.net/snappy/snappy"
+)
+
+type cmdActivate struct {
+	Args struct {
+		Snap string `positional-arg-name:"snap"`
+	} `positional-args:"yes" required:"very yes"`
+	activate bool
+}
+
+func init() {
+	_, err := parser.AddCommand("activate",
+		i18n.G(`Activate a package`),
+		i18n.G(`Activate a package that has previously been deactivated. If the package is already activated, do nothing.`),
+		&cmdActivate{activate: true})
+	if err != nil {
+		logger.Panicf("Unable to activate: %v", err)
+	}
+
+	_, err = parser.AddCommand("deactivate",
+		i18n.G(`Deactivate a package`),
+		i18n.G(`Deactivate a package. If the package is already deactivated, do nothing.`),
+		&cmdActivate{activate: false})
+	if err != nil {
+		logger.Panicf("Unable to deactivate: %v", err)
+	}
+}
+
+func (x *cmdActivate) Execute(args []string) error {
+	return withMutex(x.doActivate)
+}
+
+func (x *cmdActivate) doActivate() error {
+	return snappy.SetActive(x.Args.Snap, x.activate, progress.MakeProgressBar())
+}

=== modified file 'cmd/snappy/cmd_build.go'
--- cmd/snappy/cmd_build.go	2015-07-09 06:05:53 +0000
+++ cmd/snappy/cmd_build.go	2015-10-12 09:23:01 +0000
@@ -30,7 +30,8 @@
 const clickReview = "click-review"
 
 type cmdBuild struct {
-	Output string `long:"output" short:"o"`
+	Output      string `long:"output" short:"o"`
+	BuildSnapfs bool   `long:"snapfs"`
 }
 
 var longBuildHelp = i18n.G("Creates a snap package and if available, runs the review scripts.")
@@ -53,7 +54,12 @@
 		args = []string{"."}
 	}
 
-	snapPackage, err := snappy.Build(args[0], x.Output)
+	var snapPackage string
+	if x.BuildSnapfs {
+		snapPackage, err = snappy.BuildSnapfsSnap(args[0], x.Output)
+	} else {
+		snapPackage, err = snappy.BuildLegacySnap(args[0], x.Output)
+	}
 	if err != nil {
 		return err
 	}

=== modified file 'cmd/snappy/cmd_info.go'
--- cmd/snappy/cmd_info.go	2015-07-24 11:52:14 +0000
+++ cmd/snappy/cmd_info.go	2015-10-12 09:23:01 +0000
@@ -103,8 +103,8 @@
 
 func info() error {
 	release := ubuntuCoreChannel()
-	frameworks, _ := snappy.ActiveSnapNamesByType(pkg.TypeFramework)
-	apps, _ := snappy.ActiveSnapNamesByType(pkg.TypeApp)
+	frameworks, _ := snappy.ActiveSnapIterByType(snappy.FullName, pkg.TypeFramework)
+	apps, _ := snappy.ActiveSnapIterByType(snappy.FullName, pkg.TypeApp)
 
 	// TRANSLATORS: the %s release string
 	fmt.Printf(i18n.G("release: %s\n"), release)

=== modified file 'cmd/snappy/cmd_internal_unpack.go'
--- cmd/snappy/cmd_internal_unpack.go	2015-07-02 16:01:11 +0000
+++ cmd/snappy/cmd_internal_unpack.go	2015-10-12 09:23:01 +0000
@@ -30,9 +30,9 @@
 	"strings"
 	"syscall"
 
-	"launchpad.net/snappy/clickdeb"
 	"launchpad.net/snappy/helpers"
 	"launchpad.net/snappy/logger"
+	"launchpad.net/snappy/pkg/clickdeb"
 )
 
 // #include <sys/prctl.h>

=== modified file 'daemon/api.go'
--- daemon/api.go	2015-09-15 12:57:04 +0000
+++ daemon/api.go	2015-10-12 09:23:01 +0000
@@ -27,13 +27,15 @@
 	"mime/multipart"
 	"net/http"
 	"os"
+	"path/filepath"
 	"sort"
-	"strconv"
 	"strings"
 
 	"github.com/gorilla/mux"
 
+	"launchpad.net/snappy/dirs"
 	"launchpad.net/snappy/logger"
+	"launchpad.net/snappy/pkg/lightweight"
 	"launchpad.net/snappy/progress"
 	"launchpad.net/snappy/release"
 	"launchpad.net/snappy/snappy"
@@ -42,6 +44,8 @@
 var api = []*Command{
 	rootCmd,
 	v1Cmd,
+	metaIconCmd,
+	appIconCmd,
 	packagesCmd,
 	packageCmd,
 	packageConfigCmd,
@@ -62,6 +66,16 @@
 		GET:  v1Get,
 	}
 
+	metaIconCmd = &Command{
+		Path: "/1.0/icons/{icon}",
+		GET:  metaIconGet,
+	}
+
+	appIconCmd = &Command{
+		Path: "/1.0/icons/{name}.{origin}/icon",
+		GET:  appIconGet,
+	}
+
 	packagesCmd = &Command{
 		Path: "/1.0/packages",
 		GET:  getPackagesInfo,
@@ -105,53 +119,49 @@
 
 func v1Get(c *Command, r *http.Request) Response {
 	rel := release.Get()
-	return SyncResponse(map[string]string{
+	m := map[string]string{
 		"flavor":          rel.Flavor,
 		"release":         rel.Series,
 		"default_channel": rel.Channel,
 		"api_compat":      "0",
-	})
+	}
+
+	if store := snappy.StoreID(); store != "" {
+		m["store"] = store
+	}
+
+	return SyncResponse(m)
 }
 
 type metarepo interface {
 	Details(string, string) ([]snappy.Part, error)
 	All() ([]snappy.Part, error)
-}
-
-var newRepo = func() metarepo {
-	return snappy.NewMetaRepository()
-}
-
-var newLocalRepo = func() metarepo {
-	return snappy.NewMetaLocalRepository()
+	Updates() ([]snappy.Part, error)
 }
 
 var newRemoteRepo = func() metarepo {
 	return snappy.NewMetaStoreRepository()
 }
 
+var newSystemRepo = func() metarepo {
+	return snappy.NewSystemImageRepository()
+}
+
 var muxVars = mux.Vars
 
 func getPackageInfo(c *Command, r *http.Request) Response {
 	vars := muxVars(r)
 	name := vars["name"]
 	origin := vars["origin"]
-	if name == "" || origin == "" {
-		// can't happen, i think? mux won't let it
-		return BadRequest(nil, "missing name or origin")
-	}
-
-	repo := newRepo()
-	found, err := repo.Details(name, origin)
-	if err != nil {
-		if err == snappy.ErrPackageNotFound {
-			return NotFound
-		}
-
-		return InternalError(err, "unable to list packages: %v", err)
-	}
-
-	if len(found) == 0 {
+
+	repo := newRemoteRepo()
+	var part snappy.Part
+	if parts, _ := repo.Details(name, origin); len(parts) > 0 {
+		part = parts[0]
+	}
+
+	bag := lightweight.PartBagByName(name, origin)
+	if bag == nil && part == nil {
 		return NotFound
 	}
 
@@ -165,51 +175,37 @@
 		return InternalError(err, "route can't build URL for package %s.%s: %v", name, origin, err)
 	}
 
-	result := parts2map(found, url.String())
+	result := webify(bag.Map(part), url.String())
 
 	return SyncResponse(result)
 }
 
-// parts2map takes a slice of parts with the same name and returns a
-// single map with that part's metadata (including rollback_available
-// & etc).
-func parts2map(parts []snappy.Part, resource string) map[string]string {
-	if len(parts) == 0 {
-		return nil
-	}
-
-	// TODO: handle multiple results in parts; set rollback_available; set update_available
-	part := parts[0]
-	var status string
-	if part.IsInstalled() {
-		if part.IsActive() {
-			status = "active"
-		} else {
-			// can't really happen
-			status = "installed"
+func webify(result map[string]string, resource string) map[string]string {
+	result["resource"] = resource
+
+	icon := result["icon"]
+	if icon == "" || strings.HasPrefix(icon, "http") {
+		return result
+	}
+
+	result["icon"] = ""
+
+	var route *mux.Route
+	var args []string
+
+	if strings.HasPrefix(icon, dirs.SnapIconsDir) {
+		route = metaIconCmd.d.router.Get(metaIconCmd.Path)
+		args = []string{"icon", icon[len(dirs.SnapIconsDir)+1:]}
+	} else {
+		route = appIconCmd.d.router.Get(appIconCmd.Path)
+		args = []string{"name", result["name"], "origin", result["origin"]}
+	}
+
+	if route != nil {
+		url, err := route.URL(args...)
+		if err == nil {
+			result["icon"] = url.String()
 		}
-	} else {
-		status = "not installed"
-	}
-	// TODO: check for removed and transients (extend the Part interface for removed; check ops for transients)
-
-	icon := part.Icon()
-	if strings.HasPrefix(icon, iconPath) {
-		icon = iconPrefix + icon[len(iconPath):]
-	}
-
-	result := map[string]string{
-		"icon":           icon,
-		"name":           part.Name(),
-		"origin":         part.Origin(),
-		"resource":       resource,
-		"status":         status,
-		"type":           string(part.Type()),
-		"vendor":         part.Vendor(),
-		"version":        part.Version(),
-		"description":    part.Description(),
-		"installed_size": strconv.FormatInt(part.InstalledSize(), 10),
-		"download_size":  strconv.FormatInt(part.DownloadSize(), 10),
 	}
 
 	return result
@@ -223,17 +219,6 @@
 	return snappy.QualifiedName(ps[a]) < snappy.QualifiedName(ps[b])
 }
 
-func addPart(results map[string]map[string]string, current []snappy.Part, name string, origin string, route *mux.Route) error {
-	url, err := route.URL("name", name, "origin", origin)
-	if err != nil {
-		return err
-	}
-
-	results[name+"."+origin] = parts2map(current, url.String())
-
-	return nil
-}
-
 // plural!
 func getPackagesInfo(c *Command, r *http.Request) Response {
 	route := c.d.router.Get(packageCmd.Path)
@@ -241,58 +226,58 @@
 		return InternalError(nil, "router can't find route for packages")
 	}
 
-	sources := r.URL.Query().Get("sources")
-	var repo metarepo
-	switch sources {
-	case "local":
-		repo = newLocalRepo()
-	case "remote":
-		repo = newRemoteRepo()
-	default:
-		repo = newRepo()
-	}
-
-	found, err := repo.All()
-	if err != nil {
-		if err == snappy.ErrPackageNotFound {
-			return NotFound
-		}
-
-		return InternalError(err, "unable to list packages: %v", err)
-	}
-
-	if len(found) == 0 {
-		return NotFound
-	}
+	sources := make([]string, 1, 3)
+	sources[0] = "local"
+	// we're not worried if the remote repos error out
+	found, _ := newRemoteRepo().All()
+	if len(found) > 0 {
+		sources = append(sources, "store")
+	}
+
+	upd, _ := newSystemRepo().Updates()
+	if len(upd) > 0 {
+		sources = append(sources, "system-image")
+	}
+
+	found = append(found, upd...)
 
 	sort.Sort(byQN(found))
 
+	bags := lightweight.AllPartBags()
+
 	results := make(map[string]map[string]string)
-	var current []snappy.Part
-	var oldName string
-	var oldOrigin string
-	for i := range found {
-		name := found[i].Name()
-		origin := found[i].Origin()
-		if (name != oldName || origin != oldOrigin) && len(current) > 0 {
-			if err := addPart(results, current, oldName, oldOrigin, route); err != nil {
-				return InternalError(err, "can't get details for %s.%s: %v", oldName, oldOrigin, err)
-			}
-			current = nil
+	for _, part := range found {
+		name := part.Name()
+		origin := part.Origin()
+
+		url, err := route.URL("name", name, "origin", origin)
+		if err != nil {
+			return InternalError(err, "can't get route to details for %s.%s: %v", name, origin, err)
 		}
-		oldName = name
-		oldOrigin = origin
-		current = append(current, found[i])
+
+		fullname := name + "." + origin
+		qn := snappy.QualifiedName(part)
+		results[fullname] = webify(bags[qn].Map(part), url.String())
+		delete(bags, qn)
 	}
 
-	if len(current) > 0 {
-		if err := addPart(results, current, oldName, oldOrigin, route); err != nil {
-			return InternalError(err, "can't get details for %s.%s: %v", oldName, oldOrigin, err)
+	for _, v := range bags {
+		m := v.Map(nil)
+		name := m["name"]
+		origin := m["origin"]
+
+		resource := "no resource URL for this resource"
+		url, _ := route.URL("name", name, "origin", origin)
+		if url != nil {
+			resource = url.String()
 		}
+
+		results[name+"."+origin] = webify(m, resource)
 	}
 
 	return SyncResponse(map[string]interface{}{
 		"packages": results,
+		"sources":  sources,
 		"paging": map[string]interface{}{
 			"pages": 1,
 			"page":  1,
@@ -301,25 +286,6 @@
 	})
 }
 
-func getActivePkg(fullname string) ([]snappy.Part, error) {
-	// TODO: below should be rolled into ActiveSnapByName
-	// (specifically: ActiveSnapByname should know about origins)
-	repo := newLocalRepo()
-	all, err := repo.All()
-	if err != nil {
-		return nil, err
-	}
-
-	parts := all[:0]
-	for _, part := range snappy.FindSnapsByName(fullname, all) {
-		if part.IsActive() {
-			parts = append(parts, part)
-		}
-	}
-
-	return parts, nil
-}
-
 var findServices = snappy.FindServices
 
 type svcDesc struct {
@@ -362,23 +328,20 @@
 		return BadRequest(nil, "unknown action %s", action)
 	}
 
-	parts, err := getActivePkg(pkgName)
+	bag := lightweight.PartBagByName(name, origin)
+	idx := bag.ActiveIndex()
+	if idx < 0 {
+		return NotFound
+	}
+
+	ipart, err := bag.Load(idx)
 	if err != nil {
-		return InternalError(err, "unable to get package list: %v", err)
-	}
-
-	switch len(parts) {
-	default:
-		return InternalError(nil, "found %d active for %s", len(parts), pkgName)
-	case 0:
-		return NotFound
-	case 1:
-		// yay, or something
-	}
-
-	part, ok := parts[0].(snappy.ServiceYamler)
+		return InternalError(err, "unable to get load active package: %v", err)
+	}
+
+	part, ok := ipart.(*snappy.SnapPart)
 	if !ok {
-		return InternalError(nil, "active package of type %T does not implement snappy.ServiceYamler", parts[0])
+		return InternalError(nil, "active package is not a *snappy.SnapPart: %T", ipart)
 	}
 	svcs := part.ServiceYamls()
 
@@ -460,18 +423,15 @@
 	}
 	pkgName := name + "." + origin
 
-	parts, err := getActivePkg(pkgName)
+	bag := lightweight.PartBagByName(name, origin)
+	idx := bag.ActiveIndex()
+	if idx < 0 {
+		return NotFound
+	}
+
+	part, err := bag.Load(idx)
 	if err != nil {
-		return InternalError(err, "unable to get package list: %v", err)
-	}
-
-	switch len(parts) {
-	default:
-		return InternalError(nil, "found %d active for %s", len(parts), pkgName)
-	case 0:
-		return NotFound
-	case 1:
-		// yay, or something
+		return InternalError(err, "unable to get load active package: %v", err)
 	}
 
 	bs, err := ioutil.ReadAll(r.Body)
@@ -479,7 +439,7 @@
 		return BadRequest(err, "reading config request body gave %v", err)
 	}
 
-	config, err := parts[0].Config(bs)
+	config, err := part.Config(bs)
 	if err != nil {
 		return InternalError(err, "unable to retrieve config for %s: %v", pkgName, err)
 	}
@@ -569,6 +529,14 @@
 	return err
 }
 
+func (inst *packageInstruction) activate() interface{} {
+	return snappy.SetActive(inst.pkg, true, inst.prog)
+}
+
+func (inst *packageInstruction) deactivate() interface{} {
+	return snappy.SetActive(inst.pkg, false, inst.prog)
+}
+
 func (inst *packageInstruction) dispatch() func() interface{} {
 	switch inst.Action {
 	case "install":
@@ -582,6 +550,10 @@
 		return inst.purge
 	case "rollback":
 		return inst.rollback
+	case "activate":
+		return inst.activate
+	case "deactivate":
+		return inst.deactivate
 	default:
 		return nil
 	}
@@ -729,3 +701,35 @@
 
 	return SyncResponse(logs)
 }
+
+func metaIconGet(c *Command, r *http.Request) Response {
+	vars := muxVars(r)
+	name := vars["icon"]
+
+	path := filepath.Join(dirs.SnapIconsDir, name)
+
+	return FileResponse(path)
+}
+
+func appIconGet(c *Command, r *http.Request) Response {
+	vars := muxVars(r)
+	name := vars["name"]
+	origin := vars["origin"]
+
+	bag := lightweight.PartBagByName(name, origin)
+	if bag == nil || len(bag.Versions) == 0 {
+		return NotFound
+	}
+
+	part := bag.LoadBest()
+	if part == nil {
+		return NotFound
+	}
+
+	path := filepath.Clean(part.Icon())
+	if !strings.HasPrefix(path, dirs.SnapAppsDir) && !strings.HasPrefix(path, dirs.SnapOemDir) {
+		return BadRequest
+	}
+
+	return FileResponse(path)
+}

=== modified file 'daemon/api_test.go'
--- daemon/api_test.go	2015-09-15 12:55:09 +0000
+++ daemon/api_test.go	2015-10-12 09:23:01 +0000
@@ -32,11 +32,15 @@
 	"net/http/httptest"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 	"time"
 
 	"gopkg.in/check.v1"
 
+	"launchpad.net/snappy/dirs"
+	"launchpad.net/snappy/pkg"
+	"launchpad.net/snappy/pkg/lightweight"
 	"launchpad.net/snappy/progress"
 	"launchpad.net/snappy/release"
 	"launchpad.net/snappy/snappy"
@@ -62,69 +66,123 @@
 	return s.parts, s.err
 }
 
+func (s *apiSuite) Updates() ([]snappy.Part, error) {
+	return s.parts, s.err
+}
+
 func (s *apiSuite) muxVars(*http.Request) map[string]string {
 	return s.vars
 }
 
 func (s *apiSuite) SetUpSuite(c *check.C) {
-	newRepo = func() metarepo {
+	newRemoteRepo = func() metarepo {
 		return s
 	}
-	newLocalRepo = newRepo
-	newRemoteRepo = newRepo
+	newSystemRepo = newRemoteRepo
 	muxVars = s.muxVars
 }
 
 func (s *apiSuite) TearDownSuite(c *check.C) {
-	newLocalRepo = nil
 	newRemoteRepo = nil
-	newRepo = nil
+	newSystemRepo = nil
 	muxVars = nil
 }
 
 func (s *apiSuite) SetUpTest(c *check.C) {
+	dirs.SetRootDir(c.MkDir())
+
 	s.parts = nil
 	s.err = nil
 	s.vars = nil
 }
 
+func (s *apiSuite) mkInstalled(c *check.C, name, origin, version string, active bool, extraYaml string) {
+	fullname := name + "." + origin
+	c.Assert(os.MkdirAll(filepath.Join(dirs.SnapDataDir, fullname, version), 0755), check.IsNil)
+
+	metadir := filepath.Join(dirs.SnapAppsDir, fullname, version, "meta")
+	c.Assert(os.MkdirAll(metadir, 0755), check.IsNil)
+
+	content := fmt.Sprintf(`
+name: %s
+version: %s
+vendor: a vendor
+%s`, name, version, extraYaml)
+	c.Check(ioutil.WriteFile(filepath.Join(metadir, "package.yaml"), []byte(content), 0644), check.IsNil)
+	c.Check(ioutil.WriteFile(filepath.Join(metadir, "hashes.yaml"), []byte(nil), 0644), check.IsNil)
+
+	if active {
+		c.Assert(os.Symlink(version, filepath.Join(dirs.SnapAppsDir, fullname, "current")), check.IsNil)
+	}
+}
+
+func (s *apiSuite) mkOem(c *check.C, store string) {
+	content := []byte(fmt.Sprintf(`name: test
+version: 1
+vendor: a vendor
+type: oem
+oem: {store: {id: %q}}
+`, store))
+
+	d := filepath.Join(dirs.SnapOemDir, "test")
+	m := filepath.Join(d, "1", "meta")
+	c.Assert(os.MkdirAll(m, 0755), check.IsNil)
+	c.Assert(os.Symlink("1", filepath.Join(d, "current")), check.IsNil)
+	c.Assert(ioutil.WriteFile(filepath.Join(m, "package.yaml"), content, 0644), check.IsNil)
+	c.Assert(ioutil.WriteFile(filepath.Join(m, "hashes.yaml"), []byte(nil), 0644), check.IsNil)
+}
+
 func (s *apiSuite) TestPackageInfoOneIntegration(c *check.C) {
 	d := New()
 	d.addRoutes()
 
 	s.vars = map[string]string{"name": "foo", "origin": "bar"}
 
+	// the store tells us about v2
 	s.parts = []snappy.Part{&tP{
-		name:          "foo",
-		version:       "v1",
-		description:   "description",
-		origin:        "bar",
-		vendor:        "a vendor",
-		isInstalled:   true,
-		isActive:      true,
-		icon:          iconPath + "icon.png",
-		_type:         "a type",
-		installedSize: 42,
-		downloadSize:  2,
+		name:         "foo",
+		version:      "v2",
+		description:  "description",
+		origin:       "bar",
+		vendor:       "a vendor",
+		isInstalled:  true,
+		isActive:     true,
+		icon:         dirs.SnapIconsDir + "icon.png",
+		_type:        pkg.TypeApp,
+		downloadSize: 2,
 	}}
+
+	// we have v0 installed
+	s.mkInstalled(c, "foo", "bar", "v0", false, "")
+	// and v1 is current
+	s.mkInstalled(c, "foo", "bar", "v1", true, "")
+
 	rsp, ok := getPackageInfo(packageCmd, nil).(*resp)
 	c.Assert(ok, check.Equals, true)
 
+	// installed_size depends on vagaries of the filesystem, just check regexp
+	c.Assert(rsp, check.NotNil)
+	c.Assert(rsp.Result, check.FitsTypeOf, map[string]string{})
+	m := rsp.Result.(map[string]string)
+	c.Check(m["installed_size"], check.Matches, "[0-9]+")
+	delete(m, "installed_size")
+
 	expected := &resp{
 		Type:   ResponseTypeSync,
 		Status: http.StatusOK,
 		Result: map[string]string{
-			"name":           "foo",
-			"version":        "v1",
-			"description":    "description",
-			"origin":         "bar",
-			"vendor":         "a vendor",
-			"status":         "active",
-			"icon":           iconPrefix + "icon.png",
-			"type":           "a type",
-			"download_size":  "2",
-			"installed_size": "42",
-			"resource":       "/1.0/packages/foo.bar",
+			"name":               "foo",
+			"version":            "v1",
+			"description":        "description",
+			"origin":             "bar",
+			"vendor":             "a vendor",
+			"status":             "active",
+			"icon":               "/1.0/icons/foo.bar/icon",
+			"type":               string(pkg.TypeApp),
+			"download_size":      "2",
+			"resource":           "/1.0/packages/foo.bar",
+			"update_available":   "v2",
+			"rollback_available": "v0",
 		},
 	}
 
@@ -144,14 +202,14 @@
 	c.Check(getPackageInfo(packageCmd, nil).Self(nil, nil).(*resp).Status, check.Equals, http.StatusNotFound)
 }
 
-func (s *apiSuite) TestPackageInfoWeirdDetails(c *check.C) {
+func (s *apiSuite) TestPackageInfoIgnoresRemoteErrors(c *check.C) {
 	s.vars = map[string]string{"name": "foo", "origin": "bar"}
 	s.err = errors.New("weird")
 
-	rsp := getPackageInfo(packageCmd, nil).(*resp)
+	rsp := getPackageInfo(packageCmd, nil).Self(nil, nil).(*resp)
 
 	c.Check(rsp.Type, check.Equals, ResponseTypeError)
-	c.Check(rsp.Status, check.Equals, http.StatusInternalServerError)
+	c.Check(rsp.Status, check.Equals, http.StatusNotFound)
 	c.Check(rsp.Result, check.NotNil)
 }
 
@@ -188,47 +246,6 @@
 	c.Check(rsp.Result.(map[string]interface{})["msg"], check.Matches, `route can't build URL .*`)
 }
 
-func (s *apiSuite) TestParts2Map(c *check.C) {
-	parts := []snappy.Part{&tP{
-		name:          "foo",
-		version:       "v1",
-		description:   "description",
-		origin:        "bar",
-		vendor:        "a vendor",
-		isInstalled:   true,
-		isActive:      true,
-		icon:          "icon.png",
-		_type:         "a type",
-		installedSize: 42,
-		downloadSize:  2,
-	}}
-
-	resource := "/1.0/packages/foo.bar"
-
-	expected := map[string]string{
-		"name":           "foo",
-		"version":        "v1",
-		"description":    "description",
-		"origin":         "bar",
-		"vendor":         "a vendor",
-		"status":         "active",
-		"icon":           "icon.png",
-		"type":           "a type",
-		"download_size":  "2",
-		"installed_size": "42",
-		"resource":       resource,
-	}
-
-	c.Check(parts2map(parts, resource), check.DeepEquals, expected)
-}
-
-func (s *apiSuite) TestParts2MapState(c *check.C) {
-	c.Check(parts2map([]snappy.Part{&tP{}}, "")["status"], check.Equals, "not installed")
-	c.Check(parts2map([]snappy.Part{&tP{isInstalled: true}}, "")["status"], check.Equals, "installed")
-	c.Check(parts2map([]snappy.Part{&tP{isInstalled: true, isActive: true}}, "")["status"], check.Equals, "active")
-	// TODO: more statuses
-}
-
 func (s *apiSuite) TestListIncludesAll(c *check.C) {
 	// Very basic check to help stop us from not adding all the
 	// commands to the command list.
@@ -263,9 +280,8 @@
 		"findServices",
 		"maxReadBuflen",
 		"muxVars",
-		"newLocalRepo",
 		"newRemoteRepo",
-		"newRepo",
+		"newSystemRepo",
 		"newSnap",
 		"pkgActionDispatch",
 	}
@@ -294,22 +310,26 @@
 	c.Check(rsp.Result, check.DeepEquals, expected)
 }
 
-func (s *apiSuite) TestV1(c *check.C) {
-	// check it only does GET
-	c.Check(v1Cmd.PUT, check.IsNil)
-	c.Check(v1Cmd.POST, check.IsNil)
-	c.Check(v1Cmd.DELETE, check.IsNil)
-	c.Assert(v1Cmd.GET, check.NotNil)
-
-	rec := httptest.NewRecorder()
-	c.Check(v1Cmd.Path, check.Equals, "/1.0")
-
+func (s *apiSuite) mkrelease(c *check.C) {
 	// set up release
 	root := c.MkDir()
 	d := filepath.Join(root, "etc", "system-image")
 	c.Assert(os.MkdirAll(d, 0755), check.IsNil)
 	c.Assert(ioutil.WriteFile(filepath.Join(d, "channel.ini"), []byte("[service]\nchannel: ubuntu-flavor/release/channel"), 0644), check.IsNil)
 	c.Assert(release.Setup(root), check.IsNil)
+}
+
+func (s *apiSuite) TestV1(c *check.C) {
+	// check it only does GET
+	c.Check(v1Cmd.PUT, check.IsNil)
+	c.Check(v1Cmd.POST, check.IsNil)
+	c.Check(v1Cmd.DELETE, check.IsNil)
+	c.Assert(v1Cmd.GET, check.NotNil)
+
+	rec := httptest.NewRecorder()
+	c.Check(v1Cmd.Path, check.Equals, "/1.0")
+
+	s.mkrelease(c)
 
 	v1Cmd.GET(v1Cmd, nil).ServeHTTP(rec, nil)
 	c.Check(rec.Code, check.Equals, 200)
@@ -328,6 +348,30 @@
 	c.Check(rsp.Result, check.DeepEquals, expected)
 }
 
+func (s *apiSuite) TestV1Store(c *check.C) {
+	rec := httptest.NewRecorder()
+	c.Check(v1Cmd.Path, check.Equals, "/1.0")
+
+	s.mkrelease(c)
+	s.mkOem(c, "some-store")
+
+	v1Cmd.GET(v1Cmd, nil).ServeHTTP(rec, nil)
+	c.Check(rec.Code, check.Equals, 200)
+
+	expected := map[string]interface{}{
+		"flavor":          "flavor",
+		"release":         "release",
+		"default_channel": "channel",
+		"api_compat":      "0",
+		"store":           "some-store",
+	}
+	var rsp resp
+	c.Assert(json.Unmarshal(rec.Body.Bytes(), &rsp), check.IsNil)
+	c.Check(rsp.Status, check.Equals, 200)
+	c.Check(rsp.Type, check.Equals, ResponseTypeSync)
+	c.Check(rsp.Result, check.DeepEquals, expected)
+}
+
 func (s *apiSuite) TestPackagesInfoOnePerIntegration(c *check.C) {
 	d := New()
 	d.addRoutes()
@@ -335,12 +379,12 @@
 	req, err := http.NewRequest("GET", "/1.0/packages", nil)
 	c.Assert(err, check.IsNil)
 
-	s.parts = []snappy.Part{
-		&tP{name: "foo", version: "v1", origin: "bar"},
-		&tP{name: "bar", version: "v2", origin: "baz"},
-		&tP{name: "baz", version: "v3", origin: "qux"},
-		&tP{name: "qux", version: "v4", origin: "mip"},
+	ddirs := [][2]string{{"foo.bar", "v1"}, {"bar.baz", "v2"}, {"baz.qux", "v3"}, {"qux.mip", "v4"}}
+
+	for i := range ddirs {
+		c.Assert(os.MkdirAll(filepath.Join(dirs.SnapDataDir, ddirs[i][0], ddirs[i][1]), 0755), check.IsNil)
 	}
+
 	rsp, ok := getPackagesInfo(packagesCmd, req).(*resp)
 	c.Assert(ok, check.Equals, true)
 
@@ -351,21 +395,22 @@
 	meta, ok := rsp.Result.(map[string]interface{})
 	c.Assert(ok, check.Equals, true)
 	c.Assert(meta, check.NotNil)
-	c.Check(meta["paging"], check.DeepEquals, map[string]interface{}{"pages": 1, "page": 1, "count": len(s.parts)})
+	c.Check(meta["paging"], check.DeepEquals, map[string]interface{}{"pages": 1, "page": 1, "count": len(ddirs)})
 
 	packages, ok := meta["packages"].(map[string]map[string]string)
 	c.Assert(ok, check.Equals, true)
 	c.Check(packages, check.NotNil)
-	c.Check(packages, check.HasLen, len(s.parts))
+	c.Check(packages, check.HasLen, len(ddirs))
 
-	for _, part := range s.parts {
-		part := part.(*tP)
-		qn := part.name + "." + part.origin
+	for i := range ddirs {
+		qn, version := ddirs[i][0], ddirs[i][1]
+		idx := strings.LastIndex(qn, ".")
+		name, origin := qn[:idx], qn[idx+1:]
 		got := packages[qn]
 		c.Assert(got, check.NotNil, check.Commentf(qn))
-		c.Check(got["name"], check.Equals, part.name)
-		c.Check(got["version"], check.Equals, part.version)
-		c.Check(got["origin"], check.Equals, part.origin)
+		c.Check(got["name"], check.Equals, name)
+		c.Check(got["version"], check.Equals, version)
+		c.Check(got["origin"], check.Equals, origin)
 	}
 }
 
@@ -530,6 +575,14 @@
 	}
 }
 
+type cfgc struct{ cfg string }
+
+func (cfgc) IsInstalled(string) bool { return true }
+func (cfgc) ActiveIndex() int        { return 0 }
+func (c cfgc) Load(string) (snappy.Part, error) {
+	return &tP{name: "foo", version: "v1", origin: "bar", isActive: true, config: c.cfg}, nil
+}
+
 func (s *apiSuite) TestPackageGetConfig(c *check.C) {
 	d := New()
 	d.addRoutes()
@@ -538,13 +591,16 @@
 	c.Assert(err, check.IsNil)
 
 	configStr := "some: config"
+	oldConcrete := lightweight.NewConcrete
+	defer func() {
+		lightweight.NewConcrete = oldConcrete
+	}()
+	lightweight.NewConcrete = func(*lightweight.PartBag, string) lightweight.Concreter {
+		return &cfgc{configStr}
+	}
+
 	s.vars = map[string]string{"name": "foo", "origin": "bar"}
-	s.parts = []snappy.Part{
-		&tP{name: "foo", version: "v1", origin: "bar", isActive: true, config: configStr},
-		&tP{name: "bar", version: "v2", origin: "baz", isActive: true},
-		&tP{name: "baz", version: "v3", origin: "qux", isActive: true},
-		&tP{name: "qux", version: "v4", origin: "mip", isActive: true},
-	}
+	s.mkInstalled(c, "foo", "bar", "v1", true, "")
 
 	rsp := packageConfig(packagesCmd, req).(*resp)
 
@@ -564,15 +620,18 @@
 	c.Assert(err, check.IsNil)
 
 	configStr := "some: config"
+	oldConcrete := lightweight.NewConcrete
+	defer func() {
+		lightweight.NewConcrete = oldConcrete
+	}()
+	lightweight.NewConcrete = func(*lightweight.PartBag, string) lightweight.Concreter {
+		return &cfgc{configStr}
+	}
+
 	s.vars = map[string]string{"name": "foo", "origin": "bar"}
-	s.parts = []snappy.Part{
-		&tP{name: "foo", version: "v1", origin: "bar", isActive: true, config: configStr},
-		&tP{name: "bar", version: "v2", origin: "baz", isActive: true},
-		&tP{name: "baz", version: "v3", origin: "qux", isActive: true},
-		&tP{name: "qux", version: "v4", origin: "mip", isActive: true},
-	}
+	s.mkInstalled(c, "foo", "bar", "v1", true, "")
 
-	rsp := packageConfig(packagesCmd, req).(*resp)
+	rsp := packageConfig(packagesCmd, req).Self(nil, nil).(*resp)
 
 	c.Check(rsp, check.DeepEquals, &resp{
 		Type:   ResponseTypeSync,
@@ -592,11 +651,7 @@
 	req, err := http.NewRequest("GET", "/1.0/packages/foo.bar/services", nil)
 	c.Assert(err, check.IsNil)
 
-	s.parts = []snappy.Part{
-		&tP{name: "foo", version: "v1", origin: "bar", isActive: true,
-			svcYamls: []snappy.ServiceYaml{{Name: "svc"}},
-		},
-	}
+	s.mkInstalled(c, "foo", "bar", "v1", true, "services: [{name: svc}]")
 	s.vars = map[string]string{"name": "foo", "origin": "bar"} // NB: no service specified
 
 	rsp := packageService(packageSvcsCmd, req).(*resp)
@@ -605,11 +660,10 @@
 	c.Check(rsp.Status, check.Equals, http.StatusOK)
 
 	m := rsp.Result.(map[string]*svcDesc)
-	c.Assert(m["svc"], check.DeepEquals, &svcDesc{
-		Op:     "status",
-		Spec:   &snappy.ServiceYaml{Name: "svc"},
-		Status: &snappy.PackageServiceStatus{ServiceName: "svc"},
-	})
+	c.Assert(m["svc"], check.FitsTypeOf, new(svcDesc))
+	c.Check(m["svc"].Op, check.Equals, "status")
+	c.Check(m["svc"].Spec, check.DeepEquals, &snappy.ServiceYaml{Name: "svc", StopTimeout: snappy.DefaultTimeout})
+	c.Check(m["svc"].Status, check.DeepEquals, &snappy.PackageServiceStatus{ServiceName: "svc"})
 }
 
 func (s *apiSuite) TestPackageServicePut(c *check.C) {
@@ -624,11 +678,7 @@
 	req, err := http.NewRequest("PUT", "/1.0/packages/foo.bar/services", buf)
 	c.Assert(err, check.IsNil)
 
-	s.parts = []snappy.Part{
-		&tP{name: "foo", version: "v1", origin: "bar", isActive: true,
-			svcYamls: []snappy.ServiceYaml{{Name: "svc"}},
-		},
-	}
+	s.mkInstalled(c, "foo", "bar", "v1", true, "services: [{name: svc}]")
 	s.vars = map[string]string{"name": "foo", "origin": "bar"} // NB: no service specified
 
 	rsp := packageService(packageSvcsCmd, req).(*resp)

=== modified file 'daemon/daemon.go'
--- daemon/daemon.go	2015-09-15 12:55:09 +0000
+++ daemon/daemon.go	2015-10-12 09:23:01 +0000
@@ -128,11 +128,6 @@
 	return nil
 }
 
-const (
-	iconPath   = "/var/lib/snappy/icons/"
-	iconPrefix = "/1.0/icons/"
-)
-
 func (d *Daemon) addRoutes() {
 	d.router = mux.NewRouter()
 
@@ -142,8 +137,6 @@
 		d.router.Handle(c.Path, c).Name(c.Path)
 	}
 
-	// hrmph
-	d.router.PathPrefix(iconPrefix).Handler(http.StripPrefix(iconPrefix, http.FileServer(http.Dir(iconPath)))).Name(iconPrefix)
 	// also maybe add a /favicon.ico handler...
 
 	d.router.NotFoundHandler = NotFound

=== added file 'daemon/daemon_test.go'
--- daemon/daemon_test.go	1970-01-01 00:00:00 +0000
+++ daemon/daemon_test.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,95 @@
+// -*- 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 daemon
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+
+	"github.com/gorilla/mux"
+	"gopkg.in/check.v1"
+)
+
+type daemonSuite struct{}
+
+var _ = check.Suite(&daemonSuite{})
+
+type mockHandler struct {
+	cmd        *Command
+	lastMethod string
+}
+
+func (mck *mockHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	mck.lastMethod = r.Method
+}
+func (mck *mockHandler) Self(*Command, *http.Request) Response {
+	return mck
+}
+
+func mkRF(c *check.C, cmd *Command, mck *mockHandler) ResponseFunc {
+	return func(innerCmd *Command, req *http.Request) Response {
+		c.Assert(cmd, check.Equals, innerCmd)
+		return mck
+	}
+}
+
+func (s *daemonSuite) TestCommandMethodDispatch(c *check.C) {
+	cmd := &Command{}
+	mck := &mockHandler{cmd: cmd}
+	rf := mkRF(c, cmd, mck)
+	cmd.GET = rf
+	cmd.PUT = rf
+	cmd.POST = rf
+	cmd.DELETE = rf
+
+	for _, method := range []string{"GET", "POST", "PUT", "DELETE"} {
+		req, err := http.NewRequest(method, "", nil)
+		c.Assert(err, check.IsNil)
+		cmd.ServeHTTP(nil, req)
+		c.Check(mck.lastMethod, check.Equals, method)
+	}
+
+	req, err := http.NewRequest("POTATO", "", nil)
+	c.Assert(err, check.IsNil)
+	rec := httptest.NewRecorder()
+	cmd.ServeHTTP(rec, req)
+	c.Check(rec.Code, check.Equals, http.StatusMethodNotAllowed)
+}
+
+func (s *daemonSuite) TestAddRoutes(c *check.C) {
+	d := New()
+	d.addRoutes()
+
+	expected := make([]string, len(api))
+	for i, v := range api {
+		expected[i] = v.Path
+	}
+
+	got := make([]string, 0, len(api))
+	c.Assert(d.router.Walk(func(route *mux.Route, router *mux.Router, ancestors []*mux.Route) error {
+		got = append(got, route.GetName())
+		return nil
+	}), check.IsNil)
+
+	c.Check(got, check.DeepEquals, expected) // this'll stop being true if routes are added that aren't commands (e.g. for the favicon)
+
+	c.Check(fmt.Sprintf("%p", d.router.NotFoundHandler), check.Equals, fmt.Sprintf("%p", NotFound))
+}

=== modified file 'daemon/response.go'
--- daemon/response.go	2015-09-15 13:47:08 +0000
+++ daemon/response.go	2015-10-12 09:23:01 +0000
@@ -39,9 +39,8 @@
 	ResponseTypeError ResponseType = "error"
 )
 
-// Response knows how to render itself, how to handle itself, and how to find itself
+// Response knows how to serve itself, and how to find itself
 type Response interface {
-	Render(w http.ResponseWriter) ([]byte, int)
 	ServeHTTP(w http.ResponseWriter, r *http.Request)
 	Self(*Command, *http.Request) Response // has the same arity as ResponseFunc for convenience
 }
@@ -61,19 +60,15 @@
 	})
 }
 
-func (r *resp) Render(w http.ResponseWriter) (buf []byte, status int) {
+func (r *resp) ServeHTTP(w http.ResponseWriter, _ *http.Request) {
+	status := r.Status
 	bs, err := r.MarshalJSON()
 	if err != nil {
 		logger.Noticef("unable to marshal %#v to JSON: %v", *r, err)
-		return nil, http.StatusInternalServerError
+		bs = nil
+		status = http.StatusInternalServerError
 	}
 
-	return bs, r.Status
-}
-
-func (r *resp) ServeHTTP(w http.ResponseWriter, _ *http.Request) {
-	bs, status := r.Render(w)
-
 	hdr := w.Header()
 	if r.Type == ResponseTypeAsync {
 		if m, ok := r.Result.(map[string]interface{}); ok {
@@ -151,15 +146,21 @@
 	return r.SetError
 }
 
+// A FileResponse 's ServeHTTP method serves the file
+type FileResponse string
+
+// Self from the Response interface
+func (f FileResponse) Self(*Command, *http.Request) Response { return f }
+
+// ServeHTTP from the Response interface
+func (f FileResponse) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	http.ServeFile(w, r, string(f))
+}
+
 // ErrorResponseFunc is a callable error Response.
 // So you can return e.g. InternalError, or InternalError(err, "something broke"), etc.
 type ErrorResponseFunc func(error, string, ...interface{}) Response
 
-// Render the response
-func (f ErrorResponseFunc) Render(w http.ResponseWriter) ([]byte, int) {
-	return f(nil, "").Render(w)
-}
-
 func (f ErrorResponseFunc) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	f(nil, "").ServeHTTP(w, r)
 }

=== modified file 'daemon/snappy_part_iface_test.go'
--- daemon/snappy_part_iface_test.go	2015-09-14 14:35:06 +0000
+++ daemon/snappy_part_iface_test.go	2015-10-12 09:23:01 +0000
@@ -83,8 +83,8 @@
 	}
 	return p.config, p.configErr
 }
-func (p *tP) SetActive(progress.Meter) error { return p.setActiveErr }
-func (p *tP) Frameworks() ([]string, error)  { return p.frameworks, p.frameworksErr }
+func (p *tP) SetActive(bool, progress.Meter) error { return p.setActiveErr }
+func (p *tP) Frameworks() ([]string, error)        { return p.frameworks, p.frameworksErr }
 
 // for ServiceYamler interface:
 func (p *tP) ServiceYamls() []snappy.ServiceYaml { return p.svcYamls }

=== added file 'data/failure.txt'
--- data/failure.txt	1970-01-01 00:00:00 +0000
+++ data/failure.txt	2015-10-12 09:23:01 +0000
@@ -0,0 +1,8 @@
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
+░░░█▀▀░█▀▄░█░█░█▀▀░█░█░▀█▀░█▀█░█▀▀░░░█▀▀░█▀█░▀█▀░█░░░█░█░█▀▄░█▀▀░░░
+░░░█░░░█▀▄░█░█░▀▀█░█▀█░░█░░█░█░█░█░░░█▀▀░█▀█░░█░░█░░░█░█░█▀▄░█▀▀░░░
+░░░▀▀▀░▀░▀░▀▀▀░▀▀▀░▀░▀░▀▀▀░▀░▀░▀▀▀░░░▀░░░▀░▀░▀▀▀░▀▀▀░▀▀▀░▀░▀░▀▀▀░░░
+░░░░░░░░░░░░░█▀█░█▀█░█▀▄░░░█▀▄░█▀▀░█▀▀░█▀█░█▀█░▀█▀░█▀▄░░░░░░░░░░░░░
+░░░░░░░░░░░░░█▀█░█░█░█░█░░░█░█░█▀▀░▀▀█░█▀▀░█▀█░░█░░█▀▄░░░░░░░░░░░░░
+░░░░░░░░░░░░░▀░▀░▀░▀░▀▀░░░░▀▀░░▀▀▀░▀▀▀░▀░░░▀░▀░▀▀▀░▀░▀░░░░░░░░░░░░░
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░

=== added file 'data/success.txt'
--- data/success.txt	1970-01-01 00:00:00 +0000
+++ data/success.txt	2015-10-12 09:23:01 +0000
@@ -0,0 +1,20 @@
+   ▒██▒    ████      ████                                                    ██
+   ▓██▓    ████      ████                                                    ██
+   ████      ██        ██                                                    ██
+   ████      ██        ██                 ▒███▒██   ░████░    ░████░    ▒███░██
+  ▒█▓▓█▒     ██        ██                ░███████  ░██████░  ░██████░  ▒███████
+  ▓█▒▒█▓     ██        ██                ███  ███  ███  ███  ███  ███  ███  ███
+  ██  ██     ██        ██                ██░  ░██  ██░  ░██  ██░  ░██  ██░  ░██
+  ██████     ██        ██                ██    ██  ██    ██  ██    ██  ██    ██
+ ░██████░    ██        ██                ██░  ░██  ██░  ░██  ██░  ░██  ██░  ░██
+ ▒██  ██▒    ██▒       ██▒               ███  ███  ███  ███  ███  ███  ███  ███
+ ███  ███    █████     █████             ░███████  ░██████░  ░██████░  ▒███████
+ ██▒  ▒██    ░████     ░████              ▒███▒██   ░████░    ░████░    ▒███░██
+                                          █░  ▒██
+                                          ██████▓
+                                          ▒████▒
+
+         ▌     ▐            ▜   ▌             ▗ ▌  ▜
+     ▌  ▌▛▀▖▝▀▖▜▀  ▞▀▖▞▀▖▌ ▌▐ ▞▀▌ ▛▀▖▞▀▖▞▀▘▞▀▘▄ ▛▀▖▐ ▌ ▌ ▞▀▌▞▀▖ ▌  ▌▙▀▖▞▀▖▛▀▖▞▀▌
+     ▐▐▐ ▌ ▌▞▀▌▐ ▖ ▌ ▖▌ ▌▌ ▌▐ ▌ ▌ ▙▄▘▌ ▌▝▀▖▝▀▖▐ ▌ ▌▐ ▚▄▌ ▚▄▌▌ ▌ ▐▐▐ ▌  ▌ ▌▌ ▌▚▄▌
+      ▘▘ ▘ ▘▝▀▘ ▀  ▝▀ ▝▀ ▝▀▘ ▘▝▀▘ ▌  ▝▀ ▀▀ ▀▀ ▀▘▀▀  ▘▗▄▘ ▗▄▘▝▀   ▘▘ ▘  ▝▀ ▘ ▘▗▄▘

=== modified file 'debian/control'
--- debian/control	2015-09-22 05:52:46 +0000
+++ debian/control	2015-10-12 09:23:01 +0000
@@ -24,7 +24,8 @@
                golang-go-systemd-dev,
                lsb-release,
                python3,
-               python3-markdown
+               python3-markdown,
+               squashfs-tools
 Standards-Version: 3.9.6
 Homepage: https://launchpad.net/snappy
 Vcs-Browser: http://bazaar.launchpad.net/~snappy-dev/snappy/trunk/files
@@ -39,6 +40,7 @@
 Package: ubuntu-snappy
 Architecture: all
 Depends: debsig-verify,
+         squashfs-tools,
          system-image-cli (>= 3.0),
          ubuntu-snappy-cli (= ${binary:Version}),
          ubuntu-core-upgrader,

=== modified file 'debian/ubuntu-snappy.snapd.socket'
--- debian/ubuntu-snappy.snapd.socket	2015-09-16 22:01:49 +0000
+++ debian/ubuntu-snappy.snapd.socket	2015-10-12 09:23:01 +0000
@@ -2,7 +2,11 @@
 Description=Socket activation for snappy daemon
 
 [Socket]
-ListenStream=@snapd
+ListenStream=/run/snapd.socket
+SocketMode=0600
+# these are the defaults, but can't hurt to specify them anyway:
+SocketUser=root
+SocketGroup=root
 
 [Install]
 WantedBy=sockets.target

=== added directory 'dirs'
=== renamed file 'snappy/dirs.go' => 'dirs/dirs.go'
--- snappy/dirs.go	2015-06-30 12:36:00 +0000
+++ dirs/dirs.go	2015-10-12 09:23:01 +0000
@@ -17,58 +17,58 @@
  *
  */
 
-package snappy
+package dirs
 
 import "path/filepath"
 
 // the various file paths
 var (
-	globalRootDir string
-
-	snapAppsDir      string
-	snapOemDir       string
-	snapDataDir      string
-	snapDataHomeGlob string
-	snapAppArmorDir  string
-	snapSeccompDir   string
-	snapUdevRulesDir string
-	localeDir        string
-	snapIconsDir     string
-	snapMetaDir      string
-
-	snapBinariesDir  string
-	snapServicesDir  string
-	snapBusPolicyDir string
-
-	clickSystemHooksDir string
-	cloudMetaDataFile   string
+	GlobalRootDir string
+
+	SnapAppsDir      string
+	SnapOemDir       string
+	SnapDataDir      string
+	SnapDataHomeGlob string
+	SnapAppArmorDir  string
+	SnapSeccompDir   string
+	SnapUdevRulesDir string
+	LocaleDir        string
+	SnapIconsDir     string
+	SnapMetaDir      string
+
+	SnapBinariesDir  string
+	SnapServicesDir  string
+	SnapBusPolicyDir string
+
+	ClickSystemHooksDir string
+	CloudMetaDataFile   string
+
+	SnappyDir = filepath.Join("var", "lib", "snappy")
 )
 
-var snappyDir = filepath.Join("var", "lib", "snappy")
-
 // SetRootDir allows settings a new global root directory, this is useful
 // for e.g. chroot operations
 func SetRootDir(rootdir string) {
-	globalRootDir = rootdir
-
-	snapAppsDir = filepath.Join(rootdir, "/apps")
-	snapOemDir = filepath.Join(rootdir, "/oem")
-	snapDataDir = filepath.Join(rootdir, "/var/lib/apps")
-	snapDataHomeGlob = filepath.Join(rootdir, "/home/*/apps/")
-	snapAppArmorDir = filepath.Join(rootdir, "/var/lib/apparmor/clicks")
-	snapSeccompDir = filepath.Join(rootdir, snappyDir, "seccomp", "profiles")
-	snapIconsDir = filepath.Join(rootdir, snappyDir, "icons")
-	snapMetaDir = filepath.Join(rootdir, snappyDir, "meta")
-
-	snapBinariesDir = filepath.Join(snapAppsDir, "bin")
-	snapServicesDir = filepath.Join(rootdir, "/etc/systemd/system")
-	snapBusPolicyDir = filepath.Join(rootdir, "/etc/dbus-1/system.d")
-
-	clickSystemHooksDir = filepath.Join(rootdir, "/usr/share/click/hooks")
-
-	cloudMetaDataFile = filepath.Join(rootdir, "/var/lib/cloud/seed/nocloud-net/meta-data")
-
-	snapUdevRulesDir = filepath.Join(rootdir, "/etc/udev/rules.d")
-
-	localeDir = filepath.Join(rootdir, "/usr/share/locale")
+	GlobalRootDir = rootdir
+
+	SnapAppsDir = filepath.Join(rootdir, "/apps")
+	SnapOemDir = filepath.Join(rootdir, "/oem")
+	SnapDataDir = filepath.Join(rootdir, "/var/lib/apps")
+	SnapDataHomeGlob = filepath.Join(rootdir, "/home/*/apps/")
+	SnapAppArmorDir = filepath.Join(rootdir, "/var/lib/apparmor/clicks")
+	SnapSeccompDir = filepath.Join(rootdir, SnappyDir, "seccomp", "profiles")
+	SnapIconsDir = filepath.Join(rootdir, SnappyDir, "icons")
+	SnapMetaDir = filepath.Join(rootdir, SnappyDir, "meta")
+
+	SnapBinariesDir = filepath.Join(SnapAppsDir, "bin")
+	SnapServicesDir = filepath.Join(rootdir, "/etc/systemd/system")
+	SnapBusPolicyDir = filepath.Join(rootdir, "/etc/dbus-1/system.d")
+
+	ClickSystemHooksDir = filepath.Join(rootdir, "/usr/share/click/hooks")
+
+	CloudMetaDataFile = filepath.Join(rootdir, "/var/lib/cloud/seed/nocloud-net/meta-data")
+
+	SnapUdevRulesDir = filepath.Join(rootdir, "/etc/udev/rules.d")
+
+	LocaleDir = filepath.Join(rootdir, "/usr/share/locale")
 }

=== modified file 'gen-coverage.sh'
--- gen-coverage.sh	2015-06-09 13:02:49 +0000
+++ gen-coverage.sh	2015-10-12 09:23:01 +0000
@@ -8,23 +8,9 @@
 # pass alternative output dir in $1
 OUTPUTDIR=${1:-$(pwd)}
 
-(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 logger &&
-        $GOPATH/bin/gocov test | $GOPATH/bin/gocov-html > $OUTPUTDIR/cov-logger.html)
-(cd helpers &&
-        $GOPATH/bin/gocov test | $GOPATH/bin/gocov-html > $OUTPUTDIR/cov-helpers.html)
-(cd coreconfig &&
-        $GOPATH/bin/gocov test | $GOPATH/bin/gocov-html > $OUTPUTDIR/cov-coreconfig.html)
-(cd clickdeb &&
-        $GOPATH/bin/gocov test | $GOPATH/bin/gocov-html > $OUTPUTDIR/cov-clickdeb.html)
-(cd priv &&
-	$GOPATH/bin/gocov test | $GOPATH/bin/gocov-html > $OUTPUTDIR/cov-priv.html)
-(cd release &&
-	$GOPATH/bin/gocov test | $GOPATH/bin/gocov-html > $OUTPUTDIR/cov-release.html)
-(cd oauth &&
-	$GOPATH/bin/gocov test | $GOPATH/bin/gocov-html > $OUTPUTDIR/cov-release.html)
+for d in pkg/snapfs pkg/clickdeb snappy partition logger helpers coreconfig priv release oauth; do
+    (cd $d &&
+      $GOPATH/bin/gocov test | $GOPATH/bin/gocov-html > $OUTPUTDIR/cov-$(echo $d|sed -r 's#/#_#').html)
+done
 
 echo "Coverage html reports are available in $OUTPUTDIR"

=== modified file 'helpers/helpers.go'
--- helpers/helpers.go	2015-09-18 09:53:19 +0000
+++ helpers/helpers.go	2015-10-12 09:23:01 +0000
@@ -49,15 +49,16 @@
 }
 
 // ChDir runs runs "f" inside the given directory
-func ChDir(newDir string, f func()) (err error) {
+func ChDir(newDir string, f func() error) (err error) {
 	cwd, err := os.Getwd()
-	os.Chdir(newDir)
+	if err != nil {
+		return err
+	}
+	if err := os.Chdir(newDir); err != nil {
+		return err
+	}
 	defer os.Chdir(cwd)
-	if err != nil {
-		return err
-	}
-	f()
-	return err
+	return f()
 }
 
 // ExitCode extract the exit code from the error of a failed cmd.Run() or the

=== modified file 'helpers/helpers_test.go'
--- helpers/helpers_test.go	2015-09-18 09:53:19 +0000
+++ helpers/helpers_test.go	2015-10-12 09:23:01 +0000
@@ -117,11 +117,26 @@
 	cwd, err := os.Getwd()
 	c.Assert(err, IsNil)
 	c.Assert(cwd, Not(Equals), tmpdir)
-	ChDir(tmpdir, func() {
+	ChDir(tmpdir, func() error {
 		cwd, err := os.Getwd()
 		c.Assert(err, IsNil)
 		c.Assert(cwd, Equals, tmpdir)
-	})
+		return err
+	})
+}
+
+func (ts *HTestSuite) TestChdirErrorNoDir(c *C) {
+	err := ChDir("random-dir-that-does-not-exist", func() error {
+		return nil
+	})
+	c.Assert(err, ErrorMatches, "chdir .*: no such file or directory")
+}
+
+func (ts *HTestSuite) TestChdirErrorFromFunc(c *C) {
+	err := ChDir("/", func() error {
+		return fmt.Errorf("meep")
+	})
+	c.Assert(err, ErrorMatches, "meep")
 }
 
 func (ts *HTestSuite) TestExitCode(c *C) {
@@ -494,10 +509,11 @@
 	err := ioutil.WriteFile(filepath.Join(tmpdir, canaryName), []byte(nil), canaryPerms)
 	c.Assert(err, IsNil)
 
-	ChDir(tmpdir, func() {
+	ChDir(tmpdir, func() error {
 		cmd := exec.Command("tar", "cvf", tarArchive, ".")
 		_, err = cmd.CombinedOutput()
 		c.Assert(err, IsNil)
+		return err
 	})
 
 	// set crazy umask

=== renamed directory 'clickdeb' => 'pkg/clickdeb'
=== modified file 'pkg/clickdeb/deb.go'
--- clickdeb/deb.go	2015-09-16 11:02:59 +0000
+++ pkg/clickdeb/deb.go	2015-10-12 09:23:01 +0000
@@ -155,6 +155,11 @@
 	return d.file.Close()
 }
 
+// Verify checks that the clickdeb is signed
+func (d *ClickDeb) Verify(allowUnauthenticated bool) error {
+	return Verify(d.Name(), allowUnauthenticated)
+}
+
 // ControlMember returns the content of the given control member file
 // (e.g. the content of the "manifest" file in the control.tar.gz ar member)
 func (d *ClickDeb) ControlMember(controlMember string) (content []byte, err error) {

=== added directory 'pkg/lightweight'
=== added file 'pkg/lightweight/example_test.go'
--- pkg/lightweight/example_test.go	1970-01-01 00:00:00 +0000
+++ pkg/lightweight/example_test.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,58 @@
+// -*- 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 lightweight_test
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"launchpad.net/snappy/dirs"
+	"launchpad.net/snappy/pkg/lightweight"
+)
+
+// we don't use example tests nearly as often as we should :-)
+// https://blog.golang.org/examples if you haven't seen them used before.
+// (also: look at it in the 'go doc' output for this package)
+
+func ExamplePartBag() {
+	d, _ := ioutil.TempDir("", "test-xyzzy-")
+	defer os.RemoveAll(d)
+	dirs.SetRootDir(d)
+	os.MkdirAll(filepath.Join(dirs.SnapDataDir, "foo.bar", "0.1"), 0755)
+	os.MkdirAll(filepath.Join(dirs.SnapDataDir, "foo.bar", "0.2"), 0755)
+	os.MkdirAll(filepath.Join(dirs.SnapDataDir, "foo.bar", "0.5"), 0755)
+	os.MkdirAll(filepath.Join(dirs.SnapDataDir, "baz", "0.4"), 0755)
+	os.MkdirAll(filepath.Join(dirs.SnapDataDir, "qux", "0.5"), 0755)
+	os.MkdirAll(filepath.Join(dirs.SnapOemDir, "qux", "0.5"), 0755)
+
+	bags := lightweight.AllPartBags()
+
+	for _, k := range []string{"foo.bar", "baz", "qux"} {
+		bag := bags[k]
+		fmt.Printf("Found %d versions for %s, type %q: %s\n",
+			len(bag.Versions), bag.QualifiedName(), bag.Type, bag.Versions)
+	}
+	// Output:
+	// Found 3 versions for foo.bar, type "app": [0.5 0.2 0.1]
+	// Found 1 versions for baz, type "framework": [0.4]
+	// Found 1 versions for qux, type "oem": [0.5]
+}

=== added file 'pkg/lightweight/lightweight.go'
--- pkg/lightweight/lightweight.go	1970-01-01 00:00:00 +0000
+++ pkg/lightweight/lightweight.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,527 @@
+// -*- 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 lightweight provides a quick way of loading things that can become snaps.
+//
+// A lightweight.PartBag has a name and n versions; it might not even know its origin.
+package lightweight
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+
+	"launchpad.net/snappy/dirs"
+	"launchpad.net/snappy/helpers"
+	"launchpad.net/snappy/pkg"
+	"launchpad.net/snappy/pkg/removed"
+	"launchpad.net/snappy/snappy"
+)
+
+// split a path into the name and extension of the directory, and the file.
+// e.g. foo/bar.baz/quux -> bar, baz, quux
+//
+// panics if given path is lacking at least one separator (ie bar/quux
+// works (barely); quux panics). As it's supposed to be called with
+// the results of a glob on <pkgdir>/<pkg|*>/*, this is only a problem
+// if it's being used wrong.
+func split(path string) (name string, ext string, file string) {
+	const sep = string(os.PathSeparator)
+	idxFileSep := strings.LastIndex(path, sep)
+	if idxFileSep < 0 {
+		panic("bad path given to split: must have at least two separators")
+	}
+
+	file = path[idxFileSep+1:]
+	path = path[:idxFileSep]
+	name = path
+
+	idxDirSep := strings.LastIndex(path, sep)
+	if idxDirSep > -1 {
+		name = path[idxDirSep+1:]
+	}
+
+	idxOrig := strings.LastIndex(name, ".")
+	if idxOrig < 0 {
+		return name, "", file
+	}
+
+	return name[:idxOrig], name[idxOrig+1:], file
+}
+
+// extract the name, origin and list of versions from a list of paths that
+// end {name}[.{origin}]/{version}. If the name or origin changes, stop and
+// return the versions so far, and the remaining paths.
+//
+// Calls split() on each path in paths, so will panic if it does not have
+// the right number of path separators, as it's a programming error.
+func extract(paths []string) (string, string, []string, []string) {
+	name, origin, _ := split(paths[0])
+
+	var versions []string
+	for len(paths) > 0 {
+		n, o, v := split(paths[0])
+		if name != n || origin != o {
+			break
+		}
+		paths = paths[1:]
+
+		if v == "current" {
+			continue
+		}
+
+		versions = append(versions, v)
+	}
+
+	return name, origin, versions, paths
+}
+
+func versionSort(versions []string) {
+	sort.Sort(sort.Reverse(snappy.ByVersion(versions)))
+}
+
+// PartBagByName finds a PartBag with the given name.
+func PartBagByName(name string, origin string) *PartBag {
+	if strings.ContainsAny(name, ".*?/") || strings.ContainsAny(origin, ".*?/") {
+		panic("invalid name " + name + "." + origin)
+	}
+
+	for _, v := range find(name, origin) {
+		return v
+	}
+
+	return nil
+}
+
+// AllPartBags the PartBags in the system.
+func AllPartBags() map[string]*PartBag {
+	return find("*", "*")
+}
+
+type repo interface {
+	All() ([]snappy.Part, error)
+}
+
+func newCoreRepoImpl() repo {
+	return snappy.NewSystemImageRepository()
+}
+
+var newCoreRepo = newCoreRepoImpl
+
+func find(name string, origin string) map[string]*PartBag {
+	bags := make(map[string]*PartBag)
+
+	if (name == snappy.SystemImagePartName || name == "*") && (origin == snappy.SystemImagePartOrigin || origin == "*") {
+		// TODO: make this do less work
+		repo := newCoreRepo()
+		parts, err := repo.All()
+		if err != nil {
+			//  can't really happen
+			panic(fmt.Sprintf("Bad SystemImageRepository: %v", err))
+		}
+
+		// parts can be empty during testing for example
+		if len(parts) > 0 {
+			versions := make([]string, len(parts))
+			for i, part := range parts {
+				versions[i] = part.Version()
+			}
+			versionSort(versions)
+
+			bag := &PartBag{
+				Name:     snappy.SystemImagePartName,
+				Origin:   snappy.SystemImagePartOrigin,
+				Type:     pkg.TypeCore,
+				Versions: versions,
+				concrete: &concreteCore{},
+			}
+			bags[bag.QualifiedName()] = bag
+		}
+	}
+
+	type T struct {
+		inst string
+		qn   string
+		typ  pkg.Type
+	}
+
+	for _, s := range []T{
+		{dirs.SnapAppsDir, name + "." + origin, pkg.TypeApp},
+		{dirs.SnapAppsDir, name, pkg.TypeFramework}, // frameworks are installed under /apps also, for now
+	} {
+		// all snaps share the data dir, hence this bit of mess
+		paths, _ := filepath.Glob(filepath.Join(dirs.SnapDataDir, s.qn, "*"))
+		for len(paths) > 0 {
+			var name string
+			var origin string
+			var versions []string
+
+			name, origin, versions, paths = extract(paths)
+			if origin != "" && s.typ != pkg.TypeApp {
+				// this happens when called with name="*"
+				continue
+			}
+
+			versionSort(versions)
+
+			// if oems were removable, there'd be know way of
+			// telling the kind of a removed origin-less package
+			if s.typ == pkg.TypeFramework && helpers.FileExists(filepath.Join(dirs.SnapOemDir, name)) {
+				s.typ = pkg.TypeOem
+				s.inst = dirs.SnapOemDir
+			}
+
+			bag := &PartBag{
+				Name:     name,
+				Origin:   origin,
+				Type:     s.typ,
+				Versions: versions,
+			}
+
+			bag.concrete = NewConcrete(bag, s.inst)
+
+			bags[bag.QualifiedName()] = bag
+		}
+	}
+
+	return bags
+}
+
+// A PartBag is a lightweight object that represents and knows how to
+// load a Part on demand.
+type PartBag struct {
+	Name     string
+	Origin   string
+	Type     pkg.Type
+	Versions []string
+	concrete Concreter
+}
+
+// Concreter hides the part-specific details of PartBags
+type Concreter interface {
+	IsInstalled(string) bool
+	ActiveIndex() int
+	Load(string) (snappy.Part, error)
+}
+
+// NewConcrete is meant to be overridden in tests; is called when
+// needing a Concreter for app/fmk/oem snaps (ie not core).
+var NewConcrete = newConcreteImpl
+
+func newConcreteImpl(bag *PartBag, instdir string) Concreter {
+	return &concreteSnap{
+		self:    bag,
+		instdir: instdir,
+	}
+}
+
+// QualifiedName of the PartBag.
+//
+// because PartBags read their origin from the filesystem, you don't need
+// to check the pacakge type.
+func (bag *PartBag) QualifiedName() string {
+	if bag.Origin == "" {
+		return bag.Name
+	}
+	return bag.FullName()
+}
+
+// FullName of the PartBag
+func (bag *PartBag) FullName() string {
+	return bag.Name + "." + bag.Origin
+}
+
+var (
+	// ErrBadVersionIndex is returned by Load when asked to load a
+	// non-existent version.
+	ErrBadVersionIndex = errors.New("Bad version index")
+	// ErrVersionGone is returned in the case where we find a
+	// version and it disappears before we get to load it.
+	ErrVersionGone = errors.New("Version gone")
+)
+
+type concreteCore struct{}
+
+func (*concreteCore) IsInstalled(string) bool { return true }
+func (*concreteCore) ActiveIndex() int        { return 0 }
+func (*concreteCore) Load(version string) (snappy.Part, error) {
+	parts, err := newCoreRepo().All()
+	if err != nil {
+		//  can't really happen
+		return nil, fmt.Errorf("Bad SystemImageRepository: %v", err)
+	}
+
+	for _, part := range parts {
+		if part.Version() == version {
+			return part, nil
+		}
+	}
+
+	return nil, ErrVersionGone
+}
+
+type concreteSnap struct {
+	self    *PartBag
+	instdir string
+}
+
+func (c *concreteSnap) IsInstalled(version string) bool {
+	return helpers.FileExists(filepath.Join(c.instdir, c.self.QualifiedName(), version, "meta", "package.yaml"))
+}
+
+func (c *concreteSnap) ActiveIndex() int {
+	current, err := os.Readlink(filepath.Join(c.instdir, c.self.QualifiedName(), "current"))
+	if err != nil {
+		return -1
+	}
+
+	current = filepath.Base(current)
+
+	// Linear search is fine for now.
+	//
+	// If it ever becomes a problem, remember bag.Versions is sorted
+	// so you can use go's sort.Search and snappy.VersionCompare,
+	// but VersionCompare is not cheap, so that (on my machine, at
+	// the time of writing) linear of even 100k versions is only
+	// 2×-3× slower than binary; anything below about 50k versions
+	// is faster even in worst-case for linear (no match). And
+	// that's not even looking at memory impact.
+	//
+	// For example, on the ~90k lines in /usr/share/dict/words:
+	//
+	// BenchmarkBinaryPositive-4	   10000	    135041 ns/op	   11534 B/op	     316 allocs/op
+	// BenchmarkBinaryNegative-4	   10000	    109803 ns/op	   10235 B/op	     231 allocs/op
+	// BenchmarkLinearPositive-4	    5000	    272980 ns/op	       0 B/op	       0 allocs/op
+	// BenchmarkLinearNegative-4	    5000	    362244 ns/op	       0 B/op	       0 allocs/op
+	//
+	// on a corpus of 100k %016x-formatted rand.Int63()s:
+	//
+	// BenchmarkBinaryNegative-4	   10000	    152797 ns/op	   10158 B/op	     243 allocs/op
+	// BenchmarkLinearNegative-4	   10000	    163924 ns/op	       0 B/op	       0 allocs/op
+	//
+	// ... I think I might need help.
+	for i := range c.self.Versions {
+		if c.self.Versions[i] == current {
+			return i
+		}
+	}
+
+	return -1
+}
+
+func (c *concreteSnap) Load(version string) (snappy.Part, error) {
+	yamlPath := filepath.Join(c.instdir, c.self.QualifiedName(), version, "meta", "package.yaml")
+	if !helpers.FileExists(yamlPath) {
+		return removed.New(c.self.Name, c.self.Origin, version, c.self.Type), nil
+	}
+
+	part, err := snappy.NewInstalledSnapPart(yamlPath, c.self.Origin)
+	if err != nil {
+		return nil, err
+	}
+
+	return part, nil
+}
+
+// IsInstalled checks whether the given part is installed
+func (bag *PartBag) IsInstalled(idx int) bool {
+	if idx < 0 || idx >= len(bag.Versions) {
+		return false
+	}
+
+	return bag.concrete.IsInstalled(bag.Versions[idx])
+}
+
+// ActiveIndex returns the index of the active version, or -1
+func (bag *PartBag) ActiveIndex() int {
+	if bag == nil || len(bag.Versions) == 0 {
+		return -1
+	}
+
+	return bag.concrete.ActiveIndex()
+}
+
+// Load a Part from the PartBag
+func (bag *PartBag) Load(versionIdx int) (snappy.Part, error) {
+	if bag == nil {
+		return nil, nil
+	}
+
+	if versionIdx < 0 || versionIdx >= len(bag.Versions) {
+		return nil, ErrBadVersionIndex
+	}
+
+	version := bag.Versions[versionIdx]
+
+	return bag.concrete.Load(version)
+}
+
+// LoadActive gets the active index and loads it.
+// If none active, returns a nil Part and ErrBadVersionIndex.
+func (bag *PartBag) LoadActive() (snappy.Part, error) {
+	return bag.Load(bag.ActiveIndex())
+}
+
+// LoadBest looks for the best candidate Part and loads it.
+//
+// If there is an active part, load that. Otherwise, load the
+// highest-versioned installed part. Otherwise, load the first removed
+// part.
+//
+// If not even a removed part can be loaded, something is wrong. Nil
+// is returned, but you're in trouble (did the filesystem just
+// disappear under us?).
+func (bag *PartBag) LoadBest() snappy.Part {
+	if bag == nil {
+		return nil
+	}
+	if len(bag.Versions) == 0 {
+		return nil
+	}
+
+	activeIdx := bag.ActiveIndex()
+	if part, err := bag.Load(activeIdx); err == nil {
+		return part
+	}
+
+	for i := 0; i < len(bag.Versions); i++ {
+		if bag.IsInstalled(i) {
+			if part, err := bag.Load(i); err == nil {
+				return part
+			}
+		}
+	}
+
+	part, _ := bag.Load(0)
+
+	return part
+}
+
+// Map this PartBag into a map[string]string, augmenting it with the
+// given (purportedly remote) Part.
+//
+// It is a programming error (->panic) to call Map on a nil *PartBag with
+// a nil Part. PartBag or part may be nil, but not both.
+//
+// Also may panic if the remote part is nil and LoadBest can't load a
+// Part at all.
+func (bag *PartBag) Map(remotePart snappy.Part) map[string]string {
+	var version, update, rollback, icon, name, origin, _type, vendor, description string
+
+	if bag == nil && remotePart == nil {
+		panic("part bag & part both nil -- how did i even get here")
+	}
+
+	status := "not installed"
+	installedSize := "-1"
+	downloadSize := "-1"
+
+	part := bag.LoadBest()
+	if part != nil {
+		if part.IsActive() {
+			status = "active"
+		} else if part.IsInstalled() {
+			status = "installed"
+		} else {
+			status = "removed"
+		}
+	} else if remotePart == nil {
+		panic("unable to load a valid part")
+	}
+
+	if part != nil {
+		name = part.Name()
+		origin = part.Origin()
+		version = part.Version()
+		_type = string(part.Type())
+
+		icon = part.Icon()
+		vendor = part.Vendor()
+		description = part.Description()
+		installedSize = strconv.FormatInt(part.InstalledSize(), 10)
+
+		downloadSize = strconv.FormatInt(part.DownloadSize(), 10)
+	} else {
+		name = remotePart.Name()
+		origin = remotePart.Origin()
+		version = remotePart.Version()
+		_type = string(remotePart.Type())
+	}
+
+	if remotePart != nil {
+		if icon == "" {
+			icon = remotePart.Icon()
+		}
+		if description == "" {
+			description = remotePart.Description()
+		}
+		if vendor == "" {
+			vendor = remotePart.Vendor()
+		}
+
+		downloadSize = strconv.FormatInt(remotePart.DownloadSize(), 10)
+	}
+
+	if activeIdx := bag.ActiveIndex(); activeIdx >= 0 {
+		if remotePart != nil && version != remotePart.Version() {
+			// XXX: this does not handle the case where the
+			// one in the store is not the greatest version
+			// (e.g.: store has 1.1, locally available 1.1,
+			// 1.2, active 1.2)
+			update = remotePart.Version()
+		}
+
+		for i := activeIdx + 1; i < len(bag.Versions); i++ {
+			// XXX: it's also possible to "roll back" to a
+			// store version in the case mentioned above;
+			// also not covered by this code.
+			if bag.IsInstalled(i) {
+				rollback = bag.Versions[i]
+				break
+			}
+		}
+	}
+
+	result := map[string]string{
+		"icon":           icon,
+		"name":           name,
+		"origin":         origin,
+		"status":         status,
+		"type":           _type,
+		"vendor":         vendor,
+		"version":        version,
+		"description":    description,
+		"installed_size": installedSize,
+		"download_size":  downloadSize,
+	}
+
+	if rollback != "" {
+		result["rollback_available"] = rollback
+	}
+
+	if update != "" {
+		result["update_available"] = update
+	}
+
+	return result
+}

=== added file 'pkg/lightweight/lightweight_test.go'
--- pkg/lightweight/lightweight_test.go	1970-01-01 00:00:00 +0000
+++ pkg/lightweight/lightweight_test.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,417 @@
+// -*- 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 lightweight
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"gopkg.in/check.v1"
+	"gopkg.in/yaml.v2"
+
+	"launchpad.net/snappy/dirs"
+	"launchpad.net/snappy/pkg"
+	"launchpad.net/snappy/pkg/remote"
+	"launchpad.net/snappy/pkg/removed"
+	"launchpad.net/snappy/snappy"
+)
+
+type lightweightSuite struct {
+	d string
+}
+
+func Test(t *testing.T) { check.TestingT(t) }
+
+var _ = check.Suite(&lightweightSuite{})
+
+func (s *lightweightSuite) SetUpTest(c *check.C) {
+	s.d = c.MkDir()
+	dirs.SetRootDir(s.d)
+
+	s.MkInstalled(c, pkg.TypeApp, dirs.SnapAppsDir, "foo", "bar", "1.0", true)
+	s.MkRemoved(c, "foo.bar", "0.9")
+	s.MkRemoved(c, "foo.baz", "0.8")
+
+	s.MkInstalled(c, pkg.TypeFramework, dirs.SnapAppsDir, "fmk", "", "123", false)
+	s.MkInstalled(c, pkg.TypeFramework, dirs.SnapAppsDir, "fmk", "", "120", true)
+	s.MkInstalled(c, pkg.TypeFramework, dirs.SnapAppsDir, "fmk", "", "119", false)
+	s.MkRemoved(c, "fmk", "12a1")
+
+	s.MkRemoved(c, "fmk2", "4.2.0ubuntu1")
+
+	s.MkInstalled(c, pkg.TypeOem, dirs.SnapOemDir, "oem", "", "3", false)
+
+	newCoreRepo = func() repo {
+		// you can't ever have a removed systemimagepart, but for testing it'll do
+		return mockrepo{removed.New(snappy.SystemImagePartName, snappy.SystemImagePartOrigin, "1", pkg.TypeCore)}
+	}
+}
+
+func (s *lightweightSuite) TearDownTest(c *check.C) {
+	newCoreRepo = newCoreRepoImpl
+}
+
+func (s *lightweightSuite) MkInstalled(c *check.C, _type pkg.Type, appdir, name, origin, version string, active bool) {
+	qn := name
+	if origin != "" {
+		qn += "." + origin
+	}
+
+	s.MkRemoved(c, qn, version)
+
+	apath := filepath.Join(appdir, qn, version, "meta")
+	yaml := fmt.Sprintf("name: %s\nversion: %s\nvendor: example.com\nicon: icon.png\ntype: %s\n", name, version, _type)
+	c.Check(os.MkdirAll(apath, 0755), check.IsNil)
+	c.Check(ioutil.WriteFile(filepath.Join(apath, "package.yaml"), []byte(yaml), 0644), check.IsNil)
+	c.Check(ioutil.WriteFile(filepath.Join(apath, "hashes.yaml"), nil, 0644), check.IsNil)
+
+	if active {
+		c.Check(os.Symlink(version, filepath.Join(appdir, qn, "current")), check.IsNil)
+		c.Check(os.Symlink(version, filepath.Join(dirs.SnapDataDir, qn, "current")), check.IsNil)
+	}
+}
+
+func (s *lightweightSuite) MkRemoved(c *check.C, qn, version string) {
+	dpath := filepath.Join(dirs.SnapDataDir, qn, version)
+	c.Check(os.MkdirAll(dpath, 0755), check.IsNil)
+	c.Check(ioutil.WriteFile(filepath.Join(dpath, "test.txt"), []byte("hello there\n"), 0644), check.IsNil)
+
+}
+
+func (s *lightweightSuite) TestLoadBadName(c *check.C) {
+	c.Check(func() { PartBagByName("*", "*") }, check.PanicMatches, "invalid name .*")
+}
+
+func (s *lightweightSuite) TestMapFmkNoPart(c *check.C) {
+	bag := PartBagByName("fmk", "sideload")
+	m := bag.Map(nil)
+	c.Check(m["installed_size"], check.Matches, "[0-9]+")
+	delete(m, "installed_size")
+	c.Check(m, check.DeepEquals, map[string]string{
+		"name":               "fmk",
+		"origin":             "sideload",
+		"status":             "active",
+		"version":            "120",
+		"icon":               filepath.Join(s.d, "apps", "fmk", "120", "icon.png"),
+		"type":               "framework",
+		"vendor":             "example.com",
+		"download_size":      "-1",
+		"description":        "",
+		"rollback_available": "119",
+	})
+}
+
+func (s *lightweightSuite) TestMapRemovedFmkNoPart(c *check.C) {
+	bag := PartBagByName("fmk2", "sideload")
+	m := bag.Map(nil)
+	c.Check(m, check.DeepEquals, map[string]string{
+		"name":           "fmk2",
+		"origin":         "sideload",
+		"status":         "removed",
+		"version":        "4.2.0ubuntu1",
+		"icon":           "",
+		"type":           "framework",
+		"vendor":         "",
+		"installed_size": "-1",
+		"download_size":  "-1",
+		"description":    "",
+	})
+}
+
+func (s *lightweightSuite) TestMapRemovedFmkNoPartButStoreMeta(c *check.C) {
+	snap := remote.Snap{
+		Name:         "fmk2",
+		Origin:       "fmk2origin",
+		Version:      "4.2.0ubuntu1",
+		Type:         pkg.TypeFramework,
+		IconURL:      "http://example.com/icon",
+		DownloadSize: 42,
+		Publisher:    "Example Inc.",
+	}
+	part := snappy.NewRemoteSnapPart(snap)
+
+	content, err := yaml.Marshal(snap)
+	c.Assert(err, check.IsNil)
+
+	p := snappy.RemoteManifestPath(part)
+	c.Assert(os.MkdirAll(filepath.Dir(p), 0755), check.IsNil)
+	c.Assert(ioutil.WriteFile(p, content, 0644), check.IsNil)
+
+	bag := PartBagByName("fmk2", "fmk2origin")
+	m := bag.Map(nil)
+	c.Check(m, check.DeepEquals, map[string]string{
+		"name":           "fmk2",
+		"origin":         "fmk2origin",
+		"status":         "removed",
+		"version":        "4.2.0ubuntu1",
+		"icon":           "http://example.com/icon",
+		"type":           "framework",
+		"vendor":         "Example Inc.",
+		"installed_size": "-1",
+		"download_size":  "42",
+		"description":    "",
+	})
+}
+
+func (s *lightweightSuite) TestMapAppNoPart(c *check.C) {
+	bag := PartBagByName("foo", "bar")
+	m := bag.Map(nil)
+	c.Check(m["installed_size"], check.Matches, "[0-9]+")
+	delete(m, "installed_size")
+	c.Check(m, check.DeepEquals, map[string]string{
+		"name":          "foo",
+		"origin":        "bar",
+		"status":        "active",
+		"version":       "1.0",
+		"icon":          filepath.Join(s.d, "apps", "foo.bar", "1.0", "icon.png"),
+		"type":          "app",
+		"vendor":        "example.com",
+		"download_size": "-1",
+		"description":   "",
+	})
+}
+
+func (s *lightweightSuite) TestMapAppWithPart(c *check.C) {
+	snap := remote.Snap{
+		Name:         "foo",
+		Origin:       "bar",
+		Version:      "2",
+		Type:         pkg.TypeApp,
+		IconURL:      "http://example.com/icon",
+		DownloadSize: 42,
+	}
+	part := snappy.NewRemoteSnapPart(snap)
+
+	bag := PartBagByName("foo", "bar")
+	m := bag.Map(part)
+	c.Check(m["installed_size"], check.Matches, "[0-9]+")
+	delete(m, "installed_size")
+	c.Check(m, check.DeepEquals, map[string]string{
+		"name":             "foo",
+		"origin":           "bar",
+		"status":           "active",
+		"version":          "1.0",
+		"icon":             filepath.Join(s.d, "apps", "foo.bar", "1.0", "icon.png"),
+		"type":             "app",
+		"vendor":           "example.com",
+		"download_size":    "42",
+		"description":      "",
+		"update_available": "2",
+	})
+}
+
+func (s *lightweightSuite) TestMapAppNoPartBag(c *check.C) {
+	snap := remote.Snap{
+		Name:         "foo",
+		Origin:       "bar",
+		Version:      "2",
+		Type:         pkg.TypeApp,
+		IconURL:      "http://example.com/icon",
+		Publisher:    "example.com",
+		DownloadSize: 42,
+	}
+	part := snappy.NewRemoteSnapPart(snap)
+
+	m := (*PartBag)(nil).Map(part)
+	c.Check(m, check.DeepEquals, map[string]string{
+		"name":           "foo",
+		"origin":         "bar",
+		"status":         "not installed",
+		"version":        "2",
+		"icon":           snap.IconURL,
+		"type":           "app",
+		"vendor":         "example.com",
+		"installed_size": "-1",
+		"download_size":  "42",
+		"description":    "",
+	})
+
+}
+
+func (s *lightweightSuite) TestMapRemovedAppNoPart(c *check.C) {
+	bag := PartBagByName("foo", "baz")
+	m := bag.Map(nil)
+	c.Check(m, check.DeepEquals, map[string]string{
+		"name":           "foo",
+		"origin":         "baz",
+		"status":         "removed",
+		"version":        "0.8",
+		"icon":           "",
+		"type":           "app",
+		"vendor":         "",
+		"installed_size": "-1",
+		"download_size":  "-1",
+		"description":    "",
+	})
+}
+
+func (s *lightweightSuite) TestMapInactiveOemNoPart(c *check.C) {
+	bag := PartBagByName("oem", "canonical")
+	m := bag.Map(nil)
+	c.Check(m["installed_size"], check.Matches, "[0-9]+")
+	delete(m, "installed_size")
+	c.Check(m, check.DeepEquals, map[string]string{
+		"name":          "oem",
+		"origin":        "sideload", // best guess
+		"status":        "installed",
+		"version":       "3",
+		"icon":          filepath.Join(s.d, "oem", "oem", "3", "icon.png"),
+		"type":          "oem",
+		"vendor":        "example.com",
+		"download_size": "-1",
+		"description":   "",
+	})
+}
+
+func (s *lightweightSuite) TestLoadBadApp(c *check.C) {
+	s.MkRemoved(c, "quux.blah", "1")
+	// an unparsable package.yaml:
+	c.Check(os.MkdirAll(filepath.Join(dirs.SnapAppsDir, "quux.blah", "1", "meta", "package.yaml"), 0755), check.IsNil)
+
+	bag := PartBagByName("quux", "blah")
+	c.Assert(bag, check.NotNil)
+	c.Assert(bag.Versions, check.DeepEquals, []string{"1"})
+
+	p, err := bag.Load(0)
+	c.Check(err, check.NotNil)
+	c.Check(p, check.IsNil)
+	c.Check(p == nil, check.Equals, true) // NOTE this is stronger than the above
+}
+
+func (s *lightweightSuite) TestLoadFmk(c *check.C) {
+	bag := PartBagByName("fmk", "")
+	c.Assert(bag, check.NotNil)
+	c.Assert(bag.Versions, check.HasLen, 4)
+	// versions are sorted backwards by version -- index 0 is always newest version
+	c.Check(bag.Versions, check.DeepEquals, []string{"123", "120", "119", "12a1"})
+	// other things are as expected
+	c.Check(bag.Name, check.Equals, "fmk")
+	c.Check(bag.Type, check.Equals, pkg.TypeFramework)
+	c.Check(bag.ActiveIndex(), check.Equals, 1)
+
+	c.Check(bag.IsInstalled(0), check.Equals, true)
+	p, err := bag.Load(0)
+	c.Check(err, check.IsNil)
+	// load loaded the right implementation of Part
+	c.Check(p, check.FitsTypeOf, new(snappy.SnapPart))
+	c.Check(p.IsActive(), check.Equals, false)
+	c.Check(p.Version(), check.Equals, "123")
+
+	c.Check(bag.IsInstalled(1), check.Equals, true)
+	p, err = bag.Load(1)
+	c.Check(err, check.IsNil)
+	c.Check(p, check.FitsTypeOf, new(snappy.SnapPart))
+	c.Check(p.IsActive(), check.Equals, true)
+	c.Check(p.Version(), check.Equals, "120")
+
+	c.Check(bag.IsInstalled(2), check.Equals, true)
+	p, err = bag.Load(2)
+	c.Check(err, check.IsNil)
+	c.Check(p, check.FitsTypeOf, new(snappy.SnapPart))
+	c.Check(p.IsActive(), check.Equals, false)
+	c.Check(p.Version(), check.Equals, "119")
+
+	c.Check(bag.IsInstalled(3), check.Equals, false)
+	p, err = bag.Load(3)
+	c.Check(err, check.IsNil)
+	c.Check(p, check.FitsTypeOf, new(removed.Removed))
+	c.Check(p.Version(), check.Equals, "12a1")
+
+	_, err = bag.Load(42)
+	c.Check(err, check.Equals, ErrBadVersionIndex)
+
+}
+
+func (s *lightweightSuite) TestLoadApp(c *check.C) {
+	bag0 := PartBagByName("foo", "bar")
+	bag1 := PartBagByName("foo", "baz")
+
+	c.Check(bag0.QualifiedName(), check.Equals, "foo.bar")
+	c.Check(bag0.Versions, check.DeepEquals, []string{"1.0", "0.9"})
+	c.Check(bag0.Type, check.Equals, pkg.TypeApp)
+	c.Check(bag0.ActiveIndex(), check.Equals, 0)
+
+	c.Check(bag1.QualifiedName(), check.Equals, "foo.baz")
+	c.Check(bag1.Versions, check.DeepEquals, []string{"0.8"})
+	c.Check(bag1.Type, check.Equals, pkg.TypeApp)
+	c.Check(bag1.ActiveIndex(), check.Equals, -1)
+
+	c.Check(bag0.IsInstalled(0), check.Equals, true)
+	p, err := bag0.Load(0)
+	c.Check(err, check.IsNil)
+	c.Check(p, check.FitsTypeOf, new(snappy.SnapPart))
+	c.Check(p.IsActive(), check.Equals, true)
+	c.Check(p.Version(), check.Equals, "1.0")
+
+	c.Check(bag0.IsInstalled(1), check.Equals, false)
+	p, err = bag0.Load(1)
+	c.Check(err, check.IsNil)
+	c.Check(p, check.FitsTypeOf, new(removed.Removed))
+	c.Check(p.IsActive(), check.Equals, false)
+	c.Check(p.Version(), check.Equals, "0.9")
+
+	c.Check(bag1.IsInstalled(0), check.Equals, false)
+	p, err = bag1.Load(0)
+	c.Check(err, check.IsNil)
+	c.Check(p, check.FitsTypeOf, new(removed.Removed))
+	c.Check(p.IsActive(), check.Equals, false)
+	c.Check(p.Version(), check.Equals, "0.8")
+}
+
+func (s *lightweightSuite) TestLoadOem(c *check.C) {
+	oem := PartBagByName("oem", "whatever")
+	c.Assert(oem, check.NotNil)
+	c.Check(oem.Versions, check.DeepEquals, []string{"3"})
+	c.Check(oem.Type, check.Equals, pkg.TypeOem)
+
+	c.Check(oem.IsInstalled(0), check.Equals, true)
+	c.Check(oem.ActiveIndex(), check.Equals, -1)
+	p, err := oem.Load(0)
+	c.Check(err, check.IsNil)
+	c.Check(p, check.FitsTypeOf, new(snappy.SnapPart))
+	c.Check(p.Version(), check.Equals, "3")
+}
+
+type mockrepo struct{ p snappy.Part }
+
+func (r mockrepo) All() ([]snappy.Part, error) {
+	return []snappy.Part{r.p}, nil
+}
+
+func (s *lightweightSuite) TestLoadCore(c *check.C) {
+	core := PartBagByName(snappy.SystemImagePartName, snappy.SystemImagePartOrigin)
+	c.Assert(core, check.NotNil)
+	c.Check(core.Versions, check.DeepEquals, []string{"1"})
+
+	c.Check(core.IsInstalled(0), check.Equals, true)
+	c.Check(core.ActiveIndex(), check.Equals, 0)
+	p, err := core.Load(0)
+	c.Check(err, check.IsNil)
+	c.Check(p.Version(), check.Equals, "1")
+}
+
+func (s *lightweightSuite) TestAll(c *check.C) {
+	all := AllPartBags()
+
+	c.Check(all, check.HasLen, 6) // 2 fmk, 2 app, 1 oem, 1 core
+}

=== added file 'pkg/lightweight/split_test.go'
--- pkg/lightweight/split_test.go	1970-01-01 00:00:00 +0000
+++ pkg/lightweight/split_test.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,70 @@
+// -*- 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 lightweight
+
+import (
+	"gopkg.in/check.v1"
+)
+
+type splitSuite struct{}
+
+var _ = check.Suite(&splitSuite{})
+
+func (s *splitSuite) TestSplitRegular(c *check.C) {
+	for _, s := range []string{"meh/foo.bar/baz", "foo.bar/baz"} {
+		n, e, f := split(s)
+		c.Check(n, check.Equals, "foo")
+		c.Check(e, check.Equals, "bar")
+		c.Check(f, check.Equals, "baz")
+	}
+}
+
+func (s *splitSuite) TestSplitExtless(c *check.C) {
+	for _, s := range []string{"meh/foo/baz", "foo/baz"} {
+		n, e, f := split(s)
+		c.Check(n, check.Equals, "foo")
+		c.Check(e, check.Equals, "")
+		c.Check(f, check.Equals, "baz")
+	}
+}
+
+func (s *splitSuite) TestSplitBad(c *check.C) {
+	c.Check(func() {
+		split("what")
+	}, check.PanicMatches, `bad path given.*`)
+}
+
+func (s *splitSuite) TestExtract(c *check.C) {
+	ps := []string{"meh/foo.bar/v1", "meh/foo.bar/v2", "meh/foo.baz/v3"}
+	n, o, vs, ps := extract(ps)
+	c.Check(n, check.Equals, "foo")
+	c.Check(o, check.Equals, "bar")
+	c.Check(vs, check.DeepEquals, []string{"v1", "v2"})
+	c.Check(ps, check.DeepEquals, []string{"meh/foo.baz/v3"})
+}
+
+func (s *splitSuite) TestExtractCurrent(c *check.C) {
+	ps := []string{"meh/foo.bar/current", "meh/foo.bar/v1", "meh/foo.bar/v2", "meh/foo.baz/v3"}
+	n, o, vs, ps := extract(ps)
+	c.Check(n, check.Equals, "foo")
+	c.Check(o, check.Equals, "bar")
+	c.Check(vs, check.DeepEquals, []string{"v1", "v2"})
+	c.Check(ps, check.DeepEquals, []string{"meh/foo.baz/v3"})
+}

=== added directory 'pkg/remote'
=== added file 'pkg/remote/remote.go'
--- pkg/remote/remote.go	1970-01-01 00:00:00 +0000
+++ pkg/remote/remote.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,45 @@
+// -*- 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 remote
+
+import (
+	"launchpad.net/snappy/pkg"
+)
+
+// A Snap encapsulates the data sent to us from the store.
+type Snap struct {
+	Alias           string             `json:"alias,omitempty"`
+	AnonDownloadURL string             `json:"anon_download_url,omitempty"`
+	DownloadSha512  string             `json:"download_sha512,omitempty"`
+	Description     string             `json:"description,omitempty"`
+	DownloadSize    int64              `json:"binary_filesize,omitempty"`
+	DownloadURL     string             `json:"download_url,omitempty"`
+	IconURL         string             `json:"icon_url"`
+	LastUpdated     string             `json:"last_updated,omitempty"`
+	Name            string             `json:"package_name"`
+	Origin          string             `json:"origin"`
+	Prices          map[string]float64 `json:"prices,omitempty"`
+	Publisher       string             `json:"publisher,omitempty"`
+	RatingsAverage  float64            `json:"ratings_average,omitempty"`
+	SupportURL      string             `json:"support_url"`
+	Title           string             `json:"title"`
+	Type            pkg.Type           `json:"content,omitempty"`
+	Version         string             `json:"version"`
+}

=== added directory 'pkg/removed'
=== added file 'pkg/removed/removed.go'
--- pkg/removed/removed.go	1970-01-01 00:00:00 +0000
+++ pkg/removed/removed.go	2015-10-12 09:23:01 +0000
@@ -0,0 +1,158 @@
+// -*- 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 removed implements Removed packages, that are packages that
+// have been installed, removed, but not purged: there is no
+// application, but there might be data.
+package removed
+
+import (
+	"errors"
+	"io/ioutil"
+	"time"
+
+	"gopkg.in/yaml.v2"
+
+	"launchpad.net/snappy/pkg"
+	"launchpad.net/snappy/pkg/remote"
+	"launchpad.net/snappy/progress"
+	"launchpad.net/snappy/snappy"
+)
+
+// ErrRemoved is returned when you ask to operate on a removed package.
+var ErrRemoved = errors.New("package is removed")
+
+// Removed represents a removed package.
+type Removed struct {
+	name    string
+	origin  string
+	version string
+	pkgType pkg.Type
+	remote  *remote.Snap
+}
+
+// New removed package.