Merge lp:~mvo/goget-ubuntu-touch/minimal-first-boot into lp:goget-ubuntu-touch

[Michael Vogt]

This implements creating a ubuntu core 16 image with minimal support from snapd (grub only for now). Most importantly the snap install part is dropped and the code only downloads and drops the files into the right location.

This is the basis for the `firstboot` part of snapd. Also note that this is only a temporary tree that will be replaced with ubuntu-image. However ubuntu-image can still use this code (and layout) as a blueprint how to generate the basic dir layout. Plus for ubuntu-image we will need something like "snap-bootstrap" as the python-code will not be able to call into the go code.

[lp:~mvo/goget-ubuntu-touch/minimal-first-boot]

283. By Michael Vogt on 2016-06-08

prefix first-boot snaps with "first-boot"

284. By Michael Vogt on 2016-06-08

use .sideinfo instead of .meta

285. By Michael Vogt on 2016-06-08

make u-d-f install the snap under exactly the same name as snappy would expect it

286. By Michael Vogt on 2016-06-11

only create .sideinfo if we actually have sideinfo

287. By Michael Vogt on 2016-06-14

use `snap boostrap` for os,kernel,gadget install

288. By Michael Vogt on 2016-06-14

add channel and store-id to boostrap.yaml

289. By Michael Vogt on 2016-06-14

add extra installs

290. By Michael Vogt on 2016-06-14

remove dead code

291. By Michael Vogt on 2016-07-14

use new `snap weld`

292. By Michael Vogt on 2016-08-30

update to latest create-image api

293. By Michael Vogt on 2016-08-30

cherry pick r290 from lp:~mvo/goget-ubuntu-touch/minimal-first-boot-no-prepare-image

294. By Michael Vogt on 2016-08-30

fix copy

295. By Michael Vogt on 2016-08-30

take model assertion as input instead of of --kernel/--os

296. By Michael Vogt on 2016-08-31

ubuntu-device-flash/main.go: fix cmdline parsing

297. By Michael Vogt on 2016-08-31

add snapcraft.yaml that includes the "snap" command

298. By Michael Vogt on 2016-08-31

remove some dead code

299. By Michael Vogt on 2016-09-04

remove boot-assets/uEnv.txt from compat yaml

Unmerged revisions

299. By Michael Vogt on 2016-09-04

remove boot-assets/uEnv.txt from compat yaml

298. By Michael Vogt on 2016-08-31

remove some dead code

297. By Michael Vogt on 2016-08-31

add snapcraft.yaml that includes the "snap" command

296. By Michael Vogt on 2016-08-31

ubuntu-device-flash/main.go: fix cmdline parsing

295. By Michael Vogt on 2016-08-30

take model assertion as input instead of of --kernel/--os

294. By Michael Vogt on 2016-08-30

fix copy

293. By Michael Vogt on 2016-08-30

cherry pick r290 from lp:~mvo/goget-ubuntu-touch/minimal-first-boot-no-prepare-image

292. By Michael Vogt on 2016-08-30

update to latest create-image api

291. By Michael Vogt on 2016-07-14

use new `snap weld`

290. By Michael Vogt on 2016-06-14

remove dead code

=== modified file 'debian/changelog'
--- debian/changelog	2016-08-05 13:21:10 +0000
+++ debian/changelog	2016-09-04 15:15:47 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 goget-ubuntu-touch (0.34+16.10.20160805-0ubuntu1) yakkety; urgency=medium
 
   [ Andrea Bernabei ]
@@ -34,6 +35,20 @@
 
  -- Sergio Schvezov <[e-mail]>  Wed, 18 Nov 2015 09:32:39 -0300
 
