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

[John Lenton]

[lp:~chipaca/snappy/auth]

746. By John Lenton on 2015-10-07

Merged merged-list into auth.

747. By John Lenton on 2015-10-08

Merged merged-list into auth.

748. By John Lenton on 2015-10-08

Merged merged-list into auth.

749. By John Lenton on 2015-10-08

Merged merged-list into auth.

750. By John Lenton on 2015-10-09

restrict REST API calls w/auth

751. By John Lenton on 2015-10-09

fix for 1.3 not having basicAuth methods on http.Request. Also caught a nasty bug wrt null-termination

752. By John Lenton on 2015-10-09

annotated 1.3's basicAuth with return variable names

Unmerged revisions

752. By John Lenton on 2015-10-09

annotated 1.3's basicAuth with return variable names

751. By John Lenton on 2015-10-09

fix for 1.3 not having basicAuth methods on http.Request. Also caught a nasty bug wrt null-termination

750. By John Lenton on 2015-10-09

restrict REST API calls w/auth

749. By John Lenton on 2015-10-08

Merged merged-list into auth.

748. By John Lenton on 2015-10-08

Merged merged-list into auth.

747. By John Lenton on 2015-10-08

Merged merged-list into auth.

746. By John Lenton on 2015-10-07

Merged merged-list into auth.

745. By John Lenton on 2015-10-07

first pass at auth

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

=== modified file 'daemon/api_test.go'
--- daemon/api_test.go	2015-09-15 12:55:09 +0000
+++ daemon/api_test.go	2015-10-07 12:49:07 +0000
@@ -32,11 +32,15 @@
 	"net/http/httptest"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 	"time"
 
 	"gopkg.in/check.v1"
 
+	"launchpad.net/snappy/dirs"
+	"launchpad.net/snappy/pkg"
+	"launchpad.net/snappy/pkg/husk"
 	"launchpad.net/snappy/progress"
 	"launchpad.net/snappy/release"
 	"launchpad.net/snappy/snappy"
@@ -62,51 +66,81 @@
 	return s.parts, s.err
 }
 
+func (s *apiSuite) Updates() ([]snappy.Part, error) {
+	return s.parts, s.err
+}
+
 func (s *apiSuite) muxVars(*http.Request) map[string]string {
 	return s.vars
 }
 
 func (s *apiSuite) SetUpSuite(c *check.C) {
-	newRepo = func() metarepo {
+	newRemoteRepo = func() metarepo {
 		return s
 	}
-	newLocalRepo = newRepo
-	newRemoteRepo = newRepo
+	newSystemRepo = newRemoteRepo
 	muxVars = s.muxVars
 }
 
 func (s *apiSuite) TearDownSuite(c *check.C) {
-	newLocalRepo = nil
 	newRemoteRepo = nil
-	newRepo = nil
+	newSystemRepo = nil
 	muxVars = nil
 }
 
 func (s *apiSuite) SetUpTest(c *check.C) {
+	dirs.SetRootDir(c.MkDir())
+
 	s.parts = nil
 	s.err = nil
 	s.vars = nil
 }
 
+func (s *apiSuite) mkInstalled(c *check.C, name, origin, version string, active bool, extraYaml string) {
+	fullname := name + "." + origin
+	c.Assert(os.MkdirAll(filepath.Join(dirs.SnapDataDir, fullname, version), 0755), check.IsNil)
+
+	metadir := filepath.Join(dirs.SnapAppsDir, fullname, version, "meta")
+	c.Assert(os.MkdirAll(metadir, 0755), check.IsNil)
+
+	content := fmt.Sprintf(`
+name: %s
+version: %s
+vendor: a vendor
+%s`, name, version, extraYaml)
+	c.Check(ioutil.WriteFile(filepath.Join(metadir, "package.yaml"), []byte(content), 0644), check.IsNil)
+	c.Check(ioutil.WriteFile(filepath.Join(metadir, "hashes.yaml"), []byte(nil), 0644), check.IsNil)
+
+	if active {
+		c.Assert(os.Symlink(version, filepath.Join(dirs.SnapAppsDir, fullname, "current")), check.IsNil)
+	}
+}
+
 func (s *apiSuite) TestPackageInfoOneIntegration(c *check.C) {
 	d := New()
 	d.addRoutes()
 
 	s.vars = map[string]string{"name": "foo", "origin": "bar"}
 
+	// the store tells us about v2
 	s.parts = []snappy.Part{&tP{
-		name:          "foo",
-		version:       "v1",
-		description:   "description",
-		origin:        "bar",
-		vendor:        "a vendor",
-		isInstalled:   true,
-		isActive:      true,
-		icon:          iconPath + "icon.png",
-		_type:         "a type",
-		installedSize: 42,
-		downloadSize:  2,
+		name:         "foo",
+		version:      "v2",
+		description:  "description",
+		origin:       "bar",
+		vendor:       "a vendor",
+		isInstalled:  true,
+		isActive:     true,
+		icon:         dirs.SnapIconsDir + "icon.png",
+		_type:        pkg.TypeApp,
+		downloadSize: 2,
 	}}
+
+	// we have v0 installed
+	s.mkInstalled(c, "foo", "bar", "v0", false, "")
+	// and v1 is current
+	s.mkInstalled(c, "foo", "bar", "v1", true, "")
+
 	rsp, ok := getPackageInfo(packageCmd, nil).(*resp)
 	c.Assert(ok, check.Equals, true)
 
@@ -114,17 +148,19 @@
 		Type:   ResponseTypeSync,
 		Status: http.StatusOK,
 		Result: map[string]string{
-			"name":           "foo",
-			"version":        "v1",
-			"description":    "description",
-			"origin":         "bar",
-			"vendor":         "a vendor",
-			"status":         "active",
-			"icon":           iconPrefix + "icon.png",
-			"type":           "a type",
-			"download_size":  "2",
-			"installed_size": "42",
-			"resource":       "/1.0/packages/foo.bar",
+			"name":               "foo",
+			"version":            "v1",
+			"description":        "description",
+			"origin":             "bar",
+			"vendor":             "a vendor",
+			"status":             "active",
+			"icon":               "/1.0/icons/foo.bar/icon",
+			"type":               string(pkg.TypeApp),
+			"download_size":      "2",
+			"installed_size":     "180",
+			"resource":           "/1.0/packages/foo.bar",
+			"update_available":   "v2",
+			"rollback_available": "v0",
 		},
 	}
 
@@ -144,14 +180,14 @@
 	c.Check(getPackageInfo(packageCmd, nil).Self(nil, nil).(*resp).Status, check.Equals, http.StatusNotFound)
 }
 
