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

[Michael Vogt]

Merge trunk to 15.04 for the new stable release.

[Michael Vogt (mvo)]

review: Approve

=== added file '_integration-tests/data/snaps/basic-binaries/bin/fail'
--- _integration-tests/data/snaps/basic-binaries/bin/fail	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic-binaries/bin/fail	2015-10-22 07:06:04 +0000
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+exit 1

=== added file '_integration-tests/data/snaps/basic-binaries/bin/success'
--- _integration-tests/data/snaps/basic-binaries/bin/success	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic-binaries/bin/success	2015-10-22 07:06:04 +0000
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+exit 0

=== modified file '_integration-tests/data/snaps/basic-binaries/meta/package.yaml'
--- _integration-tests/data/snaps/basic-binaries/meta/package.yaml	2015-10-09 07:42:40 +0000
+++ _integration-tests/data/snaps/basic-binaries/meta/package.yaml	2015-10-22 07:06:04 +0000
@@ -4,3 +4,5 @@
 icon: meta/snappy64.png
 binaries:
  - name: bin/echo
+ - name: bin/success
+ - name: bin/fail

=== added directory '_integration-tests/data/snaps/basic-config'
=== added directory '_integration-tests/data/snaps/basic-config/meta'
=== added directory '_integration-tests/data/snaps/basic-config/meta/hooks'
=== added file '_integration-tests/data/snaps/basic-config/meta/hooks/config'
--- _integration-tests/data/snaps/basic-config/meta/hooks/config	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic-config/meta/hooks/config	2015-10-22 07:06:04 +0000
@@ -0,0 +1,37 @@
+#!/usr/bin/python3
+
+import os.path
+import sys
+import yaml
+
+PKGNAME="basic-config"
+CFG_FILE = os.path.join(os.environ["SNAP_APP_DATA_PATH"], "cfg")
+
+def get_config():
+   config = {"config": {
+               PKGNAME: {},
+               }
+            }
+   if not os.path.exists(CFG_FILE):
+      return config
+   with open(CFG_FILE) as fp:
+      val = fp.read()
+   config["config"]["basic-config"]["key"] = val
+   return config
+
+
+def set_config():
+   config = yaml.load(sys.stdin)
+   if not config:
+      return
+
+   val = config.get("key", "")
+   if val:
+      with open(CFG_FILE, "w") as fp:
+         fp.write(val)
+
+
+if __name__ == "__main__":
+   set_config()
+   config = get_config()
+   yaml.dump(config, stream=sys.stdout, default_flow_style=False)

=== added file '_integration-tests/data/snaps/basic-config/meta/package.yaml'
--- _integration-tests/data/snaps/basic-config/meta/package.yaml	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic-config/meta/package.yaml	2015-10-22 07:06:04 +0000
@@ -0,0 +1,4 @@
+name: basic-config
+version: 1.0
+vendor: Snappy Developers <[e-mail]>
+icon: meta/snappy64.png

=== added file '_integration-tests/data/snaps/basic-config/meta/readme.md'
--- _integration-tests/data/snaps/basic-config/meta/readme.md	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic-config/meta/readme.md	2015-10-22 07:06:04 +0000
@@ -0,0 +1,3 @@
+Basic Config snap
+
+A basic snap with config hook

=== added file '_integration-tests/data/snaps/basic-config/meta/snappy64.png'
Binary files _integration-tests/data/snaps/basic-config/meta/snappy64.png	1970-01-01 00:00:00 +0000 and _integration-tests/data/snaps/basic-config/meta/snappy64.png	2015-10-22 07:06:04 +0000 differ
=== added directory '_integration-tests/data/snaps/basic-framework'
=== added directory '_integration-tests/data/snaps/basic-framework/meta'
=== added file '_integration-tests/data/snaps/basic-framework/meta/package.yaml'
--- _integration-tests/data/snaps/basic-framework/meta/package.yaml	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic-framework/meta/package.yaml	2015-10-22 07:06:04 +0000
@@ -0,0 +1,5 @@
+name: basic-framework
+version: 1.0
+vendor: Snappy Developers <[e-mail]>
+icon: meta/snappy64.png
+type: framework

=== added file '_integration-tests/data/snaps/basic-framework/meta/readme.md'
--- _integration-tests/data/snaps/basic-framework/meta/readme.md	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic-framework/meta/readme.md	2015-10-22 07:06:04 +0000
@@ -0,0 +1,3 @@
+Basic framework snap
+
+A basic buildable framework snap

=== added file '_integration-tests/data/snaps/basic-framework/meta/snappy64.png'
Binary files _integration-tests/data/snaps/basic-framework/meta/snappy64.png	1970-01-01 00:00:00 +0000 and _integration-tests/data/snaps/basic-framework/meta/snappy64.png	2015-10-22 07:06:04 +0000 differ
=== added directory '_integration-tests/data/snaps/basic-service'
=== added directory '_integration-tests/data/snaps/basic-service/bin'
=== added file '_integration-tests/data/snaps/basic-service/bin/start'
--- _integration-tests/data/snaps/basic-service/bin/start	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic-service/bin/start	2015-10-22 07:06:04 +0000
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+while :; do echo 'Service running'; sleep 10; done

=== added directory '_integration-tests/data/snaps/basic-service/meta'
=== added file '_integration-tests/data/snaps/basic-service/meta/package.yaml'
--- _integration-tests/data/snaps/basic-service/meta/package.yaml	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic-service/meta/package.yaml	2015-10-22 07:06:04 +0000
@@ -0,0 +1,8 @@
+name: basic-service
+version: 1.0
+vendor: Snappy Developers <[e-mail]>
+icon: meta/snappy64.png
+services:
+  - name: service
+    start: ./bin/start
+    description: Test service

=== added file '_integration-tests/data/snaps/basic-service/meta/readme.md'
--- _integration-tests/data/snaps/basic-service/meta/readme.md	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic-service/meta/readme.md	2015-10-22 07:06:04 +0000
@@ -0,0 +1,3 @@
+Basic-service snap
+
+A basic buildable snap with a service.

=== added file '_integration-tests/data/snaps/basic-service/meta/snappy64.png'
Binary files _integration-tests/data/snaps/basic-service/meta/snappy64.png	1970-01-01 00:00:00 +0000 and _integration-tests/data/snaps/basic-service/meta/snappy64.png	2015-10-22 07:06:04 +0000 differ
=== modified file '_integration-tests/data/tpl/control'
--- _integration-tests/data/tpl/control	2015-07-22 16:36:14 +0000
+++ _integration-tests/data/tpl/control	2015-10-22 07:06:04 +0000
@@ -1,4 +1,4 @@
 {{ $filter := .Filter }}
 {{ $test := .Test }}
-Test-Command: ./_integration-tests/reboot-wrapper {{ $test }} {{ if $filter }}-gocheck.f {{ $filter }}{{ end }}
+Test-Command: ./_integration-tests/scripts/reboot-wrapper {{ $test }} {{ if $filter }}-gocheck.f {{ $filter }}{{ end }}
 Restrictions: allow-stderr

=== added directory '_integration-tests/scripts'
=== renamed file '_integration-tests/tests/get_unpartitioned_space' => '_integration-tests/scripts/get_unpartitioned_space'
=== added file '_integration-tests/scripts/install-test-initramfs'
--- _integration-tests/scripts/install-test-initramfs	1970-01-01 00:00:00 +0000
+++ _integration-tests/scripts/install-test-initramfs	2015-10-22 07:06:04 +0000
@@ -0,0 +1,25 @@
+#! /bin/sh -e
+# Prepare the initramfs image for the tests.
+
+current_boot_dir=$1
+writable_percent=$2
+tree_dir=$(pwd)
+initrd_unpack_dir=$ADT_ARTIFACTS/initrd
+
+cp ${current_boot_dir}/initrd.img /tmp/initrd.xz
+cd /tmp/
+unxz /tmp/initrd.xz
+mkdir $initrd_unpack_dir || true
+cd $initrd_unpack_dir
+cpio -id < /tmp/initrd
+# We need sfdisk to shrink the partition in mbr.
+cp /sbin/sfdisk sbin
+# Libs required by sfdisk.
+cp /lib/*/libfdisk.so.1 lib
+cp /lib/*/libsmartcols.so.1 lib
+cp $tree_dir/_integration-tests/scripts/resize-writable-test scripts/local-premount/
+sed -i "s/writable_percent=.*/writable_percent=${writable_percent}/" scripts/local-premount/resize-writable-test
+sed -i '1i /scripts/local-premount/resize-writable-test "$@"\n[ -e /conf/param.conf ] && . /conf/param.conf' scripts/local-premount/ORDER
+find .|cpio -o -H newc|xz -c -7 --check=crc32 > initrd.img
+sudo rm $current_boot_dir/initrd.img
+sudo mv initrd.img $current_boot_dir

=== renamed file '_integration-tests/reboot-wrapper' => '_integration-tests/scripts/reboot-wrapper'
=== added file '_integration-tests/scripts/resize-writable-test'
--- _integration-tests/scripts/resize-writable-test	1970-01-01 00:00:00 +0000
+++ _integration-tests/scripts/resize-writable-test	2015-10-22 07:06:04 +0000
@@ -0,0 +1,123 @@
+#! /bin/sh -ex
+# initramfs local-premount script to resize writable for testing
+
+PREREQ=""
+
+# Output pre-requisites
+prereqs()
+{
+        echo "$PREREQ"
+}
+
+case "$1" in
+    prereqs)
+        prereqs
+        exit 0
+        ;;
+esac
+
+TMPFILE="/run/initramfs/old-table-test.txt"
+LOGFILE="/run/initramfs/resize-writable-test.log"
+
+writable_percent=100
+
+wait-for-root "LABEL=writable" "${ROOTDELAY:-180}" >/dev/null || true
+
+writable_part="$(findfs LABEL=writable)"
+
+syspath="$(dirname $(realpath /sys/class/block/$(basename $writable_part)))"
+device="$(realpath /dev/block/$(cat $syspath/dev))"
+partition=$(cat $syspath/$(basename $writable_part)/partition)
+
+device_size="$(($(cat $syspath/size)/2))"
+
+get_end()
+{
+    NUM=$1
+    lastpart="$(grep -cE ^'[0-9]{1,}': $TMPFILE)"
+    if [ "$lastpart" = "$NUM" ]; then
+        endsize="$(parted -ms $DEV unit B print| grep ^/ | cut -d: -f2|sed 's/B$//')"
+    else
+        # we are not at the end ! get the start of the next partition
+        # (minus 1 byte) instead of using the absolute end of the disk
+        endsize=$(($(parted -ms $DEV unit B print|grep ^$(($num+1)):|\
+            cut -d: -f2|sed 's/B$//')-1))
+    fi
+    echo "endsize: ${endsize}" >/dev/kmsg || true
+    endsize_percent=$(($endsize*$writable_percent/100))
+    echo "endsize percent: ${endsize_percent}" >/dev/kmsg || true
+    echo "$endsize_percent"
+}
+
+do_gpt()
+{
+    DEV=$1
+    # create new empty GPT
+    parted -s $DEV mklabel gpt
+    oIFS=$IFS
+    IFS=:
+    # re-create all partitions from backup table
+    grep -E ^'[0-9]{1,}': $TMPFILE|while read -r num start end size type name flags; do
+        if [ "$name" = "writable" ]; then
+            endsize=$(get_end $num)B
+            parted -s $DEV mkpart \"$name\" \"$type\" $start $endsize
+        else
+            flags="$(echo $flags|sed -e 's/[,;]//g' -e 's/ /:/')"
+            parted -s $DEV mkpart \"$name\" \"$type\" $start $end
+            if [ -n "$flags" ]; then
+                for flag in ${flags}; do
+                    parted -s $DEV set $num $flag on
+                done
+            fi
+        fi
+    done
+    IFS=$oIFS
+    parted -ms $DEV unit B print >/run/initramfs/new-gpt-table.txt 2>/dev/null
+}
+
+do_mbr()
+{
+    DEV=$1
+    PART=$2
+    endsize=$(get_end $PART)
+    # We can't just resize with parted because it prints a warning when you try to shrink the
+    # partition.
+    part_start="$(parted -ms $DEV unit B print | grep ^$PART: | cut -d: -f2 | sed 's/B$//')"
+    part_end=$(($endsize-$part_start))
+    part_end_sectors=$(($part_end/512))
+    echo ", ${part_end_sectors}" | sfdisk -f -N$PART $DEV
+}
+
+
+echo "initrd: resize ${writable_part} to ${writable_percent}% of the disk" >/dev/kmsg || true
+echo "initrd: see ${LOGFILE} for details" >/dev/kmsg || true
+
+# check the filesystem before attempting re-size
+e2fsck -fy $writable_part >>$LOGFILE 2>&1
+# shrink the filesystem to the minimum
+resize2fs -M $writable_part >>$LOGFILE 2>&1
+
+# back up the original partition table for later use or debugging
+parted -ms $device unit B print >$TMPFILE 2>/dev/null
+table="$(parted -ms $device print| grep ^/| cut -d: -f6)"
+case $table in
+    gpt)
+        # do_gpt needs the device name
+        do_gpt $device >>$LOGFILE 2>&1
+        ;;
+    mbr|msdos)
+        # do_mbr needs the device node and partition number
+        do_mbr $device $partition >>$LOGFILE 2>&1
+        resizeopts="-f"
+            ;;
+    *)
+        echo "unknown partition table type, not resizing" >>$LOGFILE
+        exit 0
+        ;;
+esac
+# make sure we re read the partition table in any case
+blockdev --rereadpt $device >>$LOGFILE 2>&1
+# check the filesystem before attempting re-size
+e2fsck -fy $writable_part >>$LOGFILE 2>&1
+# resize the filesystem to full size of the partition
+resize2fs $resizeopts $writable_part >>$LOGFILE 2>&1

=== modified file '_integration-tests/tests/activate_test.go'
--- _integration-tests/tests/activate_test.go	2015-10-09 07:49:19 +0000
+++ _integration-tests/tests/activate_test.go	2015-10-22 07:06:04 +0000
@@ -27,10 +27,11 @@
 	"launchpad.net/snappy/_integration-tests/testutils/build"
 	"launchpad.net/snappy/_integration-tests/testutils/cli"
 	"launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/data"
 )
 
 const (
-	activateSnapName    = "basic-binaries"
+	activateSnapName    = data.BasicBinariesSnapName
 	activateBinName     = activateSnapName + ".echo"
 	activateEchoOutput  = "From basic-binaries snap\n"
 	baseActivatePattern = "(?msU).*" + activateSnapName + `\s*.*\s*.*sideload`
@@ -45,17 +46,21 @@
 	snapPath string
 }
 
-func (s *activateSuite) SetUpSuite(c *check.C) {
-	s.SnappySuite.SetUpSuite(c)
+func (s *activateSuite) SetUpTest(c *check.C) {
+	s.SnappySuite.SetUpTest(c)
+	if common.Release(c) == "15.04" {
+		c.Skip("activate CLI command not available on 15.04, reenable the test when present")
+	}
 	var err error
 	s.snapPath, err = build.LocalSnap(c, activateSnapName)
-	c.Assert(err, check.IsNil)
+	c.Assert(err, check.IsNil, check.Commentf("Error building local snap: %s", err))
 	common.InstallSnap(c, s.snapPath)
 }
 
-func (s *activateSuite) TearDownSuite(c *check.C) {
+func (s *activateSuite) TearDownTest(c *check.C) {
 	os.Remove(s.snapPath)
 	common.RemoveSnap(c, activateSnapName)
+	s.SnappySuite.TearDownTest(c)
 }
 
 func (s *activateSuite) TestDeactivateRemovesBinary(c *check.C) {
@@ -63,8 +68,9 @@
 	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)
+	c.Assert(err, check.NotNil, check.Commentf("Deactivated snap binary did not exit with an error"))
+	c.Assert(output, check.Not(check.Equals), activateEchoOutput,
+		check.Commentf("Deactivated snap binary was not removed"))
 
 	list := cli.ExecCommand(c, "snappy", "list", "-v")
 
@@ -76,7 +82,8 @@
 	cli.ExecCommand(c, "sudo", "snappy", "activate", activateSnapName)
 	output := cli.ExecCommand(c, activateBinName)
 
-	c.Assert(output, check.Equals, activateEchoOutput)
+	c.Assert(output, check.Equals, activateEchoOutput,
+		check.Commentf("Wrong output from active snap binary"))
 
 	list := cli.ExecCommand(c, "snappy", "list", "-v")
 

=== modified file '_integration-tests/tests/apt_test.go'
--- _integration-tests/tests/apt_test.go	2015-09-30 11:27:49 +0000
+++ _integration-tests/tests/apt_test.go	2015-10-22 07:06:04 +0000
@@ -36,5 +36,5 @@
 	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)
+	c.Assert(aptOutput, check.Equals, expected, check.Commentf("Wrong apt-get output"))
 }

