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

[Michael Vogt]

Backport of the branch that adds systemd socket file generation which is important for docker.

Unmerged revisions

469. By Michael Vogt on 2015-09-08

cherry pick -r 649..653 lp:~mvo/snappy/snappy-systemd-socket

468. By Michael Vogt on 2015-09-02

Backport of the trunk branch by mvo approved by chipaca

467. By Michael Vogt on 2015-09-01

Allows hwassign/unassign for /sys/class/gpio/{,un}export to fix lp1488618 by mvo approved by jdstrand

466. By Leo Arias on 2015-08-03

Backported the integration tests. by elopio approved by fgimenez

465. By Leo Arias on 2015-08-03

Backported the change to use gopkg.in/check.v1. by elopio approved by sergiusens,fgimenez

464. By Michael Vogt on 2015-07-24

Add regression tests for bug #1474125 by mvo approved by chipaca

463. By Michael Vogt on 2015-07-23

Another missing uboot piece to move from uEnv.txt to uboot.env. I will do some more cleanup in trunk, i.e. I dislike that there is no single bootvar etc. by mvo approved by rsalveti

462. By Michael Vogt on 2015-07-23

Set snappy_trial_boot to "0" instead of unsetting it

he reason is that uboot is acting really funny when vars are unset.
I.e. "if "${snappy_trial_boot}" = "1"; then echo yes; fi" will echo yes
if snappy_trial_boot is unset on older u-boot systems (e.g. odroid).

Only changing uboot in 15.04 (not grub as we do in wily). by mvo approved by mvo,chipaca

461. By Michael Vogt on 2015-07-22

Backports of the uboot.env changes from trunk. by mvo approved by chipaca

460. By Sergio Schvezov on 2015-07-14

Only update bootloader files on newer versions or channel changes. by sergiusens approved by mvo

=== added directory '_integration-tests'
=== renamed directory '_integration-tests' => '_integration-tests.moved'
=== added file '_integration-tests/README.md'
--- _integration-tests/README.md	1970-01-01 00:00:00 +0000
+++ _integration-tests/README.md	2015-09-08 06:47:52 +0000
@@ -0,0 +1,117 @@
+# Integration testing for snappy
+
+## Requirements
+
+ *  autopkgtest (>= 3.15.1)
+
+    Get the latest autopkgtest deb from
+    https://packages.debian.org/sid/all/autopkgtest/download
+
+ *  Internet access in the test bed.
+
+## Setting up the project
+
+First you need to set up the GOPATH, get the snappy sources and the
+dependencies as explained in the `README.md` that is located at the root of the
+branch.
+
+## Testing a virtual machine
+
+You can execute the full integration suite in a local virtual machine with:
+
+    go run _integration-tests/main.go
+
+The test runner will create the snappy images with `ubuntu-device-flash`, so it
+will ask for your password to run this command with `sudo`.
+
+You can also especify more options to customize the image being created, including
+the release, the channel and the revision to use. This parameters will be passed
+to `ubuntu-device-flash`:
+
+    go run _integration-tests/main.go -release 15.04 -channel stable -revision 3
+
+The default values are suited to testing the most recent version, `rolling` for
+release, `edge` for channel and an empty revision, which picks the latest
+available.
+
+## Testing snappy from a branch
+
+With the --snappy-from-branch flag, the snappy CLI command will be compiled
+from the current branch, copied to the test bed and used during the integration
+tests:
+
+    go run _integration-tests/main.go --snappy-from-branch
+
+You can use this flag to test in a remote machine too.
+
+## Filtering the tests to run
+
+With the --filter flag you can select the tests to run. For instance you can
+pass MyTestSuite, MyTestSuite.FirstCustomTest or MyTestSuite.*CustomTest:
+
+    go run _integration-tests/main.go --filter MyTestSuite.FirstCustomTest
+
+## Testing a remote machine
+
+You can execute the integration suite in a remote snappy machine with:
+
+    go run _integration-tests/main.go --ip {testbed-ip} --port {testbed-port} \
+    --arch {testbed-arch}
+
+The test runner will use `ssh-copy-id` to send your identity file to the
+testbed, so it will ask for the password of the ubuntu user in the test bed.
+
+When running in a remote machine, the test runner assumes the test bed is in
+the latest rolling edge version, and it will skip all the tests that
+require a different version. See the following section for instructions for
+setting up a BeagleBone Black as the test bed.
+
+## Testing a BeagleBone Black
+
+First flash the latest 15.04 edge version into the sd card
+(replacing /dev/sdX with the path to your card):
+
+    sudo ubuntu-device-flash core 15.04 --channel edge --oem beagleblack \
+    --developer-mode --enable-ssh -o ubuntu-15.04-edge-armhf-bbb.img
+
+    sudo dd if=ubuntu-15.04-edge-armhf-bbb.img of=/dev/sdX bs=32M
+    sync
+
+Then boot the board with the sd card, make sure that it is connected to the
+same network as the test runner host, and find the {beaglebone-ip}.
+
+Run the tests with:
+
+    go run _integration-tests/main.go --ip {beaglebone-ip} --arch arm
+
+## Testing an update
+
+With the --update flag you can flash an old image, update to the latest and
+then run the whole suite on the updated system. The release, the channel and
+the revision flags specify the image that will be flashed, and the
+target-release and target-channel flags specify the values to be used in the
+update if they are different from the flashed values.
+
+For example, to update from 15.04 edge -1 to the latest and then run the
+integration tests:
+
+    go run _integration-tests/main.go --snappy-from-branch \
+    --release=15.04 --revision=-1 --update
+
+To update from 15.04 alpha to 15.04 edge and then run the integration tests:
+
+    go run _integration-tests/main.go --snappy-from-branch \
+    --release=15.04 --channel=alpha \
+    --update --target-channel=edge
+
+## Testing a rollback
+
+With the --rollback flag you can flash an old image, update to the latest,
+rollback again to the old image and then run the whole suite on the rolled
+back system. You should use the release, channel, revision, target-release and
+target-channel flags as when testing an update.
+
+For example, to test a rollback from latest 15.04 edge to 15.04 edge -1:
+
+    go run _integration-tests/main.go \
+    --release=15.04 --revision=-1 --rollback

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

=== added file '_integration-tests/data/snaps/basic/meta/readme.md'
--- _integration-tests/data/snaps/basic/meta/readme.md	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/basic/meta/readme.md	2015-09-08 06:47:52 +0000
@@ -0,0 +1,3 @@
+Basic snap
+
+A basic buildable snap

=== added file '_integration-tests/data/snaps/basic/meta/snappy64.png'
Binary files _integration-tests/data/snaps/basic/meta/snappy64.png	1970-01-01 00:00:00 +0000 and _integration-tests/data/snaps/basic/meta/snappy64.png	2015-09-08 06:47:52 +0000 differ
=== added directory '_integration-tests/data/snaps/missing-readme'
=== added directory '_integration-tests/data/snaps/missing-readme/meta'
=== added file '_integration-tests/data/snaps/missing-readme/meta/package.yaml'
--- _integration-tests/data/snaps/missing-readme/meta/package.yaml	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/missing-readme/meta/package.yaml	2015-09-08 06:47:52 +0000
@@ -0,0 +1,4 @@
+name: missing-readme
+version: 1.0
+vendor: Snappy Developers <[e-mail]>
+icon: meta/snappy64.png

=== added file '_integration-tests/data/snaps/missing-readme/meta/snappy64.png'
Binary files _integration-tests/data/snaps/missing-readme/meta/snappy64.png	1970-01-01 00:00:00 +0000 and _integration-tests/data/snaps/missing-readme/meta/snappy64.png	2015-09-08 06:47:52 +0000 differ
=== added directory '_integration-tests/data/snaps/wrong-yaml'
=== added directory '_integration-tests/data/snaps/wrong-yaml/meta'
=== added file '_integration-tests/data/snaps/wrong-yaml/meta/package.yaml'
--- _integration-tests/data/snaps/wrong-yaml/meta/package.yaml	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/wrong-yaml/meta/package.yaml	2015-09-08 06:47:52 +0000
@@ -0,0 +1,5 @@
+# This is an invalid yaml, there's a missing colon after the 'name' field
+name wrong-yaml
+version: 1.0
+vendor: Snappy Developers <[e-mail]>
+icon: meta/snappy64.png

=== added file '_integration-tests/data/snaps/wrong-yaml/meta/readme.md'
--- _integration-tests/data/snaps/wrong-yaml/meta/readme.md	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/snaps/wrong-yaml/meta/readme.md	2015-09-08 06:47:52 +0000
@@ -0,0 +1,3 @@
+Wrong metadata snap
+
+A snap with an invalid meta/package.yaml

=== added file '_integration-tests/data/snaps/wrong-yaml/meta/snappy64.png'
Binary files _integration-tests/data/snaps/wrong-yaml/meta/snappy64.png	1970-01-01 00:00:00 +0000 and _integration-tests/data/snaps/wrong-yaml/meta/snappy64.png	2015-09-08 06:47:52 +0000 differ
=== added directory '_integration-tests/data/tpl'
=== added file '_integration-tests/data/tpl/control'
--- _integration-tests/data/tpl/control	1970-01-01 00:00:00 +0000
+++ _integration-tests/data/tpl/control	2015-09-08 06:47:52 +0000
@@ -0,0 +1,4 @@
+{{ $filter := .Filter }}
+{{ $test := .Test }}
+Test-Command: ./_integration-tests/reboot-wrapper {{ $test }} {{ if $filter }}-gocheck.f {{ $filter }}{{ end }}
+Restrictions: allow-stderr

=== added file '_integration-tests/main.go'
--- _integration-tests/main.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/main.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,105 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package main
+
+import (
+	"flag"
+	"log"
+	"os"
+	"path/filepath"
+	"strconv"
+
+	"launchpad.net/snappy/_integration-tests/testutils"
+	"launchpad.net/snappy/_integration-tests/testutils/autopkgtest"
+	"launchpad.net/snappy/_integration-tests/testutils/build"
+	"launchpad.net/snappy/_integration-tests/testutils/config"
+	"launchpad.net/snappy/_integration-tests/testutils/image"
+)
+
+const (
+	baseDir        = "/tmp/snappy-test"
+	defaultRelease = "rolling"
+	defaultChannel = "edge"
+	defaultSSHPort = 22
+	dataOutputDir  = "_integration-tests/data/output/"
+)
+
+var configFileName = filepath.Join(dataOutputDir, "testconfig.json")
+
+func main() {
+	var (
+		useSnappyFromBranch = flag.Bool("snappy-from-branch", false,
+			"If this flag is used, snappy will be compiled from this branch, copied to the testbed and used for the tests. Otherwise, the snappy installed with the image will be used.")
+		arch = flag.String("arch", "",
+			"Architecture of the test bed. Defaults to use the same architecture as the host.")
+		testbedIP = flag.String("ip", "",
+			"IP of the testbed. If no IP is passed, a virtual machine will be created for the test.")
+		testbedPort = flag.Int("port", defaultSSHPort,
+			"SSH port of the testbed. Defaults to use port "+strconv.Itoa(defaultSSHPort))
+		testFilter = flag.String("filter", "",
+			"Suites or tests to run, for instance MyTestSuite, MyTestSuite.FirstCustomTest or MyTestSuite.*CustomTest")
+		imgRelease = flag.String("release", defaultRelease,
+			"Release of the image to be built, defaults to "+defaultRelease)
+		imgChannel = flag.String("channel", defaultChannel,
+			"Channel of the image to be built, defaults to "+defaultChannel)
+		imgRevision = flag.String("revision", "",
+			"Revision of the image to be built (can be relative to the latest available revision in the given release and channel as in -1), defaults to the empty string")
+		update = flag.Bool("update", false,
+			"If this flag is used, the image will be updated before running the tests.")
+		targetRelease = flag.String("target-release", "",
+			"If the update flag is used, the image will be updated to this release before running the tests.")
+		targetChannel = flag.String("target-channel", "",
+			"If the update flag is used, the image will be updated to this channel before running the tests.")
+		rollback = flag.Bool("rollback", false,
+			"If this flag is used, the image will be updated and then rolled back before running the tests.")
+	)
+
+	flag.Parse()
+
+	build.Assets(*useSnappyFromBranch, *arch)
+
+	// TODO: generate the files out of the source tree. --elopio - 2015-07-15
+	testutils.PrepareTargetDir(dataOutputDir)
+	defer os.RemoveAll(dataOutputDir)
+
+	remoteTestbed := *testbedIP != ""
+
+	// TODO: pass the config as arguments to the test binaries.
+	// --elopio - 2015-07-15
+	cfg := config.NewConfig(
+		configFileName, *imgRelease, *imgChannel, *targetRelease, *targetChannel,
+		remoteTestbed, *update, *rollback)
+	cfg.Write()
+
+	rootPath := testutils.RootPath()
+
+	test := autopkgtest.NewAutopkgtest(rootPath, baseDir, *testFilter, build.IntegrationTestName)
+	if !remoteTestbed {
+		img := image.NewImage(*imgRelease, *imgChannel, *imgRevision, baseDir)
+
+		if imagePath, err := img.UdfCreate(); err == nil {
+			test.AdtRunLocal(imagePath)
+		} else {
+			log.Panic(err.Error())
+		}
+	} else {
+		test.AdtRunRemote(*testbedIP, *testbedPort)
+	}
+}

=== added file '_integration-tests/reboot-wrapper'
--- _integration-tests/reboot-wrapper	1970-01-01 00:00:00 +0000
+++ _integration-tests/reboot-wrapper	2015-09-08 06:47:52 +0000
@@ -0,0 +1,35 @@
+#!/bin/sh
+
+# 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/>.
+
+# This runs the $1 go test binary and reboots if necessary.
+
+set -e
+
+TEST=$1
+NEEDS_REBOOT=/tmp/needs-reboot
+
+export PATH=$(pwd)/_integration-tests/bin:$PATH
+
+# shift to remove the test binary name (first argument) and be able to pass the rest
+# of them to it
+shift
+${TEST} -check.vv -test.outputdir=$ADT_ARTIFACTS-$ADT_REBOOT_MARK "$@"
+
+if [ -e ${NEEDS_REBOOT} ]; then
+    mark=`cat ${NEEDS_REBOOT}`
+    echo "Rebooting..."
+    sudo /tmp/autopkgtest-reboot "$mark"
+fi

=== added directory '_integration-tests/tests'
=== added file '_integration-tests/tests/apt_test.go'
--- _integration-tests/tests/apt_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/apt_test.go	2015-09-08 06:47:52 +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 tests
+
+import (
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&aptSuite{})
+
+type aptSuite struct {
+	SnappySuite
+}
+
+func (s *aptSuite) TestAptGetMustPrintError(c *check.C) {
+	aptOutput := ExecCommand(c, "apt-get", "update")
+
+	expected := "Ubuntu Core does not use apt-get, see 'snappy --help'!\n"
+	c.Assert(aptOutput, check.Equals, expected)
+}

=== added file '_integration-tests/tests/base_test.go'
--- _integration-tests/tests/base_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/base_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,29 @@
+// -*- 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 (
+	"testing"
+
+	. "gopkg.in/check.v1"
+)
+
+// Hook up gocheck into the "go test" runner.
+func Test(t *testing.T) { TestingT(t) }

=== added file '_integration-tests/tests/build_test.go'
--- _integration-tests/tests/build_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/build_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,90 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	. "gopkg.in/check.v1"
+)
+
+const (
+	baseSnapPath          = "_integration-tests/data/snaps"
+	basicSnapName         = "basic"
+	wrongYamlSnapName     = "wrong-yaml"
+	missingReadmeSnapName = "missing-readme"
+)
+
+var _ = Suite(&buildSuite{})
+
+type buildSuite struct {
+	SnappySuite
+}
+
+func buildSnap(c *C, snapPath string) string {
+	return ExecCommand(c, "snappy", "build", snapPath)
+}
+
+func (s *buildSuite) TestBuildBasicSnapOnSnappy(c *C) {
+	// build basic snap and check output
+	snapPath := baseSnapPath + "/" + basicSnapName
+	buildOutput := buildSnap(c, snapPath)
+	snapName := basicSnapName + "_1.0_all.snap"
+	expected := fmt.Sprintf("Generated '%s' snap\n", snapName)
+	c.Check(buildOutput, Equals, expected)
+	defer os.Remove(snapPath + "/" + snapName)
+
+	// install built snap and check output
+	installOutput := InstallSnap(c, snapName)
+	defer RemoveSnap(c, basicSnapName)
+	expected = "(?ms)" +
+		"Installing " + snapName + "\n" +
+		".*Signature check failed, but installing anyway as requested\n" +
+		"Name +Date +Version +Developer \n" +
+		".*\n" +
+		basicSnapName + " +.* +.* +sideload  \n" +
+		".*\n"
+
+	c.Check(installOutput, Matches, expected)
+
+	// teardown, remove snap file
+	c.Assert(os.Remove(snapName), IsNil, Commentf("Error removing %s", snapName))
+}
+
+func (s *buildSuite) TestBuildWrongYamlSnapOnSnappy(c *C) {
+	commonWrongTest(c, wrongYamlSnapName, "(?msi).*Can not parse.*yaml: line 2: mapping values are not allowed in this context.*")
+}
+
+func (s *buildSuite) TestBuildMissingReadmeSnapOnSnappy(c *C) {
+	commonWrongTest(c, missingReadmeSnapName, ".*readme.md: no such file or directory\n")
+}
+
+func commonWrongTest(c *C, testName, expected string) {
+	// build wrong snap and check output
+	cmd := exec.Command("snappy", "build", fmt.Sprintf("%s/%s", baseSnapPath, testName))
+	echoOutput, err := cmd.CombinedOutput()
+	c.Assert(err, NotNil, Commentf("%s should not be built", testName))
+
+	c.Assert(string(echoOutput), Matches, expected)
+}

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

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

=== added file '_integration-tests/tests/failover_test.go'
--- _integration-tests/tests/failover_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/failover_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,58 @@
+// -*- 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 (
+	check "gopkg.in/check.v1"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+)
+
+var _ = check.Suite(&failoverSuite{})
+
+type failoverSuite struct {
+	SnappySuite
+}
+
+// The types that implement this interface can be used in the test logic
+type failer interface {
+	// Sets the failure conditions
+	set(c *check.C)
+	// Unsets the failure conditions
+	unset(c *check.C)
+}
+
+// This is the logic common to all the failover tests. Each of them has define a
+// type implementing the failer interface and call this function with an instance
+// of it
+func commonFailoverTest(c *check.C, f failer) {
+	currentVersion := GetCurrentUbuntuCoreVersion(c)
+
+	if AfterReboot(c) {
+		RemoveRebootMark(c)
+		f.unset(c)
+		c.Assert(GetSavedVersion(c), check.Equals, currentVersion)
+	} else {
+		SetSavedVersion(c, currentVersion-1)
+		CallFakeUpdate(c)
+		f.set(c)
+		Reboot(c)
+	}
+}

