Merge lp:~chipaca/snappy/husk into lp:snappy/15.04

[John Lenton]

Husks and removed packages.

[lp:~chipaca/snappy/husk]

711. By Michael Vogt on 2015-09-23

merged lp:snappy

712. By Michael Vogt on 2015-09-23

Fix incorrect untar permissions due to umask settings. by mvo approved by chipaca

713. By John Lenton on 2015-09-23

Make the updates call use the qualified name. by chipaca approved by mvo

714. By Launchpad Translations on behalf of snappy-dev on 2015-09-24

Launchpad automatic translations update.

715. By Leo Arias on 2015-09-25

Added the origin to the expected info output in the integration tests. by elopio approved by fgimenez

716. By John Lenton on 2015-09-25

Speed up VersionCompare. by chipaca approved by mvo

717. By Leo Arias on 2015-09-25

On integration tests, fixed newKernelFilenamePattern. by elopio approved by fgimenez

718. By Carlo Lobrano on 2015-09-25

Description of the changes:

- hw-assign now appends each new udev rule for snap to the existing file, if any, in place of overwriting the same file
- hw-unassign now removes only the single udev rule related to the device unassigned, in place of just deleting the file by c-lobrano approved by chipaca

719. By Leo Arias on 2015-09-28

Skip the ubuntu fan tests in 15.04. by elopio approved by fgimenez

720. By Leo Arias on 2015-09-28

Fixed the configfor updates and rollbacks in the integration tests. by elopio approved by fgimenez

721. By Federico Gimenez on 2015-09-28

functions for building snaps moved to the testutils/build package by fgimenez approved by elopio

722. By Federico Gimenez on 2015-09-28

Added wait.ForFunction to the integration test suite. by fgimenez approved by elopio

723. By Federico Gimenez on 2015-09-28

Added apiExerciser and api<Method>Exerciser interfaces and root resource refactored to use them by fgimenez approved by elopio

724. By Federico Gimenez on 2015-09-28

Added test for /1.0/packages resource by fgimenez approved by elopio

725. By John Lenton on 2015-09-29

Have a “current” symlink in the system data dir ($SNAP_APP_DATA_DIR). by chipaca approved by elopio

726. By John Lenton on 2015-09-29

Move snappy/dirs.go into its own package. by chipaca approved by sergiusens

727. By Ricardo Mendoza on 2015-09-30

Update ubuntu-core description with the right snippet. by ricmm approved by mvo

728. By Leo Arias on 2015-09-30

On the integration tests, print the boot log to stdout. by elopio approved by fgimenez

729. By Michael Vogt on 2015-09-30

Nuke "auto eth0". by mvo approved by chipaca

730. By Leo Arias on 2015-10-01

On the rollback tests, wait for boot-ok to run. Workaround for bug #1498293. by elopio approved by fgimenez

731. By Federico Gimenez on 2015-10-01

Added test for /1.0 resource by fgimenez approved by elopio

732. By Federico Gimenez on 2015-10-01

Config test by fgimenez approved by elopio

733. By Federico Gimenez on 2015-10-02

cli package with ExecCommand functions by fgimenez approved by fgimenez

734. By Federico Gimenez on 2015-10-02

MakeWritable and MakeReadonly moved from common to partition by fgimenez approved by elopio

735. By Launchpad Translations on behalf of snappy-dev on 2015-10-03

Launchpad automatic translations update.

736. By John Lenton on 2015-10-05

activate/deactivate packages. by chipaca approved by mvo

737. By John Lenton on 2015-10-05

Use staging CPI if SNAPPY_USE_STAGING_CPI environment variable is set; use staging system-image if SNAPPY_USE_STAGING_SYSIMG environment variable is set. by chipaca approved by mvo,chipaca

738. By John Lenton on 2015-10-05

use a compiled regexp instead of a string for whitelisting by chipaca approved by mvo

739. By John Lenton on 2015-10-05

Use full names when querying the cpi's .../click-metadata url (i.e., for updates). by chipaca approved by mvo

740. By John Lenton on 2015-10-05

export systemimage's name, origin and vendor

741. By John Lenton on 2015-10-05

moved remote snap (not part (yet (ok?))) into its own package. Also exported snappy.ManifestPath.

742. By John Lenton on 2015-10-05

removed packages

743. By John Lenton on 2015-10-05

husks

744. By John Lenton on 2015-10-07

Merged removed-pkg into husk.