=== modified file '_integration-tests/tests/build_test.go'
--- _integration-tests/tests/build_test.go	2015-09-28 10:35:06 +0000
+++ _integration-tests/tests/build_test.go	2015-10-22 07:06:04 +0000
@@ -26,6 +26,7 @@
 
 	"launchpad.net/snappy/_integration-tests/testutils/build"
 	"launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/data"
 
 	"gopkg.in/check.v1"
 )
@@ -38,37 +39,37 @@
 
 func (s *buildSuite) TestBuildBasicSnapOnSnappy(c *check.C) {
 	// build basic snap and check output
-	snapPath, err := build.LocalSnap(c, build.BasicSnapName)
+	snapPath, err := build.LocalSnap(c, data.BasicSnapName)
 	defer os.Remove(snapPath)
-	c.Assert(err, check.IsNil)
+	c.Assert(err, check.IsNil, check.Commentf("Error building local snap: %s", err))
 
 	// install built snap and check output
 	installOutput := common.InstallSnap(c, snapPath)
-	defer common.RemoveSnap(c, build.BasicSnapName)
+	defer common.RemoveSnap(c, data.BasicSnapName)
 	expected := "(?ms)" +
 		"Installing " + snapPath + "\n" +
 		".*Signature check failed, but installing anyway as requested\n" +
 		"Name +Date +Version +Developer \n" +
 		".*\n" +
-		build.BasicSnapName + " +.* +.* +sideload  \n" +
+		data.BasicSnapName + " +.* +.* +sideload  \n" +
 		".*\n"
 
 	c.Check(installOutput, check.Matches, expected)
 }
 
 func (s *buildSuite) TestBuildWrongYamlSnapOnSnappy(c *check.C) {
-	commonWrongTest(c, build.WrongYamlSnapName,
+	commonWrongTest(c, data.WrongYamlSnapName,
 		"(?msi).*Can not parse.*yaml: line 2: mapping values are not allowed in this context.*")
 }
 
 func (s *buildSuite) TestBuildMissingReadmeSnapOnSnappy(c *check.C) {
-	commonWrongTest(c, build.MissingReadmeSnapName,
+	commonWrongTest(c, data.MissingReadmeSnapName,
 		".*readme.md: no such file or directory\n")
 }
 
 func commonWrongTest(c *check.C, testName, expected string) {
 	// build wrong snap and check error
-	cmd := exec.Command("snappy", "build", fmt.Sprintf("%s/%s", build.BaseSnapPath, testName))
+	cmd := exec.Command("snappy", "build", fmt.Sprintf("%s/%s", data.BaseSnapPath, testName))
 	echoOutput, err := cmd.CombinedOutput()
 	c.Assert(err, check.NotNil, check.Commentf("%s should not be built", testName))
 

=== modified file '_integration-tests/tests/config_test.go'
--- _integration-tests/tests/config_test.go	2015-10-02 10:23:47 +0000
+++ _integration-tests/tests/config_test.go	2015-10-22 07:06:04 +0000
@@ -77,7 +77,7 @@
 	config := configString(targetCfg)
 
 	err := s.setConfig(c, config)
-	c.Assert(err, check.IsNil)
+	c.Assert(err, check.IsNil, check.Commentf("Error setting config: %s", err))
 
 	actualConfig := currentConfig(c)
 

=== added file '_integration-tests/tests/console_test.go'
--- _integration-tests/tests/console_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/console_test.go	2015-10-22 07:06:04 +0000
@@ -0,0 +1,141 @@
+// -*- 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 (
+	"bufio"
+	"io"
+	"os/exec"
+
+	"launchpad.net/snappy/_integration-tests/testutils/common"
+
+	"gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&consoleSuite{})
+
+type consoleSuite struct {
+	common.SnappySuite
+	cmd    *exec.Cmd
+	stdin  io.WriteCloser
+	stdout io.ReadCloser
+	outbr  *bufio.Reader
+}
+
+type consoleMsg struct {
+	txt string
+	err error
+}
+
+func (s *consoleSuite) SetUpTest(c *check.C) {
+	s.SnappySuite.SetUpTest(c)
+
+	var err error
+	s.cmd = exec.Command("snappy", "console")
+	s.stdin, err = s.cmd.StdinPipe()
+	c.Assert(err, check.IsNil, check.Commentf("Expected nil error, got %s", err))
+	s.stdout, err = s.cmd.StdoutPipe()
+	c.Assert(err, check.IsNil, check.Commentf("Expected nil error, got %s", err))
+
+	s.outbr = bufio.NewReader(s.stdout)
+
+	err = s.cmd.Start()
+	c.Assert(err, check.IsNil, check.Commentf("Expected nil error, got %s", err))
+
+	s.checkPrompt(c)
+}
+
+func (s *consoleSuite) TearDownTest(c *check.C) {
+	s.SnappySuite.TearDownTest(c)
+
+	s.stdin.Close()
+	s.stdout.Close()
+
+	proc := s.cmd.Process
+	if proc != nil {
+		proc.Kill()
+	}
+}
+
+func (s *consoleSuite) checkPrompt(c *check.C) {
+	expected := []string{"Welcome to the snappy console\n",
+		"Type 'help' for help\n",
+		"Type 'shell' for entering a shell\n"}
+
+	match, err := s.matchLinesFromConsole(expected)
+
+	c.Assert(err, check.IsNil, check.Commentf("Expected nil error, got %s", err))
+	c.Assert(match, check.Equals, true,
+		check.Commentf("Console output didn't match expected value"))
+}
+
+func (s *consoleSuite) TestHelp(c *check.C) {
+	s.writeToConsole("help\n")
+
+	expected := []string{"> Usage:\n",
+		"  snappy [OPTIONS] <command>\n", "\n",
+		"Help Options:\n",
+		"  -h, --help  Show this help message\n", "\n",
+		"Available commands:\n"}
+
+	match, err := s.matchLinesFromConsole(expected)
+
+	c.Assert(err, check.IsNil, check.Commentf("Expected nil error, got %s", err))
+	c.Assert(match, check.Equals, true,
+		check.Commentf("Console output didn't match expected value"))
+}
+
+func (s *consoleSuite) writeToConsole(msg string) (err error) {
+	_, err = s.stdin.Write([]byte(msg))
+	return
+}
+
+func (s *consoleSuite) getConsoleChannel(len int) chan *consoleMsg {
+	c := make(chan *consoleMsg)
+	go func() {
+		for i := 0; i < len; i++ {
+			txt, err := s.outbr.ReadString(byte('\n'))
+			if err == io.EOF {
+				close(c)
+				return
+			}
+			if err != nil {
+				c <- &consoleMsg{"", err}
+			}
+			c <- &consoleMsg{txt, nil}
+		}
+	}()
+	return c
+}
+
+func (s *consoleSuite) matchLinesFromConsole(lines []string) (match bool, err error) {
+	c := s.getConsoleChannel(len(lines))
+
+	for _, expected := range lines {
+		msg := <-c
+		if msg.err != nil {
+			return false, msg.err
+		}
+		if msg.txt != expected {
+			return false, nil
+		}
+	}
+	return true, nil
+}

=== modified file '_integration-tests/tests/examples_test.go'
--- _integration-tests/tests/examples_test.go	2015-10-09 16:18:01 +0000
+++ _integration-tests/tests/examples_test.go	2015-10-22 07:06:04 +0000
@@ -20,7 +20,10 @@
 package tests
 
 import (
+	"fmt"
+	"io/ioutil"
 	"net/http"
+	"os"
 
 	"launchpad.net/snappy/_integration-tests/testutils/cli"
 	"launchpad.net/snappy/_integration-tests/testutils/common"
@@ -29,25 +32,86 @@
 	"gopkg.in/check.v1"
 )
 
-var _ = check.Suite(&webserverExampleSuite{})
-
-type webserverExampleSuite struct {
-	common.SnappySuite
-}
-
-func (s *webserverExampleSuite) TestNetworkingServiceMustBeStarted(c *check.C) {
+var _ = check.Suite(&helloWorldExampleSuite{})
+
+type helloWorldExampleSuite struct {
+	common.SnappySuite
+}
+
+func (s *helloWorldExampleSuite) TestCallHelloWorldBinary(c *check.C) {
+	common.InstallSnap(c, "hello-world")
+	s.AddCleanup(func() {
+		common.RemoveSnap(c, "hello-world")
+	})
+
+	echoOutput := cli.ExecCommand(c, "hello-world.echo")
+
+	c.Assert(echoOutput, check.Equals, "Hello World!\n",
+		check.Commentf("Wrong output from hello-world binary"))
+}
+
+func (s *helloWorldExampleSuite) TestCallHelloWorldEvilMustPrintPermissionDeniedError(c *check.C) {
+	common.InstallSnap(c, "hello-world")
+	s.AddCleanup(func() {
+		common.RemoveSnap(c, "hello-world")
+	})
+
+	echoOutput, err := cli.ExecCommandErr("hello-world.evil")
+	c.Assert(err, check.NotNil, check.Commentf("hello-world.evil did not fail"))
+
+	expected := "" +
+		"Hello Evil World!\n" +
+		"This example demonstrates the app confinement\n" +
+		"You should see a permission denied error next\n" +
+		"/apps/hello-world.canonical/.*/bin/evil: \\d+: " +
+		"/apps/hello-world.canonical/.*/bin/evil: " +
+		"cannot create /var/tmp/myevil.txt: Permission denied\n"
+
+	c.Assert(string(echoOutput), check.Matches, expected)
+}
+
+var _ = check.Suite(&pythonWebserverExampleSuite{})
+
+type pythonWebserverExampleSuite struct {
+	common.SnappySuite
+}
+
+func (s *pythonWebserverExampleSuite) 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)
+	err := wait.ForServerOnPort(c, "tcp", 80)
+	c.Assert(err, check.IsNil, check.Commentf("Error waiting for server: %s", err))
 
 	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")
+	c.Assert(err, check.IsNil, check.Commentf("Error getting the http resource: %s", err))
+	c.Check(resp.Status, check.Equals, "200 OK", check.Commentf("Wrong reply status"))
+	c.Assert(resp.Proto, check.Equals, "HTTP/1.0", check.Commentf("Wrong reply protocol"))
+}
+
+var _ = check.Suite(&goWebserverExampleSuite{})
+
+type goWebserverExampleSuite struct {
+	common.SnappySuite
+}
+
+func (s *goWebserverExampleSuite) TestGetRootPathMustPrintMessage(c *check.C) {
+	appName := "go-example-webserver"
+	common.InstallSnap(c, appName)
+	defer common.RemoveSnap(c, appName)
+
+	err := wait.ForServerOnPort(c, "tcp6", 8081)
+	c.Assert(err, check.IsNil, check.Commentf("Error waiting for server: %s", err))
+
+	resp, err := http.Get("http://localhost:8081/")
+	defer resp.Body.Close()
+	c.Assert(err, check.IsNil, check.Commentf("Error getting the http resource: %s", err))
+	c.Check(resp.Status, check.Equals, "200 OK", check.Commentf("Wrong reply status"))
+	body, err := ioutil.ReadAll(resp.Body)
+	c.Assert(err, check.IsNil, check.Commentf("Error reading the reply body: %s", err))
+	c.Assert(string(body), check.Equals, "Hello World\n", check.Commentf("Wrong reply body"))
 }
 
 var _ = check.Suite(&frameworkExampleSuite{})
@@ -70,3 +134,41 @@
 	c.Assert(output, check.Equals, expected,
 		check.Commentf("Expected output %s not found, %s", expected, output))
 }
+
+var _ = check.Suite(&configExampleSuite{})
+
+type configExampleSuite struct {
+	common.SnappySuite
+}
+
+var configTests = []struct {
+	snap    string
+	origin  string
+	message string
+}{
+	{"config-example", "", "test config example message"},
+	{"config-example-bash", ".canonical", "test config example bash message"},
+}
+
+func (s *configExampleSuite) TestPrintMessageFromConfig(c *check.C) {
+	for _, t := range configTests {
+		common.InstallSnap(c, t.snap+t.origin)
+		defer common.RemoveSnap(c, t.snap)
+
+		config := fmt.Sprintf(`config:
+  %s:
+    msg: |
+      %s`, t.snap, t.message)
+
+		configFile, err := ioutil.TempFile("", "snappy-cfg")
+		defer func() { configFile.Close(); os.Remove(configFile.Name()) }()
+		c.Assert(err, check.IsNil, check.Commentf("Error creating temp file: %s", err))
+		_, err = configFile.Write([]byte(config))
+		c.Assert(err, check.IsNil, check.Commentf("Error writing the conf to the temp file: %s", err))
+
+		cli.ExecCommand(c, "sudo", "snappy", "config", t.snap, configFile.Name())
+
+		output := cli.ExecCommand(c, t.snap+".hello")
+		c.Assert(output, check.Equals, t.message, check.Commentf("Wrong message"))
+	}
+}

=== modified file '_integration-tests/tests/failover_test.go'
--- _integration-tests/tests/failover_test.go	2015-09-30 11:27:49 +0000
+++ _integration-tests/tests/failover_test.go	2015-10-22 07:06:04 +0000
@@ -48,7 +48,8 @@
 	if common.AfterReboot(c) {
 		common.RemoveRebootMark(c)
 		f.unset(c)
-		c.Assert(common.GetSavedVersion(c), check.Equals, currentVersion)
+		c.Assert(common.GetSavedVersion(c), check.Equals, currentVersion,
+			check.Commentf("Rebooted to the wrong version"))
 	} else {
 		common.SetSavedVersion(c, currentVersion-1)
 		common.CallFakeUpdate(c)

=== modified file '_integration-tests/tests/hwAssign_test.go'
--- _integration-tests/tests/hwAssign_test.go	2015-10-07 07:39:25 +0000
+++ _integration-tests/tests/hwAssign_test.go	2015-10-22 07:06:04 +0000
@@ -49,7 +49,7 @@
 	s.SnappySuite.SetUpTest(c)
 	var err error
 	s.snapPath, err = build.LocalSnap(c, snapName)
-	c.Assert(err, check.IsNil)
+	c.Assert(err, check.IsNil, check.Commentf("Error building local snap: %s", err))
 	common.InstallSnap(c, s.snapPath)
 }
 
@@ -63,8 +63,10 @@
 	cmd := exec.Command(binName)
 	output, err := cmd.CombinedOutput()
 
-	c.Assert(err, check.NotNil)
-	c.Assert(string(output), check.Equals, hwAssignError)
+	c.Assert(err, check.NotNil,
+		check.Commentf("The snap binary without hardware assigned did not exit with an error"))
+	c.Assert(string(output), check.Equals, hwAssignError,
+		check.Commentf("Wrong error message"))
 }
 
 func (s *hwAssignSuite) TestSuccessAfterHwAssign(c *check.C) {
@@ -74,7 +76,8 @@
 	cmd := exec.Command(binName)
 	output, _ := cmd.CombinedOutput()
 
-	c.Assert(string(output), check.Not(check.Equals), hwAssignError)
+	c.Assert(string(output), check.Not(check.Equals), hwAssignError,
+		check.Commentf("The snap binary with hardware assigned printed a permission denied error"))
 }
 
 func (s *hwAssignSuite) TestErrorAfterHwUnAssign(c *check.C) {
@@ -84,23 +87,45 @@
 	cmd := exec.Command(binName)
 	output, err := cmd.CombinedOutput()
 
-	c.Assert(err, check.NotNil)
-	c.Assert(string(output), check.Equals, hwAssignError)
+	c.Assert(err, check.NotNil,
+		check.Commentf("The snap binary without hardware assigned did not exit with an error"))
+	c.Assert(string(output), check.Equals, hwAssignError,
+		check.Commentf("Wrong error message"))
+}
+
+func (s *hwAssignSuite) TestHwInfo(c *check.C) {
+	cmd := exec.Command("sudo", "snappy", "hw-info", installedSnapName)
+	boutput, _ := cmd.CombinedOutput()
+	output := string(boutput)
+	expected := fmt.Sprintf("'%s:' is not allowed to access additional hardware\n", installedSnapName)
+	c.Assert(output, check.Equals, expected,
+		check.Commentf(`Expected "%s", obtained "%s"`, expected, output))
+
+	assign(c, snapName, hwName)
+	defer unassign(c, snapName, hwName)
+
+	cmd = exec.Command("sudo", "snappy", "hw-info", installedSnapName)
+	boutput, _ = cmd.CombinedOutput()
+	output = string(boutput)
+	expected = fmt.Sprintf("%s: %s\n", installedSnapName, hwName)
+	c.Assert(output, check.Equals, expected,
+		check.Commentf(`Expected "%s", obtained "%s"`, expected, output))
 }
 
 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(err, check.IsNil, check.Commentf("Error assigning hardware: %s", err))
 	c.Assert(string(output), check.Equals,
-		fmt.Sprintf("'%s' is now allowed to access '%s'\n", installedSnapName, hwName))
+		fmt.Sprintf("'%s' is now allowed to access '%s'\n", installedSnapName, hwName),
+		check.Commentf("Wrong message after assigning hardware"))
 }
 
 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(err, check.IsNil, check.Commentf("Error unassigning hardware: %s", err))
 	c.Assert(string(output), check.Equals,
-		fmt.Sprintf("'%s' is no longer allowed to access '%s'\n", installedSnapName, hwName))
-
+		fmt.Sprintf("'%s' is no longer allowed to access '%s'\n", installedSnapName, hwName),
+		check.Commentf("Wrong message after unassigning hardware"))
 }

