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

[Sergio Schvezov]

Move away from namespaces to the origins

[lp:~sergiusens/snappy/TheOrigin]

467. By Sergio Schvezov on 2015-05-20

merging trunk

[John Lenton (chipaca)]

You missed a couple of namespaces in security.md where it's a simple s/namespace/origin/; in package-names.md it's a little bit tricker but

“As part of that effort new requirements and feature nuances for snappy namespaces could arise that snappy will work with engineering teams to realize the best solution.”

a just a substitution would do.

“(for instance it might be that touch design might deem the need to allow
co-installation and co-runnability of namespaced snap variants needed to
realize their UX/app story, but we explicitly leave that problem out for now)”

there, “namespaced snap variants” -(perhaps)-> “snaps of different origin that share a name”

“The packages will continue to be accessed in the store using their full
namespaces,”

here we're using namespaces as something different, defined in situ (and changed), and is fine but makes changing the other ones more important.

review: Needs Fixing

[Sergio Schvezov (sergiusens)]

> You missed a couple of namespaces in security.md where it's a simple
> s/namespace/origin/; in package-names.md it's a little bit tricker but
>
> “As part of that effort new requirements and feature nuances for snappy
> namespaces could arise that snappy will work with engineering teams to realize
> the best solution.”
>
> a just a substitution would do.
>
> “(for instance it might be that touch design might deem the need to allow
> co-installation and co-runnability of namespaced snap variants needed to
> realize their UX/app story, but we explicitly leave that problem out for now)”
>
> there, “namespaced snap variants” -(perhaps)-> “snaps of different origin that
> share a name”
>
> “The packages will continue to be accessed in the store using their full
> namespaces,”
>
> here we're using namespaces as something different, defined in situ (and
> changed), and is fine but makes changing the other ones more important.

Right, I left these on purpose as I could find nice wording, as the reference to namespace here seemed to be confusing, sometimes talking about a namespace as package_name.origin and sometimes saying it was namespaceless, I'm glad we are moving away from this confusion.

[lp:~sergiusens/snappy/TheOrigin]

468. By Sergio Schvezov on 2015-05-20

Updating from the bad security.md merge and applying the suggestions from Chipaca to package-names.md

[John Lenton (chipaca)]

I approve of this.

review: Approve

=== modified file 'cmd/snappy/cmd_list.go'
--- cmd/snappy/cmd_list.go	2015-05-19 17:32:01 +0000
+++ cmd/snappy/cmd_list.go	2015-05-20 20:14:40 +0000
@@ -93,7 +93,7 @@
 	fmt.Fprintln(w, "Name\tDate\tVersion\tDeveloper\t")
 	for _, part := range installed {
 		if part.IsActive() {
-			fmt.Fprintln(w, fmt.Sprintf("%s\t%s\t%s\t%s\t", part.Name(), formatDate(part.Date()), part.Version(), part.Namespace()))
+			fmt.Fprintln(w, fmt.Sprintf("%s\t%s\t%s\t%s\t", part.Name(), formatDate(part.Date()), part.Version(), part.Origin()))
 		}
 	}
 	w.Flush()
@@ -116,7 +116,7 @@
 			active = "!"
 		}
 
-		fmt.Fprintln(w, fmt.Sprintf("%s%s\t%s\t%s\t%s%s\t", part.Name(), needsReboot, formatDate(part.Date()), part.Version(), part.Namespace(), active))
+		fmt.Fprintln(w, fmt.Sprintf("%s%s\t%s\t%s\t%s%s\t", part.Name(), needsReboot, formatDate(part.Date()), part.Version(), part.Origin(), active))
 	}
 	w.Flush()
 

=== modified file 'cmd/snappy/cmd_search.go'
--- cmd/snappy/cmd_search.go	2015-05-19 17:32:01 +0000
+++ cmd/snappy/cmd_search.go	2015-05-20 20:14:40 +0000
@@ -71,10 +71,10 @@
 			}
 		} else {
 			for _, part := range sharedName.Parts {
-				if sharedName.IsAlias(part.Namespace()) || part.Type() == pkg.TypeFramework {
+				if sharedName.IsAlias(part.Origin()) || part.Type() == pkg.TypeFramework {
 					fmt.Fprintln(w, fmt.Sprintf("%s\t%s\t%s\t", part.Name(), part.Version(), part.Description()))
 				} else {
-					fmt.Fprintln(w, fmt.Sprintf("%s.%s\t%s\t%s\t", part.Name(), part.Namespace(), part.Version(), part.Description()))
+					fmt.Fprintln(w, fmt.Sprintf("%s.%s\t%s\t%s\t", part.Name(), part.Origin(), part.Version(), part.Description()))
 				}
 			}
 		}

=== modified file 'docs/frameworks.md'
--- docs/frameworks.md	2015-05-12 17:39:14 +0000
+++ docs/frameworks.md	2015-05-20 20:14:40 +0000
@@ -8,7 +8,8 @@
 * Frameworks provide a significant benefit for many users
 * Frameworks are delivered via snaps
 * Frameworks can be installed on the same system without conflicts
-* Frameworks typically will use a toplevel namespace
+* Frameworks are unique, multiple origins for a framework are not supported for which
+  frameworks must be referred to without an `origin`.
 * Framework `binaries` may be used without appending the package name and
   these binary names are governed by the framework onboarding process (below)
 * Frameworks must not depend on other frameworks

=== modified file 'docs/package-names.md'
--- docs/package-names.md	2015-05-19 11:46:49 +0000
+++ docs/package-names.md	2015-05-20 20:14:40 +0000
@@ -105,26 +105,26 @@
 You can only sideload one fork of an app, there is no switching on sideloads.
 
 ## Touch & other GUIs
-Snappy will provide the basic building blocks, each platform can decide how to 
-deal with it.
-The store will guarantee the uniqueness of a package name and origin 
-combination, Snappy will allow packages with the same name to be co-installed 
-but will not be co-runnable.
-How UIs will be mapped to the primitives described in this document is not yet 
-defined. As part of that effort new requirements and feature nuances for 
-snappy namespaces could arise that snappy will work with engineering teams to 
-realize the best solution.
-(for instance it might be that touch design might deem the need to allow 
-co-installation and co-runnability of namespaced snap variants needed to 
-realize their UX/app story, but we explicitly leave that problem out for now).
+Snappy will provide the basic building blocks, each platform can decide how to
+deal with it. The store will guarantee the uniqueness of a package name and
+origin combination, Snappy will allow packages with the same name to be
+co-installed but will not be co-runnable.
+
+How UIs will be mapped to the primitives described in this document is not yet
+defined. As part of that effort new requirements and feature nuances for snappy
+package origins could arise that snappy will work with engineering teams to
+realize the best solution. (for instance it might be that touch design might
+deem the need to allow co-installation and co-runnability of snappy packages of
+different origin to realize their UX/app story, but we explicitly leave that
+problem out for now).
 
 ## Implementation details
 The packages will continue to be accessed in the store using their full
-namespaces (`/api/v1/vim.beuno`)
-On install, Snappy will ask you to choose which vim to use on runtime
-if you have more than one (defaults to what you are installing)
-There will have to be a (secure) way of persisting the user’s selection 
-of which vim is active
+namespaces, which would be composed from the `package name` and the `origin`
+(`/api/v1/vim.beuno`) On install, Snappy will ask you to choose which vim to
+use on runtime if you have more than one (defaults to what you are installing)
+There will have to be a (secure) way of persisting the user’s selection of
+which vim is active
 
 ## Ecosystem details
 Package names will now mean a specific piece of software. We will have to make 

=== modified file 'docs/security.md'
--- docs/security.md	2015-05-19 11:46:49 +0000
+++ docs/security.md	2015-05-20 20:14:40 +0000
@@ -16,10 +16,10 @@
 
 Applications are tracked by the system by using the concept of an
 ApplicationId. The `APP_ID is` the composition of the package name, the app's
-origin namespace from the store (if applicable-- only snaps of `type: app` (the
-default) have an origin namespace as part of their `APP_ID`), the
+origin from the store if applicable -- only snaps of `type: app` (the
+default) use an origin to compose the `APP_ID`), the
 service/binary name and package version. The `APP_ID` takes the form of
-`<pkgname>.<namespace>_<appname>_<version>`. For example, if this is in
+`<pkgname>.<origin>_<appname>_<version>`. For example, if this is in
 `package.yaml`:
 
     name: foo
@@ -29,7 +29,7 @@
       - name: bar
         start: bin/bar
 
-and the app was uploaded to the `myorigin` namespace in the store, then the
+and the app was uploaded to the `myorigin` origin in the store, then the
 `APP_ID` for the `bar` service is `foo.myorigin_bar_0.1`. The `APP_ID` is used
 throughout the system including in the enforcement of security policy by the
 app launcher.
@@ -129,7 +129,7 @@
       - name: cli-exe
         caps: []
 
-If this package is uploaded to the store in the `myorigin` namespace, then:
+If this package is uploaded to the store in the `myorigin` origin, then:
 
 * `APP_ID` for `bar` is `foo.myorigin_bar_1.0`. It uses the `default` template
   and `network-client` (default) cap
@@ -211,9 +211,9 @@
   socket says that app is ok).
     * `names`: (optional) list of abstract socket names
       (`<name>_<binaryname>` is prepended)