-func (s *apiSuite) TestPackageInfoWeirdDetails(c *check.C) {
+func (s *apiSuite) TestPackageInfoIgnoresRemoteErrors(c *check.C) {
 	s.vars = map[string]string{"name": "foo", "origin": "bar"}
 	s.err = errors.New("weird")
 
-	rsp := getPackageInfo(packageCmd, nil).(*resp)
+	rsp := getPackageInfo(packageCmd, nil).Self(nil, nil).(*resp)
 
 	c.Check(rsp.Type, check.Equals, ResponseTypeError)
-	c.Check(rsp.Status, check.Equals, http.StatusInternalServerError)
+	c.Check(rsp.Status, check.Equals, http.StatusNotFound)
 	c.Check(rsp.Result, check.NotNil)
 }
 
@@ -188,47 +224,6 @@
 	c.Check(rsp.Result.(map[string]interface{})["msg"], check.Matches, `route can't build URL .*`)
 }
 
-func (s *apiSuite) TestParts2Map(c *check.C) {
-	parts := []snappy.Part{&tP{
-		name:          "foo",
-		version:       "v1",
-		description:   "description",
-		origin:        "bar",
-		vendor:        "a vendor",
-		isInstalled:   true,
-		isActive:      true,
-		icon:          "icon.png",
-		_type:         "a type",
-		installedSize: 42,
-		downloadSize:  2,
-	}}
-
-	resource := "/1.0/packages/foo.bar"
-
-	expected := map[string]string{
-		"name":           "foo",
-		"version":        "v1",
-		"description":    "description",
-		"origin":         "bar",
-		"vendor":         "a vendor",
-		"status":         "active",
-		"icon":           "icon.png",
-		"type":           "a type",
-		"download_size":  "2",
-		"installed_size": "42",
-		"resource":       resource,
-	}
-
-	c.Check(parts2map(parts, resource), check.DeepEquals, expected)
-}
-
-func (s *apiSuite) TestParts2MapState(c *check.C) {
-	c.Check(parts2map([]snappy.Part{&tP{}}, "")["status"], check.Equals, "not installed")
-	c.Check(parts2map([]snappy.Part{&tP{isInstalled: true}}, "")["status"], check.Equals, "installed")
-	c.Check(parts2map([]snappy.Part{&tP{isInstalled: true, isActive: true}}, "")["status"], check.Equals, "active")
-	// TODO: more statuses
-}
-
 func (s *apiSuite) TestListIncludesAll(c *check.C) {
 	// Very basic check to help stop us from not adding all the
 	// commands to the command list.
@@ -263,9 +258,8 @@
 		"findServices",
 		"maxReadBuflen",
 		"muxVars",
-		"newLocalRepo",
 		"newRemoteRepo",
-		"newRepo",
+		"newSystemRepo",
 		"newSnap",
 		"pkgActionDispatch",
 	}
@@ -335,12 +329,12 @@
 	req, err := http.NewRequest("GET", "/1.0/packages", nil)
 	c.Assert(err, check.IsNil)
 
-	s.parts = []snappy.Part{
-		&tP{name: "foo", version: "v1", origin: "bar"},
-		&tP{name: "bar", version: "v2", origin: "baz"},
-		&tP{name: "baz", version: "v3", origin: "qux"},
-		&tP{name: "qux", version: "v4", origin: "mip"},
+	ddirs := [][2]string{{"foo.bar", "v1"}, {"bar.baz", "v2"}, {"baz.qux", "v3"}, {"qux.mip", "v4"}}
+
+	for i := range ddirs {
+		c.Assert(os.MkdirAll(filepath.Join(dirs.SnapDataDir, ddirs[i][0], ddirs[i][1]), 0755), check.IsNil)
 	}
+
 	rsp, ok := getPackagesInfo(packagesCmd, req).(*resp)
 	c.Assert(ok, check.Equals, true)
 
@@ -351,21 +345,22 @@
 	meta, ok := rsp.Result.(map[string]interface{})
 	c.Assert(ok, check.Equals, true)
 	c.Assert(meta, check.NotNil)
-	c.Check(meta["paging"], check.DeepEquals, map[string]interface{}{"pages": 1, "page": 1, "count": len(s.parts)})
+	c.Check(meta["paging"], check.DeepEquals, map[string]interface{}{"pages": 1, "page": 1, "count": len(ddirs)})
 
 	packages, ok := meta["packages"].(map[string]map[string]string)
 	c.Assert(ok, check.Equals, true)
 	c.Check(packages, check.NotNil)
-	c.Check(packages, check.HasLen, len(s.parts))
+	c.Check(packages, check.HasLen, len(ddirs))
 
-	for _, part := range s.parts {
-		part := part.(*tP)
-		qn := part.name + "." + part.origin
+	for i := range ddirs {
+		qn, version := ddirs[i][0], ddirs[i][1]
+		idx := strings.LastIndexByte(qn, '.')
+		name, origin := qn[:idx], qn[idx+1:]
 		got := packages[qn]
 		c.Assert(got, check.NotNil, check.Commentf(qn))
-		c.Check(got["name"], check.Equals, part.name)
-		c.Check(got["version"], check.Equals, part.version)
-		c.Check(got["origin"], check.Equals, part.origin)
+		c.Check(got["name"], check.Equals, name)
+		c.Check(got["version"], check.Equals, version)
+		c.Check(got["origin"], check.Equals, origin)
 	}
 }
 
@@ -530,6 +525,14 @@
 	}
 }
 