=== modified file '_integration-tests/tests/info_test.go'
--- _integration-tests/tests/info_test.go	2015-10-08 06:40:06 +0000
+++ _integration-tests/tests/info_test.go	2015-10-22 07:06:04 +0000
@@ -26,6 +26,7 @@
 	"launchpad.net/snappy/_integration-tests/testutils/build"
 	"launchpad.net/snappy/_integration-tests/testutils/cli"
 	"launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/data"
 
 	"gopkg.in/check.v1"
 )
@@ -55,17 +56,17 @@
 }
 
 func (s *infoSuite) TestInfoMustPrintInstalledApps(c *check.C) {
-	snapPath, err := build.LocalSnap(c, build.BasicSnapName)
+	snapPath, err := build.LocalSnap(c, data.BasicSnapName)
 	defer os.Remove(snapPath)
-	c.Assert(err, check.IsNil)
+	c.Assert(err, check.IsNil, check.Commentf("Error building local snap: %s", err))
 	common.InstallSnap(c, snapPath)
-	defer common.RemoveSnap(c, build.BasicSnapName)
+	defer common.RemoveSnap(c, data.BasicSnapName)
 
 	infoOutput := cli.ExecCommand(c, "snappy", "info")
 
 	expected := "(?ms)" +
 		".*" +
-		"^apps: .*" + build.BasicSnapName + "\\.sideload.*\n"
+		"^apps: .*" + data.BasicSnapName + "\\.sideload.*\n"
 	c.Assert(infoOutput, check.Matches, expected)
 }
 

=== modified file '_integration-tests/tests/initramfs_test.go'
--- _integration-tests/tests/initramfs_test.go	2015-09-08 18:25:45 +0000
+++ _integration-tests/tests/initramfs_test.go	2015-10-22 07:06:04 +0000
@@ -20,11 +20,15 @@
 package tests
 
 import (
+	"os"
 	"os/exec"
+	"path"
 	"strconv"
 	"strings"
 
+	"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"
 )
@@ -35,14 +39,69 @@
 	common.SnappySuite
 }
 
-func (s *initRAMFSSuite) TestFreeSpace(c *check.C) {
-	cmd := exec.Command("sh", "_integration-tests/tests/get_unpartitioned_space")
+func getFreeSpacePercent(c *check.C) float64 {
+	cmd := exec.Command("sh", "_integration-tests/scripts/get_unpartitioned_space")
 	free, err := cmd.Output()
 	c.Assert(err, check.IsNil, check.Commentf("Error running the script to get the free space: %s", err))
 	freePercent := strings.TrimRight(strings.TrimSpace(string(free)), "%")
 	freePercentFloat, err := strconv.ParseFloat(freePercent, 32)
 	c.Assert(err, check.IsNil,
 		check.Commentf("Error converting the free space percentage to float: %s", err))
-	c.Assert(freePercentFloat < 10, check.Equals, true,
-		check.Commentf("The free space at the end of the disk is greater than 10%"))
+	return freePercentFloat
+}
+
+func getCurrentBootDir(c *check.C) string {
+	system, err := partition.BootSystem()
+	c.Assert(err, check.IsNil, check.Commentf("Error getting the boot system: %s", err))
+	bootDir := partition.BootDir(system)
+	current, err := partition.CurrentPartition()
+	c.Assert(err, check.IsNil, check.Commentf("Error getting the current partition: %s", err))
+	return path.Join(bootDir, current)
+}
+
+func (s *initRAMFSSuite) SetUpTest(c *check.C) {
+	s.SnappySuite.SetUpTest(c)
+	if common.BeforeReboot() {
+		bootDir := getCurrentBootDir(c)
+		cli.ExecCommand(c, "cp", path.Join(bootDir, "initrd.img"), os.Getenv("ADT_ARTIFACTS"))
+	}
+}
+
+func (s *initRAMFSSuite) TearDownTest(c *check.C) {
+	s.SnappySuite.TearDownTest(c)
+	if !common.IsInRebootProcess() {
+		bootDir := getCurrentBootDir(c)
+		cli.ExecCommand(
+			c, "sudo", "mv", path.Join(os.Getenv("ADT_ARTIFACTS"), "initrd.img"), bootDir)
+	}
+}
+
+func (s *initRAMFSSuite) TestFreeSpaceWithoutResize(c *check.C) {
+	writablePercent := "95"
+	if common.BeforeReboot() {
+		bootDir := getCurrentBootDir(c)
+		cli.ExecCommand(
+			c, "sh", "-x", "_integration-tests/scripts/install-test-initramfs", bootDir, writablePercent)
+		common.Reboot(c)
+	} else if common.AfterReboot(c) {
+		common.RemoveRebootMark(c)
+		freeSpace := getFreeSpacePercent(c)
+		c.Assert(freeSpace, check.Equals, float64(5),
+			check.Commentf("The writable partition was resized"))
+	}
+}
+
+func (s *initRAMFSSuite) TestFreeSpaceWithResize(c *check.C) {
+	if common.BeforeReboot() {
+		bootDir := getCurrentBootDir(c)
+		writablePercent := "85"
+		cli.ExecCommand(
+			c, "sh", "-x", "_integration-tests/scripts/install-test-initramfs", bootDir, writablePercent)
+		common.Reboot(c)
+	} else if common.AfterReboot(c) {
+		common.RemoveRebootMark(c)
+		freeSpace := getFreeSpacePercent(c)
+		c.Assert(freeSpace < 10, check.Equals, true,
+			check.Commentf("The writable partition was not resized"))
+	}
 }

=== modified file '_integration-tests/tests/installApp_test.go'
--- _integration-tests/tests/installApp_test.go	2015-10-08 06:45:29 +0000
+++ _integration-tests/tests/installApp_test.go	2015-10-22 07:06:04 +0000
@@ -20,10 +20,14 @@
 package tests
 
 import (
+	"fmt"
+	"os"
 	"os/exec"
 
+	"launchpad.net/snappy/_integration-tests/testutils/build"
 	"launchpad.net/snappy/_integration-tests/testutils/cli"
 	"launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/data"
 
 	"gopkg.in/check.v1"
 )
@@ -35,59 +39,53 @@
 }
 
 func (s *installAppSuite) TestInstallAppMustPrintPackageInformation(c *check.C) {
-	installOutput := common.InstallSnap(c, "hello-world")
-	s.AddCleanup(func() {
-		common.RemoveSnap(c, "hello-world")
-	})
+	snapPath, err := build.LocalSnap(c, data.BasicSnapName)
+	defer os.Remove(snapPath)
+	c.Assert(err, check.IsNil, check.Commentf("Error building local snap: %s", err))
+	installOutput := common.InstallSnap(c, snapPath)
+	defer common.RemoveSnap(c, data.BasicSnapName)
 
 	expected := "(?ms)" +
-		"Installing hello-world\n" +
+		fmt.Sprintf("Installing %s\n", snapPath) +
+		".*Signature check failed, but installing anyway as requested\n" +
 		"Name +Date +Version +Developer \n" +
 		".*" +
-		"^hello-world +.* +.* +canonical \n" +
+		"^basic +.* +.* +sideload *\n" +
 		".*"
 
 	c.Assert(installOutput, check.Matches, expected)
 }
 
-func (s *installAppSuite) TestCallBinaryFromInstalledSnap(c *check.C) {
-	common.InstallSnap(c, "hello-world")
-	s.AddCleanup(func() {
-		common.RemoveSnap(c, "hello-world")
-	})
-
-	echoOutput := cli.ExecCommand(c, "hello-world.echo")
-
-	c.Assert(echoOutput, check.Equals, "Hello World!\n")
+func (s *installAppSuite) TestCallSuccessfulBinaryFromInstalledSnap(c *check.C) {
+	snapPath, err := build.LocalSnap(c, data.BasicBinariesSnapName)
+	defer os.Remove(snapPath)
+	c.Assert(err, check.IsNil, check.Commentf("Error building local snap: %s", err))
+	common.InstallSnap(c, snapPath)
+	defer common.RemoveSnap(c, data.BasicBinariesSnapName)
+
+	// Exec command does not fail.
+	cli.ExecCommand(c, "basic-binaries.success")
 }
 
-func (s *installAppSuite) TestCallBinaryWithPermissionDeniedMustPrintError(c *check.C) {
-	common.InstallSnap(c, "hello-world")
-	s.AddCleanup(func() {
-		common.RemoveSnap(c, "hello-world")
-	})
-
-	cmd := exec.Command("hello-world.evil")
-	echoOutput, err := cmd.CombinedOutput()
-	c.Assert(err, check.NotNil, check.Commentf("hello-world.evil did not fail"))
-
-	expected := "" +
-		"Hello Evil World!\n" +
-		"This example demonstrates the app confinement\n" +
-		"You should see a permission denied error next\n" +
-		"/apps/hello-world.canonical/.*/bin/evil: \\d+: " +
-		"/apps/hello-world.canonical/.*/bin/evil: " +
-		"cannot create /var/tmp/myevil.txt: Permission denied\n"
-
-	c.Assert(string(echoOutput), check.Matches, expected)
+func (s *installAppSuite) TestCallFailBinaryFromInstalledSnap(c *check.C) {
+	snapPath, err := build.LocalSnap(c, data.BasicBinariesSnapName)
+	defer os.Remove(snapPath)
+	c.Assert(err, check.IsNil, check.Commentf("Error building local snap: %s", err))
+	common.InstallSnap(c, snapPath)
+	defer common.RemoveSnap(c, data.BasicBinariesSnapName)
+
+	_, err = cli.ExecCommandErr("basic-binaries.fail")
+	c.Assert(err, check.NotNil, check.Commentf("The binary did not fail"))
 }
 
 func (s *installAppSuite) TestInstallUnexistingAppMustPrintError(c *check.C) {
 	cmd := exec.Command("sudo", "snappy", "install", "unexisting.canonical")
 	output, err := cmd.CombinedOutput()
 
-	c.Assert(err, check.NotNil)
+	c.Check(err, check.NotNil,
+		check.Commentf("Trying to install an unexisting snap did not exit with an error"))
 	c.Assert(string(output), check.Equals,
 		"Installing unexisting.canonical\n"+
-			"unexisting failed to install: snappy package not found\n")
+			"unexisting failed to install: snappy package not found\n",
+		check.Commentf("Wrong error message"))
 }

=== modified file '_integration-tests/tests/installFramework_test.go'
--- _integration-tests/tests/installFramework_test.go	2015-10-08 06:53:50 +0000
+++ _integration-tests/tests/installFramework_test.go	2015-10-22 07:06:04 +0000
@@ -20,7 +20,12 @@
 package tests
 
 import (
+	"fmt"
+	"os"
+
+	"launchpad.net/snappy/_integration-tests/testutils/build"
 	"launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/data"
 
 	"gopkg.in/check.v1"
 )
@@ -32,14 +37,18 @@
 }
 
 func (s *installFrameworkSuite) TestInstallFrameworkMustPrintPackageInformation(c *check.C) {
-	installOutput := common.InstallSnap(c, "hello-dbus-fwk.canonical")
-	defer common.RemoveSnap(c, "hello-dbus-fwk.canonical")
+	snapPath, err := build.LocalSnap(c, data.BasicFrameworkSnapName)
+	defer os.Remove(snapPath)
+	c.Assert(err, check.IsNil, check.Commentf("Error building local snap: %s", err))
+	installOutput := common.InstallSnap(c, snapPath)
+	defer common.RemoveSnap(c, data.BasicFrameworkSnapName)
 
 	expected := "(?ms)" +
-		"Installing hello-dbus-fwk.canonical\n" +
+		fmt.Sprintf("Installing %s\n", snapPath) +
+		".*Signature check failed, but installing anyway as requested\n" +
 		"Name +Date +Version +Developer \n" +
 		".*" +
-		"^hello-dbus-fwk +.* +.* +canonical \n" +
+		"^basic-framework +.* +.* +sideload *\n" +
 		".*"
 
 	c.Assert(installOutput, check.Matches, expected)

=== modified file '_integration-tests/tests/rollback_test.go'
--- _integration-tests/tests/rollback_test.go	2015-10-02 10:29:29 +0000
+++ _integration-tests/tests/rollback_test.go	2015-10-22 07:06:04 +0000
@@ -24,8 +24,6 @@
 
 	"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"
 
 	"gopkg.in/check.v1"
 )
@@ -42,18 +40,17 @@
 		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)
+		c.Assert(currentVersion > common.GetSavedVersion(c), check.Equals, true,
+			check.Commentf("Rebooted to the wrong version: %d", currentVersion))
 		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(
-			common.GetCurrentUbuntuCoreVersion(c) < common.GetSavedVersion(c), check.Equals, true)
+		currentVersion := common.GetCurrentUbuntuCoreVersion(c)
+		c.Assert(currentVersion < common.GetSavedVersion(c), check.Equals, true,
+			check.Commentf("Rebooted to the wrong version: %d", currentVersion))
 	}
 }