745. By John Lenton on 2015-10-08

husk.Husk -> lightweight.PartBag

746. By John Lenton on 2015-10-08

Merged removed-pkg into husk.

747. By John Lenton on 2015-10-08

fixed for 1.3

748. By John Lenton on 2015-10-08

installed size seems brittle (no tarmac)

Unmerged revisions

=== added directory 'pkg/husk'
=== added file 'pkg/husk/example_test.go'
--- pkg/husk/example_test.go	1970-01-01 00:00:00 +0000
+++ pkg/husk/example_test.go	2015-09-22 13:56:40 +0000
@@ -0,0 +1,50 @@
+// -*- 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 husk_test
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"launchpad.net/snappy/pkg/husk"
+)
+
+func ExampleHusk() {
+	d, _ := ioutil.TempDir("", "test-xyzzy-")
+	defer os.RemoveAll(d)
+	os.MkdirAll(filepath.Join(d, "foo.bar", "0.1"), 0755)
+	os.MkdirAll(filepath.Join(d, "foo.bar", "0.2"), 0755)
+	os.MkdirAll(filepath.Join(d, "foo.bar", "0.5"), 0755)
+	os.MkdirAll(filepath.Join(d, "foo", "0.4"), 0755)
+	os.MkdirAll(filepath.Join(d, "foo.baz", "0.5"), 0755)
+
+	finder := husk.Finder{AppDataPath: d, FmkDataPath: d}
+
+	for _, found := range finder.ByName("foo") {
+		fmt.Printf("Found %d versions for %s, type %q: %s\n",
+			len(found.Versions), found.QualifiedName(), found.Type, found.Versions)
+	}
+	// Output:
+	// Found 3 versions for foo.bar, type "app": [0.5 0.2 0.1]
+	// Found 1 versions for foo.baz, type "app": [0.5]
+	// Found 1 versions for foo, type "framework": [0.4]
+}