=== added file '_integration-tests/tests/failover_zero_size_file_test.go'
--- _integration-tests/tests/failover_zero_size_file_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/failover_zero_size_file_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,258 @@
+// -*- 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"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+const (
+	origBootFilenamePattern    = "boot/%s%s*"
+	origSystemdFilenamePattern = "lib/systemd/%s%s"
+	kernelFilename             = "vmlinuz"
+	initrdFilename             = "initrd"
+	systemdFilename            = "systemd"
+	destFilenamePrefix         = "snappy-selftest-"
+	bootBase                   = "/boot"
+	ubootDir                   = bootBase + "/uboot"
+	grubDir                    = bootBase + "/grub"
+	ubootConfigFile            = ubootDir + "/snappy-system.txt"
+	grubConfigFile             = grubDir + "/grubenv"
+)
+
+type zeroSizeKernel struct{}
+type zeroSizeInitrd struct{}
+type zeroSizeSystemd struct{}
+
+func (zeroSizeKernel) set(c *check.C) {
+	commonSet(c, BaseAltPartitionPath, origBootFilenamePattern, kernelFilename)
+}
+
+func (zeroSizeKernel) unset(c *check.C) {
+	commonUnset(c, BaseAltPartitionPath, origBootFilenamePattern, kernelFilename)
+}
+
+func (zeroSizeInitrd) set(c *check.C) {
+	if classicKernelFiles(c) {
+		commonSet(c, BaseAltPartitionPath, origBootFilenamePattern, initrdFilename)
+	} else {
+		boot := bootSystem(c)
+		dir := bootDirectory(boot)
+		bootFileNamePattern := newKernelFilenamePattern(c, boot, true)
+		commonSet(c, dir, bootFileNamePattern, initrdFilename)
+	}
+}
+
+func (zeroSizeInitrd) unset(c *check.C) {
+	if classicKernelFiles(c) {
+		commonUnset(c, BaseAltPartitionPath, origBootFilenamePattern, initrdFilename)
+	} else {
+		boot := bootSystem(c)
+		dir := bootDirectory(boot)
+		bootFileNamePattern := newKernelFilenamePattern(c, boot, false)
+		commonUnset(c, dir, bootFileNamePattern, initrdFilename)
+	}
+}
+
+func (zeroSizeSystemd) set(c *check.C) {
+	commonSet(c, BaseAltPartitionPath, origSystemdFilenamePattern, systemdFilename)
+}
+
+func (zeroSizeSystemd) unset(c *check.C) {
+	commonUnset(c, BaseAltPartitionPath, origSystemdFilenamePattern, systemdFilename)
+}
+
+func commonSet(c *check.C, baseOtherPath, origPattern, filename string) {
+	filenamePattern := fmt.Sprintf(origPattern, "", filename)
+	completePattern := filepath.Join(
+		baseOtherPath,
+		filenamePattern)
+	oldFilename := getSingleFilename(c, completePattern)
+	filenameSuffix := fmt.Sprintf(
+		strings.Replace(origPattern, "*", "", 1), destFilenamePrefix, filepath.Base(oldFilename))
+	newFilename := fmt.Sprintf(
+		"%s/%s", baseOtherPath, filenameSuffix)
+
+	renameFile(c, baseOtherPath, oldFilename, newFilename, true)
+}
+
+func commonUnset(c *check.C, baseOtherPath, origPattern, filename string) {
+	completePattern := filepath.Join(
+		baseOtherPath,
+		fmt.Sprintf(origPattern, destFilenamePrefix, filename))
+	oldFilename := getSingleFilename(c, completePattern)
+	newFilename := strings.Replace(oldFilename, destFilenamePrefix, "", 1)
+
+	renameFile(c, baseOtherPath, oldFilename, newFilename, false)
+}
+
+func renameFile(c *check.C, basePath, oldFilename, newFilename string, keepOld bool) {
+	// Only need to make writable and revert for BaseAltPartitionPath,
+	// kernel files' boot directory is writable
+	if basePath == BaseAltPartitionPath {
+		MakeWritable(c, basePath)
+		defer MakeReadonly(c, basePath)
+	}
+
+	ExecCommand(c, "sudo", "mv", oldFilename, newFilename)
+
+	if keepOld {
+		ExecCommand(c, "sudo", "touch", oldFilename)
+		mode := getFileMode(c, newFilename)
+		ExecCommand(c, "sudo", "chmod", fmt.Sprintf("%o", mode), oldFilename)
+	}
+}
+
+func getFileMode(c *check.C, filePath string) os.FileMode {
+	info, err := os.Stat(filePath)
+	c.Check(err, check.IsNil, check.Commentf("Error getting Stat of %s", filePath))
+
+	return info.Mode()
+}
+
+func getSingleFilename(c *check.C, pattern string) string {
+	matches, err := filepath.Glob(pattern)
+
+	c.Assert(err, check.IsNil, check.Commentf("Error: %v", err))
+	c.Assert(len(matches), check.Equals, 1,
+		check.Commentf("%d files matching %s, 1 expected", len(matches), pattern))
+
+	return matches[0]
+}
+
+func classicKernelFiles(c *check.C) bool {
+	initrdClassicFilenamePattern := fmt.Sprintf("/boot/%s*-generic", initrdFilename)
+	matches, err := filepath.Glob(initrdClassicFilenamePattern)
+
+	c.Assert(err, check.IsNil, check.Commentf("Error: %v", err))
+
+	return len(matches) == 1
+}
+
+func bootSystem(c *check.C) string {
+	matches, err := filepath.Glob(bootBase + "/grub")
+
+	c.Assert(err, check.IsNil, check.Commentf("Error: %v", err))
+
+	if len(matches) == 1 {
+		return "grub"
+	}
+	return "uboot"
+}
+
+func bootDirectory(bootSystem string) string {
+	if bootSystem == "grub" {
+		return grubDir
+	}
+	return ubootDir
+}
+
+func bootConfigFile(bootSystem string) string {
+	if bootSystem == "grub" {
+		return grubConfigFile
+	}
+	return ubootConfigFile
+}
+
+func currentPartition(c *check.C, bootSystem string) (partition string) {
+	bootConfigFile := bootConfigFile(bootSystem)
+	file, err := os.Open(bootConfigFile)
+
+	c.Assert(err, check.IsNil,
+		check.Commentf("Error reading boot config file %s", bootConfigFile))
+
+	defer file.Close()
+
+	reader := bufio.NewReader(file)
+	scanner := bufio.NewScanner(reader)
+
+	scanner.Split(bufio.ScanLines)
+
+	for scanner.Scan() {
+		if strings.HasPrefix(scanner.Text(), "snappy_ab") {
+			fields := strings.Split(scanner.Text(), "=")
+			if len(fields) > 1 {
+				if bootSystem == "grub" {
+					partition = fields[1]
+				} else {
+					partition = otherPart(fields[1])
+				}
+			}
+			return
+		}
+	}
+	return
+}
+
+func otherPart(current string) string {
+	if current == "a" {
+		return "b"
+	}
+	return "a"
+}
+
+// newKernelFilenamePattern returns the filename pattern to modify files
+// in the partition declared in the boot config file.
+//
+// After the update, the config file is already changed to point to the new partition.
+// If we are on a and update, the config file would point to b
+// and this function would return "b/%s%s*"
+// If we are not in an update process (ie. we are unsetting the failover conditions)
+// we want to change the files in the other partition
+func newKernelFilenamePattern(c *check.C, bootSystem string, afterUpdate bool) string {
+	var actualPartition string
+	partition := currentPartition(c, bootSystem)
+	if afterUpdate {
+		actualPartition = partition
+	} else {
+		actualPartition = otherPart(partition)
+	}
+	return filepath.Join(actualPartition, "%s%s*")
+}
+
+/*
+TODO: uncomment when bug https://bugs.launchpad.net/snappy/+bug/1467553 is fixed
+(fgimenez 20150729)
+
+func (s *failoverSuite) TestZeroSizeKernel(c *check.C) {
+	commonFailoverTest(c, zeroSizeKernel{})
+}
+*/
+
+func (s *failoverSuite) TestZeroSizeInitrd(c *check.C) {
+	// Skip if on uboot due to https://bugs.launchpad.net/snappy/+bug/1480248
+	// (fgimenez 20150731)
+	if bootSystem(c) == "uboot" {
+		c.Skip("Failover for empty initrd not working in uboot")
+	}
+	commonFailoverTest(c, zeroSizeInitrd{})
+}
+
+func (s *failoverSuite) TestZeroSizeSystemd(c *check.C) {
+	commonFailoverTest(c, zeroSizeSystemd{})
+}

=== added file '_integration-tests/tests/info_test.go'
--- _integration-tests/tests/info_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/info_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,79 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"fmt"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&infoSuite{})
+
+type infoSuite struct {
+	SnappySuite
+}
+
+func (s *infoSuite) TestInfoMustPrintReleaseAndChannel(c *check.C) {
+	// skip test when having a remote testbed (we can't know which the
+	// release and channels are)
+	if Cfg.RemoteTestbed {
+		c.Skip(fmt.Sprintf(
+			"Skipping %s while testing in remote testbed",
+			c.TestName()))
+	}
+
+	infoOutput := ExecCommand(c, "snappy", "info")
+
+	expected := "(?ms)" +
+		fmt.Sprintf("^release: ubuntu-core/%s/%s\n", Cfg.Release, Cfg.Channel) +
+		".*"
+
+	c.Assert(infoOutput, check.Matches, expected)
+}
+
+func (s *infoSuite) TestInfoMustPrintInstalledApps(c *check.C) {
+	InstallSnap(c, "hello-world")
+	s.AddCleanup(func() {
+		RemoveSnap(c, "hello-world")
+	})
+	infoOutput := ExecCommand(c, "snappy", "info")
+
+	expected := "(?ms)" +
+		".*" +
+		"^apps: .*hello-world.*\n"
+	c.Assert(infoOutput, check.Matches, expected)
+}
+
+func (s *infoSuite) TestInfoMustPrintInstalledFrameworks(c *check.C) {
+	InstallSnap(c, "hello-dbus-fwk.canonical")
+	s.AddCleanup(func() {
+		RemoveSnap(c, "hello-dbus-fwk.canonical")
+	})
+	infoOutput := ExecCommand(c, "snappy", "info")
+
+	expected := "(?ms)" +
+		".*" +
+		"^frameworks: .*hello-dbus-fwk.*\n" +
+		".*"
+	c.Assert(infoOutput, check.Matches, expected)
+}

=== added file '_integration-tests/tests/installApp_test.go'
--- _integration-tests/tests/installApp_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/installApp_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,128 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"fmt"
+	"net/http"
+	"os/exec"
+	"time"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&installAppSuite{})
+
+type installAppSuite struct {
+	SnappySuite
+}
+
+func (s *installAppSuite) TestInstallAppMustPrintPackageInformation(c *check.C) {
+	installOutput := InstallSnap(c, "hello-world")
+	s.AddCleanup(func() {
+		RemoveSnap(c, "hello-world")
+	})
+
+	expected := "(?ms)" +
+		"Installing hello-world\n" +
+		"Name +Date +Version +Developer \n" +
+		".*" +
+		"^hello-world +.* +.* +canonical \n" +
+		".*"
+
+	c.Assert(installOutput, check.Matches, expected)
+}
+
+func (s *installAppSuite) TestCallBinaryFromInstalledSnap(c *check.C) {
+	InstallSnap(c, "hello-world")
+	s.AddCleanup(func() {
+		RemoveSnap(c, "hello-world")
+	})
+
+	echoOutput := ExecCommand(c, "hello-world.echo")
+
+	c.Assert(echoOutput, check.Equals, "Hello World!\n")
+}
+
+func (s *installAppSuite) TestCallBinaryWithPermissionDeniedMustPrintError(c *check.C) {
+	InstallSnap(c, "hello-world")
+	s.AddCleanup(func() {
+		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) TestInfoMustPrintInstalledPackageInformation(c *check.C) {
+	InstallSnap(c, "hello-world")
+	s.AddCleanup(func() {
+		RemoveSnap(c, "hello-world")
+	})
+
+	infoOutput := ExecCommand(c, "snappy", "info")
+
+	expected := "(?ms).*^apps: hello-world\n"
+	c.Assert(infoOutput, check.Matches, expected)
+}
+
+func (s *installAppSuite) TestAppNetworkingServiceMustBeStarted(c *check.C) {
+	baseAppName := "xkcd-webserver"
+	appName := baseAppName + ".canonical"
+	InstallSnap(c, appName)
+	s.AddCleanup(func() {
+		RemoveSnap(c, appName)
+	})
+
+	appVersion := GetCurrentVersion(c, baseAppName)
+	appService := fmt.Sprintf("%s_%s_%s.service", baseAppName, baseAppName, appVersion)
+
+	err := WaitForActiveService(c, appService)
+	c.Assert(err, check.IsNil)
+
+	time.Sleep(1 * time.Second)
+	resp, err := http.Get("http://localhost")
+	c.Assert(err, check.IsNil)
+	c.Check(resp.Status, check.Equals, "200 OK")
+	c.Assert(resp.Proto, check.Equals, "HTTP/1.0")
+}
+
+func (s *installAppSuite) TestInstallUnexistingAppMustPrintError(c *check.C) {
+	cmd := exec.Command("sudo", "snappy", "install", "unexisting.canonical")
+	output, err := cmd.CombinedOutput()
+
+	c.Assert(err, check.NotNil)
+	c.Assert(string(output), check.Equals,
+		"Installing unexisting.canonical\n"+
+			"unexisting.canonical failed to install: snappy package not found\n")
+}

=== added file '_integration-tests/tests/installFramework_test.go'
--- _integration-tests/tests/installFramework_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/installFramework_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,93 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"fmt"
+	"regexp"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&installFrameworkSuite{})
+
+type installFrameworkSuite struct {
+	SnappySuite
+}
+
+func (s *installFrameworkSuite) TearDownTest(c *check.C) {
+	if !NeedsReboot() && CheckRebootMark("") {
+		RemoveSnap(c, "docker")
+	}
+	// run cleanup last
+	s.SnappySuite.TearDownTest(c)
+}
+
+func isDockerServiceRunning(c *check.C) bool {
+	dockerVersion := GetCurrentVersion(c, "docker")
+	dockerService := fmt.Sprintf("docker_docker-daemon_%s.service", dockerVersion)
+
+	err := WaitForActiveService(c, dockerService)
+	c.Assert(err, check.IsNil)
+
+	statusOutput := ExecCommand(
+		c, "systemctl", "status",
+		dockerService)
+
+	expected := "(?ms)" +
+		".* docker_docker-daemon_.*\\.service .*\n" +
+		".*Loaded: loaded .*\n" +
+		".*Active: active \\(running\\) .*\n" +
+		".*"
+
+	matched, err := regexp.MatchString(expected, statusOutput)
+	c.Assert(err, check.IsNil)
+	return matched
+}
+
+func (s *installFrameworkSuite) TestInstallFrameworkMustPrintPackageInformation(c *check.C) {
+	installOutput := InstallSnap(c, "docker")
+
+	expected := "(?ms)" +
+		"Installing docker\n" +
+		"Name +Date +Version +Developer \n" +
+		".*" +
+		"^docker +.* +.* +canonical \n" +
+		".*"
+
+	c.Assert(installOutput, check.Matches, expected)
+}
+
+func (s *installFrameworkSuite) TestInstalledFrameworkServiceMustBeStarted(c *check.C) {
+	InstallSnap(c, "docker")
+	c.Assert(isDockerServiceRunning(c), check.Equals, true)
+}
+
+func (s *installFrameworkSuite) TestFrameworkServiceMustBeStartedAfterReboot(c *check.C) {
+	if BeforeReboot() {
+		InstallSnap(c, "docker")
+		Reboot(c)
+	} else if AfterReboot(c) {
+		RemoveRebootMark(c)
+		c.Assert(isDockerServiceRunning(c), check.Equals, true)
+	}
+}

=== added file '_integration-tests/tests/list_test.go'
--- _integration-tests/tests/list_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/list_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,78 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"fmt"
+	"os"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	"github.com/mvo5/goconfigparser"
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&listSuite{})
+
+type listSuite struct {
+	SnappySuite
+}
+
+func getVersionFromConfig(c *check.C) string {
+	cfg := goconfigparser.New()
+	f, err := os.Open("/etc/system-image/channel.ini")
+	c.Assert(err, check.IsNil,
+		check.Commentf("Error opening the config file: %v:", err))
+	defer f.Close()
+	err = cfg.Read(f)
+	c.Assert(err, check.IsNil,
+		check.Commentf("Error parsing the config file: %v", err))
+	version, err := cfg.Get("service", "build_number")
+	c.Assert(err, check.IsNil,
+		check.Commentf("Error getting the build number: %v", err))
+	return version
+}
+
+func (s *listSuite) TestListMustPrintCoreVersion(c *check.C) {
+	listOutput := ExecCommand(c, "snappy", "list")
+
+	expected := "(?ms)" +
+		"Name +Date +Version +Developer *\n" +
+		".*" +
+		fmt.Sprintf("^ubuntu-core +.* +%s +ubuntu *\n", getVersionFromConfig(c)) +
+		".*"
+	c.Assert(listOutput, check.Matches, expected)
+}
+
+func (s *listSuite) TestListMustPrintAppVersion(c *check.C) {
+	InstallSnap(c, "hello-world")
+	s.AddCleanup(func() {
+		RemoveSnap(c, "hello-world")
+	})
+
+	listOutput := ExecCommand(c, "snappy", "list")
+	expected := "(?ms)" +
+		"Name +Date +Version +Developer *\n" +
+		".*" +
+		"^hello-world +.* +(\\d+)(\\.\\d+)* +.* +.* *\n" +
+		".*"
+
+	c.Assert(listOutput, check.Matches, expected)
+}