+type cfgc struct{ cfg string }
+
+func (cfgc) IsInstalled(string) bool { return true }
+func (cfgc) ActiveIndex() int        { return 0 }
+func (c cfgc) Load(string) (snappy.Part, error) {
+	return &tP{name: "foo", version: "v1", origin: "bar", isActive: true, config: c.cfg}, nil
+}
+
 func (s *apiSuite) TestPackageGetConfig(c *check.C) {
 	d := New()
 	d.addRoutes()
@@ -538,13 +541,16 @@
 	c.Assert(err, check.IsNil)
 
 	configStr := "some: config"
+	oldConcrete := husk.NewConcrete
+	defer func() {
+		husk.NewConcrete = oldConcrete
+	}()
+	husk.NewConcrete = func(*husk.Husk, string) husk.Concreter {
+		return &cfgc{configStr}
+	}
+
 	s.vars = map[string]string{"name": "foo", "origin": "bar"}
-	s.parts = []snappy.Part{
-		&tP{name: "foo", version: "v1", origin: "bar", isActive: true, config: configStr},
-		&tP{name: "bar", version: "v2", origin: "baz", isActive: true},
-		&tP{name: "baz", version: "v3", origin: "qux", isActive: true},
-		&tP{name: "qux", version: "v4", origin: "mip", isActive: true},
-	}
+	s.mkInstalled(c, "foo", "bar", "v1", true, "")
 
 	rsp := packageConfig(packagesCmd, req).(*resp)
 
@@ -564,15 +570,18 @@
 	c.Assert(err, check.IsNil)
 
 	configStr := "some: config"
+	oldConcrete := husk.NewConcrete
+	defer func() {
+		husk.NewConcrete = oldConcrete
+	}()
+	husk.NewConcrete = func(*husk.Husk, string) husk.Concreter {
+		return &cfgc{configStr}
+	}
+
 	s.vars = map[string]string{"name": "foo", "origin": "bar"}
-	s.parts = []snappy.Part{
-		&tP{name: "foo", version: "v1", origin: "bar", isActive: true, config: configStr},
-		&tP{name: "bar", version: "v2", origin: "baz", isActive: true},
-		&tP{name: "baz", version: "v3", origin: "qux", isActive: true},
-		&tP{name: "qux", version: "v4", origin: "mip", isActive: true},
-	}
+	s.mkInstalled(c, "foo", "bar", "v1", true, "")
 
-	rsp := packageConfig(packagesCmd, req).(*resp)
+	rsp := packageConfig(packagesCmd, req).Self(nil, nil).(*resp)
 
 	c.Check(rsp, check.DeepEquals, &resp{
 		Type:   ResponseTypeSync,
@@ -592,11 +601,7 @@
 	req, err := http.NewRequest("GET", "/1.0/packages/foo.bar/services", nil)
 	c.Assert(err, check.IsNil)
 
-	s.parts = []snappy.Part{
-		&tP{name: "foo", version: "v1", origin: "bar", isActive: true,
-			svcYamls: []snappy.ServiceYaml{{Name: "svc"}},
-		},
-	}
+	s.mkInstalled(c, "foo", "bar", "v1", true, "services: [{name: svc}]")
 	s.vars = map[string]string{"name": "foo", "origin": "bar"} // NB: no service specified
 
 	rsp := packageService(packageSvcsCmd, req).(*resp)
@@ -605,11 +610,10 @@
 	c.Check(rsp.Status, check.Equals, http.StatusOK)
 
 	m := rsp.Result.(map[string]*svcDesc)
-	c.Assert(m["svc"], check.DeepEquals, &svcDesc{
-		Op:     "status",
-		Spec:   &snappy.ServiceYaml{Name: "svc"},
-		Status: &snappy.PackageServiceStatus{ServiceName: "svc"},
-	})
+	c.Assert(m["svc"], check.FitsTypeOf, new(svcDesc))
+	c.Check(m["svc"].Op, check.Equals, "status")
+	c.Check(m["svc"].Spec, check.DeepEquals, &snappy.ServiceYaml{Name: "svc", StopTimeout: snappy.DefaultTimeout})
+	c.Check(m["svc"].Status, check.DeepEquals, &snappy.PackageServiceStatus{ServiceName: "svc"})
 }
 
 func (s *apiSuite) TestPackageServicePut(c *check.C) {
@@ -624,11 +628,7 @@
 	req, err := http.NewRequest("PUT", "/1.0/packages/foo.bar/services", buf)
 	c.Assert(err, check.IsNil)
 
-	s.parts = []snappy.Part{
-		&tP{name: "foo", version: "v1", origin: "bar", isActive: true,
-			svcYamls: []snappy.ServiceYaml{{Name: "svc"}},
-		},
-	}
+	s.mkInstalled(c, "foo", "bar", "v1", true, "services: [{name: svc}]")
 	s.vars = map[string]string{"name": "foo", "origin": "bar"} // NB: no service specified
 
 	rsp := packageService(packageSvcsCmd, req).(*resp)

=== added directory 'daemon/crypt'
=== added file 'daemon/crypt/bcrypt.go'
--- daemon/crypt/bcrypt.go	1970-01-01 00:00:00 +0000
+++ daemon/crypt/bcrypt.go	2015-10-07 12:49:07 +0000
@@ -0,0 +1,38 @@
+// -*- 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 crypt
+
+import (
+	"golang.org/x/crypto/bcrypt"
+)
+
+var bcryptAlg = cryptAlg{
+	gen: func(password []byte) ([]byte, error) {
+		hash, err := bcrypt.GenerateFromPassword(password, -1)
+		if err != nil {
+			return nil, err
+		}
+
+		return hash, nil
+	},
+	cmp: func(hashedPassword, password []byte) error {
+		return bcrypt.CompareHashAndPassword(hashedPassword, password)
+	},
+}

=== added file 'daemon/crypt/crypt.go'
--- daemon/crypt/crypt.go	1970-01-01 00:00:00 +0000
+++ daemon/crypt/crypt.go	2015-10-07 12:49:07 +0000
@@ -0,0 +1,112 @@
+// -*- 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 crypt
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+
+	"launchpad.net/snappy/dirs"
+	"launchpad.net/snappy/helpers"
+)
+
+type cryptAlg struct {
+	gen func(password []byte) ([]byte, error)
+	cmp func(hashed, password []byte) error
+}
+
+// the known crypt algorithms
+//
+// xxx is algorithm the right name even
+const (
+	SHA512 = "sha512"
+	SCRYPT = "scrypt"
+	BCRYPT = "bcrypt"
+)
+
+// the default algorithm
+var DefaultAlg = SCRYPT
+
+var cryptAlgs = map[string]cryptAlg{
+	SCRYPT: scryptAlg,
+	BCRYPT: bcryptAlg,
+	SHA512: sha512cryptAlg,
+}
+
+var errBadCreds = errors.New("bad credentials")
+
+const (
+	maxSecretLen = 1024 // upper bound of the length of a secret
+	maxPrefixLen = 8    // upper bound of the prefix length (e.g. "scrypt:")
+)
+
+func pwFile() string {
+	return filepath.Join(dirs.GlobalRootDir, dirs.SnappyDir, ".snapd_creds")
+}
+
+// Write the given password out to the file, crypting it first
+func Write(password []byte) error {
+	// TODO: cracklib
+
+	hash, err := cryptAlgs[DefaultAlg].gen(password)
+	if err != nil {
+		return err
+	}
+
+	buf := append([]byte(DefaultAlg+":"), hash...)
+	if err := helpers.AtomicWriteFile(pwFile(), buf, 0600); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Check whether this password and the one on file match.
+func Check(password []byte) bool {
+	f, err := os.Open(pwFile())
+	if err != nil {
+		return false
+	}
+
+	buf := make([]byte, maxPrefixLen+maxSecretLen)
+	n, err := f.ReadAt(buf, 0)
+	if err != io.EOF {
+		return false
+	}
+
+	if n < maxPrefixLen {
+		return false
+	}
+
+	idx := bytes.IndexByte(buf[:maxPrefixLen], ':')
+	if idx < 1 {
+		return false
+	}
+
+	alg, ok := cryptAlgs[string(buf[:idx])]
+	if !ok {
+		return false
+	}
+
+	return alg.cmp(buf[idx+1:n], password) == nil
+}

=== added file 'daemon/crypt/crypt_test.go'
--- daemon/crypt/crypt_test.go	1970-01-01 00:00:00 +0000
+++ daemon/crypt/crypt_test.go	2015-10-07 12:49:07 +0000
@@ -0,0 +1,95 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package crypt
+
+import (
+	"crypto/rand"
+	"io"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"gopkg.in/check.v1"
+
+	"launchpad.net/snappy/dirs"
+)
+
+// Hook up check.v1 into the "go test" runner
+func Test(t *testing.T) { check.TestingT(t) }
+
+type cryptSuite struct {
+	oldReader io.Reader
+}
+
+var _ = check.Suite(&cryptSuite{})
+
+type totallyRandom struct{}
+
+func (totallyRandom) Read(p []byte) (int, error) {
+	if len(p) < 1 {
+		return 0, nil
+	}
+	p[0] = 9 // http://dilbert.com/strip/2001-10-25  -- wait, 2001? Ow.
+	return 1, nil
+}
+
+func (s *cryptSuite) SetUpTest(c *check.C) {
+	dirs.SetRootDir(c.MkDir())
+	c.Check(os.MkdirAll(filepath.Join(dirs.GlobalRootDir, dirs.SnappyDir), 0755), check.IsNil)
+
+	s.oldReader = rand.Reader
+	rand.Reader = totallyRandom{}
+}
+
+func (s *cryptSuite) TearDownTest(c *check.C) {
+	rand.Reader = s.oldReader
+}
+
+func (s *cryptSuite) TestCryptAlgs(c *check.C) {
+
+	for _, password := range [][]byte{
+		[]byte("hello"),
+		[]byte{0, 255, 0, 255},
+		// know any interesting values to try? call 0800-CHIPACA
+	} {
+		for k, v := range cryptAlgs {
+			hash, err := v.gen(password)
+			c.Assert(err, check.IsNil, check.Commentf(k))
+			c.Assert(hash, check.NotNil, check.Commentf(k))
+
+			c.Check(v.cmp(hash, password), check.IsNil, check.Commentf(k))
+			c.Check(v.cmp(hash, []byte("what")), check.NotNil, check.Commentf(k))
+		}
+	}
+}
+
+func (s *cryptSuite) TestRoundtrip(c *check.C) {
+	c.Check(Write([]byte("hello")), check.IsNil)
+	c.Check(Check([]byte("hello")), check.Equals, true)
+	c.Check(Check([]byte("bye")), check.Equals, false)
+}
+
+func (s *cryptSuite) TestRoundtripChangedDefaults(c *check.C) {
+	DefaultAlg = "bcrypt"
+	c.Check(Write([]byte("hello")), check.IsNil)
+	DefaultAlg = "scrypt"
+	c.Check(Check([]byte("hello")), check.Equals, true)
+	c.Check(Check([]byte("bye")), check.Equals, false)
+}

=== added file 'daemon/crypt/scrypt.go'
--- daemon/crypt/scrypt.go	1970-01-01 00:00:00 +0000
+++ daemon/crypt/scrypt.go	2015-10-07 12:49:07 +0000
@@ -0,0 +1,75 @@
+// -*- 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 crypt
+
+import (
+	"bytes"
+	"crypto/rand"
+	"encoding/ascii85"
+	"io"
+
+	"golang.org/x/crypto/scrypt"
+)
+
+const (
+	scryptSaltLen = 32
+	scryptHashLen = 64
+	scryptN       = 1 << 14
+	scryptR       = 8
+	scryptP       = 16
+)
+
+var scryptAlg = cryptAlg{
+	cmp: func(hashedPassword, password []byte) error {
+		saltedHash := make([]byte, scryptSaltLen+scryptHashLen)
+		_, _, err := ascii85.Decode(saltedHash, hashedPassword, true)
+		if err != nil {
+			return err
+		}
+
+		salt := saltedHash[:scryptSaltLen]
+		hash, err := scrypt.Key([]byte(password), salt, scryptN, scryptR, scryptP, scryptHashLen)
+		if err != nil {
+			return err
+		}
+
+		if !bytes.Equal(hash, saltedHash[scryptSaltLen:]) {
+			return errBadCreds
+		}
+
+		return nil
+	},
+	gen: func(password []byte) ([]byte, error) {
+		salt := make([]byte, scryptSaltLen)
+		if _, err := io.ReadFull(rand.Reader, salt); err != nil {
+			return nil, err
+		}
+
+		hash, err := scrypt.Key([]byte(password), salt, scryptN, scryptR, scryptP, scryptHashLen)
+		if err != nil {
+			return nil, err
+		}
+
+		coded := make([]byte, ascii85.MaxEncodedLen(scryptSaltLen+scryptHashLen))
+		n := ascii85.Encode(coded, append(salt, hash...))
+
+		return coded[:n], nil
+	},
+}

=== added file 'daemon/crypt/sha512crypt.go'
--- daemon/crypt/sha512crypt.go	1970-01-01 00:00:00 +0000
+++ daemon/crypt/sha512crypt.go	2015-10-07 12:49:07 +0000
@@ -0,0 +1,114 @@
+// -*- 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 crypt
+
+/*
+#cgo CFLAGS: -D_GNU_SOURCE -O3 -Wextra -Werror -pedantic
+#cgo LDFLAGS: -lcrypt
+#include <crypt.h>
+#include <string.h>
+*/
+import "C"
+
+import (
+	"bytes"
+	"crypto/rand"
+	"encoding/binary"
+	"unsafe"
+)
+
+const (
+	sha512saltLetters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./"
+	sha512saltNChars  = 16
+)
+
+func mksalt() ([]byte, error) {
+	raw := make([]uint32, 3)
+	if err := binary.Read(rand.Reader, binary.LittleEndian, &raw); err != nil {
+		return nil, err
+	}
+
+	full := make([]byte, sha512saltNChars+4)
+	full[0] = byte('$')
+	full[1] = byte('6')
+	full[2] = byte('$')
+	full[3+sha512saltNChars] = byte('$')
+	salt := full[3 : 3+sha512saltNChars]
+
+	m := uint32(0)
+	for i, n := range raw {
+		for j := 1; j < 6; j++ {
+			salt[i*5+j] = sha512saltLetters[n&63]
+			n >>= 6
+		}
+		m += n << (2 * uint(i))
+	}
+	salt[0] = sha512saltLetters[m]
+
+	return full, nil
+}
+
+func crypt(password, saltOrHashedPassword []byte, checkOnly bool) ([]byte, error) {
+	s := C.struct_crypt_data{}
+	s.initialized = 0
+
+	p, err := C.crypt_r(
+		(*C.char)(unsafe.Pointer(&password[0])),
+		(*C.char)(unsafe.Pointer(&saltOrHashedPassword[0])),
+		&s,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	n := C.strnlen(p, maxSecretLen)
+	if n == maxSecretLen {
+		// just in case
+		return nil, errBadCreds
+	}
+
+	buf := (*[1024]byte)(unsafe.Pointer(p))[:n]
+
+	if checkOnly {
+		if bytes.Equal(buf, saltOrHashedPassword) {
+			return nil, nil
+		}
+
+		return nil, errBadCreds
+	}
+
+	return append([]byte(nil), buf...), nil
+}
+
+var sha512cryptAlg = cryptAlg{
+	gen: func(password []byte) ([]byte, error) {
+		salt, err := mksalt()
+		if err != nil {
+			return nil, err
+		}
+
+		return crypt(password, salt, false)
+	},
+	cmp: func(hashedPassword, password []byte) error {
+		_, err := crypt(password, hashedPassword, true)
+
+		return err
+	},
+}

=== modified file 'daemon/daemon.go'
--- daemon/daemon.go	2015-09-15 12:55:09 +0000
+++ daemon/daemon.go	2015-10-07 12:49:07 +0000
@@ -30,6 +30,7 @@
 	"github.com/gorilla/mux"
 	"gopkg.in/tomb.v2"
 
+	"launchpad.net/snappy/daemon/crypt"
 	"launchpad.net/snappy/logger"
 )
 
@@ -47,7 +48,8 @@
 
 // A Command routes a request to an individual per-verb ResponseFUnc
 type Command struct {
-	Path string
+	Path    string
+	GuestOK bool
 	//
 	GET    ResponseFunc
 	PUT    ResponseFunc
@@ -57,7 +59,26 @@
 	d *Daemon
 }
 
+// AuthOK checks whether the request has enough authorization for the command
+func (c *Command) AuthOK(r *http.Request) bool {
+	if c.GuestOK {
+		return true
+	}
+
+	user, pass, ok := r.BasicAuth()
+	if !ok {
+		return false
+	}
+
+	return crypt.Check([]byte(user + pass))
+}
+
 func (c *Command) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if !c.AuthOK(r) {
+		Unauthorized.ServeHTTP(w, r)
+		return
+	}
+
 	var rspf ResponseFunc
 	var rsp Response = BadMethod
 
@@ -128,11 +149,6 @@
 	return nil
 }
 
-const (
-	iconPath   = "/var/lib/snappy/icons/"
-	iconPrefix = "/1.0/icons/"
-)
-
 func (d *Daemon) addRoutes() {
 	d.router = mux.NewRouter()
 
@@ -142,8 +158,6 @@
 		d.router.Handle(c.Path, c).Name(c.Path)
 	}
 
-	// hrmph
-	d.router.PathPrefix(iconPrefix).Handler(http.StripPrefix(iconPrefix, http.FileServer(http.Dir(iconPath)))).Name(iconPrefix)
 	// also maybe add a /favicon.ico handler...
 
 	d.router.NotFoundHandler = NotFound

=== added file 'daemon/daemon_test.go'
--- daemon/daemon_test.go	1970-01-01 00:00:00 +0000
+++ daemon/daemon_test.go	2015-10-07 12:49:07 +0000
@@ -0,0 +1,117 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package daemon
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+
+	"github.com/gorilla/mux"
+	"gopkg.in/check.v1"
+
+	"launchpad.net/snappy/daemon/crypt"
+	"launchpad.net/snappy/dirs"
+)
+
+type daemonSuite struct{}
+
+var _ = check.Suite(&daemonSuite{})
+
+type nullHandler struct{}
+
+func (nu *nullHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+}
+func (nu *nullHandler) Self(*Command, *http.Request) Response {
+	return nu
+}
+
+func mkRF(c *check.C, cmd *Command, method string) ResponseFunc {
+	return func(innerCmd *Command, req *http.Request) Response {
+		c.Assert(cmd, check.Equals, innerCmd)
+		c.Assert(method, check.Equals, req.Method)
+		return &nullHandler{}
+	}
+}
+
+func (s *daemonSuite) TestCommandMethodDispatch(c *check.C) {
+	dirs.SetRootDir(c.MkDir())
+	c.Check(os.MkdirAll(filepath.Join(dirs.GlobalRootDir, dirs.SnappyDir), 0755), check.IsNil)
+
+	cmd := &Command{}
+	cmd.GET = mkRF(c, cmd, "GET")
+	cmd.PUT = mkRF(c, cmd, "PUT")
+	cmd.POST = mkRF(c, cmd, "POST")
+	cmd.DELETE = mkRF(c, cmd, "DELETE")
+
+	crypt.DefaultAlg = crypt.SHA512
+	c.Check(crypt.Write([]byte("hithere")), check.IsNil)
+
+	for _, method := range []string{"GET", "POST", "PUT", "DELETE"} {
+		req, err := http.NewRequest(method, "", nil)
+		c.Assert(err, check.IsNil)
+
+		cmd.GuestOK = false
+		rec := httptest.NewRecorder()
+		cmd.ServeHTTP(rec, req)
+		c.Check(rec.Code, check.Equals, http.StatusUnauthorized)
+
+		cmd.GuestOK = true
+		rec = httptest.NewRecorder()
+		cmd.ServeHTTP(rec, req)
+		c.Check(rec.Code, check.Equals, http.StatusOK)
+
+		cmd.GuestOK = false
+		rec = httptest.NewRecorder()
+		req.SetBasicAuth("hi", "there")
+		cmd.ServeHTTP(rec, req)
+		c.Check(rec.Code, check.Equals, http.StatusOK)
+	}
+
+	cmd.GuestOK = true
+
+	req, err := http.NewRequest("POTATO", "", nil)
+	c.Assert(err, check.IsNil)
+	rec := httptest.NewRecorder()
+	cmd.ServeHTTP(rec, req)
+	c.Check(rec.Code, check.Equals, http.StatusMethodNotAllowed)
+}
+
+func (s *daemonSuite) TestAddRoutes(c *check.C) {
+	d := New()
+	d.addRoutes()
+
+	expected := make([]string, len(api))
+	for i, v := range api {
+		expected[i] = v.Path
+	}
+
+	got := make([]string, 0, len(api))
+	c.Assert(d.router.Walk(func(route *mux.Route, router *mux.Router, ancestors []*mux.Route) error {
+		got = append(got, route.GetName())
+		return nil
+	}), check.IsNil)
+
+	c.Check(got, check.DeepEquals, expected) // this'll stop being true if routes are added that aren't commands (e.g. for the favicon)
+
+	c.Check(fmt.Sprintf("%p", d.router.NotFoundHandler), check.Equals, fmt.Sprintf("%p", NotFound))
+}

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

=== 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-10-07 12:49:07 +0000
@@ -0,0 +1,54 @@
+// -*- 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/dirs"
+	"launchpad.net/snappy/pkg/husk"
+)
+
+func ExampleHusk() {
+	d, _ := ioutil.TempDir("", "test-xyzzy-")
+	defer os.RemoveAll(d)
+	dirs.SetRootDir(d)
+	os.MkdirAll(filepath.Join(dirs.SnapDataDir, "foo.bar", "0.1"), 0755)
+	os.MkdirAll(filepath.Join(dirs.SnapDataDir, "foo.bar", "0.2"), 0755)
+	os.MkdirAll(filepath.Join(dirs.SnapDataDir, "foo.bar", "0.5"), 0755)
+	os.MkdirAll(filepath.Join(dirs.SnapDataDir, "baz", "0.4"), 0755)
+	os.MkdirAll(filepath.Join(dirs.SnapDataDir, "qux", "0.5"), 0755)
+	os.MkdirAll(filepath.Join(dirs.SnapOemDir, "qux", "0.5"), 0755)
+
+	husks := husk.All()
+
+	for _, k := range []string{"foo.bar", "baz", "qux"} {
+		h := husks[k]
+		fmt.Printf("Found %d versions for %s, type %q: %s\n",
+			len(h.Versions), h.QualifiedName(), h.Type, h.Versions)
+	}
+	// Output:
+	// Found 3 versions for foo.bar, type "app": [0.5 0.2 0.1]
+	// Found 1 versions for baz, type "framework": [0.4]
+	// Found 1 versions for qux, type "oem": [0.5]
+}

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

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