=== added file 'pkg/husk/husk.go'
--- pkg/husk/husk.go	1970-01-01 00:00:00 +0000
+++ pkg/husk/husk.go	2015-09-22 13:56:40 +0000
@@ -0,0 +1,253 @@
+// -*- 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 husk provides a quick way of loading things that can become snaps.
+//
+// A husk has a name and n versions; it might not even know its origin.
+package husk
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"launchpad.net/snappy/helpers"
+	"launchpad.net/snappy/pkg"
+	"launchpad.net/snappy/pkg/removed"
+	"launchpad.net/snappy/snappy"
+)
+
+// A Finder knows how to find parts in the system
+type Finder struct {
+	OEMPath     string
+	AppPath     string
+	AppDataPath string
+	FmkPath     string
+	FmkDataPath string
+	MetaDir     string
+}
+
+// split a path into the name and extension of the directory, and the file.
+// e.g. foo/bar.baz/quux -> bar, baz, quux
+//
+// panics if given path is lacking at least one separator (ie bar/quux
+// works; quux panics)
+func split(path string) (name string, ext string, file string) {
+	idxFileSep := strings.LastIndexByte(path, os.PathSeparator)
+	if idxFileSep < 0 {
+		panic("bad path given to split: must have at least two separators")
+	}
+
+	file = path[idxFileSep+1:]
+	path = path[:idxFileSep]
+	name = path
+
+	idxDirSep := strings.LastIndexByte(path, os.PathSeparator)
+	if idxDirSep > -1 {
+		name = path[idxDirSep+1:]
+	}
+
+	idxOrig := strings.LastIndexByte(name, '.')
+	if idxOrig < 0 {
+		return name, "", file
+	}
+
+	return name[:idxOrig], name[idxOrig+1:], file
+}
+
+// extract the name, origin and list of versions from a list of paths that
+// end {name}[.{origin}]/{version}. If the origin changes, stop and
+// return the versions so far, and the remaining paths.
+func extract(paths []string) (string, string, []string, []string) {
+	name, origin, _ := split(paths[0])
+
+	var versions []string
+	for len(paths) > 0 {
+		n, o, v := split(paths[0])
+		if name != n || origin != o {
+			break
+		}
+
+		versions = append(versions, v)
+		paths = paths[1:]
+	}
+
+	return name, origin, versions, paths
+}
+
+func versionSort(versions []string) {
+	sort.Sort(sort.Reverse(snappy.ByVersion(versions)))
+}
+
+// ByName finds husks with the given name.
+func (finder *Finder) ByName(name string) []*Husk {
+	if strings.ContainsAny(name, ".*?/") {
+		panic("invalid name " + name)
+	}
+
+	return finder.find(name)
+}
+
+// All the husks in the system.
+func (finder *Finder) All() []*Husk {
+	return finder.find("*")
+}
+
+type repo interface {
+	All() ([]snappy.Part, error)
+}
+
+func newCoreRepoImpl() repo {
+	return snappy.NewSystemImageRepository()
+}
+
+var newCoreRepo = newCoreRepoImpl
+
+func (finder *Finder) find(name string) []*Husk {
+
+	var husks []*Husk
+
+	if name == snappy.SystemImagePartName || name == "*" {
+		// TODO: make this do less work
+		repo := newCoreRepo()
+		parts, err := repo.All()
+		if err != nil {
+			//  can't really happen
+			panic(fmt.Sprintf("Bad SystemImageRepository: %v", err))
+		}
+
+		versions := make([]string, len(parts))
+		for i, part := range parts {
+			versions[i] = part.Version()
+		}
+		versionSort(versions)
+
+		husks = append(husks, &Husk{
+			Name:     snappy.SystemImagePartName,
+			Origin:   snappy.SystemImagePartOrigin,
+			Type:     pkg.TypeCore,
+			Versions: versions,
+			Paths:    finder,
+		})
+	}
+
+	type T struct {
+		base string
+		full string
+		typ  pkg.Type
+	}
+
+	for _, s := range []T{
+		{finder.AppDataPath, name + ".*", pkg.TypeApp},
+		{finder.FmkDataPath, name, pkg.TypeFramework},
+		{finder.OEMPath, name, pkg.TypeOem},
+	} {
+		paths, _ := filepath.Glob(filepath.Join(s.base, s.full, "*"))
+		for len(paths) > 0 {
+			var name string
+			var origin string
+			var versions []string
+
+			name, origin, versions, paths = extract(paths)
+			if origin != "" && s.typ != pkg.TypeApp {
+				continue
+			}
+			versionSort(versions)
+			husks = append(husks, &Husk{
+				Name:     name,
+				Origin:   origin,
+				Type:     s.typ,
+				Versions: versions,
+				Paths:    finder,
+			})
+		}
+	}
+
+	return husks
+}
+
+// A Husk is a lightweight object that represents and knows how to
+// load a Part on demand.
+type Husk struct {
+	Name     string
+	Origin   string
+	Type     pkg.Type
+	Versions []string
+	Paths    *Finder
+}
+
+// QualifiedName of the husk.
+func (h *Husk) QualifiedName() string {
+	if h.Origin == "" {
+		return h.Name
+	}
+	return h.Name + "." + h.Origin
+}
+
+var (
+	// ErrBadVersionIndex is returned by Load when asked to load a
+	// non-existent version.
+	ErrBadVersionIndex = errors.New("Bad version index")
+	// ErrVersionGone is returned in the case where we find a
+	// version and it disappears before we get to load it.
+	ErrVersionGone = errors.New("Version gone")
+)
+
+// Load a Part from the Husk
+func (h *Husk) Load(versionIdx int) (snappy.Part, error) {
+	if versionIdx < 0 || versionIdx >= len(h.Versions) {
+		return nil, ErrBadVersionIndex
+	}
+	version := h.Versions[versionIdx]
+
+	var basedir string
+	switch h.Type {
+	case pkg.TypeCore:
+		repo := newCoreRepo()
+		parts, err := repo.All()
+		if err != nil {
+			//  can't really happen
+			return nil, fmt.Errorf("Bad SystemImageRepository: %v", err)
+		}
+
+		for _, part := range parts {
+			if part.Version() == version {
+				return part, nil
+			}
+		}
+
+		return nil, ErrVersionGone
+	case pkg.TypeApp:
+		basedir = h.Paths.AppPath
+	case pkg.TypeFramework:
+		basedir = h.Paths.FmkPath
+	case pkg.TypeOem:
+		basedir = h.Paths.OEMPath
+	}
+
+	yamlPath := filepath.Join(basedir, h.QualifiedName(), version, "meta", "package.yaml")
+	if !helpers.FileExists(yamlPath) {
+		return removed.New(basedir, h.Name, h.Origin, version, h.Type), nil
+	}
+
+	return snappy.NewInstalledSnapPart(yamlPath, h.Origin)
+}