=== modified file '_integration-tests/tests/service_test.go'
--- _integration-tests/tests/service_test.go	2015-10-08 05:57:00 +0000
+++ _integration-tests/tests/service_test.go	2015-10-22 07:06:04 +0000
@@ -21,10 +21,13 @@
 
 import (
 	"fmt"
+	"os"
 	"regexp"
 
+	"launchpad.net/snappy/_integration-tests/testutils/build"
 	"launchpad.net/snappy/_integration-tests/testutils/cli"
 	"launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/data"
 	"launchpad.net/snappy/_integration-tests/testutils/wait"
 
 	"gopkg.in/check.v1"
@@ -38,25 +41,23 @@
 
 func (s *serviceSuite) TearDownTest(c *check.C) {
 	if !common.NeedsReboot() && common.CheckRebootMark("") {
-		common.RemoveSnap(c, "hello-dbus-fwk.canonical")
+		common.RemoveSnap(c, data.BasicServiceSnapName)
 	}
 	// run cleanup last
 	s.SnappySuite.TearDownTest(c)
 }
 
 func isServiceRunning(c *check.C) bool {
-	packageVersion := common.GetCurrentVersion(c, "hello-dbus-fwk")
-	service := fmt.Sprintf("hello-dbus-fwk_srv_%s.service", packageVersion)
+	packageVersion := common.GetCurrentVersion(c, data.BasicServiceSnapName)
+	service := fmt.Sprintf("%s_service_%s.service", data.BasicServiceSnapName, packageVersion)
 
 	err := wait.ForActiveService(c, service)
 	c.Assert(err, check.IsNil)
 
-	statusOutput := cli.ExecCommand(
-		c, "systemctl", "status",
-		service)
+	statusOutput := cli.ExecCommand(c, "systemctl", "status", service)
 
 	expected := "(?ms)" +
-		".* hello-dbus-fwk_srv_.*\\.service .*\n" +
+		fmt.Sprintf(".* %s_service_.*\\.service .*\n", data.BasicServiceSnapName) +
 		".*Loaded: loaded .*\n" +
 		".*Active: active \\(running\\) .*\n" +
 		".*"
@@ -66,29 +67,35 @@
 	return matched
 }
 
+func installSnapWithService(c *check.C) {
+	snapPath, err := build.LocalSnap(c, data.BasicServiceSnapName)
+	defer os.Remove(snapPath)
+	c.Assert(err, check.IsNil, check.Commentf("Error building local snap: %s", err))
+	common.InstallSnap(c, snapPath)
+}
+
 func (s *serviceSuite) TestInstalledServiceMustBeStarted(c *check.C) {
-	common.InstallSnap(c, "hello-dbus-fwk.canonical")
-
-	c.Assert(isServiceRunning(c), check.Equals, true)
+	installSnapWithService(c)
+	c.Assert(isServiceRunning(c), check.Equals, true, check.Commentf("Service is not running"))
 }
 
 func (s *serviceSuite) TestServiceMustBeStartedAfterReboot(c *check.C) {
 	if common.BeforeReboot() {
-		common.InstallSnap(c, "hello-dbus-fwk.canonical")
+		installSnapWithService(c)
 		common.Reboot(c)
 	} else if common.AfterReboot(c) {
 		common.RemoveRebootMark(c)
-		c.Assert(isServiceRunning(c), check.Equals, true)
+		c.Assert(isServiceRunning(c), check.Equals, true, check.Commentf("Service is not running"))
 	}
 }
 
 func (s *serviceSuite) TestServiceMustBeStartedAfterUpdate(c *check.C) {
 	if common.BeforeReboot() {
-		common.InstallSnap(c, "hello-dbus-fwk.canonical")
+		installSnapWithService(c)
 		common.CallFakeUpdate(c)
 		common.Reboot(c)
 	} else if common.AfterReboot(c) {
 		common.RemoveRebootMark(c)
-		c.Assert(isServiceRunning(c), check.Equals, true)
+		c.Assert(isServiceRunning(c), check.Equals, true, check.Commentf("Service is not running"))
 	}
 }

=== modified file '_integration-tests/tests/snapd_1_0_packages_test.go'
--- _integration-tests/tests/snapd_1_0_packages_test.go	2015-10-08 08:55:17 +0000
+++ _integration-tests/tests/snapd_1_0_packages_test.go	2015-10-22 07:06:04 +0000
@@ -24,6 +24,7 @@
 
 	"launchpad.net/snappy/_integration-tests/testutils/build"
 	"launchpad.net/snappy/_integration-tests/testutils/common"
+	"launchpad.net/snappy/_integration-tests/testutils/data"
 
 	"gopkg.in/check.v1"
 )
@@ -64,14 +65,14 @@
 func (s *snapd10PackagesTestSuite) SetUpTest(c *check.C) {
 	s.snapdTestSuite.SetUpTest(c)
 	var err error
-	s.snapPath, err = build.LocalSnap(c, build.BasicSnapName)
+	s.snapPath, err = build.LocalSnap(c, data.BasicConfigSnapName)
 	c.Assert(err, check.IsNil)
 }
 
 func (s *snapd10PackagesTestSuite) TearDownTest(c *check.C) {
 	s.snapdTestSuite.TearDownTest(c)
 	os.Remove(s.snapPath)
-	common.RemoveSnap(c, build.BasicSnapName)
+	common.RemoveSnap(c, data.BasicConfigSnapName)
 }
 
 func (s *snapd10PackagesTestSuite) resource() string {
@@ -92,7 +93,17 @@
 		payload:     s.snapPath,
 		waitPattern: `(?U){.*,"status":"active".*"status":"OK","status_code":200,"type":"sync"}`,
 		waitFunction: func() (string, error) {
-			output, err := genericRequest(s.resource()+"/"+build.BasicSnapName+".sideload", "GET", nil)
+			output, err := genericRequest(s.resource()+"/"+data.BasicConfigSnapName+".sideload", "GET", nil)
+			return string(output), err
+		}}}
+}
+
+func (s *snapd10PackagesTestSuite) putInteractions() apiInteractions {
+	return []apiInteraction{{
+		payload:     `{"` + data.BasicConfigSnapName + ".sideload" + `": "key: value"}`,
+		waitPattern: `(?Us){"result":.*` + data.BasicConfigSnapName + `.*key: value.*","status":"OK","status_code":200,"type":"sync"}`,
+		waitFunction: func() (string, error) {
+			output, err := genericRequest(s.resource()+"/"+data.BasicConfigSnapName+".sideload/config", "GET", nil)
 			return string(output), err
 		}}}
 }

=== modified file '_integration-tests/tests/snapd_test.go'
--- _integration-tests/tests/snapd_test.go	2015-09-28 11:15:51 +0000
+++ _integration-tests/tests/snapd_test.go	2015-10-22 07:06:04 +0000
@@ -51,13 +51,14 @@
 
 func (s *snapdTestSuite) SetUpTest(c *check.C) {
 	s.SnappySuite.SetUpTest(c)
-	s.cmd = exec.Command("sudo", "/lib/systemd/systemd-activate",
+	s.cmd = exec.Command("sudo", "env", "PATH="+os.Getenv("PATH"),
+		"/lib/systemd/systemd-activate",
 		"-l", "0.0.0.0:"+port, "snapd")
 
 	s.cmd.Start()
 
 	intPort, _ := strconv.Atoi(port)
-	err := wait.ForServerOnPort(c, intPort)
+	err := wait.ForServerOnPort(c, "tcp", intPort)
 	c.Assert(err, check.IsNil)
 }
 
@@ -191,20 +192,20 @@
 	}
 
 	body, err := genericRequest(resource, verb, payload)
-	c.Check(err, check.IsNil)
+	c.Check(err, check.IsNil, check.Commentf("Error making the request: %s", err))
 
 	if interaction.responseObject == nil {
 		interaction.responseObject = &response{}
 	}
 	err = json.Unmarshal(body, interaction.responseObject)
-	c.Check(err, check.IsNil)
+	c.Check(err, check.IsNil, check.Commentf("Error unmarshalling the response: %s", err))
 
 	if interaction.responsePattern != "" {
 		c.Check(string(body), check.Matches, interaction.responsePattern)
 	}
 	if interaction.waitPattern != "" {
 		err = wait.ForFunction(c, interaction.waitPattern, interaction.waitFunction)
-		c.Check(err, check.IsNil)
+		c.Check(err, check.IsNil, check.Commentf("Error waiting for function: %s", err))
 	}
 }
 

=== modified file '_integration-tests/tests/ubuntuFan_test.go'
--- _integration-tests/tests/ubuntuFan_test.go	2015-09-30 11:27:49 +0000
+++ _integration-tests/tests/ubuntuFan_test.go	2015-10-22 07:06:04 +0000
@@ -53,7 +53,7 @@
 	s.SnappySuite.SetUpTest(c)
 	var err error
 	s.subjectIP, err = getIPAddr(c)
-	c.Assert(err, check.IsNil)
+	c.Assert(err, check.IsNil, check.Commentf("Error getting IP address: %s", err))
 
 	s.fanCtl(c, "up")
 	s.bridgeIP = s.fanBridgeIP(c)
@@ -179,8 +179,11 @@
 	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")
-	c.Assert(err, check.IsNil)
+	err := wait.ForActiveService(c, dockerService)
+	c.Assert(err, check.IsNil, check.Commentf("Expected nil error, got %s", err))
+
+	err = wait.ForCommand(c, `(?ms).*docker\.sock\s.*`, "ls", "/run")
+	c.Assert(err, check.IsNil, check.Commentf("Expected nil error, got %s", err))
 }
 
 func (s *fanTestSuite) fanName() string {
@@ -198,7 +201,10 @@
 	dockerService := fmt.Sprintf("docker_docker-daemon_%s.service", dockerVersion)
 
 	err := wait.ForActiveService(c, dockerService)
-	c.Assert(err, check.IsNil)
+	c.Assert(err, check.IsNil, check.Commentf("Error waiting for service: %s", err))
+
+	err = wait.ForCommand(c, `(?ms).*docker\.sock\s.*`, "ls", "/run")
+	c.Assert(err, check.IsNil, check.Commentf("Expected nil error, got %s", err))
 
 	cli.ExecCommand(c, "docker", "pull", baseContainer)
 }

=== modified file '_integration-tests/testutils/build/snap.go'
--- _integration-tests/testutils/build/snap.go	2015-09-30 11:06:40 +0000
+++ _integration-tests/testutils/build/snap.go	2015-10-22 07:06:04 +0000
@@ -25,20 +25,10 @@
 
 	"gopkg.in/check.v1"
 	"launchpad.net/snappy/_integration-tests/testutils/cli"
-)
-
-const (
-	// BaseSnapPath is the path for the snap sources used in testing
-	BaseSnapPath = "_integration-tests/data/snaps"
-	// BasicSnapName is the name of the basic snap
-	BasicSnapName = "basic"
-	// WrongYamlSnapName is the name of a snap with an invalid meta yaml
-	WrongYamlSnapName = "wrong-yaml"
-	// MissingReadmeSnapName is the name of a snap without readme
-	MissingReadmeSnapName = "missing-readme"
-
-	snapFilenameSufix = "_1.0_all.snap"
-)
+	"launchpad.net/snappy/_integration-tests/testutils/data"
+)
+
+const snapFilenameSufix = "_1.0_all.snap"
 
 var (
 	// dependency aliasing
@@ -67,5 +57,5 @@
 }
 
 func buildPath(snap string) string {
-	return filepath.Join(BaseSnapPath, snap)
+	return filepath.Join(data.BaseSnapPath, snap)
 }

=== modified file '_integration-tests/testutils/common/common.go'
--- _integration-tests/testutils/common/common.go	2015-10-01 09:37:04 +0000
+++ _integration-tests/testutils/common/common.go	2015-10-22 07:06:04 +0000
@@ -33,6 +33,7 @@
 	"launchpad.net/snappy/_integration-tests/testutils/cli"
 	"launchpad.net/snappy/_integration-tests/testutils/config"
 	"launchpad.net/snappy/_integration-tests/testutils/partition"
+	"launchpad.net/snappy/_integration-tests/testutils/wait"
 )
 
 const (
@@ -55,6 +56,12 @@
 // SetUpSuite disables the snappy autopilot. It will run before all the
 // integration suites.
 func (s *SnappySuite) SetUpSuite(c *check.C) {
+	// Workaround for bug https://bugs.launchpad.net/snappy/+bug/1498293
+	// TODO remove once the bug is fixed
+	// originally added by elopio - 2015-09-30 to the rollback test, moved
+	// here by --fgimenez - 2015-10-15
+	wait.ForFunction(c, "regular", partition.Mode)
+
 	cli.ExecCommand(c, "sudo", "systemctl", "stop", "snappy-autopilot.timer")
 	cli.ExecCommand(c, "sudo", "systemctl", "disable", "snappy-autopilot.timer")
 	var err error
@@ -62,7 +69,7 @@
 		"_integration-tests/data/output/testconfig.json")
 	c.Assert(err, check.IsNil, check.Commentf("Error reading config: %v", err))
 
-	if !isInRebootProcess() {
+	if !IsInRebootProcess() {
 		if Cfg.Update || Cfg.Rollback {
 			switchSystemImageConf(c, Cfg.TargetRelease, Cfg.TargetChannel, "0")
 			// Always use the installed snappy because we are updating from an old
@@ -275,7 +282,8 @@
 	return os.Getenv("ADT_REBOOT_MARK") == mark
 }
 
-func isInRebootProcess() bool {
+// IsInRebootProcess returns True if the suite needs to execute a reboot or has just rebooted.
+func IsInRebootProcess() bool {
 	return !CheckRebootMark("") || NeedsReboot()
 }
 

=== added directory '_integration-tests/testutils/data'
=== added file '_integration-tests/testutils/data/data.go'
--- _integration-tests/testutils/data/data.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/data/data.go	2015-10-22 07:06:04 +0000
@@ -0,0 +1,39 @@
+// -*- 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 data
+
+const (
+	// BaseSnapPath is the path for the snap sources used in testing
+	BaseSnapPath = "_integration-tests/data/snaps"
+	// BasicSnapName is the name of the basic snap
+	BasicSnapName = "basic"
+	// BasicBinariesSnapName is the name of the basic snap with binaries
+	BasicBinariesSnapName = "basic-binaries"
+	// BasicConfigSnapName is the name of the basic snap with config hook
+	BasicConfigSnapName = "basic-config"
+	// BasicFrameworkSnapName is the name of the basic framework snap
+	BasicFrameworkSnapName = "basic-framework"
+	// BasicServiceSnapName is the name of the basic snap with a service
+	BasicServiceSnapName = "basic-service"
+	// WrongYamlSnapName is the name of a snap with an invalid meta yaml
+	WrongYamlSnapName = "wrong-yaml"
+	// MissingReadmeSnapName is the name of a snap without readme
+	MissingReadmeSnapName = "missing-readme"
+)

=== modified file '_integration-tests/testutils/wait/wait.go'
--- _integration-tests/testutils/wait/wait.go	2015-09-30 11:06:40 +0000
+++ _integration-tests/testutils/wait/wait.go	2015-10-22 07:06:04 +0000
@@ -46,8 +46,9 @@
 }
 
 // ForServerOnPort uses ForCommand to check for process listening on the given port
-func ForServerOnPort(c *check.C, port int) (err error) {
-	return ForCommand(c, fmt.Sprintf(`(?msU)^.*tcp.*0\.0\.0\.0:%d .*`, port), "netstat", "-tapn")
+func ForServerOnPort(c *check.C, protocol string, port int) (err error) {
+	return ForCommand(c, fmt.Sprintf(`(?msU)^.*%s .*:%d .* LISTEN.*`, protocol, port),
+		"netstat", "-tapn")
 }
 
 // forCommand uses ForFunction to check for the execCommand output

=== modified file '_integration-tests/testutils/wait/wait_test.go'
--- _integration-tests/testutils/wait/wait_test.go	2015-09-28 10:54:40 +0000
+++ _integration-tests/testutils/wait/wait_test.go	2015-10-22 07:06:04 +0000
@@ -177,9 +177,9 @@
 		return
 	}
 
-	ForServerOnPort(c, 1234)
+	ForServerOnPort(c, "tcp", 1234)
 
-	expectedCalled := `ForCommand called with pattern '(?msU)^.*tcp.*0\.0\.0\.0:1234 .*' and cmds 'netstat -tapn'`
+	expectedCalled := `ForCommand called with pattern '(?msU)^.*tcp .*:1234 .* LISTEN.*' and cmds 'netstat -tapn'`
 	c.Assert(called, check.Equals, expectedCalled, check.Commentf("Expected call to ForCommand didn't happen"))
 }
 

=== modified file 'cmd/snappy/cmd_info.go'
--- cmd/snappy/cmd_info.go	2015-10-01 19:28:27 +0000
+++ cmd/snappy/cmd_info.go	2015-10-22 07:06:04 +0000
@@ -30,8 +30,9 @@
 )
 
 type cmdInfo struct {
-	Verbose    bool `short:"v" long:"verbose"`
-	Positional struct {
+	Verbose       bool `short:"v" long:"verbose"`
+	IncludeRemote bool `long:"include-remote"`
+	Positional    struct {
 		PackageName string `positional-arg-name:"package name"`
 	} `positional-args:"yes"`
 }
@@ -56,19 +57,28 @@
 		logger.Panicf("Unable to info: %v", err)
 	}
 	addOptionDescription(arg, "verbose", i18n.G("Provides more detailed information"))
+	addOptionDescription(arg, "include-remote", i18n.G("Include information about packages from the snappy store"))
 	addOptionDescription(arg, "package name", i18n.G("Provide information about a specific installed package"))
 }
 
 func (x *cmdInfo) Execute(args []string) (err error) {
 	if x.Positional.PackageName != "" {
-		return snapInfo(x.Positional.PackageName, x.Verbose)
+		return snapInfo(x.Positional.PackageName, x.IncludeRemote, x.Verbose)
 	}
 
 	return info()
 }
 