=== added file '_integration-tests/tests/rollback_test.go'
--- _integration-tests/tests/rollback_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/rollback_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,53 @@
+// -*- 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 (
+	"strconv"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&rollbackSuite{})
+
+type rollbackSuite struct {
+	SnappySuite
+}
+
+func (s *rollbackSuite) TestRollbackMustRebootToOtherVersion(c *check.C) {
+	if BeforeReboot() {
+		CallFakeUpdate(c)
+		Reboot(c)
+	} else if CheckRebootMark(c.TestName()) {
+		RemoveRebootMark(c)
+		currentVersion := GetCurrentUbuntuCoreVersion(c)
+		c.Assert(currentVersion > GetSavedVersion(c), check.Equals, true)
+		ExecCommand(c, "sudo", "snappy", "rollback", "ubuntu-core",
+			strconv.Itoa(GetSavedVersion(c)))
+		SetSavedVersion(c, currentVersion)
+		RebootWithMark(c, c.TestName()+"-rollback")
+	} else if CheckRebootMark(c.TestName() + "-rollback") {
+		RemoveRebootMark(c)
+		c.Assert(
+			GetCurrentUbuntuCoreVersion(c) < GetSavedVersion(c), check.Equals, true)
+	}
+}

=== added file '_integration-tests/tests/search_test.go'
--- _integration-tests/tests/search_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/search_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,44 @@
+// -*- 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 (
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	. "gopkg.in/check.v1"
+)
+
+var _ = Suite(&searchSuite{})
+
+type searchSuite struct {
+	SnappySuite
+}
+
+func (s *searchSuite) TestSearchFrameworkMustPrintMatch(c *C) {
+	searchOutput := ExecCommand(c, "snappy", "search", "hello-dbus-fwk")
+
+	expected := "(?ms)" +
+		"Name +Version +Summary *\n" +
+		".*" +
+		"^hello-dbus-fwk +.* +hello-dbus-fwk *\n" +
+		".*"
+
+	c.Assert(searchOutput, Matches, expected)
+}

=== added file '_integration-tests/tests/update_test.go'
--- _integration-tests/tests/update_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/update_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,51 @@
+// -*- 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 (
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+var _ = check.Suite(&updateSuite{})
+
+type updateSuite struct {
+	SnappySuite
+}
+
+// Test that the update to the same release and channel must install a newer
+// version. If there is no update available, the channel version will be
+// modified to fake an update. If there is a version available, the image will
+// be up-to-date after running this test.
+func (s *updateSuite) TestUpdateToSameReleaseAndChannel(c *check.C) {
+	if BeforeReboot() {
+		updateOutput := CallFakeUpdate(c)
+		expected := "(?ms)" +
+			".*" +
+			"^Reboot to use .*ubuntu-core.\n"
+		c.Assert(updateOutput, check.Matches, expected)
+		Reboot(c)
+	} else if AfterReboot(c) {
+		RemoveRebootMark(c)
+		c.Assert(GetCurrentUbuntuCoreVersion(c) > GetSavedVersion(c),
+			check.Equals, true)
+	}
+}

=== added file '_integration-tests/tests/writablePaths_test.go'
--- _integration-tests/tests/writablePaths_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/tests/writablePaths_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,106 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package tests
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	. "launchpad.net/snappy/_integration-tests/testutils/common"
+
+	check "gopkg.in/check.v1"
+)
+
+const writablePathsListFile = "/etc/system-image/writable-paths"
+
+var _ = check.Suite(&writablePathsSuite{})
+
+type writablePathsSuite struct {
+	SnappySuite
+}
+
+var IsWritable check.Checker = &isWritable{}
+
+type isWritable struct {
+}
+
+func (is *isWritable) Info() *check.CheckerInfo {
+	return &check.CheckerInfo{Name: "IsWritable", Params: []string{"path"}}
+}
+
+func (is *isWritable) Check(params []interface{}, names []string) (result bool, error string) {
+	if path, ok := params[0].(string); ok {
+		filename := filepath.Join(path, "tmpfile")
+
+		cmd := exec.Command("sudo", "touch", filename)
+		rmCmd := exec.Command("sudo", "rm", filename)
+		defer rmCmd.Run()
+
+		if _, err := cmd.CombinedOutput(); err == nil {
+			result = true
+		} else {
+			error = fmt.Sprintf("Error creating file %s", filename)
+		}
+	} else {
+		error = fmt.Sprintf("First param of checker %v is of type %T and it should be a string", params[0], params[0])
+	}
+	return result, error
+}
+
+func (s *writablePathsSuite) TestWritablePathsAreWritable(c *check.C) {
+	for writablePath := range generateWritablePaths(c) {
+		c.Logf("Checking if %s is writable", writablePath)
+		c.Check(writablePath, IsWritable)
+	}
+}
+
+func generateWritablePaths(c *check.C) chan string {
+	ch := make(chan string)
+
+	go func() {
+		file, err := os.Open(writablePathsListFile)
+
+		c.Assert(err, check.IsNil,
+			check.Commentf("Error reading writable files list %s", writablePathsListFile))
+
+		defer file.Close()
+
+		reader := bufio.NewReader(file)
+		scanner := bufio.NewScanner(reader)
+
+		scanner.Split(bufio.ScanLines)
+
+		for scanner.Scan() {
+			fields := strings.Fields(scanner.Text())
+			if len(fields) > 0 && fields[0] != "#" {
+				if src, err := os.Stat(fields[0]); err == nil && src.IsDir() {
+					ch <- fields[0]
+				}
+			}
+		}
+		close(ch)
+	}()
+
+	return ch
+}

=== added directory '_integration-tests/testutils'
=== added directory '_integration-tests/testutils/autopkgtest'
=== added file '_integration-tests/testutils/autopkgtest/autopkgtest.go'
--- _integration-tests/testutils/autopkgtest/autopkgtest.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/autopkgtest/autopkgtest.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,111 @@
+// -*- 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 autopkgtest
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"text/template"
+
+	"log"
+
+	"launchpad.net/snappy/_integration-tests/testutils"
+)
+
+const (
+	controlTpl    = "_integration-tests/data/tpl/control"
+	dataOutputDir = "_integration-tests/data/output/"
+)
+
+var controlFile = filepath.Join(dataOutputDir, "control")
+
+// Autopkgtest is the type that knows how to call adt-run
+type Autopkgtest struct {
+	sourceCodePath      string // location of the source code on the host
+	testArtifactsPath   string // location of the test artifacts on the host
+	testFilter          string
+	integrationTestName string
+}
+
+// NewAutopkgtest is the Autopkgtest constructor
+func NewAutopkgtest(sourceCodePath, testArtifactsPath, testFilter, integrationTestName string) *Autopkgtest {
+	return &Autopkgtest{
+		sourceCodePath:      sourceCodePath,
+		testArtifactsPath:   testArtifactsPath,
+		testFilter:          testFilter,
+		integrationTestName: integrationTestName}
+}
+
+// AdtRunLocal starts a kvm running the image passed as argument and runs the
+// autopkgtests using it as the testbed.
+func (a *Autopkgtest) AdtRunLocal(imgPath string) {
+	// Run the tests on the latest rolling edge image.
+	a.adtRun(kvmSSHOptions(imgPath))
+}
+
+// AdtRunRemote runs the autopkgtests using a remote machine as the testbed.
+func (a *Autopkgtest) AdtRunRemote(testbedIP string, testbedPort int) {
+	testutils.ExecCommand("ssh-copy-id", "-p", strconv.Itoa(testbedPort),
+		"ubuntu@"+testbedIP)
+	a.adtRun(remoteTestbedSSHOptions(testbedIP, testbedPort))
+}
+
+func (a *Autopkgtest) adtRun(testbedOptions []string) {
+	a.createControlFile()
+
+	fmt.Println("Calling adt-run...")
+	outputDir := filepath.Join(a.testArtifactsPath, "output")
+	testutils.PrepareTargetDir(outputDir)
+
+	cmd := []string{
+		"adt-run", "-B",
+		"--setup-commands", "touch /run/autopkgtest_no_reboot.stamp",
+		"--override-control", controlFile,
+		"--built-tree", a.sourceCodePath,
+		"--output-dir", outputDir}
+
+	testutils.ExecCommand(append(cmd, testbedOptions...)...)
+}
+
+func (a *Autopkgtest) createControlFile() {
+	type controlData struct {
+		Filter string
+		Test   string
+	}
+
+	tpl, err := template.ParseFiles(controlTpl)
+	if err != nil {
+		log.Panicf("Error reading adt-run control template %s", controlTpl)
+	}
+
+	outputFile, err := os.Create(controlFile)
+	if err != nil {
+		log.Panicf("Error creating control file %s", controlFile)
+	}
+	defer outputFile.Close()
+
+	err = tpl.Execute(outputFile,
+		controlData{Test: a.integrationTestName, Filter: a.testFilter})
+	if err != nil {
+		log.Panicf("execution: %s", err)
+	}
+}

=== added file '_integration-tests/testutils/autopkgtest/ssh.go'
--- _integration-tests/testutils/autopkgtest/ssh.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/autopkgtest/ssh.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,46 @@
+// -*- 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 autopkgtest
+
+import (
+	"os"
+	"path/filepath"
+	"strconv"
+)
+
+var commonSSHOptions = []string{"---", "ssh"}
+
+func kvmSSHOptions(imagePath string) []string {
+	return append(
+		commonSSHOptions,
+		[]string{
+			"-s", "/usr/share/autopkgtest/ssh-setup/snappy",
+			"--", "-i", imagePath}...)
+}
+
+func remoteTestbedSSHOptions(testbedIP string, testbedPort int) []string {
+	options := []string{
+		"-H", testbedIP,
+		"-p", strconv.Itoa(testbedPort),
+		"-l", "ubuntu",
+		"-i", filepath.Join(os.Getenv("HOME"), ".ssh", "id_rsa"),
+		"--reboot"}
+	return append(commonSSHOptions, options...)
+}

=== added directory '_integration-tests/testutils/build'
=== added file '_integration-tests/testutils/build/build.go'
--- _integration-tests/testutils/build/build.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/build/build.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,76 @@
+// -*- 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 build
+
+import (
+	"fmt"
+	"os"
+
+	"launchpad.net/snappy/_integration-tests/testutils"
+)
+
+const (
+	// IntegrationTestName is the name of the test binary.
+	IntegrationTestName = "integration.test"
+	defaultGoArm        = "7"
+	testsBinDir         = "_integration-tests/bin/"
+)
+
+// Assets builds the snappy and integration tests binaries for the target
+// architecture.
+func Assets(useSnappyFromBranch bool, arch string) {
+	testutils.PrepareTargetDir(testsBinDir)
+
+	if useSnappyFromBranch {
+		// FIXME We need to build an image that has the snappy from the branch
+		// installed. --elopio - 2015-06-25.
+		buildSnappyCLI(arch)
+	}
+	buildTests(arch)
+}
+
+func buildSnappyCLI(arch string) {
+	fmt.Println("Building snappy CLI...")
+	// On the root of the project we have a directory called snappy, so we
+	// output the binary for the tests in the tests directory.
+	goCall(arch, "build", "-o", testsBinDir+"snappy", "./cmd/snappy")
+}
+
+func buildTests(arch string) {
+	fmt.Println("Building tests...")
+
+	goCall(arch, "test", "-c", "./_integration-tests/tests")
+	// XXX Go test 1.3 does not have the output flag, so we move the
+	// binaries after they are generated.
+	os.Rename("tests.test", testsBinDir+IntegrationTestName)
+}
+
+func goCall(arch string, cmds ...string) {
+	if arch != "" {
+		defer os.Setenv("GOARCH", os.Getenv("GOARCH"))
+		os.Setenv("GOARCH", arch)
+		if arch == "arm" {
+			defer os.Setenv("GOARM", os.Getenv("GOARM"))
+			os.Setenv("GOARM", defaultGoArm)
+		}
+	}
+	goCmd := append([]string{"go"}, cmds...)
+	testutils.ExecCommand(goCmd...)
+}

=== added directory '_integration-tests/testutils/common'
=== added file '_integration-tests/testutils/common/common.go'
--- _integration-tests/testutils/common/common.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/common/common.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,379 @@
+// -*- 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 common
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	check "gopkg.in/check.v1"
+
+	"launchpad.net/snappy/_integration-tests/testutils/config"
+)
+
+const (
+	// BaseAltPartitionPath is the path to the B system partition.
+	BaseAltPartitionPath = "/writable/cache/system"
+	needsRebootFile      = "/tmp/needs-reboot"
+	channelCfgFile       = "/etc/system-image/channel.ini"
+)
+
+// Cfg is a struct that contains the configuration values passed from the
+// host to the testbed.
+var Cfg *config.Config
+
+// SnappySuite is a structure used as a base test suite for all the snappy
+// integration tests.
+type SnappySuite struct {
+	cleanupHandlers []func()
+}
+
+// SetUpSuite disables the snappy autopilot. It will run before all the
+// integration suites.
+func (s *SnappySuite) SetUpSuite(c *check.C) {
+	ExecCommand(c, "sudo", "systemctl", "stop", "snappy-autopilot.timer")
+	ExecCommand(c, "sudo", "systemctl", "disable", "snappy-autopilot.timer")
+	if !isInRebootProcess() {
+		var err error
+		Cfg, err = config.ReadConfig(
+			"_integration-tests/data/output/testconfig.json")
+		c.Assert(err, check.IsNil, check.Commentf("Error reading config: %v", err))
+		if Cfg.Update || Cfg.Rollback {
+			switchSystemImageConf(c, Cfg.TargetRelease, Cfg.TargetChannel, "0")
+			// Always use the installed snappy because we are updating from an old
+			// image, so we should not use the snappy from the branch.
+			output := ExecCommand(c, "sudo", "/usr/bin/snappy", "update")
+			if output != "" {
+				RebootWithMark(c, "setupsuite-update")
+			}
+		}
+	} else if CheckRebootMark("setupsuite-update") {
+		RemoveRebootMark(c)
+		if Cfg.Rollback {
+			ExecCommand(c, "sudo", "snappy", "rollback", "ubuntu-core")
+			RebootWithMark(c, "setupsuite-rollback")
+		}
+	} else if CheckRebootMark("setupsuite-rollback") {
+		RemoveRebootMark(c)
+	}
+}
+
+// SetUpTest handles reboots and stores version information. It will run before
+// all the integration tests. Before running a test, it will save the
+// ubuntu-core version. If a reboot was requested by a previous test, it
+// will skip all the following tests. If the suite is being called after the
+// test bed was rebooted, it will resume the test that requested the reboot.
+func (s *SnappySuite) SetUpTest(c *check.C) {
+	if NeedsReboot() {
+		contents, err := ioutil.ReadFile(needsRebootFile)
+		c.Assert(err, check.IsNil, check.Commentf("Error reading needs-reboot file %v", err))
+		c.Skip(fmt.Sprintf("****** Skipped %s during reboot caused by %s",
+			c.TestName(), contents))
+	} else {
+		if CheckRebootMark("") {
+			c.Logf("****** Running %s", c.TestName())
+			SetSavedVersion(c, GetCurrentUbuntuCoreVersion(c))
+		} else {
+			if AfterReboot(c) {
+				c.Logf("****** Resuming %s after reboot", c.TestName())
+			} else {
+				c.Skip(fmt.Sprintf("****** Skipped %s after reboot caused by %s",
+					c.TestName(), os.Getenv("ADT_REBOOT_MARK")))
+			}
+		}
+	}
+	// clear slice
+	s.cleanupHandlers = nil
+}
+
+// TearDownTest cleans up the channel.ini files in case they were changed by
+// the test.
+// It also runs the cleanup handlers
+func (s *SnappySuite) TearDownTest(c *check.C) {
+	if !NeedsReboot() && CheckRebootMark("") {
+		// Only restore the channel config files if the reboot has been handled.
+		m := make(map[string]string)
+		m[channelCfgBackupFile()] = "/"
+		m[channelCfgOtherBackupFile()] = BaseAltPartitionPath
+		for backup, target := range m {
+			if _, err := os.Stat(backup); err == nil {
+				MakeWritable(c, target)
+				defer MakeReadonly(c, target)
+				original := filepath.Join(target, channelCfgFile)
+				c.Logf("Restoring %s...", original)
+				ExecCommand(c, "sudo", "mv", backup, original)
+			}
+		}
+	}
+
+	// run cleanup handlers and clear the slice
+	for _, f := range s.cleanupHandlers {
+		f()
+	}
+	s.cleanupHandlers = nil
+}
+
+// AddCleanup adds a new cleanup function to the test
+func (s *SnappySuite) AddCleanup(f func()) {
+	s.cleanupHandlers = append(s.cleanupHandlers, f)
+}
+
+func switchSystemImageConf(c *check.C, release, channel, version string) {
+	targets := []string{"/", BaseAltPartitionPath}
+	for _, target := range targets {
+		file := filepath.Join(target, channelCfgFile)
+		if _, err := os.Stat(file); err == nil {
+			MakeWritable(c, target)
+			defer MakeReadonly(c, target)
+			replaceSystemImageValues(c, file, release, channel, version)
+		}
+	}
+}
+
+func replaceSystemImageValues(c *check.C, file, release, channel, version string) {
+	c.Log("Switching the system image conf...")
+	replaceRegex := map[string]string{
+		release: `s#channel: ubuntu-core/.*/\(.*\)#channel: ubuntu-core/%s/\1#`,
+		channel: `s#channel: ubuntu-core/\(.*\)/.*#channel: ubuntu-core/\1/%s#`,
+		version: `s/build_number: .*/build_number: %s/`,
+	}
+	for value, regex := range replaceRegex {
+		if value != "" {
+			ExecCommand(c,
+				"sudo", "sed", "-i", fmt.Sprintf(regex, value), file)
+		}
+	}
+	// Leave the new file in the test log.
+	ExecCommand(c, "cat", file)
+}
+
+func channelCfgBackupFile() string {
+	return filepath.Join(os.Getenv("ADT_ARTIFACTS"), "channel.ini")
+}
+
+func channelCfgOtherBackupFile() string {
+	return filepath.Join(os.Getenv("ADT_ARTIFACTS"), "channel.ini.other")
+}
+
+// ExecCommand executes a shell command and returns a string with the output
+// of the command. In case of error, it will fail the test.
+func ExecCommand(c *check.C, cmds ...string) string {
+	fmt.Println(strings.Join(cmds, " "))
+	cmd := exec.Command(cmds[0], cmds[1:len(cmds)]...)
+	output, err := cmd.CombinedOutput()
+	stringOutput := string(output)
+	fmt.Print(stringOutput)
+	c.Assert(err, check.IsNil, check.Commentf("Error: %v", stringOutput))
+	return stringOutput
+}
+
+// ExecCommandToFile executes a shell command and saves the output of the
+// command to a file. In case of error, it will fail the test.
+func ExecCommandToFile(c *check.C, filename string, cmds ...string) {
+	cmd := exec.Command(cmds[0], cmds[1:len(cmds)]...)
+	outfile, err := os.Create(filename)
+	c.Assert(err, check.IsNil, check.Commentf("Error creating output file %s", filename))
+
+	defer outfile.Close()
+	cmd.Stdout = outfile
+
+	err = cmd.Run()
+	c.Assert(err, check.IsNil, check.Commentf("Error executing command '%v': %v", cmds, err))
+}
+
+// GetCurrentVersion returns the version of the installed and active package.
+func GetCurrentVersion(c *check.C, packageName string) string {
+	output := ExecCommand(c, "snappy", "list")
+	pattern := "(?mU)^" + packageName + " +(.*)$"
+	re := regexp.MustCompile(pattern)
+	match := re.FindStringSubmatch(string(output))
+	c.Assert(match, check.NotNil, check.Commentf("Version not found in %s", output))
+
+	// match is like "ubuntu-core   2015-06-18 93        ubuntu"
+	items := strings.Fields(match[0])
+	return items[2]
+}
+
+// GetCurrentUbuntuCoreVersion returns the version number of the installed and
+// active ubuntu-core.
+func GetCurrentUbuntuCoreVersion(c *check.C) int {
+	versionString := GetCurrentVersion(c, "ubuntu-core")
+	version, err := strconv.Atoi(versionString)
+	c.Assert(err, check.IsNil, check.Commentf("Error converting version to int %v", version))
+	return version
+}
+
+// CallFakeUpdate calls snappy update after faking the current version
+func CallFakeUpdate(c *check.C) string {
+	c.Log("Preparing fake and calling update.")
+	fakeAvailableUpdate(c)
+	return ExecCommand(c, "sudo", "snappy", "update")
+}
+
+func fakeAvailableUpdate(c *check.C) {
+	c.Log("Faking an available update...")
+	currentVersion := GetCurrentUbuntuCoreVersion(c)
+	switchChannelVersionWithBackup(c, currentVersion-1)
+	SetSavedVersion(c, currentVersion-1)
+}
+
+func switchChannelVersionWithBackup(c *check.C, newVersion int) {
+	m := make(map[string]string)
+	m["/"] = channelCfgBackupFile()
+	m[BaseAltPartitionPath] = channelCfgOtherBackupFile()
+	for target, backup := range m {
+		file := filepath.Join(target, channelCfgFile)
+		if _, err := os.Stat(file); err == nil {
+			MakeWritable(c, target)
+			defer MakeReadonly(c, target)
+			// Back up the file. It will be restored during the test tear down.
+			ExecCommand(c, "cp", file, backup)
+			replaceSystemImageValues(c, file, "", "", strconv.Itoa(newVersion))
+		}
+	}
+}
+
+// MakeWritable remounts a path with read and write permissions.
+func MakeWritable(c *check.C, path string) {
+	ExecCommand(c, "sudo", "mount", "-o", "remount,rw", path)
+}
+
+// MakeReadonly remounts a path with only read permissions.
+func MakeReadonly(c *check.C, path string) {
+	ExecCommand(c, "sudo", "mount", "-o", "remount,ro", path)
+}
+
+// Reboot requests a reboot using the test name as the mark.
+func Reboot(c *check.C) {
+	RebootWithMark(c, c.TestName())
+}
+
+// RebootWithMark requests a reboot using a specified mark.
+func RebootWithMark(c *check.C, mark string) {
+	c.Log("Preparing reboot with mark " + mark)
+	err := ioutil.WriteFile(needsRebootFile, []byte(mark), 0777)
+	c.Assert(err, check.IsNil, check.Commentf("Error writing needs-reboot file: %v", err))
+}
+
+// NeedsReboot returns True if a reboot has been requested by a test.
+func NeedsReboot() bool {
+	_, err := os.Stat(needsRebootFile)
+	return err == nil
+}
+
+// BeforeReboot returns True if the test is running before the test bed has
+// been rebooted, or after the test that requested the reboot handled it.
+func BeforeReboot() bool {
+	return CheckRebootMark("")
+}
+
+// AfterReboot returns True if the test is running after the test bed has been
+// rebooted.
+func AfterReboot(c *check.C) bool {
+	// $ADT_REBOOT_MARK contains the reboot mark, if we have rebooted it'll be the test name
+	return strings.HasPrefix(os.Getenv("ADT_REBOOT_MARK"), c.TestName())
+}
+
+// CheckRebootMark returns True if the reboot mark matches the string passed as
+// argument.
+func CheckRebootMark(mark string) bool {
+	return os.Getenv("ADT_REBOOT_MARK") == mark
+}
+
+func isInRebootProcess() bool {
+	return !CheckRebootMark("") || NeedsReboot()
+}
+
+// RemoveRebootMark removes the reboot mark to signal that the reboot has been
+// handled.
+func RemoveRebootMark(c *check.C) {
+	os.Setenv("ADT_REBOOT_MARK", "")
+}
+
+// SetSavedVersion saves a version number into a file so it can be used on
+// tests after reboots.
+func SetSavedVersion(c *check.C, version int) {
+	versionFile := getVersionFile()
+	err := ioutil.WriteFile(versionFile, []byte(strconv.Itoa(version)), 0777)
+	c.Assert(err, check.IsNil, check.Commentf("Error writing version file %s with %s", versionFile, version))
+}
+
+// GetSavedVersion returns the saved version number.
+func GetSavedVersion(c *check.C) int {
+	versionFile := getVersionFile()
+	contents, err := ioutil.ReadFile(versionFile)
+	c.Assert(err, check.IsNil, check.Commentf("Error reading version file %s", versionFile))
+
+	version, err := strconv.Atoi(string(contents))
+	c.Assert(err, check.IsNil, check.Commentf("Error converting version %v", contents))
+
+	return version
+}
+
+func getVersionFile() string {
+	return filepath.Join(os.Getenv("ADT_ARTIFACTS"), "version")
+}
+
+// InstallSnap executes the required command to install the specified snap
+func InstallSnap(c *check.C, packageName string) string {
+	return ExecCommand(c, "sudo", "snappy", "install", packageName, "--allow-unauthenticated")
+}
+
+// RemoveSnap executes the required command to remove the specified snap
+func RemoveSnap(c *check.C, packageName string) string {
+	return ExecCommand(c, "sudo", "snappy", "remove", packageName)
+}
+
+// WaitForActiveService keeps asking for the active state of the given service until
+// it is active or the maximun waiting time expires, in which case an error is returned
+func WaitForActiveService(c *check.C, serviceName string) error {
+	maxWait := time.Second * 10
+	checkInterval := time.Millisecond * 500
+
+	timer := time.NewTimer(maxWait)
+	timeChan := timer.C
+
+	ticker := time.NewTicker(checkInterval)
+	tickChan := ticker.C
+
+	for {
+		select {
+		case <-timeChan:
+			ticker.Stop()
+			journalctlOutput := ExecCommand(c, "sudo", "journalctl", "-u", serviceName)
+			return fmt.Errorf("Service %s not active after %s, journalctl output: %s",
+				serviceName, maxWait, journalctlOutput)
+		case <-tickChan:
+			statusOutput := ExecCommand(
+				c, "systemctl", "show", "-p", "ActiveState", serviceName)
+			if statusOutput == "ActiveState=active\n" {
+				timer.Stop()
+				return nil
+			}
+		}
+	}
+}