=== added file 'pkg/husk/husk_test.go'
--- pkg/husk/husk_test.go	1970-01-01 00:00:00 +0000
+++ pkg/husk/husk_test.go	2015-09-22 13:56:40 +0000
@@ -0,0 +1,204 @@
+// -*- 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 husk
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"gopkg.in/check.v1"
+
+	"launchpad.net/snappy/pkg"
+	"launchpad.net/snappy/pkg/removed"
+	"launchpad.net/snappy/snappy"
+)
+
+type huskSuite struct {
+	appd   string
+	datad  string
+	oemd   string
+	metad  string
+	finder *Finder
+}
+
+func Test(t *testing.T) { check.TestingT(t) }
+
+var _ = check.Suite(&huskSuite{})
+
+func (s *huskSuite) SetUpTest(c *check.C) {
+	s.appd = c.MkDir()
+	s.datad = c.MkDir()
+	s.oemd = c.MkDir()
+	s.metad = c.MkDir()
+
+	s.finder = &Finder{
+		OEMPath:     s.oemd,
+		AppPath:     s.appd,
+		AppDataPath: s.datad,
+		FmkPath:     s.appd,
+		FmkDataPath: s.datad,
+		MetaDir:     s.metad,
+	}
+
+	s.MkInstalled(c, s.appd, "foo", "bar", "1.0")
+	s.MkRemoved(c, "foo.bar", "0.9")
+	s.MkRemoved(c, "foo.baz", "0.8")
+
+	s.MkInstalled(c, s.appd, "fmk", "", "123")
+	s.MkRemoved(c, "fmk", "120")
+	s.MkRemoved(c, "fmk", "12a1")
+
+	s.MkInstalled(c, s.oemd, "oem", "", "3")
+
+	newCoreRepo = func() repo {
+		// you can't ever have a removed systemimagepart, but for testing it'll do
+		return mockrepo{removed.New(c.MkDir(), snappy.SystemImagePartName, snappy.SystemImagePartOrigin, "1", pkg.TypeCore)}
+	}
+}
+
+func (s *huskSuite) TearDownTest(c *check.C) {
+	newCoreRepo = newCoreRepoImpl
+}
+
+func (s *huskSuite) MkInstalled(c *check.C, appdir, name, origin, version string) {
+	// this is logic that should be encapsulated inside the different package types, but isn't (yet).
+	qn := name
+	if origin != "" {
+		qn += "." + origin
+	}
+
+	if appdir != s.oemd {
+		s.MkRemoved(c, qn, version)
+	}
+	// end logic (mostly)
+
+	apath := filepath.Join(appdir, qn, version, "meta")
+	yaml := fmt.Sprintf("name: %s\nversion: %s\nvendor: example.com\n", name, version)
+	c.Check(os.MkdirAll(apath, 0755), check.IsNil)
+	c.Check(ioutil.WriteFile(filepath.Join(apath, "package.yaml"), []byte(yaml), 0644), check.IsNil)
+	c.Check(ioutil.WriteFile(filepath.Join(apath, "hashes.yaml"), nil, 0644), check.IsNil)
+}
+
+func (s *huskSuite) MkRemoved(c *check.C, qn, version string) {
+	dpath := filepath.Join(s.datad, qn, version)
+	c.Check(os.MkdirAll(dpath, 0755), check.IsNil)
+	c.Check(ioutil.WriteFile(filepath.Join(dpath, "test.txt"), []byte("hello there\n"), 0644), check.IsNil)
+
+}
+
+func (s *huskSuite) TestLoadBadName(c *check.C) {
+	c.Check(func() { s.finder.ByName("*") }, check.PanicMatches, "invalid name .*")
+}
+
+func (s *huskSuite) TestLoadFmk(c *check.C) {
+	fmk := s.finder.ByName("fmk")
+	// two versions of the same framework are present, so one Husk, with three versions:
+	c.Assert(fmk, check.HasLen, 1)
+	h := fmk[0]
+	c.Assert(h.Versions, check.HasLen, 3)
+	// versions are sorted backwards by version -- index 0 is always newest version
+	c.Check(h.Versions, check.DeepEquals, []string{"123", "120", "12a1"})
+	// other things are as expected
+	c.Check(h.Name, check.Equals, "fmk")
+	c.Check(h.Type, check.Equals, pkg.TypeFramework)
+
+	p, err := h.Load(0)
+	c.Check(err, check.IsNil)
+	// load loaded the right implementation of Part
+	c.Check(p, check.FitsTypeOf, new(snappy.SnapPart))
+	c.Check(p.Version(), check.Equals, "123")
+
+	p, err = h.Load(1)
+	c.Check(err, check.IsNil)
+	c.Check(p, check.FitsTypeOf, new(removed.Removed))
+	c.Check(p.Version(), check.Equals, "120")
+
+	_, err = h.Load(42)
+	c.Check(err, check.Equals, ErrBadVersionIndex)
+
+}
+
+func (s *huskSuite) TestLoadApp(c *check.C) {
+	foo := s.finder.ByName("foo")
+	// there are two husks: one for foo.bar, one for foo.baz:
+	c.Assert(foo, check.HasLen, 2)
+
+	h0, h1 := foo[0], foo[1]
+
+	c.Check(h0.QualifiedName(), check.Equals, "foo.bar")
+	c.Check(h0.Versions, check.DeepEquals, []string{"1.0", "0.9"})
+	c.Check(h0.Type, check.Equals, pkg.TypeApp)
+
+	c.Check(h1.QualifiedName(), check.Equals, "foo.baz")
+	c.Check(h1.Versions, check.DeepEquals, []string{"0.8"})
+	c.Check(h1.Type, check.Equals, pkg.TypeApp)
+
+	p, err := h0.Load(0)
+	c.Check(err, check.IsNil)
+	c.Check(p, check.FitsTypeOf, new(snappy.SnapPart))
+	c.Check(p.Version(), check.Equals, "1.0")
+
+	p, err = h0.Load(1)
+	c.Check(err, check.IsNil)
+	c.Check(p, check.FitsTypeOf, new(removed.Removed))
+	c.Check(p.Version(), check.Equals, "0.9")
+
+	p, err = h1.Load(0)
+	c.Check(err, check.IsNil)
+	c.Check(p, check.FitsTypeOf, new(removed.Removed))
+	c.Check(p.Version(), check.Equals, "0.8")
+}
+
+func (s *huskSuite) TestLoadOem(c *check.C) {
+	oem := s.finder.ByName("oem")
+	c.Check(oem, check.HasLen, 1)
+	c.Check(oem[0].Versions, check.DeepEquals, []string{"3"})
+	c.Check(oem[0].Type, check.Equals, pkg.TypeOem)
+
+	p, err := oem[0].Load(0)
+	c.Check(err, check.IsNil)
+	c.Check(p, check.FitsTypeOf, new(snappy.SnapPart))
+	c.Check(p.Version(), check.Equals, "3")
+}
+
+type mockrepo struct{ p snappy.Part }
+
+func (r mockrepo) All() ([]snappy.Part, error) {
+	return []snappy.Part{r.p}, nil
+}
+
+func (s *huskSuite) TestLoadCore(c *check.C) {
+	core := s.finder.ByName(snappy.SystemImagePartName)
+	c.Check(core, check.HasLen, 1)
+	c.Check(core[0].Versions, check.DeepEquals, []string{"1"})
+
+	p, err := core[0].Load(0)
+	c.Check(err, check.IsNil)
+	c.Check(p.Version(), check.Equals, "1")
+}
+
+func (s *huskSuite) TestAll(c *check.C) {
+	all := s.finder.All()
+
+	c.Check(all, check.HasLen, 5) // 1 fmk, 2 app, 1 oem, 1 core
+}