-func snapInfo(pkgname string, verbose bool) error {
+func snapInfo(pkgname string, includeStore, verbose bool) error {
 	snap := snappy.ActiveSnapByName(pkgname)
+	if snap == nil && includeStore {
+		m := snappy.NewUbuntuStoreSnapRepository()
+		snaps, err := m.Details(snappy.SplitOrigin(pkgname))
+		if err == nil && len(snaps) == 1 {
+			snap = snaps[0]
+		}
+	}
+
 	if snap == nil {
 		return fmt.Errorf("No snap '%s' found", pkgname)
 	}

=== modified file 'cmd/snappy/common_test.go'
--- cmd/snappy/common_test.go	2015-07-09 06:05:53 +0000
+++ cmd/snappy/common_test.go	2015-10-22 07:06:04 +0000
@@ -23,8 +23,9 @@
 	"testing"
 
 	"github.com/jessevdk/go-flags"
-
 	. "gopkg.in/check.v1"
+
+	"launchpad.net/snappy/logger"
 )
 
 // Hook up check.v1 into the "go test" runner
@@ -66,6 +67,10 @@
 }
 
 func (s *CmdTestSuite) TestAddOptionDescriptionOrPanicWillPanic(c *C) {
+	// disable logging so log doesn't scare people
+	logger.SetLogger(logger.NullLogger)
+	defer func() { c.Check(logger.SimpleSetup(), IsNil) }()
+
 	parser := flags.NewParser(&struct{}{}, 0)
 	arg, err := parser.AddCommand("mock", "shortHelp", "longHelp", &struct{}{})
 	c.Assert(err, IsNil)

=== modified file 'coreconfig/config.go'
--- coreconfig/config.go	2015-09-18 15:16:17 +0000
+++ coreconfig/config.go	2015-10-22 07:06:04 +0000
@@ -20,12 +20,15 @@
 package coreconfig
 
 import (
+	"bufio"
+	"bytes"
 	"errors"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"reflect"
+	"sort"
 	"strings"
 	"syscall"
 
@@ -52,6 +55,7 @@
 
 var (
 	modprobePath        = "/etc/modprobe.d/ubuntu-core.conf"
+	modulesPath         = "/etc/modules-load.d/ubuntu-core.conf"
 	interfacesRoot      = "/etc/network/interfaces.d/"
 	pppRoot             = "/etc/ppp/"
 	watchdogConfigPath  = "/etc/watchdog.conf"
@@ -73,6 +77,7 @@
 	Timezone  *string         `yaml:"timezone,omitempty"`
 	Hostname  *string         `yaml:"hostname,omitempty"`
 	Modprobe  *string         `yaml:"modprobe,omitempty"`
+	Modules   []string        `yaml:"load-kernel-modules,omitempty"`
 	Network   *networkConfig  `yaml:"network,omitempty"`
 	Watchdog  *watchdogConfig `yaml:"watchdog,omitempty"`
 }
@@ -119,6 +124,10 @@
 	if err != nil {
 		return nil, err
 	}
+	modules, err := getModules()
+	if err != nil {
+		return nil, err
+	}
 	interfaces, err := getInterfaces()
 	if err != nil {
 		return nil, err
@@ -145,6 +154,7 @@
 		Timezone:  &tz,
 		Hostname:  &hostname,
 		Modprobe:  &modprobe,
+		Modules:   modules,
 		Network:   network,
 		Watchdog:  watchdog,
 	}
@@ -244,6 +254,10 @@
 			if err := setModprobe(*newConfig.Modprobe); err != nil {
 				return "", err
 			}
+		case "Modules":
+			if err := setModules(newConfig.Modules); err != nil {
+				return "", err
+			}
 		case "Network":
 			if oldConfig.Network == nil || !passthroughEqual(oldConfig.Network.Interfaces, newConfig.Network.Interfaces) {
 				if err := setInterfaces(newConfig.Network.Interfaces); err != nil {
@@ -297,7 +311,7 @@
 		return err
 	}
 
-	return ioutil.WriteFile(tzFile(), []byte(timezone), 0644)
+	return helpers.AtomicWriteFile(tzFile(), []byte(timezone), 0644)
 }
 
 func getPassthrough(rootDir string) (pc []passthroughConfig, err error) {
@@ -326,7 +340,7 @@
 			os.Remove(path)
 			continue
 		}
-		if err := ioutil.WriteFile(path, []byte(c.Content), 0644); err != nil {
+		if err := helpers.AtomicWriteFile(path, []byte(c.Content), 0644); err != nil {
 			return err
 		}
 	}
@@ -362,7 +376,94 @@
 
 // setModprobe sets the specified modprobe config
 var setModprobe = func(modprobe string) error {
-	return ioutil.WriteFile(modprobePath, []byte(modprobe), 0644)
+	return helpers.AtomicWriteFile(modprobePath, []byte(modprobe), 0644)
+}
+
+func getModules() ([]string, error) {
+	f, err := os.Open(modulesPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+
+		return nil, err
+	}
+
+	// there's a warning at the top of the file
+	// but you know they're just going to edit it anyway
+	// so be kind
+
+	var modules []string
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if len(line) == 0 {
+			continue
+		}
+		if line[0] == '#' || line[0] == ';' {
+			continue
+		}
+
+		modules = append(modules, line)
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+
+	// doing the sort on get makes testing easier
+	sort.Strings(modules)
+
+	return modules, nil
+}
+
+const modulesHeader = `#
+# DO NOT EDIT THIS FILE
+# it is auto-generated, and will be overwritten.
+`
+
+func setModules(modules []string) error {
+	oldModules, err := getModules()
+	if err != nil {
+		return err
+	}
+
+	for i := range modules {
+		m := strings.TrimSpace(modules[i])
+		if len(m) == 0 {
+			continue
+		}
+
+		if m[0] == '-' {
+			m = m[1:]
+			idx := sort.SearchStrings(oldModules, m)
+			if idx == len(oldModules) || oldModules[idx] != m {
+				// not found
+				continue
+			}
+			oldModules = append(oldModules[:idx], oldModules[idx+1:]...)
+		} else {
+			idx := sort.SearchStrings(oldModules, m)
+			if idx < len(oldModules) && oldModules[idx] == m {
+				// already got it
+				continue
+			}
+			oldModules = append(oldModules, "")
+			copy(oldModules[idx+1:], oldModules[idx:])
+			oldModules[idx] = m
+		}
+	}
+
+	var buf bytes.Buffer
+
+	// bytes' Write* methods always return nil error
+	buf.WriteString(modulesHeader)
+
+	for i := range oldModules {
+		buf.WriteString(oldModules[i])
+		buf.WriteByte('\n')
+	}
+
+	return helpers.AtomicWriteFile(modulesPath, buf.Bytes(), 0644)
 }
 
 // getWatchdog returns the current watchdog config
@@ -388,11 +489,11 @@
 
 // setWatchdog sets the specified watchdog config
 var setWatchdog = func(wf *watchdogConfig) error {
-	if err := ioutil.WriteFile(watchdogStartupPath, []byte(wf.Startup), 0644); err != nil {
+	if err := helpers.AtomicWriteFile(watchdogStartupPath, []byte(wf.Startup), 0644); err != nil {
 		return err
 	}
 
-	return ioutil.WriteFile(watchdogConfigPath, []byte(wf.Config), 0644)
+	return helpers.AtomicWriteFile(watchdogConfigPath, []byte(wf.Config), 0644)
 }
 
 // for testing purposes
@@ -467,5 +568,5 @@
 		return err
 	}
 
-	return ioutil.WriteFile(hostnamePath, hostnameB, 0644)
+	return helpers.AtomicWriteFile(hostnamePath, hostnameB, 0644)
 }

=== modified file 'coreconfig/config_test.go'
--- coreconfig/config_test.go	2015-09-21 15:14:41 +0000
+++ coreconfig/config_test.go	2015-10-22 07:06:04 +0000
@@ -51,6 +51,7 @@
 	originalCmdSystemctl        = cmdSystemctl
 	originalHostnamePath        = hostnamePath
 	originalModprobePath        = modprobePath
+	originalModulesPath         = modulesPath
 	originalInterfacesRoot      = interfacesRoot
 	originalPppRoot             = pppRoot
 	originalWatchdogStartupPath = watchdogStartupPath
@@ -107,6 +108,7 @@
 	cmdAutopilotEnabled = originalCmdAutopilotEnabled
 	cmdSystemctl = originalCmdSystemctl
 	modprobePath = originalModprobePath
+	modulesPath = originalModulesPath
 	interfacesRoot = originalInterfacesRoot
 	pppRoot = originalPppRoot
 	watchdogStartupPath = originalWatchdogStartupPath
@@ -489,12 +491,195 @@
 	_, err := Set(input)
 	c.Assert(err, IsNil)
 
-	// ensure its really there
+	// ensure it's really there
 	content, err := ioutil.ReadFile(modprobePath)
 	c.Assert(err, IsNil)
 	c.Assert(string(content), Equals, "blacklist floppy\nsoftdep mlx4_core post: mlx4_en\n")
 }
 
+func (cts *ConfigTestSuite) TestModules(c *C) {
+	modulesPath = filepath.Join(c.MkDir(), "test.conf")
+
+	modules, err := getModules()
+	c.Assert(err, IsNil)
+	c.Check(modules, HasLen, 0)
+
+	c.Assert(setModules([]string{"foo"}), IsNil)
+
+	modules, err = getModules()
+	c.Assert(err, IsNil)
+	c.Check(modules, DeepEquals, []string{"foo"})
+
+	c.Assert(setModules([]string{"bar"}), IsNil)
+
+	modules, err = getModules()
+	c.Assert(err, IsNil)
+	c.Check(modules, DeepEquals, []string{"bar", "foo"})
+
+	c.Assert(setModules([]string{"-foo"}), IsNil)
+
+	modules, err = getModules()
+	c.Assert(err, IsNil)
+	c.Check(modules, DeepEquals, []string{"bar"})
+}
+
+func (cts *ConfigTestSuite) TestModulesRemoveAbsent(c *C) {
+	modulesPath = filepath.Join(c.MkDir(), "test.conf")
+
+	c.Assert(setModules([]string{"foo"}), IsNil)
+	c.Assert(setModules([]string{"-bar"}), IsNil)
+
+	modules, err := getModules()
+	c.Assert(err, IsNil)
+	c.Check(modules, DeepEquals, []string{"foo"})
+}
+
+func (cts *ConfigTestSuite) TestModulesRemoveEmpty(c *C) {
+	modulesPath = filepath.Join(c.MkDir(), "test.conf")
+
+	c.Assert(setModules([]string{"foo"}), IsNil)
+	c.Assert(setModules([]string{"-"}), IsNil)
+
+	modules, err := getModules()
+	c.Assert(err, IsNil)
+	c.Check(modules, DeepEquals, []string{"foo"})
+}
+
+func (cts *ConfigTestSuite) TestModulesRemoveBlank(c *C) {
+	modulesPath = filepath.Join(c.MkDir(), "test.conf")
+
+	c.Assert(setModules([]string{"foo"}), IsNil)
+	c.Assert(setModules([]string{"- "}), IsNil)
+
+	modules, err := getModules()
+	c.Assert(err, IsNil)
+	c.Check(modules, DeepEquals, []string{"foo"})
+}
+
+func (cts *ConfigTestSuite) TestModulesAddDupe(c *C) {
+	modulesPath = filepath.Join(c.MkDir(), "test.conf")
+
+	c.Assert(setModules([]string{"foo"}), IsNil)
+	c.Assert(setModules([]string{"foo"}), IsNil)
+
+	modules, err := getModules()
+	c.Assert(err, IsNil)
+	c.Check(modules, DeepEquals, []string{"foo"})
+}
+
+func (cts *ConfigTestSuite) TestModulesAddEmpty(c *C) {
+	modulesPath = filepath.Join(c.MkDir(), "test.conf")
+
+	c.Assert(setModules([]string{"foo"}), IsNil)
+	c.Assert(setModules([]string{""}), IsNil)
+
+	modules, err := getModules()
+	c.Assert(err, IsNil)
+	c.Check(modules, DeepEquals, []string{"foo"})
+}
+
+func (cts *ConfigTestSuite) TestModulesAddBlank(c *C) {
+	modulesPath = filepath.Join(c.MkDir(), "test.conf")
+
+	c.Assert(setModules([]string{"foo"}), IsNil)
+	c.Assert(setModules([]string{" "}), IsNil)
+
+	modules, err := getModules()
+	c.Assert(err, IsNil)
+	c.Check(modules, DeepEquals, []string{"foo"})
+}
+
+func (cts *ConfigTestSuite) TestModulesHasWarning(c *C) {
+	modulesPath = filepath.Join(c.MkDir(), "test.conf")
+
+	c.Assert(setModules([]string{"foo"}), IsNil)
+
+	bs, err := ioutil.ReadFile(modulesPath)
+	c.Assert(err, IsNil)
+	c.Check(string(bs), Matches, `(?s).*DO NOT EDIT.*`)
+}
+
+func (cts *ConfigTestSuite) TestModulesIsKind(c *C) {
+	modulesPath = filepath.Join(c.MkDir(), "test.conf")
+	c.Assert(ioutil.WriteFile(modulesPath, []byte(`# hello
+# this is what happens when soembody comes and edits the file
+# just to be sure
+; modules-load.d(5) says comments can also start with a ;
+  ; actually not even start
+  # it's the first non-whitespace that counts
+#    also here's an empty line:
+
+# and here's a module with spurious whitespace:
+  oops
+# that is all. Have a good day.
+`), 0644), IsNil)
+
+	modules, err := getModules()
+	c.Check(err, IsNil)
+	c.Check(modules, DeepEquals, []string{"oops"})
+}
+
+func (cts *ConfigTestSuite) TestModulesYaml(c *C) {
+	modulesPath = filepath.Join(c.MkDir(), "test.conf")
+
+	c.Assert(setModules([]string{"foo"}), IsNil)
+
+	cfg, err := newSystemConfig()
+	c.Assert(err, IsNil)
+	c.Check(cfg.Modules, DeepEquals, []string{"foo"})
+
+	input := `config:
+  ubuntu-core:
+    load-kernel-modules: [-foo, bar]
+`
+	_, err = Set(input)
+	c.Assert(err, IsNil)
+
+	// ensure it's really there
+	content, err := ioutil.ReadFile(modulesPath)
+	c.Assert(err, IsNil)
+	c.Assert(string(content), Matches, `(?sm).*^bar$.*`)
+
+	modules, err := getModules()
+	c.Assert(err, IsNil)
+	c.Check(modules, DeepEquals, []string{"bar"})
+}
+
+func (cts *ConfigTestSuite) TestModulesErrorWrite(c *C) {
+	// modulesPath is not writable, but only notexist read error
+	modulesPath = filepath.Join(c.MkDir(), "not-there", "test.conf")
+
+	c.Check(setModules([]string{"bar"}), NotNil)
+
+	input := `config:
+  ubuntu-core:
+    load-kernel-modules: [foo]
+`
+	_, err := Set(input)
+	c.Check(err, NotNil)
+
+	_, err = getModules()
+	c.Check(err, IsNil)
+
+	_, err = newSystemConfig()
+	c.Check(err, IsNil)
+}
+
+func (cts *ConfigTestSuite) TestModulesErrorRW(c *C) {
+	modulesPath = c.MkDir()
+
+	modules, err := getModules()
+	c.Check(err, NotNil)
+	c.Check(modules, HasLen, 0)
+	c.Check(setModules([]string{"bar"}), NotNil)
+
+	_, err = newSystemConfig()
+	c.Check(err, NotNil)
+
+	_, err = Set("config: {ubuntu-core: {modules: [foo]}}")
+	c.Check(err, NotNil)
+}
+
 func (cts *ConfigTestSuite) TestNetworkGet(c *C) {
 	path := filepath.Join(interfacesRoot, "eth0")
 	content := "auto eth0"
@@ -573,7 +758,7 @@
 	_, err := Set(input)
 	c.Assert(err, IsNil)
 
-	// ensure its really there
+	// ensure it's really there
 	content, err := ioutil.ReadFile(filepath.Join(interfacesRoot, "eth0"))
 	c.Assert(err, IsNil)
 	c.Assert(string(content), Equals, "auto dhcp")
@@ -593,7 +778,7 @@
 	_, err := Set(input)
 	c.Assert(err, IsNil)
 
-	// ensure its really there
+	// ensure it's really there
 	content, err := ioutil.ReadFile(filepath.Join(pppRoot, "chap-secret"))
 	c.Assert(err, IsNil)
 	c.Assert(string(content), Equals, "password")
@@ -670,7 +855,7 @@
 	_, err := Set(input)
 	c.Assert(err, IsNil)
 
-	// ensure its really there
+	// ensure it's really there
 	content, err := ioutil.ReadFile(watchdogStartupPath)
 	c.Assert(err, IsNil)
 	c.Assert(string(content), Equals, "some startup")

=== modified file 'daemon/api.go'
--- daemon/api.go	2015-10-11 15:32:36 +0000
+++ daemon/api.go	2015-10-22 07:06:04 +0000
@@ -80,6 +80,7 @@
 		Path: "/1.0/packages",
 		GET:  getPackagesInfo,
 		POST: sideloadPackage,
+		PUT:  configMulti,
 	}
 
 	packageCmd = &Command{
@@ -112,8 +113,9 @@
 	}
 
 	operationCmd = &Command{
-		Path: "/1.0/operations/{uuid}",
-		GET:  getOpInfo,
+		Path:   "/1.0/operations/{uuid}",
+		GET:    getOpInfo,
+		DELETE: deleteOp,
 	}
 )
 