-    * `allowed-clients`: `<name>.<namespace>` or
-     `<name>.<namespace>_<binaryname>` (ie, omit version and
-     `binaryname` to allow all from snap `<name>.<namespace>` or omit
+    * `allowed-clients`: `<name>.<origin>` or
+     `<name>.<origin>_<binaryname>` (ie, omit version and
+     `binaryname` to allow all from snap `<name>.<origin>` or omit
      version to allow only `binaryname` from snap `<name>`)
 
  Eg:

=== modified file 'snappy/click.go'
--- snappy/click.go	2015-05-20 09:49:34 +0000
+++ snappy/click.go	2015-05-20 20:14:40 +0000
@@ -181,7 +181,7 @@
 
 // iterHooks will run the callback "f" for the given manifest
 // so that the call back can arrange e.g. a new link
-func iterHooks(m *packageYaml, namespace string, inhibitHooks bool, f iterHooksFunc) error {
+func iterHooks(m *packageYaml, origin string, inhibitHooks bool, f iterHooksFunc) error {
 	systemHooks, err := systemClickHooks()
 	if err != nil {
 		return err
@@ -202,7 +202,7 @@
 				continue
 			}
 
-			dst := filepath.Join(globalRootDir, expandHookPattern(m.qualifiedName(namespace), app, m.Version, systemHook.pattern))
+			dst := filepath.Join(globalRootDir, expandHookPattern(m.qualifiedName(origin), app, m.Version, systemHook.pattern))
 
 			if _, err := os.Stat(dst); err == nil {
 				if err := os.Remove(dst); err != nil {
@@ -227,8 +227,8 @@
 	return nil
 }
 
-func installClickHooks(targetDir string, m *packageYaml, namespace string, inhibitHooks bool) error {
-	return iterHooks(m, namespace, inhibitHooks, func(src, dst string, systemHook clickHook) error {
+func installClickHooks(targetDir string, m *packageYaml, origin string, inhibitHooks bool) error {
+	return iterHooks(m, origin, inhibitHooks, func(src, dst string, systemHook clickHook) error {
 		// setup the new link target here, iterHooks will take
 		// care of running the hook
 		realSrc := stripGlobalRootDir(path.Join(targetDir, src))
@@ -240,8 +240,8 @@
 	})
 }
 
-func removeClickHooks(m *packageYaml, namespace string, inhibitHooks bool) (err error) {
-	return iterHooks(m, namespace, inhibitHooks, func(src, dst string, systemHook clickHook) error {
+func removeClickHooks(m *packageYaml, origin string, inhibitHooks bool) (err error) {
+	return iterHooks(m, origin, inhibitHooks, func(src, dst string, systemHook clickHook) error {
 		// nothing we need to do here, the iterHookss will remove
 		// the hook symlink and call the hook itself
 		return nil
@@ -267,7 +267,7 @@
 		return err
 	}
 
-	if err := removeClickHooks(m, namespaceFromBasedir(clickDir), false); err != nil {
+	if err := removeClickHooks(m, originFromBasedir(clickDir), false); err != nil {
 		return err
 	}
 
@@ -343,7 +343,7 @@
 
 # app info
 export SNAP_NAME="{{.Name}}"
-export SNAP_ORIGIN="{{.Namespace}}"
+export SNAP_ORIGIN="{{.Origin}}"
 export SNAP_FULLNAME="{{.UdevAppName}}"
 
 # app paths
@@ -367,14 +367,14 @@
 `
 
 	// it's fine for this to error out; we might be in a framework or sth
-	namespace := namespaceFromBasedir(pkgPath)
+	origin := originFromBasedir(pkgPath)
 
 	if err := verifyBinariesYaml(binary); err != nil {
 		return "", err
 	}
 
 	actualBinPath := binPathForBinary(pkgPath, binary)
-	udevPartName := m.qualifiedName(namespace)
+	udevPartName := m.qualifiedName(origin)
 
 	var templateOut bytes.Buffer
 	t := template.Must(template.New("wrapper").Parse(wrapperTemplate))
@@ -385,7 +385,7 @@
 		Path        string
 		AaProfile   string
 		UdevAppName string
-		Namespace   string
+		Origin      string
 	}{
 		Name:        m.Name,
 		Version:     m.Version,
@@ -393,7 +393,7 @@
 		Path:        pkgPath,
 		AaProfile:   aaProfile,
 		UdevAppName: udevPartName,
-		Namespace:   namespace,
+		Origin:      origin,
 	}
 	t.Execute(&templateOut, wrapperData)
 
@@ -452,7 +452,7 @@
 		return "", err
 	}
 
-	udevPartName := m.qualifiedName(namespaceFromBasedir(baseDir))
+	udevPartName := m.qualifiedName(originFromBasedir(baseDir))
 
 	return systemd.New(globalRootDir, nil).GenServiceFile(
 		&systemd.ServiceDescription{
@@ -785,17 +785,17 @@
 	Notify(status string)
 }
 
-// this rewrites the json manifest to include the namespace in the on-disk
+// this rewrites the json manifest to include the origin in the on-disk
 // manifest.json to be compatible with click again
-func writeCompatManifestJSON(clickMetaDir string, manifestData []byte, namespace string) error {
+func writeCompatManifestJSON(clickMetaDir string, manifestData []byte, origin string) error {
 	var cm clickManifest
 	if err := json.Unmarshal(manifestData, &cm); err != nil {
 		return err
 	}
 
 	if cm.Type != pkg.TypeFramework && cm.Type != pkg.TypeOem {
-		// add the namespace to the name
-		cm.Name = fmt.Sprintf("%s.%s", cm.Name, namespace)
+		// add the origin to the name
+		cm.Name = fmt.Sprintf("%s.%s", cm.Name, origin)
 	}
 
 	outStr, err := json.MarshalIndent(cm, "", "  ")
@@ -809,7 +809,7 @@
 	return nil
 }
 
-func installClick(snapFile string, flags InstallFlags, inter interacter, namespace string) (name string, err error) {
+func installClick(snapFile string, flags InstallFlags, inter interacter, origin string) (name string, err error) {
 	allowUnauthenticated := (flags & AllowUnauthenticated) != 0
 	if err := auditClick(snapFile, allowUnauthenticated); err != nil {
 		return "", err
@@ -839,7 +839,7 @@
 		return "", err
 	}
 
-	if err := m.checkForPackageInstalled(namespace); err != nil {
+	if err := m.checkForPackageInstalled(origin); err != nil {
 		return "", err
 	}
 
@@ -874,7 +874,7 @@
 		}
 	}
 
-	fullName := m.qualifiedName(namespace)
+	fullName := m.qualifiedName(origin)
 	instDir := filepath.Join(targetDir, fullName, m.Version)
 	currentActiveDir, _ := filepath.EvalSymlinks(filepath.Join(instDir, "..", "current"))
 
@@ -909,7 +909,7 @@
 	if err := os.MkdirAll(clickMetaDir, 0755); err != nil {
 		return "", err
 	}
-	if err := writeCompatManifestJSON(clickMetaDir, manifestData, namespace); err != nil {
+	if err := writeCompatManifestJSON(clickMetaDir, manifestData, origin); err != nil {
 		return "", err
 	}
 
@@ -978,7 +978,7 @@
 
 	// oh, one more thing: refresh the security bits
 	if !inhibitHooks {
-		part, err := NewSnapPartFromYaml(filepath.Join(instDir, "meta", "package.yaml"), namespace, m)
+		part, err := NewSnapPartFromYaml(filepath.Join(instDir, "meta", "package.yaml"), origin, m)
 		if err != nil {
 			return "", err
 		}
@@ -1153,7 +1153,7 @@
 		}
 	}
 
-	if err := removeClickHooks(m, namespaceFromBasedir(clickDir), inhibitHooks); err != nil {
+	if err := removeClickHooks(m, originFromBasedir(clickDir), inhibitHooks); err != nil {
 		return err
 	}
 
@@ -1192,7 +1192,7 @@
 		return err
 	}
 
-	namespace := namespaceFromBasedir(baseDir)
+	origin := originFromBasedir(baseDir)
 
 	if newActiveManifest.Type == pkg.TypeFramework {
 		if err := policy.Install(m.Name, baseDir); err != nil {
@@ -1200,9 +1200,9 @@
 		}
 	}
 
-	if err := installClickHooks(baseDir, m, namespace, inhibitHooks); err != nil {
+	if err := installClickHooks(baseDir, m, origin, inhibitHooks); err != nil {
 		// cleanup the failed hooks
-		removeClickHooks(m, namespace, inhibitHooks)
+		removeClickHooks(m, origin, inhibitHooks)
 		return err
 	}
 

=== modified file 'snappy/click_test.go'
--- snappy/click_test.go	2015-05-19 19:34:13 +0000
+++ snappy/click_test.go	2015-05-20 20:14:40 +0000
@@ -151,16 +151,16 @@
 			},
 		},
 	}
-	err := installClickHooks(instDir, m, testNamespace, false)
+	err := installClickHooks(instDir, m, testOrigin, false)
 	c.Assert(err, IsNil)
-	p := fmt.Sprintf("%s/%s.%s_%s_%s", testSymlinkDir, m.Name, testNamespace, "app", m.Version)
+	p := fmt.Sprintf("%s/%s.%s_%s_%s", testSymlinkDir, m.Name, testOrigin, "app", m.Version)
 	_, err = os.Stat(p)
 	c.Assert(err, IsNil)
 	symlinkTarget, err := filepath.EvalSymlinks(p)
 	c.Assert(err, IsNil)
 	c.Assert(symlinkTarget, Equals, path.Join(instDir, "path-to-systemd-file"))
 
-	p = fmt.Sprintf("%s/%s.%s_%s_%s", testSymlinkDir2, m.Name, testNamespace, "app", m.Version)
+	p = fmt.Sprintf("%s/%s.%s_%s_%s", testSymlinkDir2, m.Name, testOrigin, "app", m.Version)
 	_, err = os.Stat(p)
 	c.Assert(err, IsNil)
 	symlinkTarget, err = filepath.EvalSymlinks(p)
@@ -168,15 +168,15 @@
 	c.Assert(symlinkTarget, Equals, path.Join(instDir, "path-to-apparmor-file"))
 
 	// now ensure we can remove
-	err = removeClickHooks(m, testNamespace, false)
+	err = removeClickHooks(m, testOrigin, false)
 	c.Assert(err, IsNil)
-	_, err = os.Stat(fmt.Sprintf("%s/%s.%s_%s_%s", testSymlinkDir, m.Name, testNamespace, "app", m.Version))
+	_, err = os.Stat(fmt.Sprintf("%s/%s.%s_%s_%s", testSymlinkDir, m.Name, testOrigin, "app", m.Version))
 	c.Assert(err, NotNil)
 }
 
 func (s *SnapTestSuite) testLocalSnapInstall(c *C) string {
 	snapFile := makeTestSnapPackage(c, "")
-	name, err := installClick(snapFile, 0, nil, testNamespace)
+	name, err := installClick(snapFile, 0, nil, testOrigin)
 	c.Assert(err, IsNil)
 	c.Check(name, Equals, "foo")
 
@@ -191,11 +191,11 @@
 	c.Assert(err, IsNil)
 
 	// ensure we have the data dir
-	_, err = os.Stat(path.Join(s.tempdir, "var", "lib", "apps", "foo."+testNamespace, "1.0"))
+	_, err = os.Stat(path.Join(s.tempdir, "var", "lib", "apps", "foo."+testOrigin, "1.0"))
 	c.Assert(err, IsNil)
 
 	// ensure we have the hashes
-	snap, err := NewInstalledSnapPart(filepath.Join(baseDir, "meta", "package.yaml"), testNamespace)
+	snap, err := NewInstalledSnapPart(filepath.Join(baseDir, "meta", "package.yaml"), testOrigin)
 	c.Assert(err, IsNil)
 	c.Assert(snap.Hash(), Not(Equals), "")
 
@@ -209,7 +209,7 @@
 func (s *SnapTestSuite) TestLocalSnapInstallFailsAlreadyInstalled(c *C) {
 	snapFile := s.testLocalSnapInstall(c)
 
-	_, err := installClick(snapFile, 0, nil, "namespaceother")
+	_, err := installClick(snapFile, 0, nil, "originother")
 	c.Assert(err, Equals, ErrPackageNameAlreadyInstalled)
 }
 
@@ -219,7 +219,7 @@
 	defer func() { clickdeb.VerifyCmd = old }()
 
 	snapFile := makeTestSnapPackage(c, "")
-	_, err := installClick(snapFile, 0, nil, testNamespace)
+	_, err := installClick(snapFile, 0, nil, testOrigin)
 	c.Assert(err, NotNil)
 
 	contentFile := path.Join(s.tempdir, "apps", fooComposedName, "1.0", "bin", "foo")
@@ -238,11 +238,11 @@
 	defer func() { clickdeb.VerifyCmd = old }()
 
 	snapFile := makeTestSnapPackage(c, "")
-	name, err := installClick(snapFile, AllowUnauthenticated, nil, testNamespace)
+	name, err := installClick(snapFile, AllowUnauthenticated, nil, testOrigin)
 	c.Assert(err, IsNil)
 	c.Check(name, Equals, "foo")
 
-	_, err = installClick(snapFile, 0, nil, testNamespace)
+	_, err = installClick(snapFile, 0, nil, testOrigin)
 	c.Assert(err, NotNil)
 }
 
@@ -263,7 +263,7 @@
 // install fails
 func (s *SnapTestSuite) TestLocalSnapInstallMissingAccepterFails(c *C) {
 	pkg := makeTestSnapPackage(c, "explicit-license-agreement: Y")
-	_, err := installClick(pkg, 0, nil, testNamespace)
+	_, err := installClick(pkg, 0, nil, testOrigin)
 	c.Check(err, Equals, ErrLicenseNotAccepted)
 }
 
@@ -271,7 +271,7 @@
 // Agreed returns false, install fails
 func (s *SnapTestSuite) TestLocalSnapInstallNegAccepterFails(c *C) {
 	pkg := makeTestSnapPackage(c, "explicit-license-agreement: Y")
-	_, err := installClick(pkg, 0, &agreerator{y: false}, testNamespace)
+	_, err := installClick(pkg, 0, &agreerator{y: false}, testOrigin)
 	c.Check(err, Equals, ErrLicenseNotAccepted)
 }
 
@@ -282,7 +282,7 @@
 	defer func() { licenseChecker = checkLicenseExists }()
 
 	pkg := makeTestSnapPackageFull(c, "explicit-license-agreement: Y", false)
-	_, err := installClick(pkg, 0, &agreerator{y: true}, testNamespace)
+	_, err := installClick(pkg, 0, &agreerator{y: true}, testOrigin)
 	c.Check(err, Equals, ErrLicenseNotProvided)
 }
 
@@ -290,7 +290,7 @@
 // Agreed returns true, install succeeds
 func (s *SnapTestSuite) TestLocalSnapInstallPosAccepterWorks(c *C) {
 	pkg := makeTestSnapPackage(c, "explicit-license-agreement: Y")
-	_, err := installClick(pkg, 0, &agreerator{y: true}, testNamespace)
+	_, err := installClick(pkg, 0, &agreerator{y: true}, testOrigin)
 	c.Check(err, Equals, nil)
 }
 
@@ -298,7 +298,7 @@
 func (s *SnapTestSuite) TestLocalSnapInstallAccepterReasonable(c *C) {
 	pkg := makeTestSnapPackage(c, "name: foobar\nexplicit-license-agreement: Y")
 	ag := &agreerator{y: true}
-	_, err := installClick(pkg, 0, ag, testNamespace)
+	_, err := installClick(pkg, 0, ag, testOrigin)
 	c.Assert(err, Equals, nil)
 	c.Check(ag.intro, Matches, ".*foobar.*requires.*license.*")
 	c.Check(ag.license, Equals, "WTFPL")
@@ -312,11 +312,11 @@
 	yamlFile, err := makeInstalledMockSnap(s.tempdir, yaml+"version: 1")
 	pkgdir := filepath.Dir(filepath.Dir(yamlFile))
 	c.Assert(os.MkdirAll(filepath.Join(pkgdir, ".click", "info"), 0755), IsNil)
-	c.Assert(ioutil.WriteFile(filepath.Join(pkgdir, ".click", "info", "foox."+testNamespace+".manifest"), []byte(`{"name": "foox"}`), 0644), IsNil)
+	c.Assert(ioutil.WriteFile(filepath.Join(pkgdir, ".click", "info", "foox."+testOrigin+".manifest"), []byte(`{"name": "foox"}`), 0644), IsNil)
 	c.Assert(setActiveClick(pkgdir, true, ag), IsNil)
 
 	pkg := makeTestSnapPackage(c, yaml+"version: 2")
-	_, err = installClick(pkg, 0, ag, testNamespace)
+	_, err = installClick(pkg, 0, ag, testOrigin)
 	c.Assert(err, Equals, nil)
 	c.Check(ag.intro, Equals, "")
 	c.Check(ag.license, Equals, "")
@@ -330,11 +330,11 @@
 	yamlFile, err := makeInstalledMockSnap(s.tempdir, yaml+"version: 1")
 	pkgdir := filepath.Dir(filepath.Dir(yamlFile))
 	c.Assert(os.MkdirAll(filepath.Join(pkgdir, ".click", "info"), 0755), IsNil)
-	c.Assert(ioutil.WriteFile(filepath.Join(pkgdir, ".click", "info", "foox."+testNamespace+".manifest"), []byte(`{"name": "foox"}`), 0644), IsNil)
+	c.Assert(ioutil.WriteFile(filepath.Join(pkgdir, ".click", "info", "foox."+testOrigin+".manifest"), []byte(`{"name": "foox"}`), 0644), IsNil)
 	c.Assert(setActiveClick(pkgdir, true, ag), IsNil)
 
 	pkg := makeTestSnapPackage(c, yaml+"version: 2\nexplicit-license-agreement: Y")
-	_, err = installClick(pkg, 0, ag, testNamespace)
+	_, err = installClick(pkg, 0, ag, testOrigin)
 	c.Assert(err, Equals, nil)
 	c.Check(ag.license, Equals, "WTFPL")
 }
@@ -347,11 +347,11 @@
 	yamlFile, err := makeInstalledMockSnap(s.tempdir, yaml+"license-version: 2\nversion: 1")
 	pkgdir := filepath.Dir(filepath.Dir(yamlFile))
 	c.Assert(os.MkdirAll(filepath.Join(pkgdir, ".click", "info"), 0755), IsNil)
-	c.Assert(ioutil.WriteFile(filepath.Join(pkgdir, ".click", "info", "foox."+testNamespace+".manifest"), []byte(`{"name": "foox"}`), 0644), IsNil)
+	c.Assert(ioutil.WriteFile(filepath.Join(pkgdir, ".click", "info", "foox."+testOrigin+".manifest"), []byte(`{"name": "foox"}`), 0644), IsNil)
 	c.Assert(setActiveClick(pkgdir, true, ag), IsNil)
 
 	pkg := makeTestSnapPackage(c, yaml+"license-version: 3\nversion: 2")
-	_, err = installClick(pkg, 0, ag, testNamespace)
+	_, err = installClick(pkg, 0, ag, testOrigin)
 	c.Assert(err, Equals, nil)
 	c.Check(ag.license, Equals, "WTFPL")
 }
@@ -364,7 +364,7 @@
 	}
 
 	targetDir := path.Join(s.tempdir, "apps")
-	_, err := installClick(makeTestSnapPackage(c, ""), 0, nil, testNamespace)
+	_, err := installClick(makeTestSnapPackage(c, ""), 0, nil, testOrigin)
 	c.Assert(err, IsNil)
 
 	instDir := path.Join(targetDir, fooComposedName, "1.0")
@@ -415,7 +415,7 @@
 		return writeHashes(tmpdir, dataTar)
 	}), IsNil)
 
-	_, err = installClick(snapName, 0, nil, testNamespace)
+	_, err = installClick(snapName, 0, nil, testOrigin)
 	c.Assert(err, IsNil)
 
 	return snapName
@@ -430,7 +430,7 @@
 	// rename the policy
 	//poldir := filepath.Join(tmpdir, "meta", "framework-policy", "apparmor", "policygroups")
 
-	_, err := installClick(snapName, 0, nil, testNamespace)
+	_, err := installClick(snapName, 0, nil, testOrigin)
 	c.Assert(err, IsNil)
 	// appdir := filepath.Join(s.tempdir, "apps", "hello.testspacethename", "1.0.1")
 	// c.Assert(removeClick(appdir, nil), IsNil)
@@ -467,7 +467,7 @@
 type: oem
 icon: foo.svg
 vendor: Foo Bar <[e-mail]>`)
-	_, err := installClick(snapFile, AllowOEM, nil, testNamespace)
+	_, err := installClick(snapFile, AllowOEM, nil, testOrigin)
 	c.Assert(err, IsNil)
 
 	contentFile := path.Join(s.tempdir, "oem", "foo", "1.0", "bin", "foo")
@@ -483,7 +483,7 @@
 type: oem
 icon: foo.svg
 vendor: Foo Bar <[e-mail]>`)
-	_, err := installClick(snapFile, AllowOEM, nil, testNamespace)
+	_, err := installClick(snapFile, AllowOEM, nil, testOrigin)
 	c.Assert(err, IsNil)
 
 	contentFile := path.Join(s.tempdir, "oem", "foo", "1.0", "bin", "foo")
@@ -498,12 +498,12 @@
 type: oem
 icon: foo.svg
 vendor: Foo Bar <[e-mail]>`)
-	_, err = installClick(snapFile, 0, nil, testNamespace)
+	_, err = installClick(snapFile, 0, nil, testOrigin)
 	c.Check(err, IsNil)
 
-	// different namespace, this shows we have no namespace support at this
+	// different origin, this shows we have no origin support at this
 	// level, but sideloading also works.
-	_, err = installClick(snapFile, 0, nil, sideloadedNamespace)
+	_, err = installClick(snapFile, 0, nil, sideloadedOrigin)
 	c.Check(err, IsNil)
 
 	// a package name fork, IOW, a different OEM package.
@@ -512,11 +512,11 @@
 type: oem
 icon: foo.svg
 vendor: Foo Bar <[e-mail]>`)
-	_, err = installClick(snapFile, 0, nil, testNamespace)
+	_, err = installClick(snapFile, 0, nil, testOrigin)
 	c.Check(err, Equals, ErrOEMPackageInstall)
 
 	// this will cause chaos, but let's test if it works
-	_, err = installClick(snapFile, AllowOEM, nil, testNamespace)
+	_, err = installClick(snapFile, AllowOEM, nil, testOrigin)
 	c.Check(err, IsNil)
 }
 
@@ -526,11 +526,11 @@
 vendor: Foo Bar <[e-mail]>
 `
 	snapFile := makeTestSnapPackage(c, packageYaml+"version: 1.0")
-	_, err := installClick(snapFile, AllowUnauthenticated, nil, testNamespace)
+	_, err := installClick(snapFile, AllowUnauthenticated, nil, testOrigin)
 	c.Assert(err, IsNil)
 
 	snapFile = makeTestSnapPackage(c, packageYaml+"version: 2.0")
-	_, err = installClick(snapFile, AllowUnauthenticated, nil, testNamespace)
+	_, err = installClick(snapFile, AllowUnauthenticated, nil, testOrigin)
 	c.Assert(err, IsNil)
 
 	// ensure v2 is active
@@ -557,7 +557,7 @@
 func (s *SnapTestSuite) TestClickCopyData(c *C) {
 	snapDataHomeGlob = filepath.Join(s.tempdir, "home", "*", "apps")
 	homeDir := filepath.Join(s.tempdir, "home", "user1", "apps")
-	appDir := "foo." + testNamespace
+	appDir := "foo." + testOrigin
 	homeData := filepath.Join(homeDir, appDir, "1.0")
 	err := helpers.EnsureDir(homeData, 0755)
 	c.Assert(err, IsNil)
@@ -569,7 +569,7 @@
 	canaryData := []byte("ni ni ni")
 
 	snapFile := makeTestSnapPackage(c, packageYaml+"version: 1.0")
-	_, err = installClick(snapFile, AllowUnauthenticated, nil, testNamespace)
+	_, err = installClick(snapFile, AllowUnauthenticated, nil, testOrigin)
 	c.Assert(err, IsNil)
 	canaryDataFile := filepath.Join(snapDataDir, appDir, "1.0", "canary.txt")
 	err = ioutil.WriteFile(canaryDataFile, canaryData, 0644)
@@ -578,7 +578,7 @@
 	c.Assert(err, IsNil)
 
 	snapFile = makeTestSnapPackage(c, packageYaml+"version: 2.0")
-	_, err = installClick(snapFile, AllowUnauthenticated, nil, testNamespace)
+	_, err = installClick(snapFile, AllowUnauthenticated, nil, testOrigin)
 	c.Assert(err, IsNil)
 	newCanaryDataFile := filepath.Join(snapDataDir, appDir, "2.0", "canary.txt")
 	content, err := ioutil.ReadFile(newCanaryDataFile)
@@ -601,16 +601,16 @@
 icon: foo.svg
 vendor: Foo Bar <[e-mail]>
 `
-	appDir := "foo." + testNamespace
+	appDir := "foo." + testOrigin
 	snapFile := makeTestSnapPackage(c, packageYaml+"version: 1.0")
-	_, err := installClick(snapFile, AllowUnauthenticated, nil, testNamespace)
+	_, err := installClick(snapFile, AllowUnauthenticated, nil, testOrigin)
 	c.Assert(err, IsNil)
 	canaryDataFile := filepath.Join(snapDataDir, appDir, "1.0", "canary.txt")
 	err = ioutil.WriteFile(canaryDataFile, []byte(""), 0644)
 	c.Assert(err, IsNil)
 
 	snapFile = makeTestSnapPackage(c, packageYaml+"version: 2.0")
-	_, err = installClick(snapFile, AllowUnauthenticated, nil, testNamespace)
+	_, err = installClick(snapFile, AllowUnauthenticated, nil, testOrigin)
 	c.Assert(err, IsNil)
 	_, err = os.Stat(filepath.Join(snapDataDir, appDir, "2.0", "canary.txt"))
 	c.Assert(err, IsNil)
@@ -636,17 +636,17 @@
  app:
   tracehook: meta/package.yaml
 `
-	appDir := "bar." + testNamespace
+	appDir := "bar." + testOrigin
 	// install 1.0 and then upgrade to 2.0
 	snapFile := makeTestSnapPackage(c, packageYaml+"version: 1.0")
-	_, err := installClick(snapFile, AllowUnauthenticated, nil, testNamespace)
+	_, err := installClick(snapFile, AllowUnauthenticated, nil, testOrigin)
 	c.Assert(err, IsNil)
 	canaryDataFile := filepath.Join(snapDataDir, appDir, "1.0", "canary.txt")
 	err = ioutil.WriteFile(canaryDataFile, []byte(""), 0644)
 	c.Assert(err, IsNil)
 
 	snapFile = makeTestSnapPackage(c, packageYaml+"version: 2.0")
-	_, err = installClick(snapFile, AllowUnauthenticated, nil, testNamespace)
+	_, err = installClick(snapFile, AllowUnauthenticated, nil, testOrigin)
 	c.Assert(err, IsNil)
 	_, err = os.Stat(filepath.Join(snapDataDir, appDir, "2.0", "canary.txt"))
 	c.Assert(err, IsNil)
@@ -657,7 +657,7 @@
 	c.Assert(err, IsNil)
 	// Forcefully in one line to avoid issues with hidden spaces,
 	// it is visually obvious in this form.
-	hookRun := fmt.Sprintf("now: ./bar.%s_app_1.0.tracehook\nnow: \nnow: ./bar.%s_app_2.0.tracehook\n", testNamespace, testNamespace)
+	hookRun := fmt.Sprintf("now: ./bar.%s_app_1.0.tracehook\nnow: \nnow: ./bar.%s_app_2.0.tracehook\n", testOrigin, testOrigin)
 	c.Assert(string(content), Equals, hookRun)
 }
 
@@ -670,7 +670,7 @@
 	hookContent := fmt.Sprintf(`Hook-Name: hooky
 User: root
 Exec: if test -e %s/bar.%s_app_2.0.hooky; then echo "this log message is harmless and can be ignored"; false; fi
-Pattern: /${id}.hooky`, s.tempdir, testNamespace)
+Pattern: /${id}.hooky`, s.tempdir, testOrigin)
 	makeClickHook(c, hookContent)
 
 	packageYaml := `name: bar
@@ -681,17 +681,17 @@
   hooky: meta/package.yaml
 `
 
-	appDir := "bar." + testNamespace
+	appDir := "bar." + testOrigin
 	// install 1.0 and then upgrade to 2.0
 	snapFile := makeTestSnapPackage(c, packageYaml+"version: 1.0")
-	_, err := installClick(snapFile, AllowUnauthenticated, nil, testNamespace)
+	_, err := installClick(snapFile, AllowUnauthenticated, nil, testOrigin)
 	c.Assert(err, IsNil)
 	canaryDataFile := filepath.Join(snapDataDir, appDir, "1.0", "canary.txt")
 	err = ioutil.WriteFile(canaryDataFile, []byte(""), 0644)
 	c.Assert(err, IsNil)
 
 	snapFile = makeTestSnapPackage(c, packageYaml+"version: 2.0")
-	_, err = installClick(snapFile, AllowUnauthenticated, nil, testNamespace)
+	_, err = installClick(snapFile, AllowUnauthenticated, nil, testOrigin)
 	c.Assert(err, NotNil)
 
 	// installing 2.0 will fail in the hooks,
@@ -905,7 +905,7 @@
    start: bin/bye
 version: `
 	snapFile := makeTestSnapPackage(c, packageYaml+"1.0")
-	_, err = installClick(snapFile, AllowUnauthenticated, inter, testNamespace)
+	_, err = installClick(snapFile, AllowUnauthenticated, inter, testOrigin)
 	c.Assert(err, IsNil)
 
 	c.Assert(helpers.FileExists(filepath.Join(snapServicesDir, "foo_svc1_1.0.service")), Equals, true)
@@ -1014,7 +1014,7 @@
    start: bin/hello
 `
 	snapFile := makeTestSnapPackage(c, packageYaml+"version: 1.0")
-	_, err := installClick(snapFile, InhibitHooks, nil, testNamespace)
+	_, err := installClick(snapFile, InhibitHooks, nil, testOrigin)
 	c.Assert(err, IsNil)
 
 	c.Assert(allSystemctl, HasLen, 0)
@@ -1060,11 +1060,11 @@
 	snapFile := makeTestSnapPackage(c, packageYaml+"version: 1.0")
 
 	// install it
-	_, err := installClick(snapFile, 0, nil, testNamespace)
+	_, err := installClick(snapFile, 0, nil, testOrigin)
 	c.Assert(err, IsNil)
 
 	// verify we have the symlink
-	c.Assert(helpers.FileExists(filepath.Join(hookSymlinkDir, fmt.Sprintf("foo.%s_app_1.0", testNamespace))), Equals, true)
+	c.Assert(helpers.FileExists(filepath.Join(hookSymlinkDir, fmt.Sprintf("foo.%s_app_1.0", testOrigin))), Equals, true)
 	// and the hook exec was called
 	c.Assert(helpers.FileExists(filepath.Join(s.tempdir, "i-ran")), Equals, true)
 }
@@ -1092,11 +1092,11 @@
 	snapFile := makeTestSnapPackage(c, packageYaml+"version: 1.0")
 
 	// install it
-	_, err := installClick(snapFile, InhibitHooks, nil, testNamespace)
+	_, err := installClick(snapFile, InhibitHooks, nil, testOrigin)
 	c.Assert(err, IsNil)
 
 	// verify we have the symlink
-	c.Assert(helpers.FileExists(filepath.Join(hookSymlinkDir, fmt.Sprintf("foo.%s_app_1.0", testNamespace))), Equals, true)
+	c.Assert(helpers.FileExists(filepath.Join(hookSymlinkDir, fmt.Sprintf("foo.%s_app_1.0", testOrigin))), Equals, true)
 	// but the hook exec was not called
 	c.Assert(helpers.FileExists(filepath.Join(s.tempdir, "i-ran")), Equals, false)
 }
@@ -1120,7 +1120,7 @@
 	verbs := []string{"Start", "Stop", "StopPost"}
 	bins := []string{"hello", "goodbye", "missya"}
 	for i := range verbs {
-		expected := fmt.Sprintf("Exec%s=/usr/bin/ubuntu-core-launcher hello-app.%s %s_svc1_1.10 %s/bin/%s", verbs[i], testNamespace, helloAppComposedName, baseDirWithoutRootPrefix, bins[i])
+		expected := fmt.Sprintf("Exec%s=/usr/bin/ubuntu-core-launcher hello-app.%s %s_svc1_1.10 %s/bin/%s", verbs[i], testOrigin, helloAppComposedName, baseDirWithoutRootPrefix, bins[i])
 		c.Check(string(content), Matches, "(?ms).*^"+regexp.QuoteMeta(expected)) // gocheck adds ^ and $ around the regexp provided
 	}
 }
@@ -1180,7 +1180,7 @@
 	needle := fmt.Sprintf(`
 cd /apps/hello-app.testspacethename/1.10
 ubuntu-core-launcher hello-app.%s hello-app.testspacethename_hello_1.10 /apps/hello-app.testspacethename/1.10/bin/hello "$@"
-`, testNamespace)
+`, testOrigin)
 	c.Assert(string(content), Matches, "(?ms).*"+regexp.QuoteMeta(needle)+".*")
 }
 
@@ -1360,7 +1360,7 @@
 		return writeHashes(tmpdir, dataTar)
 	}), IsNil)
 
-	_, err = installClick(snapName, 0, nil, testNamespace)
+	_, err = installClick(snapName, 0, nil, testOrigin)
 	c.Assert(err, ErrorMatches, ".*binary and service both called foo.*")
 }
 
@@ -1372,7 +1372,7 @@
   - missing
 `
 	snapFile := makeTestSnapPackage(c, packageYaml)
-	_, err := installClick(snapFile, 0, nil, testNamespace)
+	_, err := installClick(snapFile, 0, nil, testOrigin)
 	c.Assert(err, ErrorMatches, `.*missing framework.*`)
 }
 
@@ -1399,7 +1399,7 @@
 		return s
 	}
 
-	err := installClickHooks(c.MkDir(), m, testNamespace, false)
+	err := installClickHooks(c.MkDir(), m, testOrigin, false)
 	c.Assert(err, IsNil)
 	c.Assert(stripGlobalRootDirWasCalled, Equals, true)
 }

=== modified file 'snappy/common_test.go'
--- snappy/common_test.go	2015-05-19 17:32:01 +0000
+++ snappy/common_test.go	2015-05-20 20:14:40 +0000
@@ -35,7 +35,7 @@
 )
 
 const (
-	testNamespace        = "testspacethename"
+	testOrigin           = "testspacethename"
 	fooComposedName      = "foo.testspacethename"
 	helloAppComposedName = "hello-app.testspacethename"
 )
@@ -64,7 +64,7 @@
 		return "", err
 	}
 
-	dirName := fmt.Sprintf("%s.%s", m.Name, testNamespace)
+	dirName := fmt.Sprintf("%s.%s", m.Name, testOrigin)
 	metaDir := filepath.Join(tempdir, "apps", dirName, m.Version, "meta")
 	if err := os.MkdirAll(metaDir, 0775); err != nil {
 		return "", err
@@ -169,12 +169,12 @@
 	}
 
 	snapFile := makeTestSnapPackage(c, packageYaml+"version: 1.0")
-	n, err := installClick(snapFile, AllowUnauthenticated|AllowOEM, inter, testNamespace)
+	n, err := installClick(snapFile, AllowUnauthenticated|AllowOEM, inter, testOrigin)
 	c.Assert(err, IsNil)
 	c.Assert(n, Equals, "foo")
 
 	snapFile = makeTestSnapPackage(c, packageYaml+"version: 2.0")
-	n, err = installClick(snapFile, AllowUnauthenticated|AllowOEM, inter, testNamespace)
+	n, err = installClick(snapFile, AllowUnauthenticated|AllowOEM, inter, testOrigin)
 	c.Assert(err, IsNil)
 	c.Assert(n, Equals, "foo")
 

=== modified file 'snappy/config.go'
--- snappy/config.go	2015-05-20 09:49:34 +0000
+++ snappy/config.go	2015-05-20 20:14:40 +0000
@@ -36,13 +36,13 @@
 // This string can be empty.
 //
 // It returns the newConfig or an error
-func snapConfig(snapDir, namespace, rawConfig string) (newConfig string, err error) {
+func snapConfig(snapDir, origin, rawConfig string) (newConfig string, err error) {
 	configScript := filepath.Join(snapDir, "meta", "hooks", "config")
 	if _, err := os.Stat(configScript); err != nil {
 		return "", ErrConfigNotFound
 	}
 
-	part, err := NewInstalledSnapPart(filepath.Join(snapDir, "meta", "package.yaml"), namespace)
+	part, err := NewInstalledSnapPart(filepath.Join(snapDir, "meta", "package.yaml"), origin)
 	if err != nil {
 		return "", ErrPackageNotFound
 	}

=== modified file 'snappy/config_test.go'
--- snappy/config_test.go	2015-05-15 13:33:27 +0000
+++ snappy/config_test.go	2015-05-20 20:14:40 +0000
@@ -100,19 +100,19 @@
 type: framework
 version: 42`)
 	c.Assert(err, IsNil)
-	_, err = snapConfig(snapDir, testNamespace, configYaml)
+	_, err = snapConfig(snapDir, testOrigin, configYaml)
 	c.Assert(err, IsNil)
 
 	snapDir, err = s.makeInstalledMockSnapWithConfig(c, mockConfig, `name: potato
 type: potato
 version: 42`)
 	c.Assert(err, IsNil)
-	_, err = snapConfig(snapDir, testNamespace, configYaml)
+	_, err = snapConfig(snapDir, testOrigin, configYaml)
 	c.Assert(err, IsNil)
 
 	c.Check(aas, DeepEquals, []string{
 		"fmk_snappy-config_42",
-		"potato." + testNamespace + "_snappy-config_42",
+		"potato." + testOrigin + "_snappy-config_42",
 	})
 }
 

=== modified file 'snappy/datadir.go'
--- snappy/datadir.go	2015-05-20 09:49:34 +0000
+++ snappy/datadir.go	2015-05-20 20:14:40 +0000
@@ -26,16 +26,16 @@
 
 // A SnapDataDir represents a single data directory for a version of a package
 type SnapDataDir struct {
-	Base      string
-	Name      string
-	Namespace string
-	Version   string
+	Base    string
+	Name    string
+	Origin  string
+	Version string
 }
 
 // QualifiedName returns the filesystem directory name for this SnapDataDir
 func (dd SnapDataDir) QualifiedName() string {
-	if dd.Namespace != "" {
-		return dd.Name + "." + dd.Namespace
+	if dd.Origin != "" {
+		return dd.Name + "." + dd.Origin
 	}
 	return dd.Name
 }
@@ -67,7 +67,7 @@
 
 	// “but, Chipaca”, I hear you say, “why are you doing all this all over
 	// again, when you could just use .Installed() on an appropriate repo,
-	// and getNamespaceFromYaml and all the other lovely tools we already
+	// and getOriginFromYaml and all the other lovely tools we already
 	// have written?”
 	// To which I can only say: DataDirs finds all the data dirs on the
 	// system, not just those of packages that are installed. If you've
@@ -76,13 +76,13 @@
 	for _, dir := range dirs {
 		version := filepath.Base(dir)
 		name := filepath.Base(filepath.Dir(dir))
-		namespace := ""
+		origin := ""
 		idx := strings.LastIndexAny(name, ".")
 		if idx > -1 {
-			namespace = name[idx+1:]
+			origin = name[idx+1:]
 			name = name[:idx]
 		}
-		if filterns && specns != namespace {
+		if filterns && specns != origin {
 			continue
 		}
 		if spec != "" && spec != name {
@@ -90,10 +90,10 @@
 		}
 
 		snaps = append(snaps, SnapDataDir{
-			Base:      basedir,
-			Name:      name,
-			Namespace: namespace,
-			Version:   version,
+			Base:    basedir,
+			Name:    name,
+			Origin:  origin,
+			Version: version,
 		})
 	}
 

=== modified file 'snappy/datadir_test.go'
--- snappy/datadir_test.go	2015-05-20 09:49:34 +0000
+++ snappy/datadir_test.go	2015-05-20 20:14:40 +0000
@@ -39,10 +39,10 @@
 	c.Assert(os.MkdirAll(filepath.Join(snapDataDir, "foo.bar", "v1"), 0755), IsNil)
 	dds := DataDirs("foo")
 	c.Check(dds, DeepEquals, []SnapDataDir{{
-		Base:      snapDataDir,
-		Name:      "foo",
-		Namespace: "bar",
-		Version:   "v1",
+		Base:    snapDataDir,
+		Name:    "foo",
+		Origin:  "bar",
+		Version: "v1",
 	}})
 	c.Check(DataDirs("f"), HasLen, 0)
 	c.Check(DataDirs("foobar"), HasLen, 0)
@@ -55,10 +55,10 @@
 	c.Assert(os.MkdirAll(filepath.Join(snapDataDir, "foo", "v1"), 0755), IsNil)
 	dds := DataDirs("foo")
 	c.Check(dds, DeepEquals, []SnapDataDir{{
-		Base:      snapDataDir,
-		Name:      "foo",
-		Namespace: "",
-		Version:   "v1",
+		Base:    snapDataDir,
+		Name:    "foo",
+		Origin:  "",
+		Version: "v1",
 	}})
 	c.Check(DataDirs("foo=v1"), HasLen, 1)
 }
@@ -68,10 +68,10 @@
 	c.Assert(os.MkdirAll(filepath.Join(home, "foo.bar", "v1"), 0755), IsNil)
 	dds := DataDirs("foo")
 	c.Check(dds, DeepEquals, []SnapDataDir{{
-		Base:      snapDataHomeGlob,
-		Name:      "foo",
-		Namespace: "bar",
-		Version:   "v1",
+		Base:    snapDataHomeGlob,
+		Name:    "foo",
+		Origin:  "bar",
+		Version: "v1",
 	}})
 }
 
@@ -90,32 +90,32 @@
 		hi = 2
 	}
 	c.Check(dds[hi], DeepEquals, SnapDataDir{
-		Base:      snapDataHomeGlob,
-		Name:      "foo",
-		Namespace: "bar",
-		Version:   "v0",
+		Base:    snapDataHomeGlob,
+		Name:    "foo",
+		Origin:  "bar",
+		Version: "v0",
 	})
 	c.Check(dds[hi+1], DeepEquals, SnapDataDir{
-		Base:      snapDataHomeGlob,
-		Name:      "foo",
-		Namespace: "bar",
-		Version:   "v1",
+		Base:    snapDataHomeGlob,
+		Name:    "foo",
+		Origin:  "bar",
+		Version: "v1",
 	})
 	c.Check(dds[si], DeepEquals, SnapDataDir{
-		Base:      snapDataDir,
-		Name:      "foo",
-		Namespace: "",
-		Version:   "v3",
+		Base:    snapDataDir,
+		Name:    "foo",
+		Origin:  "",
+		Version: "v3",
 	})
 	c.Check(dds[si+1], DeepEquals, SnapDataDir{
-		Base:      snapDataDir,
-		Name:      "foo",
-		Namespace: "xyzzy",
-		Version:   "v1",
+		Base:    snapDataDir,
+		Name:    "foo",
+		Origin:  "xyzzy",
+		Version: "v1",
 	})
 }
 
 func (s *DataDirSuite) TestDataDirQualifiedName(c *C) {
-	c.Check(SnapDataDir{Name: "foo", Namespace: "bar"}.QualifiedName(), Equals, "foo.bar")
+	c.Check(SnapDataDir{Name: "foo", Origin: "bar"}.QualifiedName(), Equals, "foo.bar")
 	c.Check(SnapDataDir{Name: "foo"}.QualifiedName(), Equals, "foo")
 }

=== modified file 'snappy/errors.go'
--- snappy/errors.go	2015-05-19 17:32:01 +0000
+++ snappy/errors.go	2015-05-20 20:14:40 +0000
@@ -134,8 +134,8 @@
 	ErrSideLoaded = errors.New("cannot update system that uses custom enablement")
 
 	// ErrPackageNameNotSupported is returned when installing legacy package such as those
-	// that have namespaces in their package names.
-	ErrPackageNameNotSupported = errors.New("package name with namespace not supported")
+	// that have the origin specified in their package names.
+	ErrPackageNameNotSupported = errors.New("package name with origin not supported")
 
 	// ErrInvalidPart is returned when something on the filesystem does not make sense
 	ErrInvalidPart = errors.New("invalid package on system")

=== modified file 'snappy/install.go'
--- snappy/install.go	2015-05-20 09:49:34 +0000
+++ snappy/install.go	2015-05-20 20:14:40 +0000
@@ -91,7 +91,7 @@
 			flags |= AllowUnauthenticated
 		}
 