=== added file 'pkg/husk/split_test.go'
--- pkg/husk/split_test.go	1970-01-01 00:00:00 +0000
+++ pkg/husk/split_test.go	2015-09-22 13:56:40 +0000
@@ -0,0 +1,55 @@
+// -*- 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 husk
+
+import (
+	"gopkg.in/check.v1"
+)
+
+type splitSuite struct{}
+
+var _ = check.Suite(&splitSuite{})
+
+func (s *splitSuite) TestSplitRegular(c *check.C) {
+	for _, s := range []string{"meh/foo.bar/baz", "foo.bar/baz"} {
+		n, e, f := split(s)
+		c.Check(n, check.Equals, "foo")
+		c.Check(e, check.Equals, "bar")
+		c.Check(f, check.Equals, "baz")
+	}
+}
+
+func (s *splitSuite) TestSplitExtless(c *check.C) {
+	for _, s := range []string{"meh/foo/baz", "foo/baz"} {
+		n, e, f := split(s)
+		c.Check(n, check.Equals, "foo")
+		c.Check(e, check.Equals, "")
+		c.Check(f, check.Equals, "baz")
+	}
+}
+
+func (s *splitSuite) TestExtract(c *check.C) {
+	ps := []string{"meh/foo.bar/v1", "meh/foo.bar/v2", "meh/foo.baz/v3"}
+	n, o, vs, ps := extract(ps)
+	c.Check(n, check.Equals, "foo")
+	c.Check(o, check.Equals, "bar")
+	c.Check(vs, check.DeepEquals, []string{"v1", "v2"})
+	c.Check(ps, check.DeepEquals, []string{"meh/foo.baz/v3"})
+}