=== added directory 'pkg/remote'
=== added file 'pkg/remote/remote.go'
--- pkg/remote/remote.go	1970-01-01 00:00:00 +0000
+++ pkg/remote/remote.go	2015-10-07 12:49:07 +0000
@@ -0,0 +1,45 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package remote
+
+import (
+	"launchpad.net/snappy/pkg"
+)
+
+// A Snap encapsulates the data sent to us from the store.
+type Snap struct {
+	Alias           string             `json:"alias,omitempty"`
+	AnonDownloadURL string             `json:"anon_download_url,omitempty"`
+	DownloadSha512  string             `json:"download_sha512,omitempty"`
+	Description     string             `json:"description,omitempty"`
+	DownloadSize    int64              `json:"binary_filesize,omitempty"`
+	DownloadURL     string             `json:"download_url,omitempty"`
+	IconURL         string             `json:"icon_url"`
+	LastUpdated     string             `json:"last_updated,omitempty"`
+	Name            string             `json:"package_name"`
+	Origin          string             `json:"origin"`
+	Prices          map[string]float64 `json:"prices,omitempty"`
+	Publisher       string             `json:"publisher,omitempty"`
+	RatingsAverage  float64            `json:"ratings_average,omitempty"`
+	SupportURL      string             `json:"support_url"`
+	Title           string             `json:"title"`
+	Type            pkg.Type           `json:"content,omitempty"`
+	Version         string             `json:"version"`
+}