@@ -424,9 +426,13 @@
 	pkgName := name + "." + origin
 
 	bag := lightweight.PartBagByName(name, origin)
+	if bag == nil {
+		return NotFound
+	}
+
 	idx := bag.ActiveIndex()
 	if idx < 0 {
-		return NotFound
+		return BadRequest
 	}
 
 	part, err := bag.Load(idx)
@@ -447,6 +453,59 @@
 	return SyncResponse(config)
 }
 
+type configSubtask struct {
+	Status string      `json:"status"`
+	Output interface{} `json:"output"`
+}
+
+func configMulti(c *Command, r *http.Request) Response {
+	route := c.d.router.Get(operationCmd.Path)
+	if route == nil {
+		return InternalError(nil, "router can't find route for operation")
+	}
+
+	decoder := json.NewDecoder(r.Body)
+	var pkgmap map[string]string
+	if err := decoder.Decode(&pkgmap); err != nil {
+		return BadRequest(err, "can't decode request body into map[string]string: %v", err)
+	}
+
+	return AsyncResponse(c.d.AddTask(func() interface{} {
+		rspmap := make(map[string]*configSubtask, len(pkgmap))
+		bags := lightweight.AllPartBags()
+		for pkg, cfg := range pkgmap {
+			out := errorResult{}
+			sub := configSubtask{Status: TaskFailed, Output: &out}
+			rspmap[pkg] = &sub
+			bag, ok := bags[pkg]
+			if !ok {
+				out.Str = snappy.ErrPackageNotFound.Error()
+				out.Obj = snappy.ErrPackageNotFound
+				continue
+			}
+
+			part, _ := bag.Load(bag.ActiveIndex())
+			if part == nil {
+				out.Str = snappy.ErrSnapNotActive.Error()
+				out.Obj = snappy.ErrSnapNotActive
+				continue
+			}
+
+			config, err := part.Config([]byte(cfg))
+			if err != nil {
+				out.Msg = "Config failed"
+				out.Str = err.Error()
+				out.Obj = err
+				continue
+			}
+			sub.Status = TaskSucceeded
+			sub.Output = config
+		}
+
+		return rspmap
+	}).Map(route))
+}
+
 func getOpInfo(c *Command, r *http.Request) Response {
 	route := c.d.router.Get(c.Path)
 	if route == nil {
@@ -462,6 +521,22 @@
 	return SyncResponse(task.Map(route))
 }
 
+func deleteOp(c *Command, r *http.Request) Response {
+	id := muxVars(r)["uuid"]
+	err := c.d.DeleteTask(id)
+
+	switch err {
+	case nil:
+		return SyncResponse("done")
+	case errTaskNotFound:
+		return NotFound
+	case errTaskStillRunning:
+		return BadRequest
+	default:
+		return InternalError(err, "")
+	}
+}
+
 type packageInstruction struct {
 	Action   string `json:"action"`
 	LeaveOld bool   `json:"leave_old"`

=== modified file 'daemon/api_test.go'
--- daemon/api_test.go	2015-10-11 15:32:36 +0000
+++ daemon/api_test.go	2015-10-22 07:06:04 +0000
@@ -27,6 +27,7 @@
 	"go/ast"
 	"go/parser"
 	"go/token"
+	"io"
 	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
@@ -243,7 +244,7 @@
 
 	c.Check(rsp.Type, check.Equals, ResponseTypeError)
 	c.Check(rsp.Status, check.Equals, http.StatusInternalServerError)
-	c.Check(rsp.Result.(map[string]interface{})["msg"], check.Matches, `route can't build URL .*`)
+	c.Check(rsp.Result.(*errorResult).Msg, check.Matches, `route can't build URL .*`)
 }
 
 func (s *apiSuite) TestListIncludesAll(c *check.C) {
@@ -414,6 +415,40 @@
 	}
 }
 
+func (s *apiSuite) TestDeleteOpNotFound(c *check.C) {
+	d := New()
+	d.addRoutes()
+
+	s.vars = map[string]string{"uuid": "42"}
+	rsp := deleteOp(operationCmd, nil).Self(nil, nil).(*resp)
+	c.Check(rsp.Type, check.Equals, ResponseTypeError)
+	c.Check(rsp.Status, check.Equals, http.StatusNotFound)
+}
+
+func (s *apiSuite) TestDeleteOpStillRunning(c *check.C) {
+	d := New()
+	d.addRoutes()
+
+	d.tasks["42"] = &Task{}
+	s.vars = map[string]string{"uuid": "42"}
+	rsp := deleteOp(operationCmd, nil).Self(nil, nil).(*resp)
+	c.Check(rsp.Type, check.Equals, ResponseTypeError)
+	c.Check(rsp.Status, check.Equals, http.StatusBadRequest)
+}
+
+func (s *apiSuite) TestDeleteOp(c *check.C) {
+	d := New()
+	d.addRoutes()
+
+	task := &Task{}
+	d.tasks["42"] = task
+	task.tomb.Kill(nil)
+	s.vars = map[string]string{"uuid": "42"}
+	rsp := deleteOp(operationCmd, nil).Self(nil, nil).(*resp)
+	c.Check(rsp.Type, check.Equals, ResponseTypeSync)
+	c.Check(rsp.Status, check.Equals, http.StatusOK)
+}
+
 func (s *apiSuite) TestGetOpInfoIntegration(c *check.C) {
 	d := New()
 	d.addRoutes()
@@ -575,12 +610,16 @@
 	}
 }
 
-type cfgc struct{ cfg string }
+type cfgc struct {
+	cfg string
+	err error
+	idx int
+}
 
 func (cfgc) IsInstalled(string) bool { return true }
-func (cfgc) ActiveIndex() int        { return 0 }
+func (c cfgc) ActiveIndex() int      { return c.idx }
 func (c cfgc) Load(string) (snappy.Part, error) {
-	return &tP{name: "foo", version: "v1", origin: "bar", isActive: true, config: c.cfg}, nil
+	return &tP{name: "foo", version: "v1", origin: "bar", isActive: true, config: c.cfg, configErr: c.err}, nil
 }
 
 func (s *apiSuite) TestPackageGetConfig(c *check.C) {
@@ -596,7 +635,7 @@
 		lightweight.NewConcrete = oldConcrete
 	}()
 	lightweight.NewConcrete = func(*lightweight.PartBag, string) lightweight.Concreter {
-		return &cfgc{configStr}
+		return &cfgc{cfg: configStr}
 	}
 
 	s.vars = map[string]string{"name": "foo", "origin": "bar"}
@@ -611,6 +650,43 @@
 	})
 }
 
+func (s *apiSuite) TestPackageGetConfigMissing(c *check.C) {
+	s.vars = map[string]string{"name": "foo", "origin": "bar"}
+
+	req, err := http.NewRequest("GET", "/1.0/packages/foo.bar/config", bytes.NewBuffer(nil))
+	c.Assert(err, check.IsNil)
+
+	rsp := packageConfig(packagesCmd, req).Self(nil, nil).(*resp)
+
+	c.Check(rsp.Status, check.Equals, http.StatusNotFound)
+}
+
+func (s *apiSuite) TestPackageGetConfigInactive(c *check.C) {
+	s.vars = map[string]string{"name": "foo", "origin": "bar"}
+
+	s.mkInstalled(c, "foo", "bar", "v1", false, "")
+
+	req, err := http.NewRequest("GET", "/1.0/packages/foo.bar/config", bytes.NewBuffer(nil))
+	c.Assert(err, check.IsNil)
+
+	rsp := packageConfig(packagesCmd, req).Self(nil, nil).(*resp)
+
+	c.Check(rsp.Status, check.Equals, http.StatusBadRequest)
+}
+
+func (s *apiSuite) TestPackageGetConfigNoConfig(c *check.C) {
+	s.vars = map[string]string{"name": "foo", "origin": "bar"}
+
+	s.mkInstalled(c, "foo", "bar", "v1", true, "")
+
+	req, err := http.NewRequest("GET", "/1.0/packages/foo.bar/config", bytes.NewBuffer(nil))
+	c.Assert(err, check.IsNil)
+
+	rsp := packageConfig(packagesCmd, req).Self(nil, nil).(*resp)
+
+	c.Check(rsp.Status, check.Equals, http.StatusInternalServerError)
+}
+
 func (s *apiSuite) TestPackagePutConfig(c *check.C) {
 	d := New()
 	d.addRoutes()
@@ -625,13 +701,13 @@
 		lightweight.NewConcrete = oldConcrete
 	}()
 	lightweight.NewConcrete = func(*lightweight.PartBag, string) lightweight.Concreter {
-		return &cfgc{configStr}
+		return &cfgc{cfg: configStr}
 	}
 
 	s.vars = map[string]string{"name": "foo", "origin": "bar"}
 	s.mkInstalled(c, "foo", "bar", "v1", true, "")
 
-	rsp := packageConfig(packagesCmd, req).Self(nil, nil).(*resp)
+	rsp := packageConfig(packageConfigCmd, req).Self(nil, nil).(*resp)
 
 	c.Check(rsp, check.DeepEquals, &resp{
 		Type:   ResponseTypeSync,
@@ -640,6 +716,147 @@
 	})
 }
 