=== added directory 'pkg/removed'
=== added file 'pkg/removed/removed.go'
--- pkg/removed/removed.go	1970-01-01 00:00:00 +0000
+++ pkg/removed/removed.go	2015-09-22 13:56:40 +0000
@@ -0,0 +1,116 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+// Package removed implements Removed packages, that are packages that
+// have been installed, removed, but not purged: there is no
+// application, but there might be data.
+package removed
+
+import (
+	"errors"
+	"time"
+
+	"launchpad.net/snappy/pkg"
+	"launchpad.net/snappy/progress"
+	"launchpad.net/snappy/snappy"
+)
+
+// ErrRemoved is returned when you ask to operate on a removed package.
+var ErrRemoved = errors.New("package is removed")
+
+// Removed represents a removed package.
+type Removed struct {
+	basedir string
+	name    string
+	origin  string
+	version string
+	pkgType pkg.Type
+}
+
+// New removed package.
+func New(basedir, name, origin, version string, pkgType pkg.Type) snappy.Part {
+	return &Removed{
+		basedir: basedir,
+		name:    name,
+		origin:  origin,
+		version: version,
+		pkgType: pkgType,
+	}
+}
+
+// Name from the snappy.Part interface
+func (r *Removed) Name() string { return r.name }
+
+// Version from the snappy.Part interface
+func (r *Removed) Version() string { return r.version }
+
+// Description from the snappy.Part interface
+func (r *Removed) Description() string { return "" }
+
+// Origin from the snappy.Part interface
+func (r *Removed) Origin() string { return r.origin }
+
+// Vendor from the snappy.Part interface
+func (r *Removed) Vendor() string { return "" }
+
+// Hash from the snappy.Part interface
+func (r *Removed) Hash() string { return "" }
+
+// IsActive from the snappy.Part interface
+func (r *Removed) IsActive() bool { return false }
+
+// IsInstalled from the snappy.Part interface
+func (r *Removed) IsInstalled() bool { return false }
+
+// NeedsReboot from the snappy.Part interface
+func (r *Removed) NeedsReboot() bool { return false }
+
+// Date from the snappy.Part interface
+func (r *Removed) Date() time.Time { return time.Time{} } // XXX: keep track of when the package was removed
+// Channel from the snappy.Part interface
+func (r *Removed) Channel() string { return "" }
+
+// Icon from the snappy.Part interface
+func (r *Removed) Icon() string { return "" }
+
+// Type from the snappy.Part interface
+func (r *Removed) Type() pkg.Type { return r.pkgType }
+
+// InstalledSize from the snappy.Part interface
+func (r *Removed) InstalledSize() int64 { return -1 }
+
+// DownloadSize from the snappy.Part interface
+func (r *Removed) DownloadSize() int64 { return -1 }
+
+// Install from the snappy.Part interface
+func (r *Removed) Install(pb progress.Meter, flags snappy.InstallFlags) (name string, err error) {
+	return "", ErrRemoved
+}
+
+// Uninstall from the snappy.Part interface
+func (r *Removed) Uninstall(pb progress.Meter) error { return ErrRemoved }
+
+// Config from the snappy.Part interface
+func (r *Removed) Config(configuration []byte) (newConfig string, err error) { return "", ErrRemoved }
+
+// SetActive from the snappy.Part interface
+func (r *Removed) SetActive(pb progress.Meter) error { return ErrRemoved }
+
+// Frameworks from the snappy.Part interface
+func (r *Removed) Frameworks() ([]string, error) { return nil, ErrRemoved }