=== added directory 'pkg/removed'
=== added file 'pkg/removed/removed.go'
--- pkg/removed/removed.go	1970-01-01 00:00:00 +0000
+++ pkg/removed/removed.go	2015-10-07 12:49:07 +0000
@@ -0,0 +1,156 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+// Package removed implements Removed packages, that are packages that
+// have been installed, removed, but not purged: there is no
+// application, but there might be data.
+package removed
+
+import (
+	"errors"
+	"io/ioutil"
+	"time"
+
+	"gopkg.in/yaml.v2"
+
+	"launchpad.net/snappy/pkg"
+	"launchpad.net/snappy/pkg/remote"
+	"launchpad.net/snappy/progress"
+	"launchpad.net/snappy/snappy"
+)
+
+// ErrRemoved is returned when you ask to operate on a removed package.
+var ErrRemoved = errors.New("package is removed")
+
+// Removed represents a removed package.
+type Removed struct {
+	name    string
+	origin  string
+	version string
+	pkgType pkg.Type
+	remote  *remote.Snap
+}
+
+// New removed package.
+func New(name, origin, version string, pkgType pkg.Type) snappy.Part {
+	part := &Removed{
+		name:    name,
+		origin:  origin,
+		version: version,
+		pkgType: pkgType,
+	}
+
+	content, _ := ioutil.ReadFile(snappy.ManifestPath(part))
+	yaml.Unmarshal(content, &(part.remote))
+
+	return part
+}
+
+// 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 {
+	if r.remote != nil {
+		return r.remote.Description
+	}
+
+	return ""
+}
+
+// Origin from the snappy.Part interface
+func (r *Removed) Origin() string {
+	if r.remote != nil {
+		return r.remote.Origin
+	}
+	if r.origin == "" {
+		return snappy.SideloadedOrigin
+	}
+	return r.origin
+}
+
+// Vendor from the snappy.Part interface
+func (r *Removed) Vendor() string {
+	if r.remote != nil {
+		return r.remote.Publisher
+	}
+
+	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 {
+	if r.remote != nil {
+		return r.remote.IconURL
+	}
+
+	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 {
+	if r.remote != nil {
+		return r.remote.DownloadSize
+	}
+
+	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(bool, progress.Meter) error { return ErrRemoved }
+
+// Frameworks from the snappy.Part interface
+func (r *Removed) Frameworks() ([]string, error) { return nil, ErrRemoved }

=== added file 'pkg/removed/removed_test.go'
--- pkg/removed/removed_test.go	1970-01-01 00:00:00 +0000
+++ pkg/removed/removed_test.go	2015-10-07 12:49:07 +0000
@@ -0,0 +1,137 @@
+// -*- 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
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"gopkg.in/check.v1"
+
+	"launchpad.net/snappy/dirs"
+	"launchpad.net/snappy/pkg"
+	"launchpad.net/snappy/progress"
+	"launchpad.net/snappy/snappy"
+)
+
+type removedSuite struct{}
+
+func Test(t *testing.T) { check.TestingT(t) }
+
+var _ = check.Suite(&removedSuite{})
+
+func (s *removedSuite) SetUpTest(c *check.C) {
+	dirs.SetRootDir(c.MkDir())
+	c.Check(os.MkdirAll(filepath.Join(dirs.SnapDataDir, "foo.bar", "1"), 0755), check.IsNil)
+}
+
+func (s *removedSuite) MkStoreYaml(c *check.C, pkgType pkg.Type) {
+	// creating the part to get its manifest path is cheating, a little
+	part := &Removed{
+		name:    "foo",
+		origin:  "bar",
+		version: "1",
+		pkgType: pkgType,
+	}
+
+	content := `
+name: foo
+origin: bar
+version: 1
+type: app
+description: |-
+  bla bla bla
+publisher: example.com
+iconurl: http://i.stack.imgur.com/i8q1U.jpg
+downloadsize: 5554242
+`
+	p := snappy.ManifestPath(part)
+	c.Assert(os.MkdirAll(filepath.Dir(p), 0755), check.IsNil)
+	c.Assert(ioutil.WriteFile(p, []byte(content), 0644), check.IsNil)
+
+}
+
+func (s *removedSuite) TestNoStore(c *check.C) {
+	part := New("foo", "bar", "1", pkg.TypeApp)
+
+	c.Check(part.Name(), check.Equals, "foo")
+	c.Check(part.Origin(), check.Equals, "bar")
+	c.Check(part.Version(), check.Equals, "1")
+	c.Check(part.Description(), check.Equals, "")
+	c.Check(part.Vendor(), check.Equals, "")
+	c.Check(part.Hash(), check.Equals, "")
+	c.Check(part.Icon(), check.Equals, "")
+	c.Check(part.DownloadSize(), check.Equals, int64(-1))
+
+	c.Check(part.InstalledSize(), check.Equals, int64(-1))
+	c.Check(part.IsActive(), check.Equals, false)
+	c.Check(part.IsInstalled(), check.Equals, false)
+	c.Check(part.NeedsReboot(), check.Equals, false)
+
+	prog := &progress.NullProgress{}
+	c.Check(part.Uninstall(prog), check.Equals, ErrRemoved)
+	c.Check(part.SetActive(true, prog), check.Equals, ErrRemoved)
+	_, err := part.Install(prog, 0)
+	c.Check(err, check.Equals, ErrRemoved)
+	_, err = part.Config(nil)
+	c.Check(err, check.Equals, ErrRemoved)
+	_, err = part.Frameworks()
+	c.Check(err, check.Equals, ErrRemoved)
+}
+
+func (s *removedSuite) TestNoOrigin(c *check.C) {
+	part := New("foo", "", "1", pkg.TypeFramework)
+	c.Check(part.Origin(), check.Equals, snappy.SideloadedOrigin)
+
+	s.MkStoreYaml(c, pkg.TypeFramework)
+	part = New("foo", "", "1", pkg.TypeFramework)
+	c.Check(part.Origin(), check.Equals, "bar")
+}
+
+func (s *removedSuite) TestWithStore(c *check.C) {
+	s.MkStoreYaml(c, pkg.TypeApp)
+	part := New("foo", "bar", "1", pkg.TypeApp)
+
+	c.Check(part.Name(), check.Equals, "foo")
+	c.Check(part.Origin(), check.Equals, "bar")
+	c.Check(part.Version(), check.Equals, "1")
+	c.Check(part.Description(), check.Equals, "bla bla bla")
+	c.Check(part.Vendor(), check.Equals, "example.com")
+	c.Check(part.Hash(), check.Equals, "")
+	c.Check(part.Icon(), check.Equals, "http://i.stack.imgur.com/i8q1U.jpg")
+	c.Check(part.DownloadSize(), check.Equals, int64(5554242))
+
+	c.Check(part.InstalledSize(), check.Equals, int64(-1))
+	c.Check(part.IsActive(), check.Equals, false)
+	c.Check(part.IsInstalled(), check.Equals, false)
+	c.Check(part.NeedsReboot(), check.Equals, false)
+
+	prog := &progress.NullProgress{}
+	c.Check(part.Uninstall(prog), check.Equals, ErrRemoved)
+	c.Check(part.SetActive(true, prog), check.Equals, ErrRemoved)
+	_, err := part.Install(prog, 0)
+	c.Check(err, check.Equals, ErrRemoved)
+	_, err = part.Config(nil)
+	c.Check(err, check.Equals, ErrRemoved)
+	_, err = part.Frameworks()
+	c.Check(err, check.Equals, ErrRemoved)
+}

=== modified file 'snappy/parts.go'
--- snappy/parts.go	2015-10-01 19:28:27 +0000
+++ snappy/parts.go	2015-10-07 12:49:07 +0000
@@ -361,7 +361,7 @@
 	return filepath.Join(dirs.SnapIconsDir, fmt.Sprintf("%s_%s.png", QualifiedName(s), s.Version()))
 }
 
-// manifestPath returns the would be path for the store manifest meta data
-func manifestPath(s Part) string {
+// ManifestPath returns the would be path for the store manifest meta data
+func ManifestPath(s Part) string {
 	return filepath.Join(dirs.SnapMetaDir, fmt.Sprintf("%s_%s.manifest", QualifiedName(s), s.Version()))
 }

=== modified file 'snappy/snapp.go'
--- snappy/snapp.go	2015-10-02 15:46:24 +0000
+++ snappy/snapp.go	2015-10-07 12:49:07 +0000
@@ -44,6 +44,7 @@
 	"launchpad.net/snappy/logger"
 	"launchpad.net/snappy/oauth"
 	"launchpad.net/snappy/pkg"
+	"launchpad.net/snappy/pkg/remote"
 	"launchpad.net/snappy/policy"
 	"launchpad.net/snappy/progress"
 	"launchpad.net/snappy/release"
@@ -175,7 +176,7 @@
 // SnapPart represents a generic snap type
 type SnapPart struct {
 	m           *packageYaml
-	remoteM     *remoteSnap
+	remoteM     *remote.Snap
 	origin      string
 	hash        string
 	isActive    bool
@@ -239,29 +240,9 @@
 	LicenseVersion           string `yaml:"license-version,omitempty"`
 }
 
-type remoteSnap struct {
-	Alias           string             `json:"alias,omitempty"`
-	AnonDownloadURL string             `json:"anon_download_url,omitempty"`
-	DownloadSha512  string             `json:"download_sha512,omitempty"`
-	Description     string             `json:"description,omitempty"`
-	DownloadSize    int64              `json:"binary_filesize,omitempty"`
-	DownloadURL     string             `json:"download_url,omitempty"`
-	IconURL         string             `json:"icon_url"`
-	LastUpdated     string             `json:"last_updated,omitempty"`
-	Name            string             `json:"package_name"`
-	Origin          string             `json:"origin"`
-	Prices          map[string]float64 `json:"prices,omitempty"`
-	Publisher       string             `json:"publisher,omitempty"`
-	RatingsAverage  float64            `json:"ratings_average,omitempty"`
-	SupportURL      string             `json:"support_url"`
-	Title           string             `json:"title"`
-	Type            pkg.Type           `json:"content,omitempty"`
-	Version         string             `json:"version"`
-}
-
 type searchResults struct {
 	Payload struct {
-		Packages []remoteSnap `json:"clickindex:package"`
+		Packages []remote.Snap `json:"clickindex:package"`
 	} `json:"_embedded"`
 }
 
@@ -653,14 +634,14 @@
 	}
 	part.hash = h.ArchiveSha512
 
-	remoteManifestPath := manifestPath(part)
+	remoteManifestPath := ManifestPath(part)
 	if helpers.FileExists(remoteManifestPath) {
 		content, err := ioutil.ReadFile(remoteManifestPath)
 		if err != nil {
 			return nil, err
 		}
 
-		var r remoteSnap
+		var r remote.Snap
 		if err := yaml.Unmarshal(content, &r); err != nil {
 			return nil, &ErrInvalidYaml{File: remoteManifestPath, Err: err, Yaml: content}
 		}
@@ -1450,7 +1431,7 @@
 
 // RemoteSnapPart represents a snap available on the server
 type RemoteSnapPart struct {
-	pkg remoteSnap
+	pkg remote.Snap
 }
 
 // Type returns the type of the SnapPart (app, oem, ...)
@@ -1634,7 +1615,7 @@
 	}
 
 	// don't worry about previous contents
-	return ioutil.WriteFile(manifestPath(s), content, 0644)
+	return ioutil.WriteFile(ManifestPath(s), content, 0644)
 }
 
 // Install installs the snap