-		return installClick(name, flags, meter, sideloadedNamespace)
+		return installClick(name, flags, meter, sideloadedOrigin)
 	}
 
 	// check repos next

=== modified file 'snappy/parts.go'
--- snappy/parts.go	2015-05-20 09:49:34 +0000
+++ snappy/parts.go	2015-05-20 20:14:40 +0000
@@ -44,12 +44,12 @@
 }
 
 // QualifiedName of a Part is the Name, in most cases qualified with the
-// Namespace
+// Origin
 func QualifiedName(p Part) string {
 	if t := p.Type(); t == pkg.TypeFramework || t == pkg.TypeOem {
 		return p.Name()
 	}
-	return p.Name() + "." + p.Namespace()
+	return p.Name() + "." + p.Origin()
 }
 
 // Part representation of a snappy part
@@ -59,7 +59,7 @@
 	Name() string
 	Version() string
 	Description() string
-	Namespace() string
+	Origin() string
 	Vendor() string
 
 	Hash() string
@@ -260,11 +260,11 @@
 // FindSnapsByName returns all snaps with the given name in the "haystack"
 // slice of parts (useful for filtering)
 func FindSnapsByName(needle string, haystack []Part) (res []Part) {
-	name, namespace := splitNamespace(needle)
-	ignorens := namespace == ""
+	name, origin := splitOrigin(needle)
+	ignorens := origin == ""
 
 	for _, part := range haystack {
-		if part.Name() == name && (ignorens || part.Namespace() == namespace) {
+		if part.Name() == name && (ignorens || part.Origin() == origin) {
 			res = append(res, part)
 		}
 	}
@@ -272,7 +272,7 @@
 	return res
 }
 
-func splitNamespace(name string) (string, string) {
+func splitOrigin(name string) (string, string) {
 	idx := strings.LastIndexAny(name, ".")
 	if idx > -1 {
 		return name[:idx], name[idx+1:]
@@ -284,12 +284,12 @@
 // FindSnapsByNameAndVersion returns the parts with the name/version in the
 // given slice of parts
 func FindSnapsByNameAndVersion(needle, version string, haystack []Part) []Part {
-	name, namespace := splitNamespace(needle)
-	ignorens := namespace == ""
+	name, origin := splitOrigin(needle)
+	ignorens := origin == ""
 	var found []Part
 
 	for _, part := range haystack {
-		if part.Name() == name && part.Version() == version && (ignorens || part.Namespace() == namespace) {
+		if part.Name() == name && part.Version() == version && (ignorens || part.Origin() == origin) {
 			found = append(found, part)
 		}
 	}

=== modified file 'snappy/parts_test.go'
--- snappy/parts_test.go	2015-05-19 17:32:01 +0000
+++ snappy/parts_test.go	2015-05-20 20:14:40 +0000
@@ -68,7 +68,7 @@
 	c.Assert(err, IsNil)
 	c.Assert(parts, HasLen, 1)
 	c.Assert(parts[0].Name(), Equals, "hello-app")
-	c.Assert(parts[0].Namespace(), Equals, testNamespace)
+	c.Assert(parts[0].Origin(), Equals, testOrigin)
 }
 
 func (s *SnapTestSuite) TestFindSnapsByNameNotAvailable(c *C) {
@@ -93,19 +93,19 @@
 	c.Assert(parts[0].Name(), Equals, "hello-app")
 }
 
-func (s *SnapTestSuite) TestFindSnapsByNameWithNamespace(c *C) {
+func (s *SnapTestSuite) TestFindSnapsByNameWithOrigin(c *C) {
 	_, err := makeInstalledMockSnap(s.tempdir, "")
 	repo := NewLocalSnapRepository(snapAppsDir)
 	installed, err := repo.Installed()
 	c.Assert(err, IsNil)
 	c.Assert(installed, HasLen, 1)
 
-	parts := FindSnapsByName("hello-app."+testNamespace, installed)
+	parts := FindSnapsByName("hello-app."+testOrigin, installed)
 	c.Assert(parts, HasLen, 1)
 	c.Assert(parts[0].Name(), Equals, "hello-app")
 }
 
-func (s *SnapTestSuite) TestFindSnapsByNameWithNamespaceNotThere(c *C) {
+func (s *SnapTestSuite) TestFindSnapsByNameWithOriginNotThere(c *C) {
 	_, err := makeInstalledMockSnap(s.tempdir, "")
 	repo := NewLocalSnapRepository(snapAppsDir)
 	installed, err := repo.Installed()
@@ -140,13 +140,13 @@
 	installed, err := repo.Installed()
 	c.Assert(err, IsNil)
 
-	parts := FindSnapsByNameAndVersion("hello-app."+testNamespace, "1.10", installed)
+	parts := FindSnapsByNameAndVersion("hello-app."+testOrigin, "1.10", installed)
 	c.Check(parts, HasLen, 1)
-	parts = FindSnapsByNameAndVersion("bad-app."+testNamespace, "1.10", installed)
-	c.Check(parts, HasLen, 0)
-	parts = FindSnapsByNameAndVersion("hello-app.badNamespace", "1.10", installed)
-	c.Check(parts, HasLen, 0)
-	parts = FindSnapsByNameAndVersion("hello-app."+testNamespace, "2.20", installed)
+	parts = FindSnapsByNameAndVersion("bad-app."+testOrigin, "1.10", installed)
+	c.Check(parts, HasLen, 0)
+	parts = FindSnapsByNameAndVersion("hello-app.badOrigin", "1.10", installed)
+	c.Check(parts, HasLen, 0)
+	parts = FindSnapsByNameAndVersion("hello-app."+testOrigin, "2.20", installed)
 	c.Check(parts, HasLen, 0)
 
 	parts = FindSnapsByNameAndVersion("hello-app", "1.10", installed)
@@ -163,9 +163,9 @@
 	installed, err := repo.Installed()
 	c.Assert(err, IsNil)
 
-	parts := FindSnapsByNameAndVersion("fmk."+testNamespace, "1", installed)
+	parts := FindSnapsByNameAndVersion("fmk."+testOrigin, "1", installed)
 	c.Check(parts, HasLen, 0)
-	parts = FindSnapsByNameAndVersion("fmk.badNamespace", "1", installed)
+	parts = FindSnapsByNameAndVersion("fmk.badOrigin", "1", installed)
 	c.Check(parts, HasLen, 0)
 
 	parts = FindSnapsByNameAndVersion("fmk", "1", installed)

=== modified file 'snappy/purge.go'
--- snappy/purge.go	2015-05-20 09:49:34 +0000
+++ snappy/purge.go	2015-05-20 20:14:40 +0000
@@ -37,7 +37,7 @@
 
 var remove = removeSnapData
 
-// Purge a part by a partSpec string, name[.namespace][=version]
+// Purge a part by a partSpec string, name[.origin][=version]
 func Purge(partSpec string, flags PurgeFlags, meter progress.Meter) error {
 	var e error
 	datadirs := DataDirs(partSpec)
@@ -51,7 +51,7 @@
 
 	for _, datadir := range datadirs {
 		yamlPath := filepath.Join(snapAppsDir, datadir.QualifiedName(), datadir.Version, "meta", "package.yaml")
-		part, err := NewInstalledSnapPart(yamlPath, datadir.Namespace)
+		part, err := NewInstalledSnapPart(yamlPath, datadir.Origin)
 		if err != nil {
 			// no such part installed
 			continue

=== modified file 'snappy/purge_test.go'
--- snappy/purge_test.go	2015-05-15 13:33:27 +0000
+++ snappy/purge_test.go	2015-05-20 20:14:40 +0000
@@ -70,7 +70,7 @@
 	default:
 		panic("dunno what to do with args")
 	}
-	app := "hello-app." + testNamespace
+	app := "hello-app." + testOrigin
 	yaml := "name: hello-app\nversion: " + version + "\n" + extra
 	yamlFile, err := makeInstalledMockSnap(s.tempdir, yaml)
 	c.Assert(err, IsNil)

=== modified file 'snappy/remove.go'
--- snappy/remove.go	2015-05-19 14:09:19 +0000
+++ snappy/remove.go	2015-05-20 20:14:40 +0000
@@ -34,7 +34,7 @@
 	DoRemoveGC RemoveFlags = 1 << iota
 )
 
-// Remove a part by a partSpec string, name[.namespace][=version]
+// Remove a part by a partSpec string, name[.origin][=version]
 func Remove(partSpec string, flags RemoveFlags, meter progress.Meter) error {
 	var parts BySnapVersion
 

=== modified file 'snappy/security.go'
--- snappy/security.go	2015-05-19 17:32:01 +0000
+++ snappy/security.go	2015-05-20 20:14:40 +0000
@@ -136,9 +136,9 @@
 		return fmt.Sprintf("%s_%s_%s", m.Name, cleanedName, m.Version), nil
 	}
 
-	namespace, err := namespaceFromYamlPath(filepath.Join(baseDir, "meta", "package.yaml"))
+	origin, err := originFromYamlPath(filepath.Join(baseDir, "meta", "package.yaml"))
 
-	return fmt.Sprintf("%s.%s_%s_%s", m.Name, namespace, cleanedName, m.Version), err
+	return fmt.Sprintf("%s.%s_%s_%s", m.Name, origin, cleanedName, m.Version), err
 }
 
 var runScFilterGen = runScFilterGenImpl

=== modified file 'snappy/snapp.go'
--- snappy/snapp.go	2015-05-20 09:49:34 +0000
+++ snappy/snapp.go	2015-05-20 20:14:40 +0000
@@ -49,8 +49,8 @@
 )
 
 const (
-	// the namespace for sideloaded snaps
-	sideloadedNamespace = "sideload"
+	// the origin for sideloaded snaps
+	sideloadedOrigin = "sideload"
 )
 
 // SharedName is a structure that holds an Alias to the preferred package and
@@ -63,11 +63,11 @@
 // SharedNames is a list of all packages and it's SharedName structure.
 type SharedNames map[string]*SharedName
 
-// IsAlias determines if namespace is the one that is an alias for the
+// IsAlias determines if origin is the one that is an alias for the
 // shared name.
-func (f *SharedName) IsAlias(namespace string) bool {
+func (f *SharedName) IsAlias(origin string) bool {
 	if alias := f.Alias; alias != nil {
-		return alias.Namespace() == namespace
+		return alias.Origin() == origin
 	}
 
 	return false
@@ -165,7 +165,7 @@
 // SnapPart represents a generic snap type
 type SnapPart struct {
 	m           *packageYaml
-	namespace   string
+	origin      string
 	hash        string
 	isActive    bool
 	isInstalled bool
@@ -237,7 +237,7 @@
 	IconURL         string             `json:"icon_url"`
 	LastUpdated     string             `json:"last_updated,omitempty"`
 	Name            string             `json:"package_name"`
-	Namespace       string             `json:"origin"`
+	Origin          string             `json:"origin"`
 	Prices          map[string]float64 `json:"prices,omitempty"`
 	Publisher       string             `json:"publisher,omitempty"`
 	RatingsAverage  float64            `json:"ratings_average,omitempty"`
@@ -279,7 +279,7 @@
 	}
 
 	// this is to prevent installation of legacy packages such as those that
-	// contain the namespace/origin in the package name.
+	// contain the origin/origin in the package name.
 	if strings.ContainsRune(m.Name, '.') {
 		return nil, ErrPackageNameNotSupported
 	}
@@ -326,11 +326,11 @@
 	return &m, nil
 }
 
-func (m *packageYaml) qualifiedName(namespace string) string {
+func (m *packageYaml) qualifiedName(origin string) string {
 	if m.Type == pkg.TypeFramework || m.Type == pkg.TypeOem {
 		return m.Name
 	}
-	return m.Name + "." + namespace
+	return m.Name + "." + origin
 }
 
 func (m *packageYaml) checkForNameClashes() error {
@@ -347,14 +347,14 @@
 	return nil
 }
 
-func (m *packageYaml) checkForPackageInstalled(namespace string) error {
+func (m *packageYaml) checkForPackageInstalled(origin string) error {
 	part := ActiveSnapByName(m.Name)
 	if part == nil {
 		return nil
 	}
 
 	if m.Type != pkg.TypeFramework && m.Type != pkg.TypeOem {
-		if part.Namespace() != namespace {
+		if part.Origin() != origin {
 			return ErrPackageNameAlreadyInstalled
 		}
 	}
@@ -446,13 +446,13 @@
 }
 
 // NewInstalledSnapPart returns a new SnapPart from the given yamlPath
-func NewInstalledSnapPart(yamlPath, namespace string) (*SnapPart, error) {
+func NewInstalledSnapPart(yamlPath, origin string) (*SnapPart, error) {
 	m, err := parsePackageYamlFile(yamlPath)
 	if err != nil {
 		return nil, err
 	}
 
-	part, err := NewSnapPartFromYaml(yamlPath, namespace, m)
+	part, err := NewSnapPartFromYaml(yamlPath, origin, m)
 	if err != nil {
 		return nil, err
 	}
@@ -461,7 +461,7 @@
 }
 
 // NewSnapPartFromYaml returns a new SnapPart from the given *packageYaml at yamlPath
-func NewSnapPartFromYaml(yamlPath, namespace string, m *packageYaml) (*SnapPart, error) {
+func NewSnapPartFromYaml(yamlPath, origin string, m *packageYaml) (*SnapPart, error) {
 	if _, err := os.Stat(yamlPath); err != nil {
 		return nil, err
 	}
@@ -469,7 +469,7 @@
 	part := &SnapPart{
 		basedir:     filepath.Dir(filepath.Dir(yamlPath)),
 		isInstalled: true,
-		namespace:   namespace,
+		origin:      origin,
 		m:           m,
 	}
 
@@ -531,9 +531,9 @@
 	return s.description
 }
 
-// Namespace returns the namespace
-func (s *SnapPart) Namespace() string {
-	return s.namespace
+// Origin returns the origin
+func (s *SnapPart) Origin() string {
+	return s.origin
 }
 
 // Vendor returns the author. Or viceversa.
@@ -649,7 +649,7 @@
 
 // Config is used to to configure the snap
 func (s *SnapPart) Config(configuration []byte) (new string, err error) {
-	return snapConfig(s.basedir, s.namespace, string(configuration))
+	return snapConfig(s.basedir, s.origin, string(configuration))
 }
 
 // NeedsReboot returns true if the snap becomes active on the next reboot
@@ -798,7 +798,7 @@
 
 // Details returns details for the given snap
 func (s *SnapLocalRepository) Details(name string) (versions []Part, err error) {
-	// XXX: this is broken wrt namespaceless packages (e.g. frameworks)
+	// XXX: this is broken wrt origin packages (e.g. frameworks)
 	if !strings.ContainsRune(name, '.') {
 		name += ".*"
 	}
@@ -845,15 +845,15 @@
 			return nil, err
 		}
 
-		namespace := ""
+		origin := ""
 		if m.Type != pkg.TypeFramework && m.Type != pkg.TypeOem {
-			namespace, err = namespaceFromYamlPath(realpath)
+			origin, err = originFromYamlPath(realpath)
 			if err != nil {
 				return nil, err
 			}
 		}
 
-		snap, err := NewSnapPartFromYaml(realpath, namespace, m)
+		snap, err := NewSnapPartFromYaml(realpath, origin, m)
 		if err != nil {
 			return nil, err
 		}
@@ -864,7 +864,7 @@
 	return parts, nil
 }
 
-func namespaceFromBasedir(basedir string) (s string) {
+func originFromBasedir(basedir string) (s string) {
 	ext := filepath.Ext(filepath.Dir(filepath.Clean(basedir)))
 	if len(ext) < 2 {
 		return ""
@@ -873,14 +873,14 @@
 	return ext[1:]
 }
 
-func namespaceFromYamlPath(path string) (string, error) {
-	namespace := namespaceFromBasedir(filepath.Join(path, "..", ".."))
+func originFromYamlPath(path string) (string, error) {
+	origin := originFromBasedir(filepath.Join(path, "..", ".."))
 
-	if namespace == "" {
+	if origin == "" {
 		return "", ErrInvalidPart
 	}
 
-	return namespace, nil
+	return origin, nil
 }
 
 // RemoteSnapPart represents a snap available on the server
@@ -908,9 +908,9 @@
 	return s.pkg.Title
 }
 
-// Namespace is the origin
-func (s *RemoteSnapPart) Namespace() string {
-	return s.pkg.Namespace
+// Origin is the origin
+func (s *RemoteSnapPart) Origin() string {
+	return s.pkg.Origin
 }
 
 // Vendor is the publisher. Author. Whatever.
@@ -1031,7 +1031,7 @@
 	}
 	defer os.Remove(downloadedSnap)
 
-	return installClick(downloadedSnap, flags, pbar, s.Namespace())
+	return installClick(downloadedSnap, flags, pbar, s.Origin())
 }
 
 // SetActive sets the snap active
@@ -1313,7 +1313,7 @@
 	snapDataDir := filepath.Join(snapDataDir, part.Name(), part.Version())
 	snapEnv := map[string]string{
 		"SNAP_NAME":          part.Name(),
-		"SNAP_ORIGIN":        part.Namespace(),
+		"SNAP_ORIGIN":        part.Origin(),
 		"SNAP_FULLNAME":      QualifiedName(part),
 		"SNAP_VERSION":       part.Version(),
 		"SNAP_APP_PATH":      part.basedir,

=== modified file 'snappy/snapp_test.go'
--- snappy/snapp_test.go	2015-05-20 09:49:34 +0000
+++ snappy/snapp_test.go	2015-05-20 20:14:40 +0000
@@ -138,7 +138,7 @@
 	snapYaml, err := s.makeInstalledMockSnap()
 	c.Assert(err, IsNil)
 
-	snap, err := NewInstalledSnapPart(snapYaml, testNamespace)
+	snap, err := NewInstalledSnapPart(snapYaml, testOrigin)
 	c.Assert(err, IsNil)
 	c.Assert(snap, NotNil)
 	c.Check(snap.Name(), Equals, "hello-app")
@@ -167,7 +167,7 @@
 	err = ioutil.WriteFile(hashesFile, []byte("archive-sha512: F00F00"), 0644)
 	c.Assert(err, IsNil)
 
-	snap, err := NewInstalledSnapPart(snapYaml, testNamespace)
+	snap, err := NewInstalledSnapPart(snapYaml, testOrigin)
 	c.Assert(err, IsNil)
 	c.Assert(snap.Hash(), Equals, "F00F00")
 }
@@ -177,7 +177,7 @@
 	c.Assert(err, IsNil)
 	makeSnapActive(snapYaml)
 
-	snap, err := NewInstalledSnapPart(snapYaml, testNamespace)
+	snap, err := NewInstalledSnapPart(snapYaml, testOrigin)
 	c.Assert(err, IsNil)
 	c.Assert(snap.IsActive(), Equals, true)
 }
@@ -191,7 +191,7 @@
 `)
 	c.Assert(err, IsNil)
 
-	snap, err := NewInstalledSnapPart(snapYaml, testNamespace)
+	snap, err := NewInstalledSnapPart(snapYaml, testOrigin)
 	c.Assert(err, IsNil)
 	fmk, err := snap.Frameworks()
 	c.Assert(err, IsNil)
@@ -467,7 +467,7 @@
 	parts := results[funkyAppName].Parts
 	c.Assert(parts, HasLen, 1)
 	c.Check(parts[0].Name(), Equals, funkyAppName)
-	c.Check(parts[0].Namespace(), Equals, funkyAppOrigin)
+	c.Check(parts[0].Origin(), Equals, funkyAppOrigin)
 	c.Check(parts[0].Vendor(), Equals, funkyAppVendor)
 	c.Check(parts[0].Version(), Equals, "42")
 	c.Check(parts[0].Description(), Equals, "Returns for store credit only.")
@@ -497,8 +497,8 @@
 	c.Assert(parts, HasLen, 2)
 	c.Check(parts[0].Name(), Equals, "hello-world")
 	c.Check(parts[1].Name(), Equals, "hello-world")
-	c.Check(parts[0].Namespace(), Equals, "canonical")
-	c.Check(parts[1].Namespace(), Equals, "jdstrand")
+	c.Check(parts[0].Origin(), Equals, "canonical")
+	c.Check(parts[1].Origin(), Equals, "jdstrand")
 	c.Check(parts[0].Vendor(), Equals, "Canonical")
 	c.Check(parts[1].Vendor(), Equals, "Jamie Strandboge")
 	c.Check(parts[0].Version(), Equals, "1.0.8")
@@ -598,7 +598,7 @@
 	c.Assert(err, IsNil)
 	c.Assert(results, HasLen, 1)
 	c.Check(results[0].Name(), Equals, funkyAppName)
-	c.Check(results[0].Namespace(), Equals, funkyAppOrigin)
+	c.Check(results[0].Origin(), Equals, funkyAppOrigin)
 	c.Check(results[0].Vendor(), Equals, funkyAppVendor)
 	c.Check(results[0].Version(), Equals, "42")
 	c.Check(results[0].Hash(), Equals, "5364253e4a988f4f5c04380086d542f410455b97d48cc6c69ca2a5877d8aef2a6b2b2f83ec4f688cae61ebc8a6bf2cdbd4dbd8f743f0522fc76540429b79df42")
@@ -692,7 +692,7 @@
 
 	snap := RemoteSnapPart{}
 	snap.pkg.AnonDownloadURL = mockServer.URL + "/snap"
-	snap.pkg.Namespace = testNamespace
+	snap.pkg.Origin = testOrigin
 
 	p := &MockProgressMeter{}
 	name, err := snap.Install(p, 0)
@@ -738,12 +738,12 @@
 	yamlFile, err := makeInstalledMockSnap(s.tempdir, packageHello)
 	c.Assert(err, IsNil)
 
-	snap, err := NewInstalledSnapPart(yamlFile, testNamespace)
+	snap, err := NewInstalledSnapPart(yamlFile, testOrigin)
 	c.Assert(err, IsNil)
 	c.Assert(snap, NotNil)
 
 	c.Assert(snap.Name(), Equals, "hello-app")
-	c.Assert(snap.Namespace(), Equals, testNamespace)
+	c.Assert(snap.Origin(), Equals, testOrigin)
 	c.Assert(snap.Vendor(), Equals, "Michael Vogt")
 	c.Assert(snap.Version(), Equals, "1.10")
 	c.Assert(snap.IsActive(), Equals, false)
@@ -1018,7 +1018,7 @@
 	c.Check(yaml.checkForPackageInstalled("otherns"), Equals, ErrPackageNameAlreadyInstalled)
 }
 
-func (s *SnapTestSuite) TestIgnoresAlreadyInstalledSameNamespace(c *C) {
+func (s *SnapTestSuite) TestIgnoresAlreadyInstalledSameOrigin(c *C) {
 	// XXX: should this be allowed? right now it is (=> you can re-sideload the same version of your apps)
 	//      (remote snaps are stopped before clickInstall gets to run)
 
@@ -1029,7 +1029,7 @@
 
 	yaml, err := parsePackageYamlData([]byte(data))
 	c.Assert(err, IsNil)
-	c.Check(yaml.checkForPackageInstalled(testNamespace), IsNil)
+	c.Check(yaml.checkForPackageInstalled(testOrigin), IsNil)
 }
 
 func (s *SnapTestSuite) TestIgnoresAlreadyInstalledFrameworks(c *C) {
@@ -1101,7 +1101,7 @@
 	}()
 	touched := []string{}
 	snapAppArmorDir = c.MkDir()
-	fn := filepath.Join(snapAppArmorDir, "foo."+testNamespace+"_hello_1.0.json")
+	fn := filepath.Join(snapAppArmorDir, "foo."+testOrigin+"_hello_1.0.json")
 	c.Assert(os.Symlink(fn, fn), IsNil)
 	timestampUpdater = func(s string) error {
 		touched = append(touched, s)
@@ -1136,7 +1136,7 @@
 
 	pb := &MockProgressMeter{}
 	m, err := parsePackageYamlData([]byte(yaml))
-	part := &SnapPart{m: m, namespace: testNamespace, basedir: d1}
+	part := &SnapPart{m: m, origin: testOrigin, basedir: d1}
 	c.Assert(part.RefreshDependentsSecurity(d2, pb), IsNil)
 	c.Check(touched, DeepEquals, []string{fn})
 }
@@ -1155,7 +1155,7 @@
 `)
 	c.Assert(err, IsNil)
 
-	part := &SnapPart{m: yaml, namespace: testNamespace}
+	part := &SnapPart{m: yaml, origin: testOrigin}
 	err = part.Uninstall(new(MockProgressMeter))
 	c.Check(err, ErrorMatches, `framework still in use by: foo`)
 }
@@ -1205,11 +1205,11 @@
 	defer func() { timestampUpdater = helpers.UpdateTimestamp }()
 	// if one of the services needs updating, it's updated and returned
 	svc := Service{Name: "svc", SecurityDefinitions: SecurityDefinitions{SecurityTemplate: "foo"}}
-	part := &SnapPart{m: &packageYaml{Name: "part", Services: []Service{svc}, Version: "42"}, namespace: testNamespace}
+	part := &SnapPart{m: &packageYaml{Name: "part", Services: []Service{svc}, Version: "42"}, origin: testOrigin}
 	err := part.RequestAppArmorUpdate(nil, map[string]bool{"foo": true})
 	c.Assert(err, IsNil)
 	c.Assert(updated, HasLen, 1)
-	c.Check(filepath.Base(updated[0]), Equals, "part."+testNamespace+"_svc_42.json")
+	c.Check(filepath.Base(updated[0]), Equals, "part."+testOrigin+"_svc_42.json")
 }
 
 func (s *SnapTestSuite) TestRequestAppArmorUpdateBinary(c *C) {
@@ -1221,11 +1221,11 @@
 	defer func() { timestampUpdater = helpers.UpdateTimestamp }()
 	// if one of the binaries needs updating, the part needs updating
 	bin := Binary{Name: "echo", SecurityDefinitions: SecurityDefinitions{SecurityTemplate: "foo"}}
-	part := &SnapPart{m: &packageYaml{Name: "part", Binaries: []Binary{bin}, Version: "42"}, namespace: testNamespace}
+	part := &SnapPart{m: &packageYaml{Name: "part", Binaries: []Binary{bin}, Version: "42"}, origin: testOrigin}
 	err := part.RequestAppArmorUpdate(nil, map[string]bool{"foo": true})
 	c.Assert(err, IsNil)
 	c.Assert(updated, HasLen, 1)
-	c.Check(filepath.Base(updated[0]), Equals, "part."+testNamespace+"_echo_42.json")
+	c.Check(filepath.Base(updated[0]), Equals, "part."+testOrigin+"_echo_42.json")
 }
 
 func (s *SnapTestSuite) TestRequestAppArmorUpdateNothing(c *C) {
@@ -1237,7 +1237,7 @@
 	defer func() { timestampUpdater = helpers.UpdateTimestamp }()
 	svc := Service{Name: "svc", SecurityDefinitions: SecurityDefinitions{SecurityTemplate: "foo"}}
 	bin := Binary{Name: "echo", SecurityDefinitions: SecurityDefinitions{SecurityTemplate: "foo"}}
-	part := &SnapPart{m: &packageYaml{Services: []Service{svc}, Binaries: []Binary{bin}, Version: "42"}, namespace: testNamespace}
+	part := &SnapPart{m: &packageYaml{Services: []Service{svc}, Binaries: []Binary{bin}, Version: "42"}, origin: testOrigin}
 	err := part.RequestAppArmorUpdate(nil, nil)
 	c.Check(err, IsNil)
 	c.Check(updated, HasLen, 0)
@@ -1263,16 +1263,16 @@
 	c.Assert(err, NotNil)
 }
 
-func (s *SnapTestSuite) TestNamespaceFromPath(c *C) {
-	n, err := namespaceFromYamlPath("/oem/foo.bar/1.0/meta/package.yaml")
+func (s *SnapTestSuite) TestOriginFromPath(c *C) {
+	n, err := originFromYamlPath("/oem/foo.bar/1.0/meta/package.yaml")
 	c.Check(err, IsNil)
 	c.Check(n, Equals, "bar")
 
-	n, err = namespaceFromYamlPath("/oem/foo_bar/1.0/meta/package.yaml")
+	n, err = originFromYamlPath("/oem/foo_bar/1.0/meta/package.yaml")
 	c.Check(err, NotNil)
 	c.Check(n, Equals, "")
 
-	n, err = namespaceFromYamlPath("/oo_bar/1.0/mpackage.yaml")
+	n, err = originFromYamlPath("/oo_bar/1.0/mpackage.yaml")
 	c.Check(err, NotNil)
 	c.Check(n, Equals, "")
 }
@@ -1293,7 +1293,7 @@
 	c.Assert(getStructFields(t{}), DeepEquals, []string{"hello"})
 }
 
-func (s *SnapTestSuite) TestIllegalPackageNameWithNamespace(c *C) {
+func (s *SnapTestSuite) TestIllegalPackageNameWithOrigin(c *C) {
 	_, err := parsePackageYamlData([]byte(`name: foo.something
 `))
 

=== modified file 'snappy/systemimage.go'
--- snappy/systemimage.go	2015-05-19 17:32:01 +0000
+++ snappy/systemimage.go	2015-05-20 20:14:40 +0000
@@ -39,9 +39,9 @@
 )
 
 const (
-	systemImagePartName      = "ubuntu-core"
-	systemImagePartNamespace = "ubuntu"
-	systemImagePartVendor    = "Canonical Ltd."
+	systemImagePartName   = "ubuntu-core"
+	systemImagePartOrigin = "ubuntu"
+	systemImagePartVendor = "Canonical Ltd."
 
 	// location of the channel config on the filesystem.
 	//
@@ -107,9 +107,9 @@
 	return systemImagePartName
 }
 
-// Namespace returns the namespace ("ubuntu")
-func (s *SystemImagePart) Namespace() string {
-	return systemImagePartNamespace
+// Origin returns the origin ("ubuntu")
+func (s *SystemImagePart) Origin() string {
+	return systemImagePartOrigin
 }
 
 // Vendor returns the vendor ("Canonical Ltd.")

=== modified file 'snappy/systemimage_test.go'
--- snappy/systemimage_test.go	2015-05-15 13:33:27 +0000
+++ snappy/systemimage_test.go	2015-05-20 20:14:40 +0000
@@ -114,7 +114,7 @@
 	// we have one active and one inactive
 	c.Assert(parts, HasLen, 2)
 	c.Assert(parts[0].Name(), Equals, systemImagePartName)
-	c.Assert(parts[0].Namespace(), Equals, systemImagePartNamespace)
+	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")
@@ -353,12 +353,12 @@
 	c.Check(fmks, HasLen, 0)
 }
 
-func (s *SITestSuite) TestNamespace(c *C) {
+func (s *SITestSuite) TestOrigin(c *C) {
 	parts, err := s.systemImage.Installed()
 	c.Assert(err, IsNil)
 	c.Assert(parts, HasLen, 2)
-	c.Assert(parts[0].Namespace(), Equals, systemImagePartNamespace)
-	c.Assert(parts[1].Namespace(), Equals, systemImagePartNamespace)
+	c.Assert(parts[0].Origin(), Equals, systemImagePartOrigin)
+	c.Assert(parts[1].Origin(), Equals, systemImagePartOrigin)
 }
 
 func (s *SITestSuite) TestCannotUpdateIfSideLoaded(c *C) {

=== modified file 'systemd/systemd.go'
--- systemd/systemd.go	2015-05-19 14:09:19 +0000
+++ systemd/systemd.go	2015-05-20 20:14:40 +0000
@@ -181,7 +181,7 @@
 [Service]
 ExecStart=/usr/bin/ubuntu-core-launcher {{.UdevAppName}} {{.AaProfile}} {{.FullPathStart}}
 WorkingDirectory={{.AppPath}}
-Environment="SNAPP_APP_PATH={{.AppPath}}" "SNAPP_APP_DATA_PATH=/var/lib{{.AppPath}}" "SNAPP_APP_USER_DATA_PATH=%h{{.AppPath}}" "SNAP_APP_PATH={{.AppPath}}" "SNAP_APP_DATA_PATH=/var/lib{{.AppPath}}" "SNAP_APP_USER_DATA_PATH=%h{{.AppPath}}" "SNAP_APP={{.AppTriple}}" "TMPDIR=/tmp/snaps/{{.UdevAppName}}/{{.Version}}/tmp" "SNAP_APP_TMPDIR=/tmp/snaps/{{.UdevAppName}}/{{.Version}}/tmp" "SNAP_NAME={{.AppName}}" "SNAP_ORIGIN={{.Namespace}}" "SNAP_FULLNAME={{.UdevAppName}}"
+Environment="SNAPP_APP_PATH={{.AppPath}}" "SNAPP_APP_DATA_PATH=/var/lib{{.AppPath}}" "SNAPP_APP_USER_DATA_PATH=%h{{.AppPath}}" "SNAP_APP_PATH={{.AppPath}}" "SNAP_APP_DATA_PATH=/var/lib{{.AppPath}}" "SNAP_APP_USER_DATA_PATH=%h{{.AppPath}}" "SNAP_APP={{.AppTriple}}" "TMPDIR=/tmp/snaps/{{.UdevAppName}}/{{.Version}}/tmp" "SNAP_APP_TMPDIR=/tmp/snaps/{{.UdevAppName}}/{{.Version}}/tmp" "SNAP_NAME={{.AppName}}" "SNAP_ORIGIN={{.Origin}}" "SNAP_FULLNAME={{.UdevAppName}}"
 {{if .Stop}}ExecStop=/usr/bin/ubuntu-core-launcher {{.UdevAppName}} {{.AaProfile}} {{.FullPathStop}}{{end}}
 {{if .PostStop}}ExecStopPost=/usr/bin/ubuntu-core-launcher {{.UdevAppName}} {{.AaProfile}} {{.FullPathPostStop}}{{end}}
 {{if .StopTimeout}}TimeoutStopSec={{.StopTimeout.Seconds}}{{end}}
@@ -193,9 +193,9 @@
 `
 	var templateOut bytes.Buffer
 	t := template.Must(template.New("wrapper").Parse(serviceTemplate))
-	namespace := ""
+	origin := ""
 	if len(desc.UdevAppName) > len(desc.AppName) {
-		namespace = desc.UdevAppName[len(desc.AppName)+1:]
+		origin = desc.UdevAppName[len(desc.AppName)+1:]
 	}
 	wrapperData := struct {
 		// the service description
@@ -206,7 +206,7 @@
 		FullPathPostStop     string
 		AppTriple            string
 		ServiceSystemdTarget string
-		Namespace            string
+		Origin               string
 	}{
 		*desc,
 		filepath.Join(desc.AppPath, desc.Start),
@@ -214,7 +214,7 @@
 		filepath.Join(desc.AppPath, desc.PostStop),
 		fmt.Sprintf("%s_%s_%s", desc.AppName, desc.ServiceName, desc.Version),
 		servicesSystemdTarget,
-		namespace,
+		origin,
 	}
 	if err := t.Execute(&templateOut, wrapperData); err != nil {
 		// this can never happen, except we forget a variable