+func (s *apiSuite) TestPackagePutConfigMissing(c *check.C) {
+	s.vars = map[string]string{"name": "foo", "origin": "bar"}
+
+	req, err := http.NewRequest("PUT", "/1.0/packages/foo.bar/config", bytes.NewBuffer(nil))
+	c.Assert(err, check.IsNil)
+
+	rsp := packageConfig(packagesCmd, req).Self(nil, nil).(*resp)
+
+	c.Check(rsp.Status, check.Equals, http.StatusNotFound)
+}
+
+func (s *apiSuite) TestPackagePutConfigInactive(c *check.C) {
+	s.vars = map[string]string{"name": "foo", "origin": "bar"}
+
+	s.mkInstalled(c, "foo", "bar", "v1", false, "")
+
+	req, err := http.NewRequest("PUT", "/1.0/packages/foo.bar/config", bytes.NewBuffer(nil))
+	c.Assert(err, check.IsNil)
+
+	rsp := packageConfig(packagesCmd, req).Self(nil, nil).(*resp)
+
+	c.Check(rsp.Status, check.Equals, http.StatusBadRequest)
+}
+
+func (s *apiSuite) TestPackagePutConfigNoConfig(c *check.C) {
+	s.vars = map[string]string{"name": "foo", "origin": "bar"}
+
+	s.mkInstalled(c, "foo", "bar", "v1", true, "")
+
+	req, err := http.NewRequest("PUT", "/1.0/packages/foo.bar/config", bytes.NewBuffer(nil))
+	c.Assert(err, check.IsNil)
+
+	rsp := packageConfig(packagesCmd, req).Self(nil, nil).(*resp)
+
+	c.Check(rsp.Status, check.Equals, http.StatusInternalServerError)
+}
+
+func (s *apiSuite) TestConfigMultiBadBody(c *check.C) {
+	d := New()
+	d.addRoutes()
+
+	req, err := http.NewRequest("PUT", "/1.0/packages", bytes.NewBuffer(nil))
+	c.Assert(err, check.IsNil)
+	rsp := configMulti(packagesCmd, req).Self(nil, nil).(*resp)
+	c.Check(rsp.Status, check.Equals, http.StatusBadRequest)
+}
+
+func (s *apiSuite) TestPackagesPutStr(c *check.C) {
+	newConfigs := map[string]string{"foo.bar": "some other config", "baz.qux": "stuff", "missing.pkg": "blah blah"}
+	bs, err := json.Marshal(newConfigs)
+	c.Assert(err, check.IsNil)
+	s.genericTestPackagePut(c, bytes.NewBuffer(bs), 2, map[string]*configSubtask{
+		"foo.bar":     &configSubtask{Status: TaskSucceeded, Output: "some other config"},
+		"baz.qux":     &configSubtask{Status: TaskFailed, Output: &errorResult{Str: snappy.ErrConfigNotFound.Error(), Obj: snappy.ErrConfigNotFound, Msg: "Config failed"}},
+		"missing.pkg": &configSubtask{Status: TaskFailed, Output: &errorResult{Str: snappy.ErrPackageNotFound.Error(), Obj: snappy.ErrPackageNotFound}},
+	})
+}
+
+func (s *apiSuite) TestPackagesPutNil(c *check.C) {
+	newConfigs := map[string][]byte{"foo.bar": nil, "mip.brp": nil}
+	bs, err := json.Marshal(newConfigs)
+	c.Assert(err, check.IsNil)
+	s.genericTestPackagePut(c, bytes.NewBuffer(bs), 2, map[string]*configSubtask{
+		"foo.bar": &configSubtask{Status: TaskSucceeded, Output: "some: config"},
+		"mip.brp": &configSubtask{Status: TaskFailed, Output: &errorResult{Str: snappy.ErrSnapNotActive.Error(), Obj: snappy.ErrSnapNotActive}},
+	})
+}
+
+func (s *apiSuite) genericTestPackagePut(c *check.C, body io.Reader, concreteNo int, expected map[string]*configSubtask) {
+	d := New()
+	d.addRoutes()
+
+	req, err := http.NewRequest("PUT", "/1.0/packages", body)
+	c.Assert(err, check.IsNil)
+
+	configStr := "some: config"
+	oldConcrete := lightweight.NewConcrete
+	defer func() {
+		lightweight.NewConcrete = oldConcrete
+	}()
+	lightweight.NewConcrete = func(bag *lightweight.PartBag, _ string) lightweight.Concreter {
+		switch bag.Name {
+		case "foo":
+			return &cfgc{cfg: configStr}
+		case "mip":
+			return &cfgc{idx: -1}
+		default:
+			return &cfgc{err: snappy.ErrConfigNotFound}
+		}
+	}
+
+	s.mkInstalled(c, "foo", "bar", "v1", true, "")
+	s.mkInstalled(c, "baz", "qux", "v1", true, "")
+	s.mkInstalled(c, "mip", "brp", "v1", false, "")
+
+	rsp := configMulti(packagesCmd, req).Self(nil, nil).(*resp)
+
+	c.Check(rsp.Type, check.Equals, ResponseTypeAsync)
+	c.Check(rsp.Status, check.Equals, http.StatusAccepted)
+	m := rsp.Result.(map[string]interface{})
+	c.Check(m["resource"], check.Matches, "/1.0/operations/.*")
+
+	uuid := m["resource"].(string)[16:]
+
+	task := d.GetTask(uuid)
+	c.Assert(task, check.NotNil)
+	c.Check(task.State(), check.Equals, TaskRunning)
+
+	// wait up to another ten seconds (!) for the task to finish properly
+	for i := 0; i < 1000; i++ {
+		if d.GetTask(uuid).State() != TaskRunning {
+			break
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+
+	c.Assert(task.State(), check.Equals, TaskSucceeded)
+	out := task.Output().(map[string]*configSubtask)
+	c.Check(out, check.HasLen, len(expected))
+
+	var missing []string
+	for k, v := range out {
+		exp, ok := expected[k]
+		if !ok {
+			missing = append(missing, k)
+			continue
+		}
+
+		c.Check(v.Status, check.Equals, exp.Status, check.Commentf(k))
+		c.Check(v.Output, check.DeepEquals, exp.Output, check.Commentf(k))
+	}
+	c.Check(missing, check.HasLen, 0, check.Commentf("missing from expected"))
+	missing = nil
+	for k := range expected {
+		if _, ok := out[k]; !ok {
+			missing = append(missing, k)
+		}
+	}
+	c.Check(missing, check.HasLen, 0, check.Commentf("missing from obtained"))
+}
+
 func (s *apiSuite) TestPackageServiceGet(c *check.C) {
 	d := New()
 	d.addRoutes()

=== modified file 'daemon/daemon.go'
--- daemon/daemon.go	2015-10-05 23:10:59 +0000
+++ daemon/daemon.go	2015-10-22 07:06:04 +0000
@@ -20,6 +20,7 @@
 package daemon
 
 import (
+	"errors"
 	"fmt"
 	"net"
 	"net/http"
@@ -177,6 +178,27 @@
 	return d.tasks[uuid]
 }
 
+var (
+	errTaskNotFound     = errors.New("task not found")
+	errTaskStillRunning = errors.New("task still running")
+)
+
+// DeleteTask removes a task from the tasks map, by uuid.
+func (d *Daemon) DeleteTask(uuid string) error {
+	d.Lock()
+	defer d.Unlock()
+	task, ok := d.tasks[uuid]
+	if !ok || task == nil {
+		return errTaskNotFound
+	}
+	if task.State() != TaskRunning {
+		delete(d.tasks, uuid)
+		return nil
+	}
+
+	return errTaskStillRunning
+}
+
 // New Daemon
 func New() *Daemon {
 	return &Daemon{

=== modified file 'daemon/response.go'
--- daemon/response.go	2015-10-08 12:52:40 +0000
+++ daemon/response.go	2015-10-22 07:06:04 +0000
@@ -89,22 +89,28 @@
 	return r
 }
 
+type errorResult struct {
+	Str string `json:"str,omitempty"`
+	Msg string `json:"msg,omitempty"`
+	Obj error  `json:"obj,omitempty"`
+}
+
 func (r *resp) SetError(err error, format string, v ...interface{}) Response {
-	m := make(map[string]interface{})
+	m := errorResult{}
 	newr := &resp{
 		Type:   ResponseTypeError,
-		Result: m,
+		Result: &m,
 		Status: r.Status,
 	}
 
 	if format != "" {
 		logger.Noticef(format, v...)
-		m["msg"] = fmt.Sprintf(format, v...)
+		m.Msg = fmt.Sprintf(format, v...)
 	}
 
 	if err != nil {
-		m["obj"] = err
-		m["str"] = err.Error()
+		m.Obj = err
+		m.Str = err.Error()
 	}
 
 	return newr

=== modified file 'daemon/task.go'
--- daemon/task.go	2015-09-15 12:55:09 +0000
+++ daemon/task.go	2015-10-22 07:06:04 +0000
@@ -132,9 +132,9 @@
 
 		if err, ok := out.(error); ok {
 			// // TODO: make errors properly json-serializable, and avoid this hack (loses info!)
-			t.output = map[string]interface{}{
-				"obj": err,
-				"str": err.Error(),
+			t.output = errorResult{
+				Obj: err,
+				Str: err.Error(),
 			}
 			return err
 		}

=== modified file 'daemon/task_test.go'
--- daemon/task_test.go	2015-09-15 12:55:09 +0000
+++ daemon/task_test.go	2015-10-22 07:06:04 +0000
@@ -79,8 +79,8 @@
 	time.Sleep(time.Millisecond)
 
 	c.Check(t.State(), check.Equals, TaskFailed)
-	c.Check(t.Output(), check.DeepEquals, map[string]interface{}{
-		"obj": err,
-		"str": err.Error(),
+	c.Check(t.Output(), check.DeepEquals, errorResult{
+		Obj: err,
+		Str: err.Error(),
 	})
 }

=== modified file 'docs/meta.md'
--- docs/meta.md	2015-09-15 14:53:38 +0000
+++ docs/meta.md	2015-10-22 07:06:04 +0000
@@ -72,10 +72,23 @@
     * `bus-name`: (optional) message bus connection name for the service.
       May only be specified for snaps of 'type: framework' (see above). See
       frameworks.md for details.
-    * `socket`: (optional) Set to "true" is the service is socket activated
-    * `listen-stream`: (optional) The full path of the stream socket
-    * `socket-user`: (optional) The user that owns the stream socket
-    * `socket-group`: (optional) The group that own the stream socket
+    * `socket`: (optional) Set to "true" if the service is socket activated.
+                Must be specified with `listen-stream`.
+    * `listen-stream`: (optional) The full path of the stream socket or an
+                abstract socket. When specifying an absolute path, it should
+                normally be in one of the app-specific writable directories.
+                When specifying an abstract socket, it must start with '@' and
+                typically be followed by either the snap package name or the
+                snap package name followed by '\_' and any other characters
+                (eg, '@name' or '@name\_something').
+    * `socket-user`: (optional) The user that owns the stream socket. The user
+                     should normally match the snap package name. Must be
+                     specified with `listen-stream`. This option is reserved
+                     for future use.
+    * `socket-group`: (optional) The group that own the stream socket. The
+                      group should normally match the snap package name. Must
+                      be specified with `listen-stream`. This option is
+                      reserved for future use.
 
 * `binaries`: the binaries (executables) that the snap provides
     * `name`: (required) the name of the binary, the user will be able to

=== modified file 'helpers/helpers.go'
--- helpers/helpers.go	2015-10-08 06:25:35 +0000
+++ helpers/helpers.go	2015-10-22 07:06:04 +0000
@@ -269,7 +269,7 @@
 const letters = "ABCDEFGHIJKLMNOPQRSTUVWXYabcdefghijklmnopqrstuvwxy"
 
 // MakeRandomString returns a random string of length length
-func MakeRandomString(length int) string {
+var MakeRandomString = func(length int) string {
 
 	out := ""
 	for i := 0; i < length; i++ {
@@ -293,9 +293,12 @@
 }
 
 // AtomicWriteFile updates the filename atomically and works otherwise
-// exactly like io/ioutil.WriteFile()
+// like io/ioutil.WriteFile()
+//
+// Note that it won't follow symlinks and will replace existing symlinks
+// with the real file
 func AtomicWriteFile(filename string, data []byte, perm os.FileMode) (err error) {
-	tmp := filename + ".new"
+	tmp := filename + "." + MakeRandomString(12)
 
 	// XXX: if go switches to use aio_fsync, we need to open the dir for writing
 	dir, err := os.Open(filepath.Dir(filename))
@@ -304,7 +307,7 @@
 	}
 	defer dir.Close()
 
-	fd, err := os.OpenFile(tmp, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
+	fd, err := os.OpenFile(tmp, os.O_WRONLY|os.O_CREATE|os.O_TRUNC|os.O_EXCL, perm)
 	if err != nil {
 		return err
 	}

=== modified file 'helpers/helpers_test.go'
--- helpers/helpers_test.go	2015-10-08 06:33:39 +0000
+++ helpers/helpers_test.go	2015-10-22 07:06:04 +0000
@@ -266,6 +266,24 @@
 	c.Assert(st.Mode()&os.ModePerm, Equals, os.FileMode(0600))
 }
 
+func (ts *HTestSuite) TestAtomicWriteFileNoOverwriteTmpExisting(c *C) {
+	tmpdir := c.MkDir()
+	realMakeRandomString := MakeRandomString
+	defer func() { MakeRandomString = realMakeRandomString }()
+	MakeRandomString = func(n int) string {
+		// chosen by fair dice roll.
+		// guranteed to be random.
+		return "4"
+	}
+
+	p := filepath.Join(tmpdir, "foo")
+	err := ioutil.WriteFile(p+".4", []byte(""), 0644)
+	c.Assert(err, IsNil)
+
+	err = AtomicWriteFile(p, []byte(""), 0600)
+	c.Assert(err, ErrorMatches, "open .*: file exists")
+}
+
 func (ts *HTestSuite) TestCurrentHomeDirHOMEenv(c *C) {
 	tmpdir := c.MkDir()
 
@@ -280,6 +298,9 @@
 
 func (ts *HTestSuite) TestCurrentHomeDirNoHomeEnv(c *C) {
 	oldHome := os.Getenv("HOME")
+	if oldHome == "/sbuild-nonexistent" {
+		c.Skip("running in schroot this test won't work")
+	}
 	defer os.Setenv("HOME", oldHome)
 
 	os.Setenv("HOME", "")

=== modified file 'i18n/i18n.go'
--- i18n/i18n.go	2015-06-30 10:38:55 +0000
+++ i18n/i18n.go	2015-10-22 07:06:04 +0000
@@ -25,6 +25,9 @@
 	"github.com/gosexy/gettext"
 )
 
+// TEXTDOMAIN is the message domain used by snappy; see dgettext(3)
+// for more information.
+//
 // Note that we have to use dgettext() here because we are a library
 // and we can not use getext.Textdomain() as this would override the
 // applications default

=== modified file 'pkg/remote/remote.go'
--- pkg/remote/remote.go	2015-10-05 22:15:59 +0000
+++ pkg/remote/remote.go	2015-10-22 07:06:04 +0000
@@ -27,6 +27,7 @@
 type Snap struct {
 	Alias           string             `json:"alias,omitempty"`
 	AnonDownloadURL string             `json:"anon_download_url,omitempty"`
+	Channel         string             `json:"channel,omitempty"`
 	DownloadSha512  string             `json:"download_sha512,omitempty"`
 	Description     string             `json:"description,omitempty"`
 	DownloadSize    int64              `json:"binary_filesize,omitempty"`

=== modified file 'po/de.po'
--- po/de.po	2015-10-06 06:22:45 +0000
+++ po/de.po	2015-10-22 07:06:04 +0000
@@ -7,15 +7,15 @@
 msgstr ""
 "Project-Id-Version: snappy\n"
 "Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>\n"
-"POT-Creation-Date: 2015-09-29 10:18+0100\n"
+"POT-Creation-Date: 2015-10-15 15:53+0200\n"
 "PO-Revision-Date: 2015-09-02 22:57+0000\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: German <[e-mail]>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"X-Launchpad-Export-Date: 2015-10-06 06:22+0000\n"
-"X-Generator: Launchpad (build 17796)\n"
+"X-Launchpad-Export-Date: 2015-10-21 06:21+0000\n"
+"X-Generator: Launchpad (build 17812)\n"
 
 #. TRANSLATORS: the %s is a pkgname, the second a comma separated list of paths
 #, c-format
@@ -132,6 +132,9 @@
 msgid "Generated '%s' snap\n"
 msgstr ""
 
+msgid "Include information about packages from the snappy store"
+msgstr ""
+
 msgid "Install a snap package"
 msgstr ""
 

=== modified file 'po/es.po'
--- po/es.po	2015-10-06 06:22:45 +0000
+++ po/es.po	2015-10-22 07:06:04 +0000
@@ -7,15 +7,15 @@
 msgstr ""
 "Project-Id-Version: snappy\n"
 "Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>\n"
-"POT-Creation-Date: 2015-09-29 10:18+0100\n"
+"POT-Creation-Date: 2015-10-15 15:53+0200\n"
 "PO-Revision-Date: 2015-09-13 12:42+0000\n"
 "Last-Translator: Adolfo Jayme <[e-mail]>\n"
 "Language-Team: Spanish <[e-mail]>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"X-Launchpad-Export-Date: 2015-10-06 06:22+0000\n"
-"X-Generator: Launchpad (build 17796)\n"
+"X-Launchpad-Export-Date: 2015-10-21 06:21+0000\n"
+"X-Generator: Launchpad (build 17812)\n"
 
 #. TRANSLATORS: the %s is a pkgname, the second a comma separated list of paths
 #, c-format
@@ -142,6 +142,9 @@
 msgid "Generated '%s' snap\n"
 msgstr "Snap «%s» generado\n"
 
+msgid "Include information about packages from the snappy store"
+msgstr ""
+
 msgid "Install a snap package"
 msgstr "Instalar un paquete snap"
 

=== modified file 'po/gl.po'
--- po/gl.po	2015-10-11 05:37:57 +0000
+++ po/gl.po	2015-10-22 07:06:04 +0000
@@ -7,15 +7,15 @@
 msgstr ""
 "Project-Id-Version: snappy\n"
 "Report-Msgid-Bugs-To: FULL NAME <EMAIL@ADDRESS>\n"
-"POT-Creation-Date: 2015-09-29 10:18+0100\n"
-"PO-Revision-Date: 2015-10-10 05:33+0000\n"
+"POT-Creation-Date: 2015-10-15 15:53+0200\n"
+"PO-Revision-Date: 2015-10-21 16:12+0000\n"
 "Last-Translator: Marcos Lans <Unknown>\n"
 "Language-Team: Galician <[e-mail]>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"X-Launchpad-Export-Date: 2015-10-11 05:37+0000\n"
-"X-Generator: Launchpad (build 17802)\n"
+"X-Launchpad-Export-Date: 2015-10-22 05:57+0000\n"
+"X-Generator: Launchpad (build 17812)\n"
 
 #. TRANSLATORS: the %s is a pkgname, the second a comma separated list of paths
 #, c-format
@@ -159,6 +159,9 @@
 msgid "Generated '%s' snap\n"
 msgstr "Xerado o paquete snap de «%s»\n"
 
+msgid "Include information about packages from the snappy store"
+msgstr "Incluír información sobre paquetes da tenda de snappy"
+
 msgid "Install a snap package"
 msgstr "Instalar un paquete snap"
 

=== modified file 'po/snappy.pot'
--- po/snappy.pot	2015-09-29 09:45:15 +0000
+++ po/snappy.pot	2015-10-22 07:06:04 +0000
@@ -7,7 +7,7 @@
 msgid   ""
 msgstr  "Project-Id-Version: snappy\n"
         "Report-Msgid-Bugs-To: [e-mail]\n"
-        "POT-Creation-Date: 2015-09-29 10:18+0100\n"
+        "POT-Creation-Date: 2015-10-15 15:53+0200\n"
         "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
         "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
         "Language-Team: LANGUAGE <[e-mail]>\n"
@@ -113,6 +113,9 @@
 msgid   "Generated '%s' snap\n"
 msgstr  ""
 
+msgid   "Include information about packages from the snappy store"
+msgstr  ""
+
 msgid   "Install a snap package"
 msgstr  ""
 

=== modified file 'snappy/click.go'
--- snappy/click.go	2015-10-07 15:47:01 +0000
+++ snappy/click.go	2015-10-22 07:06:04 +0000
@@ -758,7 +758,7 @@
 	if err != nil {
 		return err
 	}
-	if err := ioutil.WriteFile(filepath.Join(clickMetaDir, cm.Name+".manifest"), []byte(outStr), 0644); err != nil {
+	if err := helpers.AtomicWriteFile(filepath.Join(clickMetaDir, cm.Name+".manifest"), []byte(outStr), 0644); err != nil {
 		return err
 	}
 

=== modified file 'snappy/click_test.go'
--- snappy/click_test.go	2015-10-10 13:27:50 +0000
+++ snappy/click_test.go	2015-10-22 07:06:04 +0000
@@ -1645,3 +1645,31 @@
 	c.Assert(err, IsNil)
 	c.Assert(generatedWrapper, Equals, expectedSocketUsingWrapper)
 }
+
+func (s *SnapTestSuite) TestWriteCompatManifestJSON(c *C) {
+	manifest := []byte(`{
+    "name": "hello-world"
+}
+`)
+	manifestJSON := filepath.Join(s.tempdir, "hello-world.some-origin.manifest")
+
+	err := writeCompatManifestJSON(s.tempdir, manifest, "some-origin")
+	c.Assert(err, IsNil)
+	c.Assert(helpers.FileExists(manifestJSON), Equals, true)
+}
+
+func (s *SnapTestSuite) TestWriteCompatManifestJSONNoFollow(c *C) {
+	manifest := []byte(`{
+    "name": "hello-world"
+}
+`)
+	manifestJSON := filepath.Join(s.tempdir, "hello-world.some-origin.manifest")
+	symlinkTarget := filepath.Join(s.tempdir, "symlink-target")
+	os.Symlink(symlinkTarget, manifestJSON)
+	c.Assert(helpers.FileExists(symlinkTarget), Equals, false)
+
+	err := writeCompatManifestJSON(s.tempdir, manifest, "some-origin")
+	c.Assert(err, IsNil)
+	c.Check(helpers.FileExists(manifestJSON), Equals, true)
+	c.Check(helpers.FileExists(symlinkTarget), Equals, false)
+}

=== modified file 'snappy/common_test.go'
--- snappy/common_test.go	2015-10-10 13:27:50 +0000
+++ snappy/common_test.go	2015-10-22 07:06:04 +0000
@@ -108,6 +108,7 @@
 		Origin:      origin,
 		Version:     version,
 		Description: desc,
+		Channel:     "remote-channel",
 	})
 	if err != nil {
 		return err

=== modified file 'snappy/install_test.go'
--- snappy/install_test.go	2015-09-29 07:07:13 +0000
+++ snappy/install_test.go	2015-10-22 07:06:04 +0000
@@ -249,12 +249,9 @@
 	}
 	defer func() { newPartition = newPartitionImpl }()
 
-	tempdir := c.MkDir()
-	systemImageRoot = tempdir
-
-	makeFakeSystemImageChannelConfig(c, filepath.Join(tempdir, systemImageChannelConfig), "1")
+	makeFakeSystemImageChannelConfig(c, filepath.Join(dirs.GlobalRootDir, systemImageChannelConfig), "1")
 	// setup fake /other partition
-	makeFakeSystemImageChannelConfig(c, filepath.Join(tempdir, "other", systemImageChannelConfig), "2")
+	makeFakeSystemImageChannelConfig(c, filepath.Join(dirs.GlobalRootDir, "other", systemImageChannelConfig), "2")
 
 	siServer := runMockSystemImageWebServer()
 	defer siServer.Close()

=== modified file 'snappy/parts.go'
--- snappy/parts.go	2015-10-07 16:07:35 +0000
+++ snappy/parts.go	2015-10-22 07:06:04 +0000
@@ -257,7 +257,8 @@
 	return res, nil
 }
 
-// ActiveSnapNamesByType returns all installed snap names with the given type
+// ActiveSnapIterByType returns the result of applying the given
+// function to all active snaps with the given type.
 var ActiveSnapIterByType = activeSnapIterByTypeImpl
 
 func activeSnapIterByTypeImpl(f func(Part) string, snapTs ...pkg.Type) ([]string, error) {
@@ -293,7 +294,7 @@
 // FindSnapsByName returns all snaps with the given name in the "haystack"
 // slice of parts (useful for filtering)
 func FindSnapsByName(needle string, haystack []Part) (res []Part) {
-	name, origin := splitOrigin(needle)
+	name, origin := SplitOrigin(needle)
 	ignorens := origin == ""
 
 	for _, part := range haystack {
@@ -305,7 +306,8 @@
 	return res
 }
 
-func splitOrigin(name string) (string, string) {
+// SplitOrigin splits a snappy name name into a (name, origin) pair
+func SplitOrigin(name string) (string, string) {
 	idx := strings.LastIndexAny(name, ".")
 	if idx > -1 {
 		return name[:idx], name[idx+1:]
@@ -317,7 +319,7 @@
 // FindSnapsByNameAndVersion returns the parts with the name/version in the
 // given slice of parts
 func FindSnapsByNameAndVersion(needle, version string, haystack []Part) []Part {
-	name, origin := splitOrigin(needle)
+	name, origin := SplitOrigin(needle)
 	ignorens := origin == ""
 	var found []Part
 

=== modified file 'snappy/snapp.go'
--- snappy/snapp.go	2015-10-10 13:35:00 +0000
+++ snappy/snapp.go	2015-10-22 07:06:04 +0000
@@ -706,8 +706,12 @@
 
 // Channel returns the channel used
 func (s *SnapPart) Channel() string {
-	// FIXME: real channel support
-	return "edge"
+	if r := s.remoteM; r != nil {
+		return r.Channel
+	}
+
+	// default for compat with older installs
+	return "stable"
 }
 
 // Icon returns the path to the icon
@@ -1468,8 +1472,7 @@
 
 // Channel returns the channel used
 func (s *RemoteSnapPart) Channel() string {
-	// FIXME: real channel support, this requires server work
-	return "edge"
+	return s.pkg.Channel
 }
 
 // Icon returns the icon
@@ -1754,6 +1757,7 @@
 	req.Header.Set("X-Ubuntu-Frameworks", strings.Join(addCoreFmk(frameworks), ","))
 	req.Header.Set("X-Ubuntu-Architecture", string(Architecture()))
 	req.Header.Set("X-Ubuntu-Release", release.String())
+	req.Header.Set("X-Ubuntu-Device-Channel", release.Get().Channel)
 
 	if storeID := os.Getenv("UBUNTU_STORE_ID"); storeID != "" {
 		req.Header.Set("X-Ubuntu-Store", storeID)
@@ -1904,7 +1908,10 @@
 	// sense in sending it our ubuntu-core snap
 	//
 	// NOTE this *will* send .sideload apps to the store.
-	installed, err := ActiveSnapIterByType(FullName, pkg.TypeApp, pkg.TypeFramework, pkg.TypeOem)
+	fullNameWithChannel := func(p Part) string {
+		return fmt.Sprintf("%s/%s", FullName(p), p.Channel())
+	}
+	installed, err := ActiveSnapIterByType(fullNameWithChannel, pkg.TypeApp, pkg.TypeFramework, pkg.TypeOem)
 	if err != nil || len(installed) == 0 {
 		return nil, err
 	}

=== modified file 'snappy/snapp_test.go'
--- snappy/snapp_test.go	2015-10-10 13:27:50 +0000
+++ snappy/snapp_test.go	2015-10-22 07:06:04 +0000
@@ -98,9 +98,6 @@
 	c.Assert(err, IsNil)
 
 	runScFilterGen = mockRunScFilterGen
-
-	// ensure we do not look at the system
-	systemImageRoot = s.tempdir
 }
 
 func (s *SnapTestSuite) TearDownTest(c *C) {
@@ -276,7 +273,7 @@
 `
 
 /* acquired via:
-curl -s --data-binary '{"name":["8nzc1x4iim2xj1g2ul64.chipaca"]}'  -H 'content-type: application/json' https://search.apps.ubuntu.com/api/v1/click-metadata/
+curl -s --data-binary '{"name":["8nzc1x4iim2xj1g2ul64.chipaca"]}'  -H 'content-type: application/json' https://search.apps.ubuntu.com/api/v1/click-metadata
 */
 const MockUpdatesJSON = `[
     {
@@ -322,6 +319,7 @@
     "blacklist_country_codes": [
         "AX"
     ],
+    "channel": "edge",
     "changelog": "",
     "click_framework": [],
     "click_version": "0.1",
@@ -476,8 +474,6 @@
 	c.Check(parts[0].Vendor(), Equals, funkyAppVendor)
 	c.Check(parts[0].Version(), Equals, "42")
 	c.Check(parts[0].Description(), Equals, "Returns for store credit only.")
-
-	c.Check(parts[0].Channel(), Equals, "edge")
 }
 
 func (s *SnapTestSuite) TestUbuntuStoreRepositoryAliasSearch(c *C) {
@@ -513,8 +509,6 @@
 
 	alias := results["hello-world"].Alias
 	c.Assert(alias, DeepEquals, parts[0])
-
-	c.Check(parts[0].Channel(), Equals, "edge")
 }
 func mockActiveSnapIterByType(mockSnaps []string) {
 	ActiveSnapIterByType = func(f func(Part) string, snapTs ...pkg.Type) (res []string, err error) {
@@ -609,6 +603,7 @@
 	c.Check(results[0].Hash(), Equals, "5364253e4a988f4f5c04380086d542f410455b97d48cc6c69ca2a5877d8aef2a6b2b2f83ec4f688cae61ebc8a6bf2cdbd4dbd8f743f0522fc76540429b79df42")
 	c.Check(results[0].Date().String(), Equals, "2015-04-15 18:30:16 +0000 UTC")
 	c.Check(results[0].DownloadSize(), Equals, int64(65375))
+	c.Check(results[0].Channel(), Equals, "edge")
 }
 
 func (s *SnapTestSuite) TestUbuntuStoreRepositoryNoDetails(c *C) {
@@ -1655,3 +1650,11 @@
 
 	c.Check(before, Not(Equals), after)
 }
+
+func (s *SnapTestSuite) TestChannelFromLocalManifest(c *C) {
+	snapYaml, err := s.makeInstalledMockSnap()
+	c.Assert(err, IsNil)
+
+	snap, err := NewInstalledSnapPart(snapYaml, testOrigin)
+	c.Assert(snap.Channel(), Equals, "remote-channel")
+}

=== modified file 'snappy/systemimage.go'
--- snappy/systemimage.go	2015-10-07 15:54:33 +0000
+++ snappy/systemimage.go	2015-10-22 07:06:04 +0000
@@ -31,6 +31,7 @@
 	"github.com/mvo5/goconfigparser"
 
 	"launchpad.net/snappy/coreconfig"
+	"launchpad.net/snappy/dirs"
 	"launchpad.net/snappy/helpers"
 	"launchpad.net/snappy/logger"
 	"launchpad.net/snappy/partition"
@@ -68,10 +69,6 @@
 	systemImageCli = "system-image-cli"
 )
 
-// This is the root directory of the filesystem. Its only useful to
-// change when writing tests
-var systemImageRoot = "/"
-
 // will replace newPartition() to return a mockPartition
 var newPartition = newPartitionImpl
 
@@ -225,7 +222,7 @@
 		// XXX: Note that systemImageDownloadUpdate() requires
 		// the s-i _client_ config file whereas otherIsEmpty()
 		// checks the s-i _channel_ config file.
-		otherConfigFile := filepath.Join(systemImageRoot, otherRoot, systemImageClientConfig)
+		otherConfigFile := filepath.Join(dirs.GlobalRootDir, otherRoot, systemImageClientConfig)
 		if !otherIsEmpty(otherRoot) && helpers.FileExists(otherConfigFile) {
 			configFile = otherConfigFile
 		}
@@ -378,7 +375,7 @@
 
 // Returns the part associated with the current rootfs
 func makeCurrentPart(p partition.Interface) Part {
-	configFile := filepath.Join(systemImageRoot, systemImageChannelConfig)
+	configFile := filepath.Join(dirs.GlobalRootDir, systemImageChannelConfig)
 	part, err := makePartFromSystemImageConfigFile(p, configFile, true)
 	if err != nil {
 		return nil
@@ -395,7 +392,7 @@
 // This function encapsulates the heuristics to determine if the rootfs
 // is complete.
 func otherIsEmpty(root string) bool {
-	configFile := filepath.Join(systemImageRoot, root, systemImageChannelConfig)
+	configFile := filepath.Join(dirs.GlobalRootDir, root, systemImageChannelConfig)
 
 	st, err := os.Stat(configFile)
 
@@ -425,7 +422,7 @@
 			return nil
 		}
 
-		configFile := filepath.Join(systemImageRoot, otherRoot, systemImageChannelConfig)
+		configFile := filepath.Join(dirs.GlobalRootDir, otherRoot, systemImageChannelConfig)
 		part, err = makePartFromSystemImageConfigFile(p, configFile, false)
 		if err != nil {
 			logger.Noticef("Can not make system-image part for %q: %v", configFile, err)
@@ -463,7 +460,7 @@
 
 // Updates returns the available updates
 func (s *SystemImageRepository) Updates() ([]Part, error) {
-	configFile := filepath.Join(systemImageRoot, systemImageChannelConfig)
+	configFile := filepath.Join(dirs.GlobalRootDir, systemImageChannelConfig)
 	updateStatus, err := systemImageClientCheckForUpdates(configFile)
 	if err != nil {
 		return nil, err

=== modified file 'snappy/systemimage_test.go'
--- snappy/systemimage_test.go	2015-10-05 22:01:44 +0000
+++ snappy/systemimage_test.go	2015-10-22 07:06:04 +0000
@@ -28,6 +28,7 @@
 	"strings"
 	"testing"
 
+	"launchpad.net/snappy/dirs"
 	"launchpad.net/snappy/partition"
 	"launchpad.net/snappy/provisioning"
 
@@ -51,13 +52,10 @@
 
 	s.systemImage = NewSystemImageRepository()
 	c.Assert(s, NotNil)
-	// setup alternative root for system image
-	tempdir := c.MkDir()
-	systemImageRoot = tempdir
 
-	makeFakeSystemImageChannelConfig(c, filepath.Join(tempdir, systemImageChannelConfig), "1")
+	makeFakeSystemImageChannelConfig(c, filepath.Join(dirs.GlobalRootDir, systemImageChannelConfig), "1")
 	// setup fake /other partition
-	makeFakeSystemImageChannelConfig(c, filepath.Join(tempdir, "other", systemImageChannelConfig), "0")
+	makeFakeSystemImageChannelConfig(c, filepath.Join(dirs.GlobalRootDir, "other", systemImageChannelConfig), "0")
 
 	// run test webserver instead of talking to the real one
 	//
@@ -66,12 +64,11 @@
 	c.Assert(s.mockSystemImageWebServer, NotNil)
 
 	// create mock system-image-cli
-	systemImageCli = makeMockSystemImageCli(c, tempdir)
+	systemImageCli = makeMockSystemImageCli(c, dirs.GlobalRootDir)
 }
 
 func (s *SITestSuite) TearDownTest(c *C) {
 	s.mockSystemImageWebServer.Close()
-	systemImageRoot = "/"
 	bootloaderDir = bootloaderDirImpl
 }
 
@@ -184,7 +181,7 @@
 	// FIXME: ideally we would change the version to "2" as a side-effect
 	// of calling sp.Install() we need to update it because the
 	// sp.Install() will verify that it got applied
-	makeFakeSystemImageChannelConfig(c, filepath.Join(systemImageRoot, "other", systemImageChannelConfig), "2")
+	makeFakeSystemImageChannelConfig(c, filepath.Join(dirs.GlobalRootDir, "other", systemImageChannelConfig), "2")
 
 	// add a update
 	mockSystemImageIndexJSON = fmt.Sprintf(mockSystemImageIndexJSONTemplate, "2")
@@ -257,7 +254,7 @@
 	// FIXME: ideally we would change the version to "2" as a side-effect
 	// of calling sp.Install() we need to update it because the
 	// sp.Install() will verify that it got applied
-	makeFakeSystemImageChannelConfig(c, filepath.Join(systemImageRoot, "other", systemImageChannelConfig), "2")
+	makeFakeSystemImageChannelConfig(c, filepath.Join(dirs.GlobalRootDir, "other", systemImageChannelConfig), "2")
 
 	// add a update
 	mockSystemImageIndexJSON = fmt.Sprintf(mockSystemImageIndexJSONTemplate, "2")
@@ -386,7 +383,7 @@
 	//  - "1" on current
 	//  - "2" on other
 	// the webserver will tell us that "2" is latest
-	makeFakeSystemImageChannelConfig(c, filepath.Join(systemImageRoot, "other", systemImageChannelConfig), "2")
+	makeFakeSystemImageChannelConfig(c, filepath.Join(dirs.GlobalRootDir, "other", systemImageChannelConfig), "2")
 	parts, err := s.systemImage.Updates()
 
 	part := parts[0].(*SystemImagePart)
@@ -399,7 +396,7 @@
 	//
 	// but this time the other part is *not* updated, i.e. we set it to
 	// something else
-	makeFakeSystemImageChannelConfig(c, filepath.Join(systemImageRoot, "other", systemImageChannelConfig), "1")
+	makeFakeSystemImageChannelConfig(c, filepath.Join(dirs.GlobalRootDir, "other", systemImageChannelConfig), "1")
 
 	// the update will have "2" and we only installed "1" on other
 	parts, err := s.systemImage.Updates()
@@ -413,7 +410,7 @@
 
 func (s *SITestSuite) TestOtherIsEmpty(c *C) {
 	otherRoot := "/other"
-	otherRootFull := filepath.Join(systemImageRoot, otherRoot)
+	otherRootFull := filepath.Join(dirs.GlobalRootDir, otherRoot)
 
 	siConfig := filepath.Join(otherRootFull, systemImageChannelConfig)
 
@@ -530,8 +527,8 @@
 
 	// we are on 1 and "upgrade" to 2 which is already installed
 	// (e.g. because we rolled back earlier)
-	makeFakeSystemImageChannelConfig(c, filepath.Join(systemImageRoot, systemImageChannelConfig), "1")
-	makeFakeSystemImageChannelConfig(c, filepath.Join(systemImageRoot, "other", systemImageChannelConfig), "2")
+	makeFakeSystemImageChannelConfig(c, filepath.Join(dirs.GlobalRootDir, systemImageChannelConfig), "1")
+	makeFakeSystemImageChannelConfig(c, filepath.Join(dirs.GlobalRootDir, "other", systemImageChannelConfig), "2")
 
 	// now we get the other part (v2)
 	parts, err := s.systemImage.Installed()
@@ -559,7 +556,7 @@
 }
 
 func (s *SITestSuite) TestNeedsBootAssetSyncNoNeed(c *C) {
-	makeFakeSystemImageChannelConfig(c, filepath.Join(systemImageRoot, "other", systemImageChannelConfig), "2")
+	makeFakeSystemImageChannelConfig(c, filepath.Join(dirs.GlobalRootDir, "other", systemImageChannelConfig), "2")
 
 	parts, err := s.systemImage.Installed()
 	c.Assert(err, IsNil)