@@ -1682,8 +1663,8 @@
 }
 
 // NewRemoteSnapPart returns a new RemoteSnapPart from the given
-// remoteSnap data
-func NewRemoteSnapPart(data remoteSnap) *RemoteSnapPart {
+// remote.Snap data
+func NewRemoteSnapPart(data remote.Snap) *RemoteSnapPart {
 	return &RemoteSnapPart{pkg: data}
 }
 
@@ -1738,7 +1719,7 @@
 	}
 
 	v := url.Values{}
-	v.Set("fields", strings.Join(getStructFields(remoteSnap{}), ","))
+	v.Set("fields", strings.Join(getStructFields(remote.Snap{}), ","))
 	storeSearchURI.RawQuery = v.Encode()
 
 	storeDetailsURI, err = storeBaseURI.Parse("package/")
@@ -1831,7 +1812,7 @@
 	}
 
 	// and decode json
-	var detailsData remoteSnap
+	var detailsData remote.Snap
 	dec := json.NewDecoder(resp.Body)
 	if err := dec.Decode(&detailsData); err != nil {
 		return nil, err
@@ -1952,7 +1933,7 @@
 	}
 	defer resp.Body.Close()
 
-	var updateData []remoteSnap
+	var updateData []remote.Snap
 	dec := json.NewDecoder(resp.Body)
 	if err := dec.Decode(&updateData); err != nil {
 		return nil, err

=== modified file 'snappy/sort_test.go'
--- snappy/sort_test.go	2015-08-21 12:08:28 +0000
+++ snappy/sort_test.go	2015-10-07 12:49:07 +0000
@@ -22,9 +22,10 @@
 import (
 	"sort"
 
+	. "gopkg.in/check.v1"
+
 	"launchpad.net/snappy/helpers"
-
-	. "gopkg.in/check.v1"
+	"launchpad.net/snappy/pkg/remote"
 )
 
 type SortTestSuite struct {
@@ -83,8 +84,8 @@
 
 func (s *SortTestSuite) TestSortSnaps(c *C) {
 	snaps := []Part{
-		&RemoteSnapPart{pkg: remoteSnap{Version: "2.0"}},
-		&RemoteSnapPart{pkg: remoteSnap{Version: "1.0"}},
+		&RemoteSnapPart{pkg: remote.Snap{Version: "2.0"}},
+		&RemoteSnapPart{pkg: remote.Snap{Version: "1.0"}},
 	}
 	sort.Sort(BySnapVersion(snaps))
 	c.Assert(snaps[0].Version(), Equals, "1.0")

=== modified file 'snappy/systemimage.go'
--- snappy/systemimage.go	2015-10-05 19:12:55 +0000
+++ snappy/systemimage.go	2015-10-07 12:49:07 +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
@@ -248,7 +253,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.
@@ -440,7 +445,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)
 	}
@@ -449,7 +454,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
 	}
 