+=======
+goget-ubuntu-touch (0.34-0ubuntu1+ppa2) xenial; urgency=medium
+
+  * add missing golang-golang-x-crypto-dev b-d
+
+ -- Michael Vogt <[e-mail]>  Wed, 06 Apr 2016 18:06:31 +0200
+
+goget-ubuntu-touch (0.34-0ubuntu1+ppa1) xenial; urgency=medium
+
+  * ppa upload of the all-snaps branch
+
+ -- Michael Vogt <[e-mail]>  Wed, 06 Apr 2016 17:58:42 +0200
+
+>>>>>>> MERGE-SOURCE
 goget-ubuntu-touch (0.33-0ubuntu1) xenial; urgency=medium
 
   * Exit 1 on parameter errors (LP: #1473333) 

=== modified file 'debian/control'
--- debian/control	2016-04-05 07:51:47 +0000
+++ debian/control	2016-09-04 15:15:47 +0000
@@ -9,9 +9,23 @@
                golang-gettext-dev,
                golang-go-flags-dev,
                golang-gocheck-dev,
+<<<<<<< TREE
+=======
+               golang-github-mvo5-goconfigparser-dev,
+>>>>>>> MERGE-SOURCE
                golang-juju-loggo-dev,
                golang-pb-dev,
+<<<<<<< TREE
+=======
+               golang-github-ubuntu-core-snappy-dev,
+               golang-github-mvo5-uboot-go-dev,
+>>>>>>> MERGE-SOURCE
                golang-yaml.v2-dev,
+<<<<<<< TREE
+=======
+               golang-golang-x-crypto-dev,
+               ubuntu-snappy-cli,
+>>>>>>> MERGE-SOURCE
 Standards-Version: 3.9.5
 Homepage: https://launchpad.net/goget-ubuntu-touch
 Vcs-Browser: http://bazaar.launchpad.net/~phablet-team/goget-ubuntu-touch/trunk/files

=== modified file 'dependencies.tsv'
--- dependencies.tsv	2016-04-04 15:54:40 +0000
+++ dependencies.tsv	2016-09-04 15:15:47 +0000
@@ -1,6 +1,11 @@
-github.com/blakesmith/ar	git	8bd4349a67f2533b078dbc524689d15dba0f4659	2015-03-11T14:59:44Z
 github.com/cheggaaa/pb	git	da1f27ad1d9509b16f65f52fd9d8138b0f2dc7b2	2015-08-13T11:06:09Z
 github.com/gosexy/gettext	git	98b7b91596d20b96909e6b60d57411547dd9959c	2013-02-21T11:21:43Z
 github.com/jessevdk/go-flags	git	4047bd797dd935ae2b557a79cc43f223066c9659	2015-10-18T21:15:10Z
+<<<<<<< TREE
+=======
+github.com/mvo5/goconfigparser	git	26426272dda20cc76aa1fa44286dc743d2972fe8	2015-02-12T09:37:50Z
+github.com/mvo5/uboot-go	git	69978a3e4b05cca9d7cfee489b3453dfed45e72c	2015-07-23T08:17:10Z
+github.com/ubuntu-core/snappy	git	a6e683cb4eca7027b331713c2f10e26a31050f20	2016-01-14T16:39:06Z
+>>>>>>> MERGE-SOURCE
 gopkg.in/yaml.v2	git	7ad95dd0798a40da1ccdff6dff35fd177b5edf40	2015-06-24T10:29:02Z
 launchpad.net/gocheck	bzr	[e-mail]-20140225173054-xu9zlkf9kxhvow02	87

=== modified file 'diskimage/bootloader.go'
--- diskimage/bootloader.go	2016-04-05 09:32:48 +0000
+++ diskimage/bootloader.go	2016-09-04 15:15:47 +0000
@@ -89,21 +89,31 @@
 	printOut("Setting up raw boot asset partitions for", imagePath, "...")
 	var part int = partCount
 
-	for _, asset := range rawPartitions {
+<<<<<<< TREE
+	for _, asset := range rawPartitions {
+=======
+	pos := 0
+	for _, asset := range rawPartitions {
+>>>>>>> MERGE-SOURCE
 		part += 1
 
-		size, err := strconv.Atoi(asset.Size)
-		if err != nil {
-			return err
-		}
-		size = size * 2
-
 		printOut("creating partition:", asset.Name)
-
-		opts := fmt.Sprintf("0:0:+%d", size)
-		if err := exec.Command("sgdisk", "-a", "1", "-n", opts, imagePath).Run(); err != nil {
+		// override position if specified, otherwise use the
+		// previous position
+		if asset.Pos > 0 {
+			pos = asset.Pos
+		}
+
+		// why * 2?
+		size := asset.Size * 2
+
+		opts := fmt.Sprintf("%d:%d:+%d", part, pos, size)
+		if output, err := exec.Command("sgdisk", "-a", "1", "-n", opts, imagePath).CombinedOutput(); err != nil {
+			println(string(output))
 			return err
 		}
+		// move postition forward
+		pos += size
 
 		opts = fmt.Sprintf("%d:%s", part, asset.Name)
 		if err := exec.Command("sgdisk", "-c", opts, imagePath).Run(); err != nil {
@@ -114,10 +124,9 @@
 		if err := exec.Command("sgdisk", "-t", opts, imagePath).Run(); err != nil {
 			return err
 		}
-
 	}
 
-	printOut("sorting partitions")
+	printOut("aligning partitions")
 	if err := exec.Command("sgdisk", "-s", imagePath).Run(); err != nil {
 		return err
 	}

=== modified file 'diskimage/common.go'
--- diskimage/common.go	2016-04-05 09:32:48 +0000
+++ diskimage/common.go	2016-09-04 15:15:47 +0000
@@ -9,7 +9,6 @@
 
 import (
 	"bufio"
-	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
@@ -17,8 +16,6 @@
 	"path/filepath"
 	"strings"
 	"syscall"
-
-	"launchpad.net/goget-ubuntu-touch/sysutils"
 )
 
 // This program is free software: you can redistribute it and/or modify it
@@ -47,10 +44,6 @@
 	initrdFileName   = "initrd.img"
 )
 
-const (
-	partLayoutSystemAB = "system-AB"
-)
-
 var (
 	syscallSync = syscall.Sync
 )
@@ -88,9 +81,16 @@
 }
 
 type BootAssetRawPartitions struct {
+<<<<<<< TREE
 	Name string `yaml:"name"`
 	Size string `yaml:"size"`
 	Type string `yaml:"type"`
+=======
+	Name string `yaml:"name"`
+	Size int    `yaml:"size"`
+	Pos  int    `yaml:"pos"`
+	Type string `yaml:"type"`
+>>>>>>> MERGE-SOURCE
 }
 
 type BootAssetFiles struct {
@@ -107,11 +107,11 @@
 	RawPartitions []BootAssetRawPartitions `yaml:"raw-partitions,omitempty"`
 }
 
-type OemDescription struct {
+type GadgetDescription struct {
 	Name    string `yaml:"name"`
 	Version string `yaml:"version"`
 
-	OEM struct {
+	Gadget struct {
 		Hardware struct {
 			Bootloader      string      `yaml:"bootloader"`
 			PartitionLayout string      `yaml:"partition-layout"`
@@ -129,7 +129,7 @@
 		Store *struct {
 			ID string `yaml:"id,omitempty"`
 		}
-	} `yaml:"oem,omitempty"`
+	} `yaml:"gadget,omitempty"`
 
 	Config struct {
 		UbuntuCore struct {
@@ -140,53 +140,42 @@
 	rootDir string
 }
 
-func (o *OemDescription) SetRoot(rootDir string) {
+func (o *GadgetDescription) SetRoot(rootDir string) {
 	o.rootDir = rootDir
 }
 
 // SystemParts returns the system labels depending on the partition layout.
 //
 // The default is to return a flat structure for any unknown layout.
-func (o *OemDescription) SystemParts() []string {
-	switch o.OEM.Hardware.PartitionLayout {
-	case partLayoutSystemAB:
-		return []string{"a", "b"}
+func (o *GadgetDescription) SystemParts() []string {
+	switch o.Gadget.Hardware.PartitionLayout {
 	default:
 		return []string{""}
 	}
 }
 
-func (o OemDescription) InstallPath() (string, error) {
-	glob, err := filepath.Glob(fmt.Sprintf("%s/oem/%s/current", o.rootDir, o.Name))
-	if err != nil {
-		return "", err
-	}
-
-	if len(glob) != 1 {
-		return "", errors.New("oem package not installed")
-	}
-
-	return glob[0], nil
-}
-
-func (o OemDescription) Architecture() string {
-	return o.OEM.Hardware.Architecture
-}
-
-func (o *OemDescription) SetArchitecture(architecture string) {
-	o.OEM.Hardware.Architecture = architecture
-}
-
-func (o OemDescription) PartitionLayout() string {
-	return o.OEM.Hardware.PartitionLayout
-}
-
-func (o OemDescription) Platform() string {
-	return o.OEM.Hardware.Platform
-}
-
-func (o *OemDescription) SetPlatform(platform string) {
-	o.OEM.Hardware.Platform = platform
+func (o GadgetDescription) InstallPath() (string, error) {
+	return o.rootDir, nil
+}
+
+func (o GadgetDescription) Architecture() string {
+	return o.Gadget.Hardware.Architecture
+}
+
+func (o *GadgetDescription) SetArchitecture(architecture string) {
+	o.Gadget.Hardware.Architecture = architecture
+}
+
+func (o GadgetDescription) PartitionLayout() string {
+	return o.Gadget.Hardware.PartitionLayout
+}
+
+func (o GadgetDescription) Platform() string {
+	return o.Gadget.Hardware.Platform
+}
+
+func (o *GadgetDescription) SetPlatform(platform string) {
+	o.Gadget.Hardware.Platform = platform
 }
 
 func sectorSize(dev string) (string, error) {
@@ -200,6 +189,7 @@
 
 // BaseImage implements the basic primitives to manage images.
 type BaseImage struct {
+<<<<<<< TREE
 	baseMount string
 	hardware  HardwareDescription
 	location  string
@@ -209,8 +199,22 @@
 	size      int64
 	rootSize  int
 	label     string
+=======
+	baseMount  string
+	bindMounts []string
+	hardware   HardwareDescription
+	location   string
+	gadget     GadgetDescription
+	parts      []partition
+	partCount  int
+	size       int64
+	rootSize   int
+	label      string
+>>>>>>> MERGE-SOURCE
 }
 
+var bindMounts = []string{"dev", "sys", "proc", filepath.Join("sys", "firmware")}
+
 // Mount mounts the image. This also maps the loop device.
 func (img *BaseImage) Mount() error {
 	if err := img.doMap(); err != nil {
@@ -267,8 +271,27 @@
 	}
 	img.baseMount = baseMount
 
+	mountpoints := make([]string, 0, len(bindMounts))
+	if img.gadget.PartitionLayout() == "minimal" {
+		mountpoints = bindMounts
+
+		for _, d := range mountpoints {
+			p := filepath.Join(baseMount, d)
+
+			if err := os.MkdirAll(p, 0755); err != nil {
+				return err
+			}
+
+			printOut("Bind mounting", d, "to", p)
+			if err := bindMount(filepath.Join("/", d), p); err != nil {
+				return err
+			}
+
+			img.bindMounts = append(img.bindMounts, p)
+		}
+	}
+
 	return nil
-
 }
 
 // Unmount unmounts the image. This also unmaps the loop device.
@@ -283,6 +306,13 @@
 		panic("No base mountpoint set")
 	}
 
+	for i := len(img.bindMounts) - 1; i >= 0; i-- {
+		if err := unmount(img.bindMounts[i]); err != nil {
+			return err
+		}
+	}
+	img.bindMounts = nil
+
 	syscallSync()
 
 	for _, part := range img.parts {
@@ -466,55 +496,28 @@
 }
 
 func (img *BaseImage) GenericBootSetup(bootPath string) error {
-	// origins
-	hardwareYamlPath := filepath.Join(img.baseMount, hardwareFileName)
-	kernelPath := filepath.Join(img.baseMount, img.hardware.Kernel)
-	initrdPath := filepath.Join(img.baseMount, img.hardware.Initrd)
-
-	// populate both A/B
-	for _, part := range img.oem.SystemParts() {
-		path := filepath.Join(bootPath, part)
-
-		printOut("Setting up", path)
-
-		if err := os.MkdirAll(path, 0755); err != nil {
-			return err
-		}
-
-		if err := sysutils.CopyFile(hardwareYamlPath, filepath.Join(path, hardwareFileName)); err != nil {
-			return err
-		}
-
-		if err := sysutils.CopyFile(kernelPath, filepath.Join(path, kernelFileName)); err != nil {
-			return err
-		}
-
-		if err := sysutils.CopyFile(initrdPath, filepath.Join(path, initrdFileName)); err != nil {
-			return err
-		}
-	}
-
-	oemRoot, err := img.oem.InstallPath()
+	gadgetRoot, err := img.gadget.InstallPath()
 	if err != nil {
 		return err
 	}
 
-	return setupBootAssetFiles(img.Boot(), bootPath, oemRoot, img.oem.OEM.Hardware.BootAssets.Files)
+	return setupBootAssetFiles(img.Boot(), bootPath, gadgetRoot, img.gadget.Gadget.Hardware.BootAssets.Files)
 }
 
 func (img *BaseImage) FlashExtra() error {
-	oemRoot, err := img.oem.InstallPath()
+	gadgetRoot, err := img.gadget.InstallPath()
 	if err != nil {
 		return err
 	}
 
-	if bootAssets := img.oem.OEM.Hardware.BootAssets; bootAssets != nil {
+	if bootAssets := img.gadget.Gadget.Hardware.BootAssets; bootAssets != nil {
 		if bootAssets.RawPartitions != nil {
 			if err := setupBootAssetRawPartitions(img.location, img.partCount, bootAssets.RawPartitions); err != nil {
 				return err
 			}
 		}
-		return setupBootAssetRawFiles(img.location, oemRoot, bootAssets.RawFiles)
+
+		return setupBootAssetRawFiles(img.location, gadgetRoot, bootAssets.RawFiles)
 	}
 
 	return nil
@@ -525,3 +528,19 @@
 		fmt.Println(args...)
 	}
 }
+
+func bindMount(src, dst string) error {
+	if out, err := exec.Command("mount", "--bind", src, dst).CombinedOutput(); err != nil {
+		return fmt.Errorf("issues while bind mounting: %s", out)
+	}
+
+	return nil
+}
+
+func unmount(dst string) error {
+	if out, err := exec.Command("umount", dst).CombinedOutput(); err != nil {
+		return fmt.Errorf("issues while unmounting: %s", out)
+	}
+
+	return nil
+}

=== modified file 'diskimage/common_test.go'
--- diskimage/common_test.go	2015-09-09 16:00:01 +0000
+++ diskimage/common_test.go	2016-09-04 15:15:47 +0000
@@ -28,7 +28,7 @@
 
 type CommonTestSuite struct {
 	tmpdir      string
-	oem         OemDescription
+	gadget      GadgetDescription
 	packageInst string
 }
 
@@ -36,27 +36,27 @@
 
 func (s *CommonTestSuite) SetUpTest(c *C) {
 	s.tmpdir = c.MkDir()
-	s.oem = OemDescription{Name: "packagename", Version: "42"}
-	s.packageInst = s.oem.Name
+	s.gadget = GadgetDescription{Name: "packagename", Version: "42"}
+	s.packageInst = s.gadget.Name
 }
 
 func (s *CommonTestSuite) TestOemInstallPath(c *C) {
-	err := os.MkdirAll(filepath.Join(s.tmpdir, "oem", s.packageInst, "current"), 0755)
-	c.Assert(err, IsNil)
-
-	s.oem.SetRoot(s.tmpdir)
-	installPath, err := s.oem.InstallPath()
-
-	c.Assert(err, IsNil)
-	c.Assert(installPath, Equals, filepath.Join(s.tmpdir, "oem/packagename/current"))
+	err := os.MkdirAll(filepath.Join(s.tmpdir, "gadget", s.packageInst, "current"), 0755)
+	c.Assert(err, IsNil)
+
+	s.gadget.SetRoot(s.tmpdir)
+	installPath, err := s.gadget.InstallPath()
+
+	c.Assert(err, IsNil)
+	c.Assert(installPath, Equals, filepath.Join(s.tmpdir, "gadget/packagename/current"))
 }
 
 func (s *CommonTestSuite) TestOemInstallPathNoOem(c *C) {
-	err := os.MkdirAll(filepath.Join(s.tmpdir, "oem", s.packageInst), 0755)
+	err := os.MkdirAll(filepath.Join(s.tmpdir, "gadget", s.packageInst), 0755)
 	c.Assert(err, IsNil)
 
-	s.oem.SetRoot(s.tmpdir)
-	installPath, err := s.oem.InstallPath()
+	s.gadget.SetRoot(s.tmpdir)
+	installPath, err := s.gadget.InstallPath()
 
 	c.Assert(err, NotNil)
 	c.Assert(installPath, Equals, "")

=== modified file 'diskimage/core_grub.go'
--- diskimage/core_grub.go	2016-04-05 09:32:48 +0000
+++ diskimage/core_grub.go	2016-09-04 15:15:47 +0000
@@ -5,6 +5,7 @@
 //
 // Written by Sergio Schvezov <[e-mail]>
 //
+
 package diskimage
 
 import (
@@ -31,25 +32,40 @@
 // You should have received a copy of the GNU General Public License along
 // with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+// CoreGrubImage holds the logic to create a core image using grub.
 type CoreGrubImage struct {
 	BaseImage
 
 	legacyGrub bool
 }
 
-func NewCoreGrubImage(location string, size int64, rootSize int, hw HardwareDescription, oem OemDescription, updateGrub bool, label string) *CoreGrubImage {
+// NewCoreGrubImage creates a new instance of CoreGrubImage
+func NewCoreGrubImage(location string, size int64, rootSize int, hw HardwareDescription, gadget GadgetDescription, updateGrub bool, label string) *CoreGrubImage {
+	var partCount int
+	switch gadget.PartitionLayout() {
+	case "minimal":
+		partCount = 3
+	}
+
 	return &CoreGrubImage{
 		BaseImage: BaseImage{
 			location:  location,
 			size:      size,
 			rootSize:  rootSize,
 			hardware:  hw,
+<<<<<<< TREE
 			oem:       oem,
 			partCount: 5,
 			label:     label,
+=======
+			gadget:    gadget,
+			partCount: partCount,
+			label:     label,
+>>>>>>> MERGE-SOURCE
 		},
 		legacyGrub: updateGrub,
 	}
+
 }
 
 const grubCfgContent = `# console only, no graphics/vga
@@ -75,9 +91,10 @@
 	}
 
 	parted.addPart(grubLabel, "", fsNone, 4)
-	parted.addPart(bootLabel, bootDir, fsFat32, 128)
-	parted.addPart(systemALabel, systemADir, fsExt4, img.rootSize)
-	parted.addPart(systemBLabel, systemBDir, fsExt4, img.rootSize)
+	switch img.gadget.PartitionLayout() {
+	case "minimal":
+		parted.addPart(bootLabel, bootDir, fsFat32, 64)
+	}
 	parted.addPart(writableLabel, writableDir, fsExt4, -1)
 
 	parted.setBoot(2)
@@ -88,6 +105,7 @@
 	return parted.create(img.location)
 }
 
+// SetupBoot sets up the bootloader logic for the image.
 func (img *CoreGrubImage) SetupBoot() error {
 	if !img.legacyGrub {
 		// destinations
@@ -121,14 +139,14 @@
 		return errors.New("cannot determined absolute path for output image")
 	}
 
-	rootDevPath := filepath.Join(img.System(), "root_dev")
+	rootDevPath := filepath.Join(img.System(), "tmp", "root_dev")
 
-	if f, err := os.Create(rootDevPath); err != nil {
+	f, err := os.Create(rootDevPath)
+	if err != nil {
 		return err
-	} else {
-		f.Close()
-		defer os.Remove(rootDevPath)
 	}
+	f.Close()
+	defer os.Remove(rootDevPath)
 
 	if err := bindMount(outputPath, rootDevPath); err != nil {
 		return err
@@ -165,7 +183,7 @@
 
 	var grubTarget string
 
-	arch := img.oem.Architecture()
+	arch := img.gadget.Architecture()
 
 	switch arch {
 	case "armhf":
@@ -174,13 +192,15 @@
 		grubTarget = "x86_64-efi"
 	case "i386":
 		grubTarget = "i386-efi"
+	case "arm64":
+		grubTarget = "arm64-efi"
 	default:
 		return fmt.Errorf("unsupported architecture for GRUB on EFI: %s", arch)
 	}
 
 	if arch == "amd64" || arch == "i386" {
 		// install grub BIOS support
-		if out, err := exec.Command("chroot", img.System(), "grub-install", "/root_dev").CombinedOutput(); err != nil {
+		if out, err := exec.Command("chroot", img.System(), "grub-install", "tmp/root_dev").CombinedOutput(); err != nil {
 			return fmt.Errorf("unable to install grub (BIOS): %s", out)
 		}
 	}
@@ -233,19 +253,3 @@
 
 	return nil
 }
-
-func bindMount(src, dst string) error {
-	if out, err := exec.Command("mount", "--bind", src, dst).CombinedOutput(); err != nil {
-		return fmt.Errorf("issues while bind mounting: %s", out)
-	}
-
-	return nil
-}
-
-func unmount(dst string) error {
-	if out, err := exec.Command("umount", dst).CombinedOutput(); err != nil {
-		return fmt.Errorf("issues while unmounting: %s", out)
-	}
-
-	return nil
-}

=== modified file 'diskimage/core_uboot.go'
--- diskimage/core_uboot.go	2016-04-05 09:32:48 +0000
+++ diskimage/core_uboot.go	2016-09-04 15:15:47 +0000
@@ -66,16 +66,27 @@
 	Bootloader []string `yaml:"bootloader"`
 }
 
-func NewCoreUBootImage(location string, size int64, rootSize int, hw HardwareDescription, oem OemDescription, label string) *CoreUBootImage {
+func NewCoreUBootImage(location string, size int64, rootSize int, hw HardwareDescription, gadget GadgetDescription, label string) *CoreUBootImage {
+	var partCount int
+	switch gadget.PartitionLayout() {
+	case "minimal":
+		partCount = 2
+	}
+
 	return &CoreUBootImage{
 		BaseImage{
 			hardware:  hw,
-			oem:       oem,
+			gadget:    gadget,
 			location:  location,
 			size:      size,
 			rootSize:  rootSize,
+<<<<<<< TREE
 			partCount: 4,
 			label:     label,
+=======
+			partCount: partCount,
+			label:     label,
+>>>>>>> MERGE-SOURCE
 		},
 	}
 }
@@ -95,9 +106,10 @@
 		return err
 	}
 
-	parted.addPart(bootLabel, bootDir, fsFat32, 128)
-	parted.addPart(systemALabel, systemADir, fsExt4, 1024)
-	parted.addPart(systemBLabel, systemBDir, fsExt4, 1024)
+	switch img.gadget.PartitionLayout() {
+	case "minimal":
+		parted.addPart(bootLabel, bootDir, fsFat32, 128)
+	}
 	parted.addPart(writableLabel, writableDir, fsExt4, -1)
 
 	parted.setBoot(1)
@@ -117,7 +129,7 @@
 	}
 
 	// populate both A/B
-	for _, part := range img.oem.SystemParts() {
+	for _, part := range img.gadget.SystemParts() {
 		bootDtbPath := filepath.Join(bootPath, part, "dtbs")
 		if err := img.provisionDtbs(bootDtbPath); err != nil {
 			return err
@@ -131,7 +143,7 @@
 	defer snappySystemFile.Close()
 
 	var fdtfile string
-	if platform := img.oem.Platform(); platform != "" {
+	if platform := img.gadget.Platform(); platform != "" {
 		fdtfile = fmt.Sprintf("fdtfile=%s.dtb", platform)
 	}
 
@@ -154,28 +166,32 @@
 		return err
 	}
 
-	dtbFis, err := ioutil.ReadDir(dtbsPath)
-	if err != nil {
-		return err
+	var dtbFis []os.FileInfo
+	if img.hardware.Dtbs != "" {
+		var err error
+		dtbFis, err = ioutil.ReadDir(dtbsPath)
+		if err != nil {
+			return err
+		}
 	}
 
 	if err := os.MkdirAll(bootDtbPath, 0755); err != nil {
 		return err
 	}
 
-	dtb := filepath.Join(dtbsPath, fmt.Sprintf("%s.dtb", img.oem.Platform()))
+	dtb := filepath.Join(dtbsPath, fmt.Sprintf("%s.dtb", img.gadget.Platform()))
 
 	// if there is a specific dtb for the platform, copy it.
-	// First look in oem and then in device.
-	if oemDtb := img.oem.OEM.Hardware.Dtb; oemDtb != "" && img.oem.Platform() != "" {
-		oemRoot, err := img.oem.InstallPath()
+	// First look in gadget and then in device.
+	if gadgetDtb := img.gadget.Gadget.Hardware.Dtb; gadgetDtb != "" && img.gadget.Platform() != "" {
+		gadgetRoot, err := img.gadget.InstallPath()
 		if err != nil {
 			return err
 		}
 
-		oemDtb := filepath.Join(oemRoot, oemDtb)
+		gadgetDtb := filepath.Join(gadgetRoot, gadgetDtb)
 		dst := filepath.Join(bootDtbPath, filepath.Base(dtb))
-		if err := sysutils.CopyFile(oemDtb, dst); err != nil {
+		if err := sysutils.CopyFile(gadgetDtb, dst); err != nil {
 			return err
 		}
 	} else if _, err := os.Stat(dtb); err == nil {

=== modified file 'diskimage/partition.go'
--- diskimage/partition.go	2015-01-15 21:05:01 +0000
+++ diskimage/partition.go	2016-09-04 15:15:47 +0000
@@ -5,6 +5,7 @@
 //
 // Written by Sergio Schvezov <[e-mail]>
 //
+
 package diskimage
 
 import (

=== added file 'snapcraft.yaml'
--- snapcraft.yaml	1970-01-01 00:00:00 +0000
+++ snapcraft.yaml	2016-09-04 15:15:47 +0000
@@ -0,0 +1,35 @@
+name: ubuntu-device-flash
+summary: Flash supported devices with Ubuntu
+description: |
+  Use this tool to flash a suported device with Ubuntu. This works
+  for different kinds of Ubuntu like Core or Touch.
+version: 11
+confinement: devmode
+
+apps:
+  ubuntu-device-flash:
+    command: bin/ubuntu-device-flash
+
+parts:
+  goget-ubuntu-touch:
+    plugin: go
+    source: lp:~mvo/goget-ubuntu-touch/minimal-first-boot
+    source-type: bzr
+    go-importpath: launchpad.net/goget-ubuntu-touch
+    organize:
+      sbin/kpartx: bin/kpartx
+      sbin/dmsetup: bin/dmsetup
+    snap:
+      - bin/ubuntu-device-flash
+      - bin/kpartx
+      - bin/dmsetup
+    stage-packages:
+      - kpartx
+      - dmsetup
+  snapd:
+    plugin: go
+    source: https://github.com/snapcore/snapd
+    source-type: git
+    go-importpath: github.com/snapcore/snapd
+    snap:
+      - bin/snap

=== modified file 'ubuntu-device-flash/common.go'
--- ubuntu-device-flash/common.go	2015-03-30 03:28:28 +0000
+++ ubuntu-device-flash/common.go	2016-09-04 15:15:47 +0000
@@ -61,11 +61,11 @@
 
 // expandFile checks for file existence, correct permissions and returns the absolute path.
 func expandFile(path string) (abspath string, err error) {
-	if p, err := filepath.Abs(path); err != nil {
+	p, err := filepath.Abs(path)
+	if err != nil {
 		return "", err
-	} else {
-		abspath = p
 	}
+	abspath = p
 
 	fi, err := os.Lstat(abspath)
 	if err != nil {

=== modified file 'ubuntu-device-flash/core.go'
--- ubuntu-device-flash/core.go	2016-04-04 15:54:40 +0000
+++ ubuntu-device-flash/core.go	2016-09-04 15:15:47 +0000
@@ -77,21 +77,20 @@
 
 	if !coreCmd.Deprecated.Cloud {
 		coreCmd.customizationFunc = append(coreCmd.customizationFunc, coreCmd.setupCloudInit)
-		coreCmd.customizationFunc = append(coreCmd.customizationFunc, coreCmd.setupOemConfigs)
+		coreCmd.customizationFunc = append(coreCmd.customizationFunc, coreCmd.setupGadgetConfigs)
 	}
 
 	return coreCmd.create()
 }
 
 // this is a hackish way to get the config in place
-func (coreCmd *CoreCmd) setupOemConfigs() error {
-	modprobeDContent := coreCmd.oem.Config.UbuntuCore.Modprobe
+func (coreCmd *CoreCmd) setupGadgetConfigs() error {
+	modprobeDContent := coreCmd.gadget.Config.UbuntuCore.Modprobe
 	if modprobeDContent == nil {
-		printOut("no modprobe")
 		return nil
 	}
 
-	fmt.Println("Setting up oem hooks...")
+	fmt.Println("Setting up gadget hooks...")
 
 	writablePath := coreCmd.img.Writable()
 
@@ -101,12 +100,20 @@
 	}
 
 	// first we need to copy all the files in modprobe.d
+<<<<<<< TREE
 	/*
 		systemModprobeDir := filepath.Join(coreCmd.img.System(), "etc", "modprobe.d")
 			if err := helpers.RSyncWithDelete(systemModprobeDir, modprobeDir); err != nil {
 				return err
 			}
 	*/
+=======
+	systemModprobeDir := filepath.Join(coreCmd.img.System(), "etc", "modprobe.d")
+	// FIXME: can we do "cp -a" here?
+	if err := RSyncWithDelete(systemModprobeDir, modprobeDir); err != nil {
+		return err
+	}
+>>>>>>> MERGE-SOURCE
 
 	modprobeD := filepath.Join(modprobeDir, "ubuntu-core.conf")
 	modprobeDFile, err := os.Create(modprobeD)

=== added file 'ubuntu-device-flash/helpers.go'
--- ubuntu-device-flash/helpers.go	1970-01-01 00:00:00 +0000
+++ ubuntu-device-flash/helpers.go	2016-09-04 15:15:47 +0000
@@ -0,0 +1,89 @@
+// -*- 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 main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"syscall"
+
+	"github.com/snapcore/snapd/osutil"
+)
+
+// 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 !osutil.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(src string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// relative to the root "srcDirName"
+		relPath := src[len(srcDirName):]
+		dst := filepath.Join(destDirName, relPath)
+		if info.IsDir() {
+			if err := os.MkdirAll(dst, info.Mode()); err != nil {
+				return err
+			}
+
+			// this can panic. The alternative would be to use the "st, ok" pattern, and then if !ok... panic?
+			st := info.Sys().(*syscall.Stat_t)
+			ts := []syscall.Timespec{st.Atim, st.Mtim}
+
+			return syscall.UtimesNano(dst, ts)
+		}
+		if !osutil.FilesAreEqual(src, dst) {
+			// XXX: we should (eventually) use CopyFile here,
+			//      but we need to teach it about preserving
+			//      of atime/mtime and permissions
+			output, err := exec.Command("cp", "-va", src, dst).CombinedOutput()
+			if err != nil {
+				return fmt.Errorf("Failed to copy %s to %s (%s)", src, dst, output)
+			}
+		}
+		return nil
+	})
+
+	return err
+}

=== added file 'ubuntu-device-flash/helpers_test.go'
--- ubuntu-device-flash/helpers_test.go	1970-01-01 00:00:00 +0000
+++ ubuntu-device-flash/helpers_test.go	2016-09-04 15:15:47 +0000
@@ -0,0 +1,135 @@
+// -*- 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 main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	. "launchpad.net/gocheck"
+)
+
+type HTestSuite struct{}
+
+var _ = Suite(&HTestSuite{})
+
+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.*")
+}

=== modified file 'ubuntu-device-flash/main.go'
--- ubuntu-device-flash/main.go	2015-11-13 15:19:25 +0000
+++ ubuntu-device-flash/main.go	2016-09-04 15:15:47 +0000
@@ -43,7 +43,7 @@
 var cacheDir = ubuntuimage.GetCacheDir()
 
 func main() {
-	execute(os.Args)
+	execute(os.Args[1:])
 }
 
 func execute(args []string) {

=== modified file 'ubuntu-device-flash/snappy.go'
--- ubuntu-device-flash/snappy.go	2016-04-05 09:39:49 +0000
+++ ubuntu-device-flash/snappy.go	2016-09-04 15:15:47 +0000
@@ -9,10 +9,32 @@
 package main
 
 import (
+<<<<<<< TREE
+=======
+	"encoding/json"
+	"errors"
+>>>>>>> MERGE-SOURCE
 	"fmt"
 
+<<<<<<< TREE
+=======
+	"github.com/snapcore/snapd/arch"
+	"github.com/snapcore/snapd/asserts"
+	"github.com/snapcore/snapd/osutil"
+	"github.com/snapcore/snapd/progress"
+	"github.com/snapcore/snapd/provisioning"
+	"github.com/snapcore/snapd/release"
+	"github.com/snapcore/snapd/snap"
+	"github.com/snapcore/snapd/store"
+
+	"gopkg.in/yaml.v2"
+>>>>>>> MERGE-SOURCE
 	"launchpad.net/goget-ubuntu-touch/diskimage"
+<<<<<<< TREE
 	"launchpad.net/goget-ubuntu-touch/ubuntuimage"
+=======
+	"launchpad.net/goget-ubuntu-touch/sysutils"
+>>>>>>> MERGE-SOURCE
 )
 
 type imageFlavor string
@@ -58,25 +80,34 @@
 	}
 }
 
+// Snapper holds common options applicable to snappy based images.
 type Snapper struct {
 	Channel string `long:"channel" description:"Specify the channel to use" default:"stable"`
 	Output  string `long:"output" short:"o" description:"Name of the image file to create" required:"true"`
-	Oem     string `long:"oem" description:"The snappy oem package to base the image out of" default:"generic-amd64"`
-	StoreID string `long:"store" description:"Set an alternate store id."`
 
 	Development struct {
 		Install       []string `long:"install" description:"Install additional packages (can be called multiple times)"`
-		DevicePart    string   `long:"device-part" description:"Specify a local device part to override the one from the server"`
 		DeveloperMode bool     `long:"developer-mode" description:"Finds the latest public key in your ~/.ssh and sets it up using cloud-init"`
 	} `group:"Development"`
 
 	Positional struct {
-		Release string `positional-arg-name:"release" description:"The release to base the image out of (15.04 or rolling)" required:"true"`
+		Release        string `positional-arg-name:"release" description:"The release to base the image out of (16 or rolling)" required:"true"`
+		ModelAssertion string `positional-arg-name:"model-assertion" description:"The model assertion to use" required:"true"`
 	} `positional-args:"yes" required:"yes"`
 
+<<<<<<< TREE
 	img      diskimage.CoreImage
 	hardware diskimage.HardwareDescription
 	oem      diskimage.OemDescription
+=======
+	img             diskimage.CoreImage
+	hardware        diskimage.HardwareDescription
+	gadget          diskimage.GadgetDescription
+	stagingRootPath string
+>>>>>>> MERGE-SOURCE
+
+	prepareImagePath string
+	modelAssertion   *asserts.Model
 
 	size int64
 
@@ -85,23 +116,500 @@
 	customizationFunc []func() error
 }
 
+<<<<<<< TREE
 func (s *Snapper) systemImage() (*ubuntuimage.Image, error) {
 	return nil, nil
+=======
+func (s Snapper) sanityCheck() error {
+	// we don't want to overwrite the output, people might get angry :-)
+	if osutil.FileExists(s.Output) {
+		return fmt.Errorf("Giving up, the desired target output file %#v already exists", s.Output)
+	}
+
+	if s.size < s.flavor.minSize() {
+		return fmt.Errorf("minimum size for %s is %d", s.flavor, s.flavor.minSize())
+	}
+
+	if syscall.Getuid() != 0 {
+		return errors.New("command requires sudo/pkexec (root)")
+	}
+	if s.Positional.Release == "15.04" {
+		return errors.New("building 15.04 core images is no longer supported. Please use the ppa:snappy-dev/tools 15.04 version of this tool")
+	}
+
+	// ensure we error when running on e.g. 14.04 with a sensible
+	// error message instead of super strange error later
+	if !osutil.FileExists("/bin/systemctl") {
+		return errors.New("need '/bin/systemctl to work")
+	}
+
+	return nil
+}
+
+func snapTargetPathFromSnapFile(src string) (string, error) {
+	snapFile, err := snap.Open(src)
+	if err != nil {
+		return "", err
+	}
+	var si snap.SideInfo
+	// XXX: copied from snapmgr.go
+	metafn := src + ".sideinfo"
+	if j, err := ioutil.ReadFile(metafn); err == nil {
+		if err := json.Unmarshal(j, &si); err != nil {
+			return "", fmt.Errorf("cannot read metadata: %s %s\n", metafn, err)
+		}
+	}
+	info, err := snap.ReadInfoFromSnapFile(snapFile, &si)
+	if err != nil {
+		return "", err
+	}
+
+	// local snap
+	if info.Revision.Unset() {
+		info.Revision = snap.R(-1)
+	}
+
+	return info.MountFile(), nil
+}
+
+func copyFile(src, dst string) error {
+	cmd := exec.Command("cp", "-va", src, dst)
+	if o, err := cmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("copy failed: %s %s", err, o)
+	}
+	return nil
+}
+
+func (s *Snapper) prepareImage() error {
+	var err error
+	s.prepareImagePath, err = ioutil.TempDir("", "prepare-image")
+	if err != nil {
+		return err
+	}
+
+	raw, err := ioutil.ReadFile(s.Positional.ModelAssertion)
+	if err != nil {
+		return err
+	}
+	as, err := asserts.Decode(raw)
+	if err != nil {
+		return err
+	}
+	s.modelAssertion = as.(*asserts.Model)
+	arch.SetArchitecture(arch.ArchitectureType(s.modelAssertion.Architecture()))
+
+	os.Setenv("SNAP_REEXEC", "0")
+	cmdArgs := []string{
+		"snap",
+		"prepare-image",
+		"--channel", s.Channel,
+		s.Positional.ModelAssertion,
+		s.prepareImagePath,
+	}
+	for _, extra := range s.Development.Install {
+		cmdArgs = append(cmdArgs, "--extra-snaps="+extra)
+	}
+
+	cmd := exec.Command(cmdArgs[0], cmdArgs[1:]...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("cannot run snap bootstrap: %s", err)
+	}
+	return nil
+>>>>>>> MERGE-SOURCE
 }
 
 func (s *Snapper) install(systemPath string) error {
-	return nil
+<<<<<<< TREE
+	return nil
+=======
+	tmpSystemPath := filepath.Join(s.prepareImagePath, "image")
+
+	mv := exec.Command("sh", "-c", fmt.Sprintf("cp -rv %s/* %s", tmpSystemPath, systemPath))
+	mv.Stdin = os.Stdin
+	mv.Stdout = os.Stdout
+	mv.Stderr = os.Stderr
+	if err := mv.Run(); err != nil {
+		return fmt.Errorf("cannot run snap bootstrap: %s", err)
+	}
+
+	return nil
+}
+
+func (s *Snapper) extractGadget(gadgetPackage string) error {
+	fakeGadgetDir := filepath.Join(s.prepareImagePath, "gadget")
+
+	// HORRIBLE - there is always one more circle of hell, never assume
+	//            you have reached the end of it yet
+	//
+	// the new gadget snaps do no have the old gadget specific stuff
+	// anymore - however we still need it to create images until we
+	// have the new stuff available
+	var gadgetMetaYaml string
+	switch gadgetPackage {
+	case "pc":
+		gadgetMetaYaml = compatCanonicalPCamd64
+	case "386":
+		gadgetMetaYaml = compatCanonicalPCi386
+	case "pi2":
+		gadgetMetaYaml = compatCanonicalPi2
+	case "dragon":
+		gadgetMetaYaml = compatCanonicalDragon
+
+	}
+	if gadgetMetaYaml != "" {
+		if err := ioutil.WriteFile(filepath.Join(fakeGadgetDir, "meta/snap.yaml"), []byte(gadgetMetaYaml), 0644); err != nil {
+			return err
+		}
+	}
+
+	f, err := ioutil.ReadFile(filepath.Join(fakeGadgetDir, "meta/snap.yaml"))
+	if err != nil {
+		return errors.New("failed to read gadget yaml")
+	}
+	var gadget diskimage.GadgetDescription
+	if err := yaml.Unmarshal([]byte(f), &gadget); err != nil {
+		return errors.New("cannot decode gadget yaml")
+	}
+
+	s.gadget = gadget
+	s.gadget.SetRoot(fakeGadgetDir)
+	return nil
+}
+
+// Creates a YAML file inside the image that contains metadata relating
+// to the installation.
+func (s Snapper) writeInstallYaml(bootMountpoint string) error {
+	selfPath, err := exec.LookPath(os.Args[0])
+	if err != nil {
+		return err
+	}
+
+	bootDir := ""
+
+	switch s.gadget.Gadget.Hardware.Bootloader {
+	// Running systems use a bindmount for /boot/grub, but
+	// since the system isn't booted, create the file in the
+	// real location.
+	case "grub":
+		bootDir = "/EFI/ubuntu/grub"
+	}
+
+	installYamlFilePath := filepath.Join(bootMountpoint, bootDir, provisioning.InstallYamlFile)
+
+	i := provisioning.InstallYaml{
+		InstallMeta: provisioning.InstallMeta{
+			Timestamp: time.Now(),
+		},
+		InstallTool: provisioning.InstallTool{
+			Name: filepath.Base(selfPath),
+			Path: selfPath,
+			// FIXME: we don't know our own version yet :)
+			// Version: "???",
+		},
+		InstallOptions: provisioning.InstallOptions{
+			Size:          s.size,
+			SizeUnit:      "GB",
+			Output:        s.Output,
+			Channel:       s.Channel,
+			DeveloperMode: s.Development.DeveloperMode,
+		},
+	}
+
+	data, err := yaml.Marshal(&i)
+	if err != nil {
+		return err
+	}
+
+	// the file isn't supposed to be modified, hence r/o.
+	return ioutil.WriteFile(installYamlFilePath, data, 0444)
+}
+
+func (s *Snapper) bindMount(d string) (string, error) {
+	src := filepath.Join(s.img.Writable(), "system-data", d)
+	dst := filepath.Join(s.img.System(), d)
+
+	if err := os.MkdirAll(src, 0755); err != nil {
+		return "", err
+	}
+	cmd := exec.Command("mount", "--bind", src, dst)
+	if o, err := cmd.CombinedOutput(); err != nil {
+		return "", fmt.Errorf("bind mount failed for %s to %s with: %s %v ", src, dst, err, string(o))
+	}
+	return dst, nil
+}
+
+func (s *Snapper) downloadSnap(snapName string) (string, error) {
+	if snapName == "" {
+		return "", nil
+	}
+	// if its pointing to a local file, just return that
+	if _, err := os.Stat(snapName); err == nil {
+		return snapName, nil
+	}
+	release.Series = s.Positional.Release
+
+	cfg := store.DefaultConfig()
+	cfg.StoreID = s.modelAssertion.Store()
+	m := store.New(cfg, nil)
+	snap, err := m.Snap(snapName, s.Channel, false, snap.R(0), nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to find os snap: %s", err)
+	}
+	pb := progress.NewTextProgress()
+	tmpName, err := m.Download(snapName, &snap.DownloadInfo, pb, nil)
+	if err != nil {
+		return "", err
+	}
+	// rename to the snapid
+	baseName := fmt.Sprintf("%s_%s.snap", snap.SnapID, snap.Revision)
+	path := filepath.Join(filepath.Dir(tmpName), baseName)
+	if err := os.Rename(tmpName, path); err != nil {
+		return "", err
+	}
+
+	// write out metadata for first boot
+	out, err := json.Marshal(snap)
+	if err != nil {
+		return "", err
+	}
+	if err := ioutil.WriteFile(path+".sideinfo", []byte(out), 0644); err != nil {
+		return "", err
+	}
+
+	return path, nil
+}
+
+func (s *Snapper) setup() error {
+	if s.gadget.PartitionLayout() != "minimal" {
+		return fmt.Errorf("only supporting 'minimal' partition layout")
+	}
+
+	printOut("Mounting...")
+	if err := s.img.Mount(); err != nil {
+		return err
+	}
+	defer func() {
+		printOut("Unmounting...")
+		if err := s.img.Unmount(); err != nil {
+			fmt.Println("WARNING: unexpected issue:", err)
+		}
+	}()
+
+	printOut("Provisioning...")
+	systemPath := s.img.System()
+
+	// setup a fake system
+	if err := os.MkdirAll(systemPath, 0755); err != nil {
+		return err
+	}
+
+	// this is a bit terrible, we need to download the OS
+	// mount it, "sync dirs" (see below) and then we
+	// will need to download it again to install it properly
+	osSnap, err := s.downloadSnap("ubuntu-core")
+	if err != nil {
+		return err
+	}
+
+	// mount os snap
+	cmd := exec.Command("mount", osSnap, systemPath)
+	if o, err := cmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("os snap mount failed with: %s %v ", err, string(o))
+	}
+	defer exec.Command("umount", systemPath).Run()
+
+	// bind mount all relevant dirs:
+	//  - /snap so that we can temporarly mount the kernel
+	//  - /var/lib/snapd to put the downloaded snaps in there
+	//  - /tmp so that we can create /tmp/root_dev for grub
+	for _, d := range []string{"snap", "var/lib/snapd", "tmp"} {
+		dst, err := s.bindMount(d)
+		if err != nil {
+			return err
+		}
+		defer exec.Command("umount", dst).Run()
+	}
+
+	// bind mount /boot/efi
+	dst := filepath.Join(systemPath, "/boot/efi")
+	cmd = exec.Command("mount", "--bind", s.img.Boot(), dst)
+	if o, err := cmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("boot bind mount failed with: %s %v ", err, string(o))
+	}
+	defer exec.Command("umount", dst).Run()
+	switch s.gadget.Gadget.Hardware.Bootloader {
+	case "grub":
+		// grub needs this
+		grubUbuntu := filepath.Join(s.img.Boot(), "EFI/ubuntu/grub")
+		os.MkdirAll(grubUbuntu, 0755)
+
+		// and /boot/grub
+		src := grubUbuntu
+		dst = filepath.Join(systemPath, "/boot/grub")
+		cmd = exec.Command("mount", "--bind", src, dst)
+		if o, err := cmd.CombinedOutput(); err != nil {
+			return fmt.Errorf("boot/ubuntu bind mount failed with: %s %v ", err, string(o))
+		}
+		defer exec.Command("umount", dst).Run()
+	case "u-boot":
+		src := s.img.Boot()
+		dst = filepath.Join(systemPath, "/boot/uboot")
+		cmd = exec.Command("mount", "--bind", src, dst)
+		if o, err := cmd.CombinedOutput(); err != nil {
+			return fmt.Errorf("boot/ubuntu bind mount failed with: %s %v ", err, string(o))
+		}
+		defer exec.Command("umount", dst).Run()
+	}
+
+	if err := s.img.SetupBoot(); err != nil {
+		return err
+	}
+
+	if err := s.install(systemPath); err != nil {
+		return err
+	}
+
+	for i := range s.customizationFunc {
+		if err := s.customizationFunc[i](); err != nil {
+			return err
+		}
+	}
+
+	return s.writeInstallYaml(s.img.Boot())
+>>>>>>> MERGE-SOURCE
 }
 
 // deploy orchestrates the priviledged part of the setup
+<<<<<<< TREE
 func (s *Snapper) deploy(systemImage *ubuntuimage.Image, filePathChan <-chan string) error {
+=======
+func (s *Snapper) deploy() error {
+	// hack to circumvent https://code.google.com/p/go/issues/detail?id=1435
+	runtime.GOMAXPROCS(1)
+	runtime.LockOSThread()
+	if err := sysutils.EscalatePrivs(); err != nil {
+		return err
+	}
+	defer sysutils.DropPrivs()
+
+	printOut("Formatting...")
+	if err := s.img.Format(); err != nil {
+		return err
+	}
+
+	if err := s.setup(); err != nil {
+		return err
+	}
+
+>>>>>>> MERGE-SOURCE
 	return nil
 }
 
+<<<<<<< TREE
 func (s *Snapper) create() error {
 	return fmt.Errorf(`Building core images is currently not supported.
 
 Images for ubuntu-core 15.04 can be build with the ppa:snappy-dev/tools.
 Building images for ubuntu-core 16.04 will be supported by this tool soon.
 `)
+=======
+func (s Snapper) printSummary() {
+	fmt.Println("New image complete")
+	fmt.Println("Summary:")
+	fmt.Println(" Output:", s.Output)
+	fmt.Println(" Architecture:", s.gadget.Architecture())
+	fmt.Println(" Channel:", s.Channel)
+	fmt.Println(" Version:", globalArgs.Revision)
+}
+
+func (s *Snapper) create() (err error) {
+	if err := s.sanityCheck(); err != nil {
+		return err
+	}
+
+	fmt.Println("Calling prepare image")
+	if err := s.prepareImage(); err != nil {
+		return err
+	}
+
+	fmt.Println("Determining gadget configuration")
+	if err := s.extractGadget(s.modelAssertion.Gadget()); err != nil {
+		return err
+	}
+	defer os.RemoveAll(s.stagingRootPath)
+
+	// hack to circumvent https://code.google.com/p/go/issues/detail?id=1435
+	runtime.GOMAXPROCS(1)
+	runtime.LockOSThread()
+	if err := sysutils.DropPrivs(); err != nil {
+		return err
+	}
+
+	switch s.gadget.Gadget.Hardware.Bootloader {
+	case "grub":
+		legacy := false
+		s.img = diskimage.NewCoreGrubImage(s.Output, s.size, s.flavor.rootSize(), s.hardware, s.gadget, legacy, "gpt")
+	case "u-boot":
+		label := "msdos"
+		if s.gadget.Architecture() == archArm64 {
+			label = "gpt"
+		}
+		s.img = diskimage.NewCoreUBootImage(s.Output, s.size, s.flavor.rootSize(), s.hardware, s.gadget, label)
+	default:
+		return errors.New("no hardware description in Gadget snap")
+	}
+
+	printOut("Partitioning...")
+	if err := s.img.Partition(); err != nil {
+		return err
+	}
+	defer func() {
+		if err != nil {
+			os.Remove(s.Output)
+		}
+	}()
+
+	// Handle SIGINT and SIGTERM.
+	go func() {
+		ch := make(chan os.Signal)
+		signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
+
+		for sig := range ch {
+			printOut("Received", sig, "... ignoring")
+		}
+	}()
+
+	// Execute the following code with escalated privs and drop them when done
+	if err := s.deploy(); err != nil {
+		return err
+	}
+
+	if err := s.img.FlashExtra(); err != nil {
+		return err
+	}
+
+	s.printSummary()
+
+	return nil
+}
+
+func isLegacy(release, channel string, revision int) bool {
+	if release != "15.04" {
+		return false
+	}
+
+	switch channel {
+	case "edge":
+		return revision <= 149
+	case "alpha":
+		return revision <= 9
+	case "stable":
+		return revision <= 4
+	}
+
+	return false
+>>>>>>> MERGE-SOURCE
 }

=== added file 'ubuntu-device-flash/snappy_compat_yaml.go'
--- ubuntu-device-flash/snappy_compat_yaml.go	1970-01-01 00:00:00 +0000
+++ ubuntu-device-flash/snappy_compat_yaml.go	2016-09-04 15:15:47 +0000
@@ -0,0 +1,124 @@
+//
+// ubuntu-device-flash - Tool to download and flash devices with an Ubuntu Image
+//                       based system
+//
+// Copyright (c) 2016 Canonical Ltd.
+//
+package main
+
+var compatCanonicalPCamd64 = `
+name: canonical-pc
+gadget:
+    branding:
+        name:  amd64
+        subname: generic
+
+    hardware:
+        bootloader: grub
+        architecture: amd64
+        partition-layout: minimal
+        boot-assets:
+            files:
+                - path: grub.cfg
+`
+
+var compatCanonicalPCi386 = `
+name: canonical-i386
+gadget:
+    branding:
+        name:  i386
+        subname: generic
+
+    hardware:
+        bootloader: grub
+        architecture: amd64
+        partition-layout: minimal
+        boot-assets:
+            files:
+                - path: grub.cfg
+`
+
+var compatCanonicalPi2 = `
+name: canonical-pi2
+gadget:
+  hardware:
+    platform: bcm2836-rpi-2-b
+    architecture: armhf
+    partition-layout: minimal
+    bootloader: u-boot
+    boot-assets:
+      files:
+        - path: boot-assets/config.txt
+        - path: boot-assets/cmdline.txt
+        - path: boot-assets/uboot.bin
+        - path: boot-assets/uboot.env
+        - path: boot-assets/bcm2708-rpi-b.dtb
+        - path: boot-assets/bcm2708-rpi-b-plus.dtb
+        - path: boot-assets/bcm2709-rpi-2-b.dtb
+        - path: boot-assets/bootcode.bin
+        - path: boot-assets/COPYING.linux
+        - path: boot-assets/fixup_cd.dat
+        - path: boot-assets/fixup.dat
+        - path: boot-assets/fixup_x.dat
+        - path: boot-assets/LICENCE.broadcom
+        - path: boot-assets/LICENSE.oracle
+        - path: boot-assets/start_cd.elf
+        - path: boot-assets/start.elf
+        - path: boot-assets/start_x.elf
+        - path: boot-assets/overlays.tgz
+`
+
+var compatCanonicalDragon = `
+name: canonical-dragon
+gadget:
+  branding:
+    name: Dragonboard
+    subname: Dragonboard
+
+  hardware:
+    platform: msm8916-mtp
+    architecture: arm64
+    partition-layout: minimal
+    bootloader: u-boot
+    boot-assets:
+      files:
+          - path: uboot.env
+      raw-files:
+          - path: sbl1.mbn
+            offset: 17408
+          - path: rpm.mbn
+            offset: 541696
+          - path: tz.mbn
+            offset: 1065984
+          - path: hyp.mbn
+            offset: 1590272
+          - path: sec.dat
+            offset: 2114560
+          - path: sd_appsboot.mbn
+            offset: 2130944
+          - path: u-boot.img
+            offset: 3179520
+      raw-partitions:
+          - name: sbl1
+            size: 512
+            pos: 34
+            type: DEA0BA2C-CBDD-4805-B4F9-F428251C3E98
+          - name: rpm
+            size: 512
+            type: 098DF793-D712-413D-9D4E-89D711772228
+          - name: tz
+            size: 512
+            type: A053AA7F-40B8-4B1C-BA08-2F68AC71A4F4
+          - name: hyp
+            size: 512
+            type: E1A6A689-0C8D-4CC6-B4E8-55A4320FBD8A
+          - name: sec
+            size: 16
+            type: 303E6AC3-AF15-4C54-9E9B-D9A8FBECF401
+          - name: aboot
+            size: 1024
+            type: 400FFDCD-22E0-47E7-9A23-F16ED9382388
+          - name: boot
+            size: 512
+            type: 20117F86-E985-4357-B9EE-374BC1D8487D
+`