=== modified file 'snappy/systemimage.go'
--- snappy/systemimage.go	2015-09-15 12:55:09 +0000
+++ snappy/systemimage.go	2015-09-22 13:56:40 +0000
@@ -39,11 +39,16 @@
 	"launchpad.net/snappy/provisioning"
 )
 
+// SystemImagePart have constant name, origin, and vendor.
 const (
-	systemImagePartName   = "ubuntu-core"
-	systemImagePartOrigin = "ubuntu"
-	systemImagePartVendor = "Canonical Ltd."
+	SystemImagePartName = "ubuntu-core"
+	// SystemImagePartOrigin is the origin of any system image part
+	SystemImagePartOrigin = "ubuntu"
+	// SystemImagePartVendor is the vendor of any system image part
+	SystemImagePartVendor = "Canonical Ltd."
+)
 
+const (
 	// location of the channel config on the filesystem.
 	//
 	// This file specifies the s-i version installed on the rootfs
@@ -97,17 +102,17 @@
 
 // Name returns the name
 func (s *SystemImagePart) Name() string {
-	return systemImagePartName
+	return SystemImagePartName
 }
 
 // Origin returns the origin ("ubuntu")
 func (s *SystemImagePart) Origin() string {
-	return systemImagePartOrigin
+	return SystemImagePartOrigin
 }
 
 // Vendor returns the vendor ("Canonical Ltd.")
 func (s *SystemImagePart) Vendor() string {
-	return systemImagePartVendor
+	return SystemImagePartVendor
 }
 
 // Version returns the version
@@ -236,7 +241,7 @@
 	if err = s.partition.ToggleNextBoot(); err != nil {
 		return "", err
 	}
-	return systemImagePartName, nil
+	return SystemImagePartName, nil
 }
 
 // Ensure the expected version update was applied to the expected partition.
@@ -428,7 +433,7 @@
 
 // Search searches the SystemImageRepository for the given terms
 func (s *SystemImageRepository) Search(terms string) (versions []Part, err error) {
-	if strings.Contains(terms, systemImagePartName) {
+	if strings.Contains(terms, SystemImagePartName) {
 		part := makeCurrentPart(s.partition)
 		versions = append(versions, part)
 	}
@@ -437,7 +442,7 @@
 
 // Details returns details for the given snap
 func (s *SystemImageRepository) Details(name string, origin string) ([]Part, error) {
-	if name == systemImagePartName && origin == systemImagePartOrigin {
+	if name == SystemImagePartName && origin == SystemImagePartOrigin {
 		return []Part{makeCurrentPart(s.partition)}, nil
 	}
 

=== modified file 'snappy/systemimage_test.go'
--- snappy/systemimage_test.go	2015-07-15 07:53:43 +0000
+++ snappy/systemimage_test.go	2015-09-22 13:56:40 +0000
@@ -115,9 +115,9 @@
 	c.Assert(err, IsNil)
 	// we have one active and one inactive
 	c.Assert(parts, HasLen, 2)
-	c.Assert(parts[0].Name(), Equals, systemImagePartName)
-	c.Assert(parts[0].Origin(), Equals, systemImagePartOrigin)
-	c.Assert(parts[0].Vendor(), Equals, systemImagePartVendor)
+	c.Assert(parts[0].Name(), Equals, SystemImagePartName)
+	c.Assert(parts[0].Origin(), Equals, SystemImagePartOrigin)
+	c.Assert(parts[0].Vendor(), Equals, SystemImagePartVendor)
 	c.Assert(parts[0].Version(), Equals, "1")
 	c.Assert(parts[0].Hash(), Equals, "e09c13f68fccef3b2fe0f5c8ff5c61acf2173b170b1f2a3646487147690b0970ef6f2c555d7bcb072035f29ee4ea66a6df7f6bb320d358d3a7d78a0c37a8a549")
 	c.Assert(parts[0].IsActive(), Equals, true)
@@ -378,8 +378,8 @@
 	parts, err := s.systemImage.Installed()
 	c.Assert(err, IsNil)
 	c.Assert(parts, HasLen, 2)
-	c.Assert(parts[0].Origin(), Equals, systemImagePartOrigin)
-	c.Assert(parts[1].Origin(), Equals, systemImagePartOrigin)
+	c.Assert(parts[0].Origin(), Equals, SystemImagePartOrigin)
+	c.Assert(parts[1].Origin(), Equals, SystemImagePartOrigin)
 }
 
 func (s *SITestSuite) TestCannotUpdateIfSideLoaded(c *C) {