@@ -457,28 +462,33 @@
 }
 
 // Updates returns the available updates
-func (s *SystemImageRepository) Updates() (parts []Part, err error) {
+func (s *SystemImageRepository) Updates() ([]Part, error) {
 	configFile := filepath.Join(systemImageRoot, systemImageChannelConfig)
 	updateStatus, err := systemImageClientCheckForUpdates(configFile)
+	if err != nil {
+		return nil, err
+	}
 
 	current := makeCurrentPart(s.partition)
 	// no VersionCompare here because the channel provides a "order" and
 	// that may go backwards when switching channels(?)
 	if current.Version() != updateStatus.targetVersion {
-		parts = append(parts, &SystemImagePart{
+		return []Part{&SystemImagePart{
 			version:        updateStatus.targetVersion,
 			versionDetails: updateStatus.targetVersionDetails,
 			lastUpdate:     updateStatus.lastUpdate,
 			updateSize:     updateStatus.updateSize,
 			channelName:    current.(*SystemImagePart).channelName,
-			partition:      s.partition})
+			partition:      s.partition}}, nil
 	}
 
-	return parts, err
+	return nil, nil
 }
 
 // Installed returns the installed snaps from this repository
-func (s *SystemImageRepository) Installed() (parts []Part, err error) {
+func (s *SystemImageRepository) Installed() ([]Part, error) {
+	var parts []Part
+
 	// current partition
 	curr := makeCurrentPart(s.partition)
 	if curr != nil {
@@ -491,12 +501,18 @@
 		parts = append(parts, other)
 	}
 
-	return parts, err
+	return parts, nil
 }
 
 // All installed parts. SystemImageParts are non-removable.
 func (s *SystemImageRepository) All() ([]Part, error) {
-	return s.Installed()
+	parts, _ := s.Updates()
+	inst, err := s.Installed()
+	if err != nil {
+		return nil, err
+	}
+
+	return append(inst, parts...), nil
 }
 
 // needsSync determines if syncing boot assets is required

=== modified file 'snappy/systemimage_test.go'
--- snappy/systemimage_test.go	2015-09-29 09:45:15 +0000
+++ snappy/systemimage_test.go	2015-10-07 12:49:07 +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)
@@ -461,8 +461,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) {