=== added file '_integration-tests/testutils/common/common_test.go'
--- _integration-tests/testutils/common/common_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/common/common_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,68 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package common
+
+import (
+	"testing"
+
+	. "gopkg.in/check.v1"
+)
+
+// Hook up check.v1 into the "go test" runner
+func Test(t *testing.T) { TestingT(t) }
+
+// testing a testsuite - thats so meta
+type MetaTestSuite struct {
+}
+
+var _ = Suite(&MetaTestSuite{})
+
+// test trivial cleanup
+func (m *MetaTestSuite) TestCleanupSimple(c *C) {
+	canary := "not-called"
+	s := SnappySuite{}
+
+	s.AddCleanup(func() {
+		canary = "was-called"
+	})
+	s.TearDownTest(c)
+
+	c.Assert(canary, Equals, "was-called")
+}
+
+// a mock method that takes a parameter
+func mockCleanupMethodWithParameters(s *string) {
+	*s = "was-called"
+}
+
+// test that whle AddCleanup() does not take any parameters itself,
+// functions that need parameters can be passed by creating an
+// anonymous function as a wrapper
+func (m *MetaTestSuite) TestCleanupWithParameters(c *C) {
+	canary := "not-called"
+	s := SnappySuite{}
+
+	s.AddCleanup(func() {
+		mockCleanupMethodWithParameters(&canary)
+	})
+	s.TearDownTest(c)
+
+	c.Assert(canary, Equals, "was-called")
+}

=== added directory '_integration-tests/testutils/config'
=== added file '_integration-tests/testutils/config/config.go'
--- _integration-tests/testutils/config/config.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/config/config.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,75 @@
+// -*- 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 config
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+)
+
+// Config contains the values to pass to the test bed from the host.
+type Config struct {
+	FileName      string
+	Release       string
+	Channel       string
+	TargetRelease string
+	TargetChannel string
+	RemoteTestbed bool
+	Update        bool
+	Rollback      bool
+}
+
+// NewConfig is the Config constructor
+func NewConfig(fileName, release, channel, targetRelease, targetChannel string, remoteTestbed, update, rollback bool) *Config {
+	return &Config{
+		FileName: fileName, Release: release, Channel: channel,
+		TargetRelease: targetRelease, TargetChannel: targetChannel,
+		RemoteTestbed: remoteTestbed, Update: update, Rollback: rollback,
+	}
+}
+
+// Write writes the config to a file that will be copied to the test bed.
+func (cfg Config) Write() {
+	fmt.Println("Writing test config...")
+	fmt.Println(cfg)
+	encoded, err := json.Marshal(cfg)
+	if err != nil {
+		log.Panicf("Error encoding the test config: %v", err)
+	}
+	err = ioutil.WriteFile(cfg.FileName, encoded, 0644)
+	if err != nil {
+		log.Panicf("Error writing the test config: %v", err)
+	}
+}
+
+// ReadConfig the config from a file
+func ReadConfig(fileName string) (*Config, error) {
+	b, err := ioutil.ReadFile(fileName)
+	if err != nil {
+		return nil, err
+	}
+	var decoded Config
+	if err = json.Unmarshal(b, &decoded); err != nil {
+		return nil, err
+	}
+	return &decoded, nil
+}

=== added file '_integration-tests/testutils/config/config.test'
Binary files _integration-tests/testutils/config/config.test	1970-01-01 00:00:00 +0000 and _integration-tests/testutils/config/config.test	2015-09-08 06:47:52 +0000 differ
=== added file '_integration-tests/testutils/config/config_test.go'
--- _integration-tests/testutils/config/config_test.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/config/config_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,121 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package config
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	check "gopkg.in/check.v1"
+)
+
+// Hook up check.v1 into the "go test" runner
+func Test(t *testing.T) { check.TestingT(t) }
+
+type ConfigSuite struct{}
+
+var _ = check.Suite(&ConfigSuite{})
+
+func testConfigFileName(c *check.C) string {
+	tmpDir, err := ioutil.TempDir("", "")
+	c.Assert(err, check.IsNil, check.Commentf(
+		"Error creating a temporary directory: %v", err))
+	return filepath.Join(tmpDir, "test.config")
+}
+
+func testConfigStruct(fileName string) *Config {
+	return NewConfig(
+		fileName,
+		"testrelease", "testchannel", "testtargetrelease", "testtargetchannel",
+		true, true, true)
+}
+func testConfigContents(fileName string) string {
+	return `{` +
+		fmt.Sprintf(`"FileName":"%s",`, fileName) +
+		`"Release":"testrelease",` +
+		`"Channel":"testchannel",` +
+		`"TargetRelease":"testtargetrelease",` +
+		`"TargetChannel":"testtargetchannel",` +
+		`"RemoteTestbed":true,` +
+		`"Update":true,` +
+		`"Rollback":true` +
+		`}`
+}
+
+func (s *ConfigSuite) TestWriteConfig(c *check.C) {
+	// Do not print to stdout.
+	devnull, err := os.Open(os.DevNull)
+	c.Assert(err, check.IsNil)
+	oldStdout := os.Stdout
+	os.Stdout = devnull
+	defer func() {
+		os.Stdout = oldStdout
+	}()
+	configFileName := testConfigFileName(c)
+
+	cfg := testConfigStruct(configFileName)
+	cfg.Write()
+
+	writtenConfig, err := ioutil.ReadFile(configFileName)
+	c.Assert(err, check.IsNil, check.Commentf("Error reading config: %v", err))
+	c.Assert(string(writtenConfig), check.Equals, testConfigContents(configFileName))
+}
+
+func (s *ConfigSuite) TestReadConfig(c *check.C) {
+	configFileName := testConfigFileName(c)
+
+	configContents := testConfigContents(configFileName)
+	ioutil.WriteFile(configFileName, []byte(configContents), 0644)
+
+	cfg, err := ReadConfig(configFileName)
+
+	c.Assert(err, check.IsNil, check.Commentf("Error reading config: %v", err))
+	c.Assert(cfg, check.DeepEquals, testConfigStruct(configFileName))
+}
+
+func (s *ConfigSuite) TestReadConfigLocalTestBed(c *check.C) {
+	configFileName := testConfigFileName(c)
+
+	configContents := `{` +
+		fmt.Sprintf(`"FileName":"%s",`, configFileName) +
+		`"Release":"testrelease",` +
+		`"Channel":"testchannel",` +
+		`"TargetRelease":"testtargetrelease",` +
+		`"TargetChannel":"testtargetchannel",` +
+		`"RemoteTestbed":false,` +
+		`"Update":true,` +
+		`"Rollback":true` +
+		`}`
+
+	ioutil.WriteFile(configFileName, []byte(configContents), 0644)
+
+	cfg, err := ReadConfig(configFileName)
+
+	testConfigStruct := NewConfig(
+		configFileName,
+		"testrelease", "testchannel", "testtargetrelease", "testtargetchannel",
+		false, true, true)
+
+	c.Assert(err, check.IsNil, check.Commentf("Error reading config: %v", err))
+	c.Assert(cfg, check.DeepEquals, testConfigStruct)
+}

=== added directory '_integration-tests/testutils/image'
=== added file '_integration-tests/testutils/image/image.go'
--- _integration-tests/testutils/image/image.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/image/image.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,86 @@
+// -*- 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 image
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"launchpad.net/snappy/_integration-tests/testutils"
+)
+
+// Image type encapsulates image actions
+type Image struct {
+	release  string
+	channel  string
+	revision string
+	baseDir  string
+}
+
+// NewImage is the Image constructor
+func NewImage(release, channel, revision, baseDir string) *Image {
+	return &Image{release: release, channel: channel, revision: revision, baseDir: baseDir}
+}
+
+// UdfCreate forms and executes the UDF command for creating the image
+func (img Image) UdfCreate() (string, error) {
+	fmt.Println("Creating image...")
+
+	imageDir := filepath.Join(img.baseDir, "image")
+
+	testutils.PrepareTargetDir(imageDir)
+
+	udfCommand := []string{"sudo", "ubuntu-device-flash", "--verbose"}
+
+	if img.revision != "" {
+		udfCommand = append(udfCommand, "--revision", img.revision)
+	}
+
+	imagePath := img.imagePath(imageDir)
+
+	coreOptions := []string{
+		"core", img.release,
+		"--output", imagePath,
+		"--channel", img.channel,
+		"--developer-mode",
+	}
+
+	err := testutils.ExecCommand(append(udfCommand, coreOptions...)...)
+
+	return imagePath, err
+}
+
+func (img Image) imagePath(imageDir string) string {
+	revisionTag := img.revision
+	if revisionTag == "" {
+		revisionTag = "latest"
+	}
+
+	imageName := strings.Join(
+		[]string{"snappy", img.release, img.channel, revisionTag}, "-") + ".img"
+
+	return filepath.Join(imageDir, imageName)
+}
+
+// SetRevision is the setter method for revision
+func (img Image) SetRevision(rev string) {
+	img.revision = rev
+}

=== added file '_integration-tests/testutils/testutils.go'
--- _integration-tests/testutils/testutils.go	1970-01-01 00:00:00 +0000
+++ _integration-tests/testutils/testutils.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,61 @@
+// -*- 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 testutils
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"strings"
+)
+
+// PrepareTargetDir creates the given target directory, removing it previously if it didn't exist
+func PrepareTargetDir(targetDir string) {
+	if _, err := os.Stat(targetDir); err == nil {
+		// dir exists, remove it
+		os.RemoveAll(targetDir)
+	}
+	os.MkdirAll(targetDir, 0777)
+}
+
+// RootPath return the test current working directory.
+func RootPath() string {
+	dir, err := os.Getwd()
+	if err != nil {
+		log.Panic(err)
+	}
+	return dir
+}
+
+// ExecCommand executes the given command and pipes the results to os.Stdout and os.Stderr, returning the resulting error
+func ExecCommand(cmds ...string) error {
+	fmt.Println(strings.Join(cmds, " "))
+
+	cmd := exec.Command(cmds[0], cmds[1:]...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	err := cmd.Run()
+	if err != nil {
+		log.Panicf("Error while running %s: %s\n", cmd.Args, err)
+	}
+	return err
+}

=== modified file 'clickdeb/deb.go'
=== modified file 'clickdeb/deb_test.go'
=== modified file 'cmd/snappy/cmd_internal_unpack.go'
--- cmd/snappy/cmd_internal_unpack.go	2015-07-02 16:01:11 +0000
+++ cmd/snappy/cmd_internal_unpack.go	2015-09-08 06:47:52 +0000
@@ -129,6 +129,7 @@
 
 		// first find out what user to use
 		passFile := passwdFile(rootDir, "passwd")
+<<<<<<< TREE
 		for _, dropPrivsUser = range dropPrivsUsers {
 			_, err := readUID(dropPrivsUser, passFile)
 			if err == nil {
@@ -138,6 +139,9 @@
 
 		// then get uid/gid
 		uid, err := readUID(dropPrivsUser, passFile)
+=======
+		uid, err := readUID(dropPrivsUser, passFile)
+>>>>>>> MERGE-SOURCE
 		if err != nil {
 			return err
 		}

=== modified file 'cmd/snappy/cmd_internal_unpack_test.go'
--- cmd/snappy/cmd_internal_unpack_test.go	2015-07-02 16:01:11 +0000
+++ cmd/snappy/cmd_internal_unpack_test.go	2015-09-08 06:47:52 +0000
@@ -42,7 +42,11 @@
 snappypkg:x:101:104::/nonexistent:/bin/false
 `)
 
+<<<<<<< TREE
 	uid, err := readUID("snappypkg", f.Name())
+=======
+	uid, err := readUID("clickpkg", f.Name())
+>>>>>>> MERGE-SOURCE
 	c.Assert(err, IsNil)
 	c.Assert(uid, Equals, 101)
 }
@@ -53,7 +57,11 @@
 snappypkg:x:104:
 `)
 
+<<<<<<< TREE
 	gid, err := readUID("snappypkg", f.Name())
+=======
+	gid, err := readUID("clickpkg", f.Name())
+>>>>>>> MERGE-SOURCE
 	c.Assert(err, IsNil)
 	c.Assert(gid, Equals, 104)
 }
@@ -66,7 +74,11 @@
 `)
 	defer os.Remove(f.Name())
 
+<<<<<<< TREE
 	uid, err := readUID("snappypkg", f.Name())
+=======
+	uid, err := readUID("clickpkg", f.Name())
+>>>>>>> MERGE-SOURCE
 	c.Assert(err, IsNil)
 	c.Assert(uid, Equals, 102)
 }
@@ -77,7 +89,11 @@
 snappypkg:x:
 `)
 
+<<<<<<< TREE
 	_, err := readUID("snappypkg", f.Name())
+=======
+	_, err := readUID("clickpkg", f.Name())
+>>>>>>> MERGE-SOURCE
 	c.Assert(err, NotNil)
 }
 
@@ -86,6 +102,10 @@
 daemon:
 `)
 
+<<<<<<< TREE
 	_, err := readUID("snappypkg", f.Name())
+=======
+	_, err := readUID("clickpkg", f.Name())
+>>>>>>> MERGE-SOURCE
 	c.Assert(err, NotNil)
 }

=== modified file 'cmd/snappy/cmd_rollback.go'
--- cmd/snappy/cmd_rollback.go	2015-07-09 06:05:53 +0000
+++ cmd/snappy/cmd_rollback.go	2015-09-08 06:47:52 +0000
@@ -79,5 +79,14 @@
 	parts := snappy.FindSnapsByNameAndVersion(pkg, nowVersion, installed)
 	showVerboseList(parts, os.Stdout)
 
+	m := snappy.NewMetaRepository()
+	installed, err := m.Installed()
+	if err != nil {
+		return err
+	}
+
+	parts := snappy.FindSnapsByNameAndVersion(pkg, nowVersion, installed)
+	showVerboseList(parts, os.Stdout)
+
 	return nil
 }

=== modified file 'cmd/snappy/cmd_set.go'
--- cmd/snappy/cmd_set.go	2015-06-30 12:52:52 +0000
+++ cmd/snappy/cmd_set.go	2015-09-08 06:47:52 +0000
@@ -23,8 +23,12 @@
 	"fmt"
 	"strings"
 
+<<<<<<< TREE
 	"launchpad.net/snappy/i18n"
 	"launchpad.net/snappy/logger"
+=======
+	"launchpad.net/snappy/priv"
+>>>>>>> MERGE-SOURCE
 	"launchpad.net/snappy/progress"
 	"launchpad.net/snappy/snappy"
 )
@@ -53,8 +57,18 @@
 }
 
 func (x *cmdSet) Execute(args []string) (err error) {
+<<<<<<< TREE
 	x.args = args
 	return withMutex(x.doSet)
+=======
+	privMutex := priv.New()
+	if err := privMutex.TryLock(); err != nil {
+		return err
+	}
+	defer privMutex.Unlock()
+
+	return set(args)
+>>>>>>> MERGE-SOURCE
 }
 
 func (x *cmdSet) doSet() (err error) {

=== modified file 'cmd/snappy/cmd_set_test.go'
--- cmd/snappy/cmd_set_test.go	2015-07-08 07:58:40 +0000
+++ cmd/snappy/cmd_set_test.go	2015-09-08 06:47:52 +0000
@@ -20,9 +20,26 @@
 package main
 
 import (
-	. "gopkg.in/check.v1"
+<<<<<<< TREE
+	. "gopkg.in/check.v1"
+=======
+	"testing"
+
+	. "gopkg.in/check.v1"
+>>>>>>> MERGE-SOURCE
 )
 
+<<<<<<< TREE
+=======
+// Hook up check.v1 into the "go test" runner
+func Test(t *testing.T) { TestingT(t) }
+
+type CmdTestSuite struct {
+}
+
+var _ = Suite(&CmdTestSuite{})
+
+>>>>>>> MERGE-SOURCE
 func (s *CmdTestSuite) TestParseSetPropertyCmdline(c *C) {
 
 	// simple case

=== modified file 'cmd/snappy/main.go'
--- cmd/snappy/main.go	2015-06-11 20:30:46 +0000
+++ cmd/snappy/main.go	2015-09-08 06:47:52 +0000
@@ -52,10 +52,14 @@
 			// the CLI user.
 			err = snappy.ErrNeedRoot
 		}
+<<<<<<< TREE
 		fmt.Fprintln(os.Stderr, err)
 		if _, ok := err.(*flags.Error); !ok {
 			logger.Debugf("%v failed: %v", os.Args, err)
 		}
+=======
+		fmt.Fprintln(os.Stderr, err)
+>>>>>>> MERGE-SOURCE
 		os.Exit(1)
 	}
 }

=== modified file 'coreconfig/config_test.go'
=== modified file 'debian/control'
--- debian/control	2015-07-21 19:07:56 +0000
+++ debian/control	2015-09-08 06:47:52 +0000
@@ -9,17 +9,26 @@
                fakeroot,
                gettext,
                golang-ar-dev,
+<<<<<<< TREE
                golang-check.v1-dev,
                golang-gettext-dev,
+=======
+               golang-check.v1-dev,
+>>>>>>> MERGE-SOURCE
                golang-go,
                golang-go-flags-dev,
                golang-go.crypto-dev,
                golang-goconfigparser-dev,
                golang-pb-dev,
+<<<<<<< TREE
                golang-uboot-go-dev,
                golang-yaml.v2-dev,
                python3,
                python3-markdown
+=======
+               golang-uboot-go-dev,
+               golang-yaml.v2-dev
+>>>>>>> MERGE-SOURCE
 Standards-Version: 3.9.6
 Homepage: https://launchpad.net/snappy
 Vcs-Browser: http://bazaar.launchpad.net/~snappy-dev/snappy/trunk/files

=== modified file 'debian/rules'
--- debian/rules	2015-08-24 08:27:39 +0000
+++ debian/rules	2015-09-08 06:47:52 +0000
@@ -54,6 +54,7 @@
 		--no-start \
 		-pubuntu-snappy \
 		snappy-autopilot.service
+<<<<<<< TREE
 	# start wait4network
 	dh_systemd_start \
 		-pubuntu-snappy \
@@ -68,6 +69,14 @@
 	GOPATH=${BUILDDIR} go generate ./i18n
 
 override_dh_auto_install: snappy.8
+=======
+	# start wait4network
+	dh_systemd_start \
+		-pubuntu-snappy \
+		snappy-wait4network.service
+
+override_dh_auto_install:
+>>>>>>> MERGE-SOURCE
 	dh_auto_install -O--buildsystem=golang
 	# Making the packages private
 	rm -rf ${CURDIR}/debian/ubuntu-snappy/usr/share/gocode

=== added file 'debian/snappy-wait4network.service'
--- debian/snappy-wait4network.service	1970-01-01 00:00:00 +0000
+++ debian/snappy-wait4network.service	2015-09-08 06:47:52 +0000
@@ -0,0 +1,10 @@
+[Unit]
+Description=Wait for network
+After=network-online.target
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+TimeoutStartSec=0
+ExecStart=/bin/sh -ec 'while [ -z "$( /sbin/ip route show 0/0 )" ]; do sleep 5; done'
+

=== renamed file 'debian/snappy-wait4network.service' => 'debian/snappy-wait4network.service.moved'
=== modified file 'dependencies.tsv'
--- dependencies.tsv	2015-08-18 13:34:46 +0000
+++ dependencies.tsv	2015-09-08 06:47:52 +0000
@@ -3,7 +3,12 @@
 github.com/gosexy/gettext	git	98b7b91596d20b96909e6b60d57411547dd9959c	2013-02-21T11:21:43Z
 github.com/jessevdk/go-flags	git	1acbbaff2f347c412a0c7884873bd72cc9c1f5b4	2015-08-16T10:05:21Z
 github.com/mvo5/goconfigparser	git	26426272dda20cc76aa1fa44286dc743d2972fe8	2015-02-12T09:37:50Z
+<<<<<<< TREE
 github.com/mvo5/uboot-go	git	361f6ebcbb54f389d15dc9faefa000e996ba3e37	2015-07-22T06:53:46Z
 golang.org/x/crypto	git	60052bd85f2d91293457e8811b0cf26b773de469	2015-06-22T23:34:07Z
 gopkg.in/check.v1	git	64131543e7896d5bcc6bd5a76287eb75ea96c673	2014-10-24T13:38:53Z
+=======
+github.com/mvo5/uboot-go	git	361f6ebcbb54f389d15dc9faefa000e996ba3e37	2015-07-22T06:53:46Z
+gopkg.in/check.v1	git	64131543e7896d5bcc6bd5a76287eb75ea96c673	2014-10-24T13:38:53Z
+>>>>>>> MERGE-SOURCE
 gopkg.in/yaml.v2	git	49c95bdc21843256fb6c4e0d370a05f24a0bf213	2015-02-24T22:57:58Z

=== added directory 'etc'
=== added directory 'etc/grub.d'
=== added file 'etc/grub.d/09_snappy.OTHER'
--- etc/grub.d/09_snappy.OTHER	1970-01-01 00:00:00 +0000
+++ etc/grub.d/09_snappy.OTHER	2015-09-08 06:47:52 +0000
@@ -0,0 +1,441 @@
+#!/bin/sh
+#---------------------------------------------------------------------
+# Summary: Grub bootloader logic for Ubuntu Snappy systems.
+# Description: This is a heavily modified "10_linux" grub snippet that
+#   deals with Snappy dual-rootfs systems.
+#
+# XXX: Note that this script is called from within a chroot environment
+# on snappy systems!
+#
+#---------------------------------------------------------------------
+
+set -e
+
+prefix="/usr"
+exec_prefix="/usr"
+datarootdir="/usr/share"
+
+# Utility functions
+. "${datarootdir}/grub/grub-mkconfig_lib"
+
+# Globals
+machine=`uname -m`
+
+SNAPPY_OS="Ubuntu Core Snappy"
+SNAPPY_TYPE=simple
+
+#---------------------------------------------------------------------
+
+# Display message and exit
+die()
+{
+    msg="$*"
+    echo "ERROR: $msg" >&2
+    exit 1
+}
+
+# Create a grub menu entry by writing a menuentry to stdout.
+linux_entry_ext()
+{
+  local name="$1"
+  local os="$2"
+  local version="$3"
+  local type="$4"
+  local args="$5"
+  local device="$6"
+  local kernel="$7"
+  local initrd="$8"
+
+  local boot_device_id=
+  local prepare_root_cache=
+  local prepare_boot_cache=
+
+  if [ -z "$boot_device_id" ]; then
+      boot_device_id="$(grub_get_device_id "${device}")"
+  fi
+
+  echo "menuentry '$name' ${CLASS} \$menuentry_id_option 'gnulinux-simple-$boot_device_id' {" | sed "s/^/$submenu_indentation/"
+
+  if [ x$type != xrecovery ] ; then
+      save_default_entry | grub_add_tab
+  fi
+
+  # Use ELILO's generic "efifb" when it's known to be available.
+  # FIXME: We need an interface to select vesafb in case efifb can't be used.
+  if [ "x$GRUB_GFXPAYLOAD_LINUX" = x ]; then
+      echo "	load_video" | sed "s/^/$submenu_indentation/"
+  else
+      if [ "x$GRUB_GFXPAYLOAD_LINUX" != xtext ]; then
+	  echo "	load_video" | sed "s/^/$submenu_indentation/"
+      fi
+  fi
+  if ([ "$ubuntu_recovery" = 0 ] || [ x$type != xrecovery ]) && \
+     ([ "x$GRUB_GFXPAYLOAD_LINUX" != x ] || [ "$gfxpayload_dynamic" = 1 ]); then
+      echo "	gfxmode \$linux_gfx_mode" | sed "s/^/$submenu_indentation/"
+  fi
+
+  echo "	insmod gzio" | sed "s/^/$submenu_indentation/"
+  echo "	if [ x\$grub_platform = xxen ]; then insmod xzio; insmod lzopio; fi" | sed "s/^/$submenu_indentation/"
+
+  # device may be a label (LABEL=name), so convert back to full path
+  label_name=$(echo "$device"|sed 's/^LABEL=//g')
+  if [ "$device" = "$label_name" ]
+  then
+    device_path="$device"
+  else
+    # found a label
+    device_path=$(get_partition_from_label "$label_name")
+  fi
+
+  if [ x$dirname = x/ ]; then
+    if [ -z "${prepare_root_cache}" ]; then
+
+      prepare_root_cache="$(prepare_grub_to_access_device ${device_path} | grub_add_tab)"
+    fi
+    printf '%s\n' "${prepare_root_cache}" | sed "s/^/$submenu_indentation/"
+  else
+    if [ -z "${prepare_boot_cache}" ]; then
+      prepare_boot_cache="$(prepare_grub_to_access_device ${device_path} | grub_add_tab)"
+    fi
+    printf '%s\n' "${prepare_boot_cache}" | sed "s/^/$submenu_indentation/"
+  fi
+
+  if [ x"$quiet_boot" = x0 ] || [ x"$type" != xsimple ]; then
+    message="$(gettext_printf "Loading Linux %s ..." ${version})"
+    sed "s/^/$submenu_indentation/" << EOF
+	echo	'$(echo "$message" | grub_quote)'
+EOF
+  fi
+
+    sed "s/^/$submenu_indentation/" << EOF
+	linux ${kernel} root=${device} ro ${args}
+EOF
+
+  if test -n "${initrd}"; then
+    # TRANSLATORS: ramdisk isn't identifier. Should be translated.
+    if [ x"$quiet_boot" = x0 ] || [ x"$type" != xsimple ]; then
+      message="$(gettext_printf "Loading initial ramdisk ...")"
+      sed "s/^/$submenu_indentation/" << EOF
+	echo	'$(echo "$message" | grub_quote)'
+EOF
+    fi
+    sed "s/^/$submenu_indentation/" << EOF
+	initrd ${initrd}
+EOF
+  fi
+
+  sed "s/^/$submenu_indentation/" << EOF
+}
+EOF
+}
+
+# Returns a list of the currently available kernels.
+# $1: If set, look for kernel below "$1/boot/".
+get_kernels()
+{
+    local prefix_dir="$1"
+    local list
+
+    case "x$machine" in
+    xi?86 | xx86_64)
+    list=`for i in $prefix_dir/boot/vmlinuz-* \
+                         $prefix_dir/vmlinuz-* \
+                         $prefix_dir/boot/kernel-* ; do
+                  if grub_file_is_not_garbage "$i" ; then echo -n "$i " ; fi
+              done` ;;
+    *) 
+    list=`for i in $prefix_dir/boot/vmlinuz-* \
+                         $prefix_dir/boot/vmlinux-* \
+                         $prefix_dir/vmlinuz-* \
+                         $prefix_dir/vmlinux-* \
+                         $prefix_dir/boot/kernel-* ; do
+                  if grub_file_is_not_garbage "$i" ; then echo -n "$i " ; fi
+         done` ;;
+    esac
+    echo "$list"
+}
+
+# Composes and returns a kernel cmd line
+get_cmdline() {
+    channel_ini="/etc/system-image/channel.ini"
+    grep -q 'device: azure_amd64' "$channel_ini" && azure_cmdline="rootdelay=300"
+
+    echo "${GRUB_CMDLINE_LINUX} ${GRUB_CMDLINE_LINUX_DEFAULT} $azure_cmdline"
+}
+
+# Returns the path to the initrd for the kernel specified by $1.
+# $1: kernel version.
+# $2: directory to look in.
+get_initrd()
+{
+  local version="$1"
+  local dir="$2"
+
+  local alt_version=`echo $version | sed -e "s,\.old$,,g"`
+  local initrd=
+  local i=
+
+  for i in "initrd.img-${version}" "initrd-${version}.img" "initrd-${version}.gz" \
+           "initrd-${version}" "initramfs-${version}.img" \
+           "initrd.img-${alt_version}" "initrd-${alt_version}.img" \
+           "initrd-${alt_version}" "initramfs-${alt_version}.img" \
+           "initramfs-genkernel-${version}" \
+           "initramfs-genkernel-${alt_version}" \
+           "initramfs-genkernel-${GENKERNEL_ARCH}-${version}" \
+           "initramfs-genkernel-${GENKERNEL_ARCH}-${alt_version}"; do
+    if test -e "${dir}/${i}" ; then
+      initrd="${dir}/${i}"
+      break
+    fi
+  done
+  echo "$initrd"
+}
+
+# Determine full path to disk partition given a filesystem label.
+get_partition_from_label()
+{
+    local label="$1"
+    local part=
+    local path=
+
+    [ -n "$label" ] || grub_warn "need FS label"
+
+    part=$(find /dev -name "$label"|tail -1)
+    [ -z "$part" ] && return
+    path=$(readlink -f "$part")
+    [ -n "$path" ] && echo "$path"
+}
+
+# Return the partition label for the given partition device.
+# $1: full path to partition device.
+get_label_from_device()
+{
+    local root="$1"
+
+    local label=
+    local std_label=
+    local label_rootfs=
+
+    for std_label in system-a system-b; do
+        label_rootfs=$(findfs "PARTLABEL=$std_label" 2>/dev/null || :)
+        if [ "$label_rootfs" = "$root" ]; then
+            label="$std_label"
+            break
+        fi
+    done
+
+    echo "$label"
+}
+
+# Return the full path to the device corresponding to the given
+# partition label.
+#
+# $1: partition label.
+get_device_from_label()
+{
+    local label="$1"
+    local device=
+
+    device=$(findfs "PARTLABEL=$label" 2>/dev/null || :)
+    echo "$device"
+}
+
+# Given a rootfs label, return the rootfs label corresponding to the
+# "other" rootfs partition.
+get_other_rootfs_label()
+{
+    local label="$1"
+
+    if [ "$label" = "system-a" ]; then
+        echo "system-b"
+    else
+        echo "system-a"
+    fi
+}
+
+# Given a mountpoint, return the corresponding device path
+# $1: mountpoint.
+get_device_from_mountpoint()
+{
+    local mountpoint="$1"
+    local device=
+
+    # XXX: Parse mount output rather than looking in /proc/mounts to
+    # avoid seeing the mounts outside the chroot.
+    device=$(/bin/mount | grep "^/dev/.* on ${mountpoint}[[:space:]]" 2>/dev/null |\
+        awk '{print $1}' || :)
+
+    echo "$device"
+}
+
+# Convert a partition label name to a menuentry name
+make_name()
+{
+    local label="$1"
+
+    echo "$SNAPPY_OS $label rootfs" | grub_quote
+}
+
+# Arrange for a grub menuentry to be created for the given partition.
+#
+# $1: full path to rootfs partition device
+# $2: partition label associated with $1
+# $3: mountpoint of $1.
+handle_menu_entry()
+{
+    local rootfs_device="$1"
+    local label="$2"
+    local mountpoint="$3"
+
+    local name=
+    local device=
+    local mount_prefix=
+    local list=
+    local linux=
+    local basename=
+    local dirname=
+    local rel_dirname=
+    local version=
+    local initrd=
+    local cmdline=
+
+    # boot by label
+    device="LABEL=$label"
+
+    name=$(make_name "$label")
+
+    # avoid double-leading slashes and the subsequent need to call
+    # 'readlink -f'.
+    if [ "$mountpoint" = "/" ]; then
+        mount_prefix=""
+    else
+        mount_prefix="$mountpoint"
+    fi
+    list=$(get_kernels "$mount_prefix")
+
+    linux=$(version_find_latest $list)
+    basename=$(basename "$linux")
+    dirname=$(dirname "$linux")
+    rel_dirname=$(make_system_path_relative_to_its_root "$dirname")
+    version=$(echo "$basename" | sed -e "s,^[^0-9]*-,,g")
+
+    initrd=$(get_initrd "$version" "$dirname")
+
+    cmdline=$(get_cmdline)
+
+    # convert the path to the mounted "other" rootfs back to a
+    # a standard one by removing the mountpoint prefix.
+    if [ "$mountpoint" != "/" ]; then
+        linux=$(echo "$linux" | sed "s!^${mountpoint}!!g")
+        initrd=$(echo "$initrd" | sed "s!^${mountpoint}!!g")
+    fi
+
+    # Create menu entries for the 2 snappy rootfs's.
+    linux_entry_ext "$name" "$SNAPPY_OS" "$version" \
+        "$SNAPPY_TYPE" "$cmdline" "$device" \
+        "$linux" "$initrd"
+}
+
+#---------------------------------------------------------------------
+# main
+
+case "$machine" in
+    i?86) GENKERNEL_ARCH="x86" ;;
+    mips|mips64) GENKERNEL_ARCH="mips" ;;
+    mipsel|mips64el) GENKERNEL_ARCH="mipsel" ;;
+    arm*) GENKERNEL_ARCH="arm" ;;
+    *) GENKERNEL_ARCH="$machine" ;;
+esac
+
+# Determine which partition label is being used for the current root
+# directory. This is slightly convoluted but required since this code
+# runs within a chroot environment (where lsblk does not work).
+#
+# XXX: Note that since this code is run from within a chroot (where the
+# "other" rootfs is mounted), it might appear that the logic is
+# inverted. However, the code below simply 
+this_mountpoint="/"
+this_root=$(get_device_from_mountpoint "$this_mountpoint")
+[ -z "$this_root" ] && {
+    die "cannot determine rootfs for $this_mountpoint"
+}
+
+this_label=$(get_label_from_device "$this_root")
+[ -z "$this_label" ] && {
+    die "cannot determine partition label for rootfs $this_root"
+}
+
+handle_menu_entry "$this_root" "$this_label" "$this_mountpoint"
+
+other_mountpoint="/writable/cache/system"
+
+# When this script is run on a real snappy system, even if there is only
+# a single rootfs provisioned, the other rootfs partition is expected to
+# be formatted and mounted.
+#
+# However this script is also run at provisioning time where
+# $other_mountpoint will not be a mountpoint. Therefore in the provisioning
+# scenario, only a single menuentry will be generated if only a single
+# rootfs is provisioned.
+if $(mountpoint -q "$other_mountpoint"); then
+    other_label=$(get_other_rootfs_label "$this_label")
+
+    other_root=$(get_device_from_label "$other_label")
+    [ -z "$other_root" ] && {
+        die "cannot determine rootfs"
+    }
+
+    handle_menu_entry "$other_root" "$other_label" "$other_mountpoint"
+fi
+
+# Toggle rootfs if previous boot failed.
+#
+# Since grub sets snappy_trial_boot, if it is _already_ set when grub starts
+# and we're in try mode, the previous boot must have failed to unset it,
+# so toggle the rootfs.
+sed "s/^/$submenu_indentation/" << EOF
+    # set defaults
+    if [ -z "\$snappy_mode" ]; then
+        set snappy_mode=regular
+        save_env snappy_mode
+    fi
+    if [ -z "\$snappy_ab" ]; then
+        set snappy_ab=a
+        save_env snappy_ab
+    fi
+
+    if [ "\$snappy_mode" = "try" ]; then
+        if [ "\$snappy_trial_boot" = "1" ]; then
+            # Previous boot failed to unset snappy_trial_boot, so toggle
+            # rootfs.
+            if [ "\$snappy_ab" = "a" ]; then
+                set default="$(make_name system-b)"
+                set snappy_ab=b
+            else
+                set snappy_ab=a
+                set default="$(make_name system-a)"
+            fi
+            save_env snappy_ab
+        else
+            # Trial mode so set the snappy_trial_boot (which snappy is
+            # expected to unset).
+            #
+            # Note: don't use the standard recordfail variable since that forces
+            # the menu to be displayed and sets an infinite timeout if set.
+            set snappy_trial_boot=1
+            save_env snappy_trial_boot
+
+            if [ "\$snappy_ab" = "a" ]; then
+                set default="$(make_name system-a)"
+            else
+                set default="$(make_name system-b)"
+            fi
+        fi
+    else
+        if [ "\$snappy_ab" = "a" ]; then
+            set default="$(make_name system-a)"
+        else
+            set default="$(make_name system-b)"
+        fi
+    fi
+EOF

=== modified file 'helpers/cmp_test.go'
=== modified file 'helpers/helpers.go'
--- helpers/helpers.go	2015-09-01 10:00:49 +0000
+++ helpers/helpers.go	2015-09-08 06:47:52 +0000
@@ -26,6 +26,7 @@
 	"encoding/hex"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"math/rand"
 	"os"
 	"os/exec"
@@ -198,14 +199,37 @@
 	}
 }
 
-// IsSupportedArchitecture returns true if the system architecture is in the
-// list of architectures.
-func IsSupportedArchitecture(architectures []string) bool {
-	systemArch := UbuntuArchitecture()
-
-	for _, arch := range architectures {
-		if arch == "all" || arch == systemArch {
-			return true
+<<<<<<< TREE
+// IsSupportedArchitecture returns true if the system architecture is in the
+// list of architectures.
+func IsSupportedArchitecture(architectures []string) bool {
+	systemArch := UbuntuArchitecture()
+
+	for _, arch := range architectures {
+		if arch == "all" || arch == systemArch {
+			return true
+=======
+// IsSupportedArchitecture returns true if the system architecture is in the
+// list of architectures.
+func IsSupportedArchitecture(architectures []string) bool {
+	systemArch := UbuntuArchitecture()
+
+	for _, arch := range architectures {
+		if arch == "all" || arch == systemArch {
+			return true
+		}
+	}
+
+	return false
+}
+
+// EnsureDir ensures that the given directory exists and if
+// not creates it with the given permissions.
+func EnsureDir(dir string, perm os.FileMode) (err error) {
+	if _, err := os.Stat(dir); os.IsNotExist(err) {
+		if err := os.MkdirAll(dir, perm); err != nil {
+			return err
+>>>>>>> MERGE-SOURCE
 		}
 	}
 
@@ -360,6 +384,7 @@
 	return syscall.Getuid() == 0 || syscall.Getgid() == 0
 
 }
+<<<<<<< TREE
 
 // MajorMinor returns the major/minor number of the given os.FileInfo
 func MajorMinor(info os.FileInfo) (uint32, uint32, error) {
@@ -530,3 +555,140 @@
 
 	return nil
 }
+=======
+
+func makeDirMap(dirName string) (map[string]struct{}, error) {
+	dir, err := ioutil.ReadDir(dirName)
+	if err != nil {
+		return nil, err
+	}
+
+	dirMap := make(map[string]struct{})
+	for _, dent := range dir {
+		if dent.IsDir() {
+			return nil, fmt.Errorf("subdirs are not supported")
+		}
+		dirMap[dent.Name()] = struct{}{}
+	}
+
+	return dirMap, nil
+}
+
+// RSyncWithDelete syncs srcDir to destDir
+func RSyncWithDelete(srcDirName, destDirName string) error {
+
+	// first remove everything thats not in srcdir
+	err := filepath.Walk(destDirName, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// relative to the root "destDirName"
+		relPath := path[len(destDirName):]
+		if !FileExists(filepath.Join(srcDirName, relPath)) {
+			if err := os.RemoveAll(path); err != nil {
+				return err
+			}
+			if info.IsDir() {
+				return filepath.SkipDir
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	// then copy or update the data from srcdir to destdir
+	err = filepath.Walk(srcDirName, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// relative to the root "srcDirName"
+		relPath := path[len(srcDirName):]
+		if info.IsDir() {
+			return os.MkdirAll(filepath.Join(destDirName, relPath), info.Mode())
+		}
+		src := path
+		dst := filepath.Join(destDirName, relPath)
+		if !FilesAreEqual(src, dst) {
+			// XXX: on snappy-trunk we can use CopyFile here
+			output, err := exec.Command("cp", "-va", src, dst).CombinedOutput()
+			if err != nil {
+				fmt.Errorf("Failed to copy %s to %s (%s)", src, dst, output)
+			}
+		}
+		return nil
+	})
+
+	return err
+}
+
+func fillSnapEnvVars(desc interface{}, vars []string) []string {
+	for i, v := range vars {
+		var templateOut bytes.Buffer
+		t := template.Must(template.New("wrapper").Parse(v))
+		if err := t.Execute(&templateOut, desc); err != nil {
+			// this can never happen, except we forget a variable
+			logger.LogAndPanic(err)
+		}
+		vars[i] = templateOut.String()
+	}
+	return vars
+}
+
+// GetBasicSnapEnvVars returns the app-level environment variables for a snap.
+// Despite this being a bit snap-specific, this is in helpers.go because it's
+// used by so many other modules, we run into circular dependencies if it's
+// somewhere more reasonable like the snappy module.
+func GetBasicSnapEnvVars(desc interface{}) []string {
+	return fillSnapEnvVars(desc, []string{
+		"TMPDIR=/tmp/snaps/{{.UdevAppName}}/{{.Version}}/tmp",
+		"TEMPDIR=/tmp/snaps/{{.UdevAppName}}/{{.Version}}/tmp",
+		"SNAP_APP_PATH={{.AppPath}}",
+		"SNAP_APP_DATA_PATH=/var/lib{{.AppPath}}",
+		"SNAP_APP_TMPDIR=/tmp/snaps/{{.UdevAppName}}/{{.Version}}/tmp",
+		"SNAP_NAME={{.AppName}}",
+		"SNAP_VERSION={{.Version}}",
+		"SNAP_ORIGIN={{.Namespace}}",
+		"SNAP_FULLNAME={{.UdevAppName}}",
+		"SNAP_ARCH={{.AppArch}}",
+	})
+}
+
+// GetUserSnapEnvVars returns the user-level environment variables for a snap.
+// Despite this being a bit snap-specific, this is in helpers.go because it's
+// used by so many other modules, we run into circular dependencies if it's
+// somewhere more reasonable like the snappy module.
+func GetUserSnapEnvVars(desc interface{}) []string {
+	return fillSnapEnvVars(desc, []string{
+		"SNAP_APP_USER_DATA_PATH={{.Home}}{{.AppPath}}",
+	})
+}
+
+// GetDeprecatedBasicSnapEnvVars returns the app-level deprecated environment
+// variables for a snap.
+// Despite this being a bit snap-specific, this is in helpers.go because it's
+// used by so many other modules, we run into circular dependencies if it's
+// somewhere more reasonable like the snappy module.
+func GetDeprecatedBasicSnapEnvVars(desc interface{}) []string {
+	return fillSnapEnvVars(desc, []string{
+		"SNAPP_APP_PATH={{.AppPath}}",
+		"SNAPP_APP_DATA_PATH=/var/lib{{.AppPath}}",
+		"SNAPP_APP_TMPDIR=/tmp/snaps/{{.UdevAppName}}/{{.Version}}/tmp",
+		"SNAPPY_APP_ARCH={{.AppArch}}",
+	})
+}
+
+// GetDeprecatedUserSnapEnvVars returns the user-level deprecated environment
+// variables for a snap.
+// Despite this being a bit snap-specific, this is in helpers.go because it's
+// used by so many other modules, we run into circular dependencies if it's
+// somewhere more reasonable like the snappy module.
+func GetDeprecatedUserSnapEnvVars(desc interface{}) []string {
+	return fillSnapEnvVars(desc, []string{
+		"SNAPP_APP_USER_DATA_PATH={{.Home}}{{.AppPath}}",
+	})
+}
+>>>>>>> MERGE-SOURCE

=== modified file 'helpers/helpers_test.go'
--- helpers/helpers_test.go	2015-08-21 12:14:16 +0000
+++ helpers/helpers_test.go	2015-09-08 06:47:52 +0000
@@ -271,6 +271,7 @@
 	c.Assert(err, IsNil)
 	c.Assert(home, Equals, oldHome)
 }
+<<<<<<< TREE
 
 func skipOnMissingDevKmsg(c *C) {
 	_, err := os.Stat("/dev/kmsg")
@@ -483,3 +484,106 @@
 	err := CopyIfDifferent(src, dst)
 	c.Assert(err, NotNil)
 }
+=======
+
+func makeTestFiles(c *C, srcDir, destDir string) {
+	// a new file
+	err := ioutil.WriteFile(filepath.Join(srcDir, "new"), []byte(nil), 0644)
+	c.Assert(err, IsNil)
+
+	// a existing file that needs update
+	err = ioutil.WriteFile(filepath.Join(destDir, "existing-update"), []byte("old-content"), 0644)
+	c.Assert(err, IsNil)
+	err = ioutil.WriteFile(filepath.Join(srcDir, "existing-update"), []byte("some-new-content"), 0644)
+	c.Assert(err, IsNil)
+
+	// existing file that needs no update
+	err = ioutil.WriteFile(filepath.Join(srcDir, "existing-unchanged"), []byte(nil), 0644)
+	c.Assert(err, IsNil)
+	err = exec.Command("cp", "-a", filepath.Join(srcDir, "existing-unchanged"), filepath.Join(destDir, "existing-unchanged")).Run()
+	c.Assert(err, IsNil)
+
+	// a file that needs removal
+	err = ioutil.WriteFile(filepath.Join(destDir, "to-be-deleted"), []byte(nil), 0644)
+	c.Assert(err, IsNil)
+}
+
+func compareDirs(c *C, srcDir, destDir string) {
+	d1, err := exec.Command("ls", "-al", srcDir).CombinedOutput()
+	c.Assert(err, IsNil)
+	d2, err := exec.Command("ls", "-al", destDir).CombinedOutput()
+	c.Assert(err, IsNil)
+	c.Assert(string(d1), Equals, string(d2))
+	// ensure content got updated
+	c1, err := exec.Command("sh", "-c", fmt.Sprintf("find %s -type f |xargs cat", srcDir)).CombinedOutput()
+	c.Assert(err, IsNil)
+	c2, err := exec.Command("sh", "-c", fmt.Sprintf("find %s -type f |xargs cat", destDir)).CombinedOutput()
+	c.Assert(err, IsNil)
+	c.Assert(string(c1), Equals, string(c2))
+}
+
+func (ts *HTestSuite) TestSyncDirs(c *C) {
+
+	for _, l := range [][2]string{
+		[2]string{"src-short", "dst-loooooooooooong"},
+		[2]string{"src-loooooooooooong", "dst-short"},
+		[2]string{"src-eq", "dst-eq"},
+	} {
+
+		// ensure we have src, dest dirs with different length
+		srcDir := filepath.Join(c.MkDir(), l[0])
+		err := os.MkdirAll(srcDir, 0755)
+		c.Assert(err, IsNil)
+		destDir := filepath.Join(c.MkDir(), l[1])
+		err = os.MkdirAll(destDir, 0755)
+		c.Assert(err, IsNil)
+
+		// add a src subdir
+		subdir := filepath.Join(srcDir, "subdir")
+		err = os.Mkdir(subdir, 0755)
+		c.Assert(err, IsNil)
+		makeTestFiles(c, subdir, destDir)
+
+		// add a dst subdir that needs to get deleted
+		subdir2 := filepath.Join(destDir, "to-be-deleted-subdir")
+		err = os.Mkdir(subdir2, 0755)
+		subdir3 := filepath.Join(subdir2, "to-be-deleted-sub-subdir")
+		err = os.Mkdir(subdir3, 0755)
+
+		// and a toplevel
+		makeTestFiles(c, srcDir, destDir)
+
+		// do it
+		err = RSyncWithDelete(srcDir, destDir)
+		c.Assert(err, IsNil)
+
+		// ensure meta-data is identical
+		compareDirs(c, srcDir, destDir)
+		compareDirs(c, filepath.Join(srcDir, "subdir"), filepath.Join(destDir, "subdir"))
+	}
+}
+
+func (ts *HTestSuite) TestSyncDirFails(c *C) {
+	srcDir := c.MkDir()
+	err := os.MkdirAll(srcDir, 0755)
+	c.Assert(err, IsNil)
+
+	destDir := c.MkDir()
+	err = os.MkdirAll(destDir, 0755)
+	c.Assert(err, IsNil)
+
+	err = ioutil.WriteFile(filepath.Join(destDir, "meep"), []byte(nil), 0644)
+	c.Assert(err, IsNil)
+
+	// ensure remove fails
+	err = os.Chmod(destDir, 0100)
+	c.Assert(err, IsNil)
+	// make tempdir cleanup work again
+	defer os.Chmod(destDir, 0755)
+
+	// do it
+	err = RSyncWithDelete(srcDir, destDir)
+	c.Check(err, NotNil)
+	c.Check(err, ErrorMatches, ".*permission denied.*")
+}
+>>>>>>> MERGE-SOURCE

=== modified file 'helpers/touch.go'
=== modified file 'helpers/touch_test.go'
=== added directory 'logger'
=== renamed directory 'logger' => 'logger.moved'
=== added file 'logger/logger_test.go'
--- logger/logger_test.go	1970-01-01 00:00:00 +0000
+++ logger/logger_test.go	2015-09-08 06:47:52 +0000
@@ -0,0 +1,331 @@
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package logger
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"log/syslog"
+	"regexp"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/juju/loggo"
+	. "gopkg.in/check.v1"
+)
+
+func Test(t *testing.T) { TestingT(t) }
+
+type LoggerTestSuite struct {
+}
+
+var _ = Suite(&LoggerTestSuite{})
+
+type MockLogWriter struct {
+	buf bytes.Buffer
+}
+
+var mockWriter *MockLogWriter
+
+var loggoLevels = []string{"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"}
+
+func mockGetSyslog(priority syslog.Priority, tag string) (w logWriterInterface, err error) {
+	mockWriter = &MockLogWriter{}
+	return mockWriter, nil
+}
+
+func readLines() (lines []string) {
+	lines = strings.Split(string(mockWriter.buf.Bytes()), "\n")
+
+	// remove the last line if empty due to split.
+	length := len(lines)
+	last := lines[length-1]
+	if last == "" {
+		lines = lines[:length-1]
+	}
+	// clear the buffer to avoid contents accumulating indefinitely
+	mockWriter.buf.Reset()
+	return lines
+}
+
+func (ts *LoggerTestSuite) SetUpTest(c *C) {
+	getSyslog = mockGetSyslog
+}
+
+func (w *MockLogWriter) Debug(m string) error {
+	_, err := w.buf.Write([]byte(fmt.Sprintf("DEBUG: %s\n", m)))
+	return err
+}
+
+func (w *MockLogWriter) Info(m string) error {
+	_, err := w.buf.Write([]byte(fmt.Sprintf("INFO: %s\n", m)))
+	return err
+}
+
+func (w *MockLogWriter) Warning(m string) error {
+	_, err := w.buf.Write([]byte(fmt.Sprintf("WARNING: %s\n", m)))
+	return err
+}
+
+func (w *MockLogWriter) Err(m string) error {
+	_, err := w.buf.Write([]byte(fmt.Sprintf("ERROR: %s\n", m)))
+	return err
+}
+
+func (w *MockLogWriter) Crit(m string) error {
+	_, err := w.buf.Write([]byte(fmt.Sprintf("CRITICAL: %s\n", m)))
+	return err
+}
+
+// Search for value in array and return true if found
+func sliceContainsString(array []string, value string) bool {
+	str := string(strings.Join(array, ""))
+
+	return strings.Contains(str, value)
+}
+
+// Return true if array contains the pattern regex.
+func sliceContainsRegex(array []string, regex string) bool {
+	str := string(strings.Join(array, ""))
+
+	pattern := regexp.MustCompile(regex)
+
+	matches := pattern.FindAllStringSubmatch(str, -1)
+
+	return matches != nil
+}
+
+func (ts *LoggerTestSuite) TestNewLogWriter(c *C) {
+	var w, w2 *LogWriter
+	var err error
+
+	w, err = newLogWriter()
+	c.Assert(err, IsNil)
+	c.Assert(w, Not(IsNil))
+	c.Assert(w.systemLog, Not(IsNil))
+
+	w2, err = newLogWriter()
+	c.Assert(err, IsNil)
+	c.Assert(w2, Not(IsNil))
+	c.Assert(w2.systemLog, Not(IsNil))
+
+	// There should be a single shared syslog connection, hence the
+	// systemLog objects should be identical.
+	c.Assert(w.systemLog, Equals, w2.systemLog)
+	c.Assert(w.systemLog, DeepEquals, w2.systemLog)
+}
+
+func (ts *LoggerTestSuite) TestWrite(c *C) {
+	w, err := newLogWriter()
+	c.Assert(err, IsNil)
+	c.Assert(w, Not(IsNil))
+	c.Assert(w.systemLog, Not(IsNil))
+
+	t := time.Now()
+	strTime := fmt.Sprintf("%s", t)
+
+	for _, l := range loggoLevels {
+		level := stringToLogLevel(l)
+
+		w.Write(level, "module", "filename", 1234, t, "a message")
+		lines := readLines()
+
+		if level < loggo.ERROR {
+			c.Assert(len(lines), Equals, 1)
+		} else {
+			c.Assert(len(lines) > 1, Equals, true)
+
+			c.Assert(sliceContainsString(lines, "filename"), Equals, true)
+			c.Assert(sliceContainsString(lines, "1234"), Equals, true)
+		}
+
+		c.Assert(sliceContainsString(lines, "module"), Equals, true)
+
+		// We discard the timestamp as syslog adds that itself
+		c.Assert(sliceContainsString(lines, strTime), Equals, false)
+
+		c.Assert(sliceContainsString(lines, "a message"), Equals, true)
+	}
+
+}
+
+// Convert a loggo log level string representation into a real log
+// level.
+func stringToLogLevel(name string) loggo.Level {
+	level, ok := loggo.ParseLevel(name)
+
+	if !ok {
+		panic(fmt.Sprintf("unknown loggo level string: %q", name))
+	}
+
+	return level
+}
+
+func (ts *LoggerTestSuite) TestFormat(c *C) {
+	w, err := newLogWriter()
+	c.Assert(err, IsNil)
+	c.Assert(w, Not(IsNil))
+	c.Assert(w.systemLog, Not(IsNil))
+
+	for _, l := range loggoLevels {
+		level := stringToLogLevel(l)
+
+		if level < loggo.ERROR {
+			out := w.Format(level, "module", "filename", 1234, time.Now(), "a message")
+			c.Assert(out, Equals, fmt.Sprintf("%s:%s:%s", l, "module", "a message"))
+		} else {
+			out := w.Format(level, "module", "filename", 1234, time.Now(), "a message")
+			c.Assert(out, Equals, fmt.Sprintf("%s:%s:%s:%d:%s", l, "module", "filename", 1234, "a message"))
+		}
+	}
+}
+
+func (ts *LoggerTestSuite) TestLogStackTrace(c *C) {
+	var output []string
+
+	w, err := newLogWriter()
+	c.Assert(err, IsNil)
+	c.Assert(w, Not(IsNil))
+
+	f := func(s string) error {
+		output = append(output, s)
+		return nil
+	}
+
+	t := time.Now()
+	strTime := fmt.Sprintf("%s", t)
+
+	w.logStacktrace(loggo.DEBUG, "name", "filename", 9876, t, f)
+
+	c.Assert(sliceContainsString(output, "Stack trace"), Equals, true)
+	c.Assert(sliceContainsString(output, "name"), Equals, true)
+	c.Assert(sliceContainsString(output, "filename"), Equals, true)
+	c.Assert(sliceContainsString(output, "9876"), Equals, true)
+
+	// We discard the timestamp as syslog adds that itself
+	c.Assert(sliceContainsString(output, strTime), Equals, false)
+}
+
+func (ts *LoggerTestSuite) checkLogLevel(c *C, level, msg string) {
+	err := ActivateLogger()
+	c.Assert(err, IsNil)
+
+	expectBacktrace := (level == "ERROR" || level == "CRITICAL")
+
+	logger := loggo.GetLogger("snappy")
+	c.Assert(logger, Not(IsNil))
+
+	switch level {
+	case "DEBUG":
+		c.Assert(logger.IsDebugEnabled(), Equals, true)
+		logger.Debugf(msg)
+
+	case "INFO":
+		c.Assert(logger.IsInfoEnabled(), Equals, true)
+		logger.Infof(msg)
+
+	case "WARNING":
+		c.Assert(logger.IsWarningEnabled(), Equals, true)
+		logger.Warningf(msg)
+
+	case "ERROR":
+		c.Assert(logger.IsErrorEnabled(), Equals, true)
+		logger.Errorf(msg)
+
+	case "CRITICAL":
+		// loggo doesn't provide a IsCriticalEnabled()
+		c.Assert(logger.IsErrorEnabled(), Equals, true)
+		logger.Criticalf(msg)
+	}
+
+	lines := readLines()
+
+	if expectBacktrace {
+		c.Assert(len(lines) > 1, Equals, true)
+	} else {
+		c.Assert(len(lines), Equals, 1)
+	}
+
+	needle := fmt.Sprintf("%s.*%s", level, msg)
+	c.Assert(sliceContainsRegex(lines, needle), Equals, true)
+
+	c.Assert(sliceContainsString(lines, "Stack trace"), Equals, expectBacktrace)
+}
+
+func (ts *LoggerTestSuite) TestLogLevels(c *C) {
+	msg := "an error message"
+
+	for _, level := range loggoLevels {
+		ts.checkLogLevel(c, level, msg)
+	}
+}
+
+func (ts *LoggerTestSuite) TestLogError(c *C) {
+	level := "ERROR"
+	msg := "I am an error"
+
+	err := ActivateLogger()
+	c.Assert(err, IsNil)
+
+	result := LogError(nil)
+	c.Assert(result, IsNil)
+
+	err = errors.New(msg)
+	c.Assert(err, Not(IsNil))
+
+	// We expect to get back exactly what was passsed...
+	result = LogError(err)
+	c.Assert(result, DeepEquals, err)
+
+	// ... but also to have the error logged
+	ts.checkLogLevel(c, level, msg)
+}
+
+func (ts *LoggerTestSuite) TestLogAndPanic(c *C) {
+	level := "CRITICAL"
+	msg := "I am a fatal error"
+
+	panicked := false
+
+	err := ActivateLogger()
+	c.Assert(err, IsNil)
+
+	// If the specified error is nil, no panic is expected and no
+	// log entry should be added.
+	func() {
+		defer func() {
+			if r := recover(); r != nil {
+				panicked = true
+			}
+		}()
+		LogAndPanic(nil)
+	}()
+
+	c.Assert(panicked, Equals, false)
+	c.Assert(len(readLines()), Equals, 0)
+
+	err = errors.New(msg)
+
+	// expect a panic...
+	c.Assert(func() { LogAndPanic(err) }, Panics, err)
+
+	// ... and a log entry
+	ts.checkLogLevel(c, level, msg)
+}

=== modified file 'partition/bootloader.go'
=== modified file 'partition/bootloader_grub.go'
--- partition/bootloader_grub.go	2015-07-23 11:54:14 +0000
+++ partition/bootloader_grub.go	2015-09-08 06:47:52 +0000
@@ -32,7 +32,12 @@
 	bootloaderGrubConfigFileReal = "/boot/grub/grub.cfg"
 	bootloaderGrubEnvFileReal    = "/boot/grub/grubenv"
 
+<<<<<<< TREE
 	bootloaderGrubEnvCmdReal = "/usr/bin/grub-editenv"
+=======
+	bootloaderGrubEnvCmdReal    = "/usr/bin/grub-editenv"
+	bootloaderGrubUpdateCmdReal = "/usr/sbin/update-grub"
+>>>>>>> MERGE-SOURCE
 )
 
 // var to make it testable
@@ -115,9 +120,24 @@
 	return g.GetBootVar(bootloaderRootfsVar)
 }
 
+<<<<<<< TREE
 func (g *grub) MarkCurrentBootSuccessful(currentRootfs string) (err error) {
 	// Clear the variable set on boot to denote a good boot.
 	if err := g.setBootVar(bootloaderTrialBootVar, "0"); err != nil {
+=======
+func (g *grub) GetRootFSName() string {
+	return g.currentRootfs
+}
+
+func (g *grub) GetOtherRootFSName() string {
+	return g.otherRootfs
+}
+
+func (g *grub) MarkCurrentBootSuccessful() (err error) {
+	// Clear the variable set by grub on boot to denote a good
+	// boot.
+	if err := g.unsetBootVar(bootloaderTrialBootVar); err != nil {
+>>>>>>> MERGE-SOURCE
 		return err
 	}
 

=== modified file 'partition/bootloader_grub_test.go'
--- partition/bootloader_grub_test.go	2015-07-23 11:54:14 +0000
+++ partition/bootloader_grub_test.go	2015-09-08 06:47:52 +0000
@@ -23,11 +23,16 @@
 	"fmt"
 	"io/ioutil"
 	"os"
+<<<<<<< TREE
 	"path/filepath"
 
 	"launchpad.net/snappy/helpers"
 
 	. "gopkg.in/check.v1"
+=======
+
+	. "gopkg.in/check.v1"
+>>>>>>> MERGE-SOURCE
 )
 
 func mockGrubFile(c *C, newPath string, mode os.FileMode) {

=== modified file 'partition/bootloader_uboot.go'
--- partition/bootloader_uboot.go	2015-07-24 12:00:01 +0000
+++ partition/bootloader_uboot.go	2015-09-08 06:47:52 +0000
@@ -55,9 +55,14 @@
 	bootloaderUbootConfigFile = bootloaderUbootConfigFileReal
 	bootloaderUbootStampFile  = bootloaderUbootStampFileReal
 	bootloaderUbootEnvFile    = bootloaderUbootEnvFileReal
+<<<<<<< TREE
 	bootloaderUbootFwEnvFile  = bootloaderUbootFwEnvFileReal
 
 	atomicWriteFile = helpers.AtomicWriteFile
+=======
+	bootloaderUbootFwEnvFile  = bootloaderUbootFwEnvFileReal
+	atomicFileUpdate          = atomicFileUpdateImpl
+>>>>>>> MERGE-SOURCE
 )
 
 const bootloaderNameUboot bootloaderName = "u-boot"
@@ -103,15 +108,64 @@
 	return bootloaderNameUboot
 }
 
+<<<<<<< TREE
 func (u *uboot) ToggleRootFS(otherRootfs string) (err error) {
 	if err := setBootVar(bootloaderRootfsVar, string(otherRootfs)); err != nil {
 		return err
+=======
+// ToggleRootFS make the U-Boot bootloader switch rootfs's.
+//
+// Approach:
+//
+// - Assume the device's installed version of u-boot supports
+//   CONFIG_SUPPORT_RAW_INITRD (that allows u-boot to boot a
+//   standard initrd+kernel on the fat32 disk partition).
+// - Copy the "other" rootfs's kernel+initrd to the boot partition,
+//   renaming them in the process to ensure the next boot uses the
+//   correct versions.
+func (u *uboot) ToggleRootFS() (err error) {
+	// modern system
+	if helpers.FileExists(bootloaderUbootFwEnvFile) {
+		return u.toggleRootFSFwEnv()
+	}
+
+	// legacy
+	return u.toggleRootFSLegacy()
+}
+
+func (u *uboot) toggleRootFSFwEnv() (err error) {
+	if err := u.setBootVar(bootloaderRootfsVar, string(u.otherRootfs)); err != nil {
+		return err
+	}
+
+	return u.setBootVar(bootloaderBootmodeVar, bootloaderBootmodeTry)
+}
+
+func (u *uboot) toggleRootFSLegacy() (err error) {
+	// If the file exists, update it. Otherwise create it.
+	//
+	// The file _should_ always exist, but since it's on a writable
+	// partition, it's possible the admin removed it by mistake. So
+	// recreate to allow the system to boot!
+	changes := []configFileChange{
+		configFileChange{Name: bootloaderRootfsVar,
+			Value: string(u.otherRootfs),
+		},
+		configFileChange{Name: bootloaderBootmodeVar,
+			Value: bootloaderBootmodeTry,
+		},
+>>>>>>> MERGE-SOURCE
 	}
 
 	return setBootVar(bootloaderBootmodeVar, bootloaderBootmodeTry)
 }
 
+<<<<<<< TREE
 func getBootVarLegacy(name string) (value string, err error) {
+=======
+func (u *uboot) getBootVarLegacy(name string) (value string, err error) {
+
+>>>>>>> MERGE-SOURCE
 	cfg := goconfigparser.New()
 	cfg.AllowNoSectionHeader = true
 	if err := cfg.ReadFile(bootloaderUbootEnvFile); err != nil {
@@ -121,6 +175,7 @@
 	return cfg.Get("", name)
 }
 
+<<<<<<< TREE
 func setBootVarLegacy(name, value string) error {
 	curVal, err := getBootVarLegacy(name)
 	if err == nil && curVal == value {
@@ -165,6 +220,16 @@
 	return getBootVar(name)
 }
 
+=======
+func (u *uboot) GetBootVar(name string) (value string, err error) {
+	if helpers.FileExists(bootloaderUbootFwEnvFile) {
+		return u.getBootVar(name)
+	}
+
+	return u.getBootVarLegacy(name)
+}
+
+>>>>>>> MERGE-SOURCE
 func (u *uboot) GetNextBootRootFSName() (label string, err error) {
 	value, err := u.GetBootVar(bootloaderRootfsVar)
 	if err != nil {
@@ -175,6 +240,7 @@
 	return value, nil
 }
 
+<<<<<<< TREE
 // FIXME: this is super similar to grub now, refactor to extract the
 //        common code
 func (u *uboot) MarkCurrentBootSuccessful(currentRootfs string) error {
@@ -197,6 +263,260 @@
 
 func (u *uboot) BootDir() string {
 	return bootloaderUbootDir
+=======
+func (u *uboot) GetRootFSName() string {
+	return u.currentRootfs
+}
+
+func (u *uboot) GetOtherRootFSName() string {
+	return u.otherRootfs
+}
+
+// FIXME: put into utils package
+func readLines(path string) (lines []string, err error) {
+
+	file, err := os.Open(path)
+
+	if err != nil {
+		return nil, err
+	}
+
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		lines = append(lines, scanner.Text())
+	}
+
+	return lines, scanner.Err()
+}
+
+// FIXME: put into utils package
+func writeLines(lines []string, path string) (err error) {
+
+	file, err := os.Create(path)
+
+	if err != nil {
+		return err
+	}
+
+	defer func() {
+		e := file.Close()
+		if err == nil {
+			err = e
+		}
+	}()
+
+	writer := bufio.NewWriter(file)
+
+	for _, line := range lines {
+		if _, err := fmt.Fprintln(writer, line); err != nil {
+			return err
+		}
+	}
+
+	if err := writer.Flush(); err != nil {
+		return err
+	}
+
+	return file.Sync()
+}
+
+func (u *uboot) SyncBootFiles() (err error) {
+	srcDir := u.currentBootPath
+	destDir := u.otherBootPath
+
+	return helpers.RSyncWithDelete(srcDir, destDir)
+}
+
+func (u *uboot) HandleAssets() (err error) {
+	// check if we have anything, if there is no hardware yaml, there is nothing
+	// to process.
+	hardware, err := u.partition.hardwareSpec()
+	if err == ErrNoHardwareYaml {
+		return nil
+	} else if err != nil {
+		return err
+	}
+	// ensure to remove the file once we are done
+	defer os.Remove(u.partition.hardwareSpecFile)
+
+	// validate bootloader
+	if hardware.Bootloader != u.Name() {
+		return fmt.Errorf(
+			"bootloader is of type %s but hardware spec requires %s",
+			u.Name(),
+			hardware.Bootloader)
+	}
+
+	// validate partition layout
+	if u.partition.dualRootPartitions() && hardware.PartitionLayout != bootloaderSystemAB {
+		return fmt.Errorf("hardware spec requires dual root partitions")
+	}
+
+	// ensure we have the destdir
+	destDir := u.otherBootPath
+	if err := os.MkdirAll(destDir, dirMode); err != nil {
+		return err
+	}
+
+	// install kernel+initrd
+	for _, file := range []string{hardware.Kernel, hardware.Initrd} {
+
+		if file == "" {
+			continue
+		}
+
+		// expand path
+		path := path.Join(u.partition.cacheDir(), file)
+
+		if !helpers.FileExists(path) {
+			return fmt.Errorf("can not find file %s", path)
+		}
+
+		// ensure we remove the dir later
+		defer os.RemoveAll(filepath.Dir(path))
+
+		if err := runCommand("/bin/cp", path, destDir); err != nil {
+			return err
+		}
+	}
+
+	// TODO: look at the OEM package for dtb changes too once that is
+	//       fully speced
+
+	// install .dtb files
+	dtbSrcDir := filepath.Join(u.partition.cacheDir(), hardware.DtbDir)
+	if helpers.FileExists(dtbSrcDir) {
+		// ensure we cleanup the source dir
+		defer os.RemoveAll(dtbSrcDir)
+
+		dtbDestDir := path.Join(destDir, "dtbs")
+		if err := os.MkdirAll(dtbDestDir, dirMode); err != nil {
+			return err
+		}
+
+		files, err := filepath.Glob(path.Join(dtbSrcDir, "*"))
+		if err != nil {
+			return err
+		}
+
+		for _, file := range files {
+			if err := runCommand("/bin/cp", file, dtbDestDir); err != nil {
+				return err
+			}
+		}
+	}
+
+	flashAssetsDir := u.partition.flashAssetsDir()
+
+	if helpers.FileExists(flashAssetsDir) {
+		// FIXME: we don't currently do anything with the
+		// MLO + uImage files since they are not specified in
+		// the hardware spec. So for now, just remove them.
+
+		if err := os.RemoveAll(flashAssetsDir); err != nil {
+			return err
+		}
+	}
+
+	return err
+}
+
+func (u *uboot) setBootVar(name, value string) error {
+	env, err := uenv.Open(bootloaderUbootFwEnvFile)
+	if err != nil {
+		return err
+	}
+
+	// already set, nothing to do
+	if env.Get(name) == value {
+		return nil
+	}
+
+	env.Set(name, value)
+	return env.Save()
+}
+
+func (u *uboot) hasBootVar(name string) (bool, error) {
+	v, err := u.getBootVar(name)
+	return v != "", err
+}
+
+func (u *uboot) getBootVar(name string) (string, error) {
+	env, err := uenv.Open(bootloaderUbootFwEnvFile)
+	if err != nil {
+		return "", err
+	}
+
+	return env.Get(name), nil
+}
+
+// FIXME: this is super similar to grub now, refactor to extract the
+//        common code
+func (u *uboot) markCurrentBootSuccessfulFwEnv(currentRootfs string) error {
+	// Clear the variable set on boot to denote a good boot.
+	if err := u.setBootVar(bootloaderTrialBootVar, "0"); err != nil {
+		return err
+	}
+
+	if err := u.setBootVar(bootloaderRootfsVar, currentRootfs); err != nil {
+		return err
+	}
+
+	return u.setBootVar(bootloaderBootmodeVar, bootloaderBootmodeSuccess)
+}
+
+func (u *uboot) markCurrentBootSuccessfulLegacy(currentRootfs string) error {
+	changes := []configFileChange{
+		configFileChange{Name: bootloaderBootmodeVar,
+			Value: bootloaderBootmodeSuccess,
+		},
+		configFileChange{Name: bootloaderRootfsVar,
+			Value: string(u.currentRootfs),
+		},
+	}
+
+	if err := modifyNameValueFile(bootloaderUbootEnvFile, changes); err != nil {
+		return err
+	}
+
+	return os.RemoveAll(bootloaderUbootStampFile)
+}
+
+func (u *uboot) MarkCurrentBootSuccessful() error {
+	// modern system
+	if helpers.FileExists(bootloaderUbootFwEnvFile) {
+		return u.markCurrentBootSuccessfulFwEnv(u.currentRootfs)
+	}
+
+	// legacy
+	return u.markCurrentBootSuccessfulLegacy(u.currentRootfs)
+}
+
+// Write lines to file atomically. File does not have to preexist.
+// FIXME: put into utils package
+func atomicFileUpdateImpl(file string, lines []string) (err error) {
+	tmpFile := fmt.Sprintf("%s.NEW", file)
+
+	// XXX: if go switches to use aio_fsync, we need to open the dir for writing
+	dir, err := os.Open(filepath.Dir(file))
+	if err != nil {
+		return err
+	}
+	defer dir.Close()
+
+	if err := writeLines(lines, tmpFile); err != nil {
+		return err
+	}
+
+	// atomic update
+	if err := os.Rename(tmpFile, file); err != nil {
+		return err
+	}
+
+	return dir.Sync()
+>>>>>>> MERGE-SOURCE
 }
 
 // Rewrite the specified file, applying the specified set of changes.
@@ -206,8 +526,13 @@
 // appended to the file.
 //
 // FIXME: put into utils package
+<<<<<<< TREE
 // FIXME: improve logic
 func modifyNameValueFile(path string, changes []configFileChange) error {
+=======
+// FIXME: improve logic
+func modifyNameValueFile(file string, changes []configFileChange) (err error) {
+>>>>>>> MERGE-SOURCE
 	var updated []configFileChange
 
 	// we won't write to a file if we don't need to.
@@ -217,12 +542,21 @@
 	if err != nil {
 		return err
 	}
+<<<<<<< TREE
 	defer file.Close()
 
 	buf := bytes.NewBuffer(nil)
 	scanner := bufio.NewScanner(file)
 	for scanner.Scan() {
 		line := scanner.Text()
+=======
+
+	var new []string
+	// we won't write to a file if we don't need to.
+	updateNeeded := false
+
+	for _, line := range lines {
+>>>>>>> MERGE-SOURCE
 		for _, change := range changes {
 			if strings.HasPrefix(line, fmt.Sprintf("%s=", change.Name)) {
 				value := strings.SplitN(line, "=", 2)[1]
@@ -260,9 +594,18 @@
 		}
 	}
 
+<<<<<<< TREE
 	if updateNeeded {
 		return atomicWriteFile(path, buf.Bytes(), 0644)
 	}
+=======
+	if updateNeeded {
+		return atomicFileUpdate(file, lines)
+	}
+
+	return nil
+}
+>>>>>>> MERGE-SOURCE
 
 	return nil
 }

=== modified file 'partition/bootloader_uboot_test.go'
--- partition/bootloader_uboot_test.go	2015-07-24 11:58:04 +0000
+++ partition/bootloader_uboot_test.go	2015-09-08 06:47:52 +0000
@@ -382,3 +382,93 @@
 	c.Assert(err, IsNil)
 	c.Assert(st.ModTime(), Equals, st2.ModTime())
 }
+
+func (s *PartitionTestSuite) TestNoWriteNotNeeded(c *C) {
+	s.makeFakeUbootEnv(c)
+
+	atomiCall := false
+	atomicFileUpdate = func(a string, b []string) error { atomiCall = true; return atomicFileUpdateImpl(a, b) }
+
+	partition := New()
+	u := newUboot(partition)
+	c.Assert(u, NotNil)
+
+	c.Check(u.MarkCurrentBootSuccessful(), IsNil)
+	c.Assert(atomiCall, Equals, false)
+}
+
+func (s *PartitionTestSuite) TestWriteDueToMissingValues(c *C) {
+	s.makeFakeUbootEnv(c)
+
+	// this file needs specific data
+	c.Assert(ioutil.WriteFile(bootloaderUbootEnvFile, []byte(""), 0644), IsNil)
+
+	atomiCall := false
+	atomicFileUpdate = func(a string, b []string) error { atomiCall = true; return atomicFileUpdateImpl(a, b) }
+
+	partition := New()
+	u := newUboot(partition)
+	c.Assert(u, NotNil)
+
+	c.Check(u.MarkCurrentBootSuccessful(), IsNil)
+	c.Assert(atomiCall, Equals, true)
+
+	bytes, err := ioutil.ReadFile(bootloaderUbootEnvFile)
+	c.Assert(err, IsNil)
+	c.Check(strings.Contains(string(bytes), "snappy_mode=try"), Equals, false)
+	c.Check(strings.Contains(string(bytes), "snappy_mode=regular"), Equals, true)
+	c.Check(strings.Contains(string(bytes), "snappy_ab=a"), Equals, true)
+}
+
+func (s *PartitionTestSuite) TestUbootMarkCurrentBootSuccessfulFwEnv(c *C) {
+	s.makeFakeUbootEnv(c)
+
+	env, err := uenv.Create(bootloaderUbootFwEnvFile, 4096)
+	c.Assert(err, IsNil)
+	env.Set("snappy_ab", "a")
+	env.Set("snappy_mode", "try")
+	env.Set("snappy_trial_boot", "1")
+	err = env.Save()
+	c.Assert(err, IsNil)
+
+	partition := New()
+	u := newUboot(partition)
+	c.Assert(u, NotNil)
+
+	err = u.MarkCurrentBootSuccessful()
+	c.Assert(err, IsNil)
+
+	env, err = uenv.Open(bootloaderUbootFwEnvFile)
+	c.Assert(err, IsNil)
+	c.Assert(env.String(), Equals, "snappy_ab=a\nsnappy_mode=regular\nsnappy_trial_boot=0\n")
+}
+
+func (s *PartitionTestSuite) TestUbootSetEnvNoUselessWrites(c *C) {
+	s.makeFakeUbootEnv(c)
+
+	env, err := uenv.Create(bootloaderUbootFwEnvFile, 4096)
+	c.Assert(err, IsNil)
+	env.Set("snappy_ab", "a")
+	env.Set("snappy_mode", "regular")
+	err = env.Save()
+	c.Assert(err, IsNil)
+
+	st, err := os.Stat(bootloaderUbootFwEnvFile)
+	c.Assert(err, IsNil)
+	time.Sleep(100 * time.Millisecond)
+
+	partition := New()
+	u := newUboot(partition)
+	c.Assert(u, NotNil)
+
+	err = u.(*uboot).setBootVar(bootloaderRootfsVar, "a")
+	c.Assert(err, IsNil)
+
+	env, err = uenv.Open(bootloaderUbootFwEnvFile)
+	c.Assert(err, IsNil)
+	c.Assert(env.String(), Equals, "snappy_ab=a\nsnappy_mode=regular\n")
+
+	st2, err := os.Stat(bootloaderUbootFwEnvFile)
+	c.Assert(err, IsNil)
+	c.Assert(st.ModTime(), Equals, st2.ModTime())
+}

=== modified file 'partition/partition.go'
--- partition/partition.go	2015-07-15 07:53:43 +0000
+++ partition/partition.go	2015-09-08 06:47:52 +0000
@@ -596,6 +596,7 @@
 		return errors.New("System is not dual root")
 	}
 
+<<<<<<< TREE
 	bootloader, err := bootloader(p)
 	if err != nil {
 		return err
@@ -619,4 +620,23 @@
 	}
 
 	return bootloader.BootDir()
+=======
+	bootloader, err := getBootloader(p)
+	if err != nil {
+		return err
+	}
+
+	// XXX: first toggle roofs and then handle assets? that seems
+	//      wrong given that handleAssets may fails and we will
+	//      knowingly boot into a broken system
+	err = p.RunWithOther(RW, func(otherRoot string) (err error) {
+		return bootloader.ToggleRootFS()
+	})
+
+	if err != nil {
+		return err
+	}
+
+	return bootloader.HandleAssets()
+>>>>>>> MERGE-SOURCE
 }

=== modified file 'partition/partition_test.go'
=== modified file 'partition/utils_test.go'
=== modified file 'policy/policy_test.go'
=== modified file 'priv/priv_test.go'
=== modified file 'progress/progress.go'
=== modified file 'progress/progress_test.go'
=== modified file 'release/release_test.go'
=== modified file 'run-checks'
--- run-checks	2015-09-02 18:11:49 +0000
+++ run-checks	2015-09-08 06:47:52 +0000
@@ -53,6 +53,7 @@
 lint=$(golint ./... && golint ./_integration-tests/testutils/... && golint ./_integration-tests/tests/...)
 if [ -n "$lint" ]; then
     echo "Lint complains:"
+<<<<<<< TREE
     echo "$lint"
     exit 1
 fi
@@ -83,6 +84,24 @@
     if which subunit2pyunit >/dev/null 2>&1; then
         subunit-1to2 /tmp/snappy-test/output/artifacts/results.subunit | subunit2pyunit
     fi
+=======
+    echo "$lint"
+    exit 1
+>>>>>>> MERGE-SOURCE
+fi
+
+# integration tests
+echo Building the integration tests
+go build _integration-tests/main.go
+
+# the rabbit hole
+echo Running the tests for the integration testutils
+$goctest -v -cover ./_integration-tests/testutils/...
+
+# integration suite in kvm
+if which adt-run >/dev/null 2>&1; then
+    echo "Running integration tests on 15.04 edge"
+    go run _integration-tests/main.go --snappy-from-branch --release=15.04
 fi
 
 echo "All good, what could possibly go wrong"

=== modified file 'snappy/auth.go'
=== modified file 'snappy/auth_test.go'
--- snappy/auth_test.go	2015-06-09 12:56:34 +0000
+++ snappy/auth_test.go	2015-09-08 06:47:52 +0000
@@ -36,8 +36,8 @@
 const mockStoreInvalidLoginCode = 401
 const mockStoreInvalidLogin = `
 {
-    "message": "Provided email/password is not correct.", 
-    "code": "INVALID_CREDENTIALS", 
+    "message": "Provided email/password is not correct.",
+    "code": "INVALID_CREDENTIALS",
     "extra": {}
 }
 `
@@ -45,22 +45,22 @@
 const mockStoreNeeds2faHTTPCode = 401
 const mockStoreNeeds2fa = `
 {
-    "message": "2-factor authentication required.", 
-    "code": "TWOFACTOR_REQUIRED", 
+    "message": "2-factor authentication required.",
+    "code": "TWOFACTOR_REQUIRED",
     "extra": {}
 }
 `
 
 const mockStoreReturnToken = `
 {
-    "openid": "the-open-id-string-that-is-also-the-consumer-key-in-our-store", 
-    "token_name": "some-token-name", 
-    "date_updated": "2015-02-27T15:00:55.062", 
-    "token_key": "the-token-key", 
-    "consumer_secret": "the-consumer-secret", 
-    "href": "/api/v2/tokens/oauth/something", 
-    "date_created": "2015-02-27T14:54:30.863", 
-    "consumer_key": "the-consumer-key", 
+    "openid": "the-open-id-string-that-is-also-the-consumer-key-in-our-store",
+    "token_name": "some-token-name",
+    "date_updated": "2015-02-27T15:00:55.062",
+    "token_key": "the-token-key",
+    "consumer_secret": "the-consumer-secret",
+    "href": "/api/v2/tokens/oauth/something",
+    "date_created": "2015-02-27T14:54:30.863",
+    "consumer_key": "the-consumer-key",
     "token_secret": "the-token-secret"
 }
 `

=== modified file 'snappy/build_test.go'
--- snappy/build_test.go	2015-07-29 09:49:41 +0000
+++ snappy/build_test.go	2015-09-08 06:47:52 +0000
@@ -25,11 +25,16 @@
 	"os/exec"
 	"path/filepath"
 	"strings"
+<<<<<<< TREE
 	"syscall"
 
 	"launchpad.net/snappy/helpers"
 
 	. "gopkg.in/check.v1"
+=======
+
+	. "gopkg.in/check.v1"
+>>>>>>> MERGE-SOURCE
 )
 
 func makeFakeDuCommand(c *C) string {

=== modified file 'snappy/click.go'
--- snappy/click.go	2015-09-04 13:08:48 +0000
+++ snappy/click.go	2015-09-08 06:47:52 +0000
@@ -332,9 +332,15 @@
 		AppArch     string
 		AppPath     string
 		Version     string
+<<<<<<< TREE
 		UdevAppName string
 		Origin      string
 		Home        string
+=======
+		UdevAppName string
+		Namespace   string
+		Home        string
+>>>>>>> MERGE-SOURCE
 		Target      string
 		AaProfile   string
 		OldAppVars  string
@@ -344,9 +350,15 @@
 		AppArch:     helpers.UbuntuArchitecture(),
 		AppPath:     pkgPath,
 		Version:     m.Version,
+<<<<<<< TREE
 		UdevAppName: udevPartName,
 		Origin:      origin,
 		Home:        "$HOME",
+=======
+		UdevAppName: udevPartName,
+		Namespace:   namespace,
+		Home:        "$HOME",
+>>>>>>> MERGE-SOURCE
 		Target:      actualBinPath,
 		AaProfile:   aaProfile,
 	}
@@ -436,8 +448,14 @@
 		socketFileName = filepath.Base(generateSocketFileName(m, service))
 	}
 
+	socketFileName := ""
+	if service.Socket {
+		socketFileName = filepath.Base(generateSocketFileName(m, service))
+	}
+
 	return systemd.New(globalRootDir, nil).GenServiceFile(
 		&systemd.ServiceDescription{
+<<<<<<< TREE
 			AppName:        m.Name,
 			ServiceName:    service.Name,
 			Version:        m.Version,
@@ -474,6 +492,45 @@
 }
 
 func generateServiceFileName(m *packageYaml, service ServiceYaml) string {
+=======
+			AppName:        m.Name,
+			ServiceName:    service.Name,
+			Version:        m.Version,
+			Description:    service.Description,
+			AppPath:        baseDir,
+			Start:          service.Start,
+			Stop:           service.Stop,
+			PostStop:       service.PostStop,
+			StopTimeout:    time.Duration(service.StopTimeout),
+			AaProfile:      aaProfile,
+			IsFramework:    m.Type == SnapTypeFramework,
+			IsNetworked:    service.Ports != nil && len(service.Ports.External) > 0,
+			BusName:        service.BusName,
+			UdevAppName:    udevPartName,
+			Socket:         service.Socket,
+			SocketFileName: socketFileName,
+		}), nil
+}
+
+func generateSnapSocketFile(service Service, baseDir string, aaProfile string, m *packageYaml) (string, error) {
+	if err := verifyServiceYaml(service); err != nil {
+		return "", err
+	}
+
+	serviceFileName := filepath.Base(generateServiceFileName(m, service))
+
+	return systemd.New(globalRootDir, nil).GenSocketFile(
+		&systemd.ServiceDescription{
+			ServiceFileName: serviceFileName,
+			ListenStream:    service.ListenStream,
+			SocketMode:      service.SocketMode,
+			SocketUser:      service.SocketUser,