Merge lp:~allenap/juju-core/break-out-juju-store into lp:~juju/juju-core/trunk

[Gavin Panella]

Break out store and cmd/charm* into lp:juju-store

Red Squad are going to be working on the charm store, and it was
suggested that an early task would be to split the charm store out
into a separate project. That work has already been done - see
lp:juju-store - and this is the clean-up job.

mgz helped me a lot in doing both these tasks.

Fwiw, juju-store has not been advertised, so feel free to suggest a
different name.

https://codereview.appspot.com/7058063/

[Gavin Panella (allenap)]

Reviewers: mp+142564_code.launchpad.net,

Message:
Please take a look.

Description:
Break out store and cmd/charm* into lp:juju-store

Red Squad are going to be working on the charm store, and it was
suggested that an early task would be to split the charm store out
into a separate project. That work has already been done - see
lp:juju-store - and this is the clean-up job.

mgz helped me a lot in doing both these tasks.

Fwiw, juju-store has not been advertised, so feel free to suggest a
different name.

https://code.launchpad.net/~allenap/juju-core/break-out-juju-store/+merge/142564

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/7058063/

Affected files:
   A [revision details]
   D cmd/charmd/config.yaml
   D cmd/charmd/main.go
   D cmd/charmload/config.yaml
   D cmd/charmload/main.go
   D store/branch.go
   D store/branch_test.go
   D store/lpad.go
   D store/lpad_test.go
   D store/mgo_test.go
   D store/server.go
   D store/server_test.go
   D store/store.go
   D store/store_test.go

[William Reade (fwereade)]

On 2013/01/09 17:59:58, allenap wrote:
> Please take a look.

LGTM; I'm +1 on juju-store myself.

https://codereview.appspot.com/7058063/

[William Reade (fwereade)]

Note that https://code.launchpad.net/~dave-cheney/juju-core/068-CONTRIBUTING/+merge/143057 merges a bug fix; please ensure it makes it across to lp:juju-store.

[Gavin Panella (allenap)]

Reopening. This consensus from Austin is that the store should be broken out into a separate project.

[William Reade (fwereade)]

As long as the latest version of store is taken, and any bugs are moved, I'm +1 on just going ahead and doing this.

[Gavin Panella (allenap)]

William, would you be able to land this please? I don't have the necessary fu. However, before you do, do you know if this will break any service deployment scripts for store.juju.ubuntu.com (if I remember the hostname correctly)?

[Gavin Panella (allenap)]

I forgot to mention: lp:juju-store has the latest store code from lp:juju-core, and I'm happy to find and move all the bugs over when this lands.

=== removed directory 'cmd/charmd'
=== removed file 'cmd/charmd/config.yaml'
--- cmd/charmd/config.yaml	2012-04-02 15:05:40 +0000
+++ cmd/charmd/config.yaml	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-mongo-url: localhost:60017
-api-addr: localhost:8080

=== removed file 'cmd/charmd/main.go'
--- cmd/charmd/main.go	2012-06-21 20:40:39 +0000
+++ cmd/charmd/main.go	1970-01-01 00:00:00 +0000
@@ -1,74 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-	"launchpad.net/goyaml"
-	"launchpad.net/juju-core/log"
-	"launchpad.net/juju-core/store"
-	stdlog "log"
-	"net/http"
-	"os"
-	"path/filepath"
-)
-
-func main() {
-	log.Target = stdlog.New(os.Stdout, "", stdlog.LstdFlags)
-	err := serve()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "%v\n", err)
-		os.Exit(1)
-	}
-}
-
-type config struct {
-	MongoURL string `yaml:"mongo-url"`
-	APIAddr  string `yaml:"api-addr"`
-}
-
-func readConfig(path string, conf interface{}) error {
-	f, err := os.Open(path)
-	if err != nil {
-		return fmt.Errorf("opening config file: %v", err)
-	}
-	data, err := ioutil.ReadAll(f)
-	f.Close()
-	if err != nil {
-		return fmt.Errorf("reading config file: %v", err)
-	}
-	err = goyaml.Unmarshal(data, conf)
-	if err != nil {
-		return fmt.Errorf("processing config file: %v", err)
-	}
-	return nil
-}
-
-func serve() error {
-	var confPath string
-	if len(os.Args) == 2 {
-		if _, err := os.Stat(os.Args[1]); err == nil {
-			confPath = os.Args[1]
-		}
-	}
-	if confPath == "" {
-		return fmt.Errorf("usage: %s <config path>", filepath.Base(os.Args[0]))
-	}
-	var conf config
-	err := readConfig(confPath, &conf)
-	if err != nil {
-		return err
-	}
-	if conf.MongoURL == "" || conf.APIAddr == "" {
-		return fmt.Errorf("missing mongo-url or api-addr in config file")
-	}
-	s, err := store.Open(conf.MongoURL)
-	if err != nil {
-		return err
-	}
-	defer s.Close()
-	server, err := store.NewServer(s)
-	if err != nil {
-		return err
-	}
-	return http.ListenAndServe(conf.APIAddr, server)
-}

=== removed directory 'cmd/charmload'
=== removed file 'cmd/charmload/config.yaml'
--- cmd/charmload/config.yaml	2012-04-02 15:05:40 +0000
+++ cmd/charmload/config.yaml	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-mongo-url: localhost:60017

=== removed file 'cmd/charmload/main.go'
--- cmd/charmload/main.go	2012-06-21 20:40:39 +0000
+++ cmd/charmload/main.go	1970-01-01 00:00:00 +0000
@@ -1,75 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-	"launchpad.net/goyaml"
-	"launchpad.net/juju-core/log"
-	"launchpad.net/juju-core/store"
-	"launchpad.net/lpad"
-	stdlog "log"
-	"os"
-	"path/filepath"
-)
-
-func main() {
-	log.Target = stdlog.New(os.Stdout, "", stdlog.LstdFlags)
-	err := load()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "%v\n", err)
-		os.Exit(1)
-	}
-}
-
-type config struct {
-	MongoURL string `yaml:"mongo-url"`
-}
-
-func readConfig(path string, conf interface{}) error {
-	f, err := os.Open(path)
-	if err != nil {
-		return fmt.Errorf("opening config file: %v", err)
-	}
-	data, err := ioutil.ReadAll(f)
-	f.Close()
-	if err != nil {
-		return fmt.Errorf("reading config file: %v", err)
-	}
-	err = goyaml.Unmarshal(data, conf)
-	if err != nil {
-		return fmt.Errorf("processing config file: %v", err)
-	}
-	return nil
-}
-
-func load() error {
-	var confPath string
-	if len(os.Args) == 2 {
-		if _, err := os.Stat(os.Args[1]); err == nil {
-			confPath = os.Args[1]
-		}
-	}
-	if confPath == "" {
-		return fmt.Errorf("usage: %s <config path>", filepath.Base(os.Args[0]))
-	}
-	var conf config
-	err := readConfig(confPath, &conf)
-	if err != nil {
-		return err
-	}
-	if conf.MongoURL == "" {
-		return fmt.Errorf("missing mongo-url in config file")
-	}
-	s, err := store.Open(conf.MongoURL)
-	if err != nil {
-		return err
-	}
-	defer s.Close()
-	err = store.PublishCharmsDistro(s, lpad.Production)
-	if _, ok := err.(store.PublishBranchErrors); ok {
-		// Ignore branch errors since they're commonplace here.
-		// They're logged, though.
-		return nil
-	}
-	return err
-}

=== removed directory 'store'
=== removed file 'store/branch.go'
--- store/branch.go	2012-07-24 09:36:51 +0000
+++ store/branch.go	1970-01-01 00:00:00 +0000
@@ -1,152 +0,0 @@
-package store
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"launchpad.net/juju-core/charm"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-)
-
-// PublishBazaarBranch checks out the Bazaar branch from burl and
-// publishes its latest revision at urls in the given store.
-// The digest parameter must be the most recent known Bazaar
-// revision id for the branch tip. If publishing this specific digest
-// for these URLs has been attempted already, the publishing
-// procedure may abort early. The published digest is the Bazaar
-// revision id of the checked out branch's tip, though, which may
-// differ from the digest parameter.
-func PublishBazaarBranch(store *Store, urls []*charm.URL, burl string, digest string) error {
-
-	// Prevent other publishers from updating these specific URLs
-	// concurrently.
-	lock, err := store.LockUpdates(urls)
-	if err != nil {
-		return err
-	}
-	defer lock.Unlock()
-
-	var branchDir string
-NewTip:
-	// Prepare the charm publisher. This will compute the revision
-	// to be assigned to the charm, and it will also fail if the
-	// operation is unnecessary because charms are up-to-date.
-	pub, err := store.CharmPublisher(urls, digest)
-	if err != nil {
-		return err
-	}
-
-	// Figure if publishing this charm was already attempted before and
-	// failed. We won't try again endlessly if so. In the future we may
-	// retry automatically in certain circumstances.
-	event, err := store.CharmEvent(urls[0], digest)
-	if err == nil && event.Kind != EventPublished {
-		return fmt.Errorf("charm publishing previously failed: %s", strings.Join(event.Errors, "; "))
-	} else if err != nil && err != ErrNotFound {
-		return err
-	}
-
-	if branchDir == "" {
-		// Retrieve the branch with a lightweight checkout, so that it
-		// builds a working tree as cheaply as possible. History
-		// doesn't matter here.
-		tempDir, err := ioutil.TempDir("", "publish-branch-")
-		if err != nil {
-			return err
-		}
-		defer os.RemoveAll(tempDir)
-		branchDir = filepath.Join(tempDir, "branch")
-		output, err := exec.Command("bzr", "checkout", "--lightweight", burl, branchDir).CombinedOutput()
-		if err != nil {
-			return outputErr(output, err)
-		}
-
-		// Pick actual digest from tip. Publishing the real tip
-		// revision rather than the revision for the digest provided is
-		// strictly necessary to prevent a race condition. If the
-		// provided digest was published instead, there's a chance
-		// another publisher concurrently running could have found a
-		// newer revision and published that first, and the digest
-		// parameter provided is in fact an old version that would
-		// overwrite the new version.
-		tipDigest, err := bzrRevisionId(branchDir)
-		if err != nil {
-			return err
-		}
-		if tipDigest != digest {
-			digest = tipDigest
-			goto NewTip
-		}
-	}
-
-	ch, err := charm.ReadDir(branchDir)
-	if err == nil {
-		// Hand over the charm to the store for bundling and
-		// streaming its content into the database.
-		err = pub.Publish(ch)
-		if err == ErrUpdateConflict {
-			// A conflict may happen in edge cases if the whole
-			// locking mechanism fails due to an expiration event,
-			// and then the expired concurrent publisher revives
-			// for whatever reason and attempts to finish
-			// publishing. The state of the system is still
-			// consistent in that case, and the error isn't logged
-			// since the revision was properly published before.
-			return err
-		}
-	}
-
-	// Publishing is done. Log failure or error.
-	event = &CharmEvent{
-		URLs:   urls,
-		Digest: digest,
-	}
-	if err == nil {
-		event.Kind = EventPublished
-		event.Revision = pub.Revision()
-	} else {
-		event.Kind = EventPublishError
-		event.Errors = []string{err.Error()}
-	}
-	if logerr := store.LogCharmEvent(event); logerr != nil {
-		if err == nil {
-			err = logerr
-		} else {
-			err = fmt.Errorf("%v; %v", err, logerr)
-		}
-	}
-	return err
-}
-
-// bzrRevisionId returns the Bazaar revision id for the branch in branchDir.
-func bzrRevisionId(branchDir string) (string, error) {
-	cmd := exec.Command("bzr", "revision-info")
-	cmd.Dir = branchDir
-	stderr := &bytes.Buffer{}
-	cmd.Stderr = stderr
-	output, err := cmd.Output()
-	if err != nil {
-		output = append(output, '\n')
-		output = append(output, stderr.Bytes()...)
-		return "", outputErr(output, err)
-	}
-	pair := bytes.Fields(output)
-	if len(pair) != 2 {
-		output = append(output, '\n')
-		output = append(output, stderr.Bytes()...)
-		return "", fmt.Errorf(`invalid output from "bzr revision-info": %s`, output)
-	}
-	return string(pair[1]), nil
-}
-
-// outputErr returns an error that assembles some command's output and its
-// error, if both output and err are set, and returns only err if output is nil.
-func outputErr(output []byte, err error) error {
-	if len(output) > 0 {
-		return fmt.Errorf("%v\n%s", err, output)
-	}
-	return err
-}

=== removed file 'store/branch_test.go'
--- store/branch_test.go	2012-10-09 01:19:01 +0000
+++ store/branch_test.go	1970-01-01 00:00:00 +0000
@@ -1,238 +0,0 @@
-package store_test
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	. "launchpad.net/gocheck"
-	"launchpad.net/juju-core/charm"
-	"launchpad.net/juju-core/store"
-	"launchpad.net/juju-core/testing"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"time"
-)
-
-func (s *StoreSuite) dummyBranch(c *C, suffix string) bzrDir {
-	tmpDir := c.MkDir()
-	if suffix != "" {
-		tmpDir = filepath.Join(tmpDir, suffix)
-		err := os.MkdirAll(tmpDir, 0755)
-		c.Assert(err, IsNil)
-	}
-	branch := bzrDir(tmpDir)
-	branch.init()
-
-	copyCharmDir(branch.path(), testing.Charms.Dir("series", "dummy"))
-	branch.add()
-	branch.commit("Imported charm.")
-	return branch
-}
-
-var urls = []*charm.URL{
-	charm.MustParseURL("cs:~joe/oneiric/dummy"),
-	charm.MustParseURL("cs:oneiric/dummy"),
-}
-
-type fakePlugin struct {
-	oldEnv string
-}
-
-func (p *fakePlugin) install(dir string, content string) {
-	p.oldEnv = os.Getenv("BZR_PLUGINS_AT")
-	err := ioutil.WriteFile(filepath.Join(dir, "__init__.py"), []byte(content), 0644)
-	if err != nil {
-		panic(err)
-	}
-	os.Setenv("BZR_PLUGINS_AT", "fakePlugin@"+dir)
-}
-
-func (p *fakePlugin) uninstall() {
-	os.Setenv("BZR_PLUGINS_AT", p.oldEnv)
-}
-
-func (s *StoreSuite) TestPublish(c *C) {
-	branch := s.dummyBranch(c, "")
-
-	// Ensure that the streams are parsed separately by inserting
-	// garbage on stderr. The wanted information is still there.
-	plugin := fakePlugin{}
-	plugin.install(c.MkDir(), `import sys; sys.stderr.write("STDERR STUFF FROM TEST\n")`)
-	defer plugin.uninstall()
-
-	err := store.PublishBazaarBranch(s.store, urls, branch.path(), "wrong-rev")
-	c.Assert(err, IsNil)
-
-	for _, url := range urls {
-		info, rc, err := s.store.OpenCharm(url)
-		c.Assert(err, IsNil)
-		defer rc.Close()
-		c.Assert(info.Revision(), Equals, 0)
-		c.Assert(info.Meta().Name, Equals, "dummy")
-
-		data, err := ioutil.ReadAll(rc)
-		c.Assert(err, IsNil)
-
-		bundle, err := charm.ReadBundleBytes(data)
-		c.Assert(err, IsNil)
-		c.Assert(bundle.Revision(), Equals, 0)
-		c.Assert(bundle.Meta().Name, Equals, "dummy")
-	}
-
-	// Attempt to publish the same content again while providing the wrong
-	// tip revision. It must pick the real revision from the branch and
-	// note this was previously published.
-	err = store.PublishBazaarBranch(s.store, urls, branch.path(), "wrong-rev")
-	c.Assert(err, Equals, store.ErrRedundantUpdate)
-
-	// Bump the content revision and lie again about the known tip revision.
-	// This time, though, pretend it's the same as the real branch revision
-	// previously published. It must error and not publish the new revision
-	// because it will use the revision provided as a parameter to check if
-	// publishing was attempted before. This is the mechanism that enables
-	// stopping fast without having to download every single branch. Real
-	// revision is picked in the next scan.
-	digest1 := branch.digest()
-	branch.change()
-	err = store.PublishBazaarBranch(s.store, urls, branch.path(), digest1)
-	c.Assert(err, Equals, store.ErrRedundantUpdate)
-
-	// Now allow it to publish the new content by providing an unseen revision.
-	err = store.PublishBazaarBranch(s.store, urls, branch.path(), "wrong-rev")
-	c.Assert(err, IsNil)
-	digest2 := branch.digest()
-
-	info, err := s.store.CharmInfo(urls[0])
-	c.Assert(err, IsNil)
-	c.Assert(info.Revision(), Equals, 1)
-	c.Assert(info.Meta().Name, Equals, "dummy")
-
-	// There are two events published, for each of the successful attempts.
-	// The failures are ignored given that they are artifacts of the
-	// publishing mechanism rather than actual problems.
-	_, err = s.store.CharmEvent(urls[0], "wrong-rev")
-	c.Assert(err, Equals, store.ErrNotFound)
-	for i, digest := range []string{digest1, digest2} {
-		event, err := s.store.CharmEvent(urls[0], digest)
-		c.Assert(err, IsNil)
-		c.Assert(event.Kind, Equals, store.EventPublished)
-		c.Assert(event.Revision, Equals, i)
-		c.Assert(event.Errors, IsNil)
-		c.Assert(event.Warnings, IsNil)
-	}
-}
-
-func (s *StoreSuite) TestPublishErrorFromBzr(c *C) {
-	branch := s.dummyBranch(c, "")
-
-	// In TestPublish we ensure that the streams are parsed
-	// separately by inserting garbage on stderr. Now make
-	// sure that stderr isn't simply trashed, as we want to
-	// know about what a real error tells us.
-	plugin := fakePlugin{}
-	plugin.install(c.MkDir(), `import sys; sys.stderr.write("STDERR STUFF FROM TEST\n"); sys.exit(1)`)
-	defer plugin.uninstall()
-
-	err := store.PublishBazaarBranch(s.store, urls, branch.path(), "wrong-rev")
-	c.Assert(err, ErrorMatches, "(?s).*STDERR STUFF.*")
-}
-
-func (s *StoreSuite) TestPublishErrorInCharm(c *C) {
-	branch := s.dummyBranch(c, "")
-
-	// Corrupt the charm.
-	branch.remove("metadata.yaml")
-	branch.commit("Removed metadata.yaml.")
-
-	// Attempt to publish the erroneous content.
-	err := store.PublishBazaarBranch(s.store, urls, branch.path(), "wrong-rev")
-	c.Assert(err, ErrorMatches, ".*/metadata.yaml: no such file or directory")
-
-	// The event should be logged as well, since this was an error in the charm
-	// that won't go away and must be communicated to the author.
-	event, err := s.store.CharmEvent(urls[0], branch.digest())
-	c.Assert(err, IsNil)
-	c.Assert(event.Kind, Equals, store.EventPublishError)
-	c.Assert(event.Revision, Equals, 0)
-	c.Assert(event.Errors, NotNil)
-	c.Assert(event.Errors[0], Matches, ".*/metadata.yaml: no such file or directory")
-	c.Assert(event.Warnings, IsNil)
-}
-
-type bzrDir string
-
-func (dir bzrDir) path(args ...string) string {
-	return filepath.Join(append([]string{string(dir)}, args...)...)
-}
-
-func (dir bzrDir) run(args ...string) []byte {
-	cmd := exec.Command("bzr", args...)
-	oldemail := os.Getenv("EMAIL")
-	defer os.Setenv("EMAIL", oldemail)
-	// bzr will complain if bzr whoami has not been run previously,
-	// avoid this by passing $EMAIL into the environment.
-	os.Setenv("EMAIL", "[e-mail]")
-	cmd.Dir = string(dir)
-	output, err := cmd.Output()
-	if err != nil {
-		panic(fmt.Sprintf("command failed: bzr %s\n%s", strings.Join(args, " "), output))
-	}
-	return output
-}
-
-func (dir bzrDir) init() {
-	dir.run("init")
-}
-
-func (dir bzrDir) add(paths ...string) {
-	dir.run(append([]string{"add"}, paths...)...)
-}
-
-func (dir bzrDir) remove(paths ...string) {
-	dir.run(append([]string{"rm"}, paths...)...)
-}
-
-func (dir bzrDir) commit(msg string) {
-	dir.run("commit", "-m", msg)
-}
-
-func (dir bzrDir) write(path string, data string) {
-	err := ioutil.WriteFile(dir.path(path), []byte(data), 0644)
-	if err != nil {
-		panic(err)
-	}
-}
-
-func (dir bzrDir) change() {
-	t := time.Now().String()
-	dir.write("timestamp", t)
-	dir.add("timestamp")
-	dir.commit("Revision bumped at " + t)
-}
-
-func (dir bzrDir) digest() string {
-	output := dir.run("revision-info")
-	f := bytes.Fields(output)
-	if len(f) != 2 {
-		panic("revision-info returned bad output: " + string(output))
-	}
-	return string(f[1])
-}
-
-func copyCharmDir(dst string, dir *charm.Dir) {
-	var b bytes.Buffer
-	err := dir.BundleTo(&b)
-	if err != nil {
-		panic(err)
-	}
-	bundle, err := charm.ReadBundleBytes(b.Bytes())
-	if err != nil {
-		panic(err)
-	}
-	err = bundle.ExpandTo(dst)
-	if err != nil {
-		panic(err)
-	}
-}

=== removed file 'store/lpad.go'
--- store/lpad.go	2012-06-21 20:40:39 +0000
+++ store/lpad.go	1970-01-01 00:00:00 +0000
@@ -1,113 +0,0 @@
-package store
-
-import (
-	"fmt"
-	"launchpad.net/juju-core/charm"
-	"launchpad.net/juju-core/log"
-	"launchpad.net/lpad"
-	"strings"
-	"time"
-)
-
-type PublishBranchError struct {
-	URL string
-	Err error
-}
-
-type PublishBranchErrors []PublishBranchError
-
-func (errs PublishBranchErrors) Error() string {
-	return fmt.Sprintf("%d branch(es) failed to be published", len(errs))
-}
-
-// PublishCharmsDistro publishes all branch tips found in
-// the /charms distribution in Launchpad onto store under
-// the "cs:" scheme.
-// apiBase specifies the Launchpad base API URL, such
-// as lpad.Production or lpad.Staging.
-// Errors found while processing one or more branches are
-// all returned as a PublishBranchErrors value.
-func PublishCharmsDistro(store *Store, apiBase lpad.APIBase) error {
-	oauth := &lpad.OAuth{Anonymous: true, Consumer: "juju"}
-	root, err := lpad.Login(apiBase, oauth)
-	if err != nil {
-		return err
-	}
-	distro, err := root.Distro("charms")
-	if err != nil {
-		return err
-	}
-	tips, err := distro.BranchTips(time.Time{})
-	if err != nil {
-		return err
-	}
-
-	var errs PublishBranchErrors
-	for _, tip := range tips {
-		if !strings.HasSuffix(tip.UniqueName, "/trunk") {
-			continue
-		}
-		burl, curl, err := uniqueNameURLs(tip.UniqueName)
-		if err != nil {
-			errs = append(errs, PublishBranchError{tip.UniqueName, err})
-			log.Printf("error: %v\n", err)
-			continue
-		}
-		log.Printf("----- %s\n", burl)
-		if tip.Revision == "" {
-			errs = append(errs, PublishBranchError{burl, fmt.Errorf("branch has no revisions")})
-			log.Printf("error: branch has no revisions\n")
-			continue
-		}
-		// Charm is published in the personal URL and in any explicitly
-		// assigned official series.
-		urls := []*charm.URL{curl}
-		schema, name := curl.Schema, curl.Name
-		for _, series := range tip.OfficialSeries {
-			curl = &charm.URL{Schema: schema, Name: name, Series: series, Revision: -1}
-			curl.Series = series
-			curl.User = ""
-			urls = append(urls, curl)
-		}
-
-		err = PublishBazaarBranch(store, urls, burl, tip.Revision)
-		if err == ErrRedundantUpdate {
-			continue
-		}
-		if err != nil {
-			errs = append(errs, PublishBranchError{burl, err})
-			log.Printf("error: %v\n", err)
-		}
-	}
-	if errs != nil {
-		return errs
-	}
-	return nil
-}
-
-// uniqueNameURLs returns the branch URL and the charm URL for the
-// provided Launchpad branch unique name. The unique name must be
-// in the form:
-//
-//     ~<user>/charms/<series>/<charm name>/trunk
-//
-// For testing purposes, if name has a prefix preceding a string in
-// this format, the prefix is stripped out for computing the charm
-// URL, and the unique name is returned unchanged as the branch URL.
-func uniqueNameURLs(name string) (burl string, curl *charm.URL, err error) {
-	u := strings.Split(name, "/")
-	if len(u) > 5 {
-		u = u[len(u)-5:]
-		burl = name
-	} else {
-		burl = "lp:" + name
-	}
-	if len(u) < 5 || u[1] != "charms" || u[4] != "trunk" || len(u[0]) == 0 || u[0][0] != '~' {
-		return "", nil, fmt.Errorf("unwanted branch name: %s", name)
-	}
-	curl, err = charm.ParseURL(fmt.Sprintf("cs:%s/%s/%s", u[0], u[2], u[3]))
-	if err != nil {
-		return "", nil, err
-	}
-	return burl, curl, nil
-}

=== removed file 'store/lpad_test.go'
--- store/lpad_test.go	2012-08-18 22:48:02 +0000
+++ store/lpad_test.go	1970-01-01 00:00:00 +0000
@@ -1,68 +0,0 @@
-package store_test
-
-import (
-	"fmt"
-	. "launchpad.net/gocheck"
-	"launchpad.net/juju-core/charm"
-	"launchpad.net/juju-core/store"
-	"launchpad.net/juju-core/testing"
-	"launchpad.net/lpad"
-)
-
-var jsonType = map[string]string{
-	"Content-Type": "application/json",
-}
-
-func (s *StoreSuite) TestPublishCharmDistro(c *C) {
-	branch := s.dummyBranch(c, "~joe/charms/oneiric/dummy/trunk")
-
-	// The Distro call will look for bare /charms, first.
-	testing.Server.Response(200, jsonType, []byte("{}"))
-
-	// And then it picks up the tips.
-	data := fmt.Sprintf(`[`+
-		`["file://%s", "rev1", ["oneiric", "precise"]],`+
-		`["file://%s", "%s", []],`+
-		`["file:///non-existent/~jeff/charms/precise/bad/trunk", "rev2", []],`+
-		`["file:///non-existent/~jeff/charms/precise/bad/skip-me", "rev3", []]`+
-		`]`,
-		branch.path(), branch.path(), branch.digest())
-	testing.Server.Response(200, jsonType, []byte(data))
-
-	apiBase := lpad.APIBase(testing.Server.URL)
-	err := store.PublishCharmsDistro(s.store, apiBase)
-
-	// Should have a single failure from the trunk branch that doesn't
-	// exist. The redundant update with the known digest should be
-	// ignored, and skip-me isn't a supported branch name so it's
-	// ignored as well.
-	c.Assert(err, ErrorMatches, `1 branch\(es\) failed to be published`)
-	berr := err.(store.PublishBranchErrors)[0]
-	c.Assert(berr.URL, Equals, "file:///non-existent/~jeff/charms/precise/bad/trunk")
-	c.Assert(berr.Err, ErrorMatches, "(?s).*bzr: ERROR: Not a branch.*")
-
-	for _, url := range []string{"cs:oneiric/dummy", "cs:precise/dummy-0", "cs:~joe/oneiric/dummy-0"} {
-		dummy, err := s.store.CharmInfo(charm.MustParseURL(url))
-		c.Assert(err, IsNil)
-		c.Assert(dummy.Meta().Name, Equals, "dummy")
-	}
-
-	// The known digest should have been ignored, so revision is still at 0.
-	_, err = s.store.CharmInfo(charm.MustParseURL("cs:~joe/oneiric/dummy-1"))
-	c.Assert(err, Equals, store.ErrNotFound)
-
-	// bare /charms lookup
-	req := testing.Server.WaitRequest()
-	c.Assert(req.Method, Equals, "GET")
-	c.Assert(req.URL.Path, Equals, "/charms")
-
-	// tips request
-	req = testing.Server.WaitRequest()
-	c.Assert(req.Method, Equals, "GET")
-	c.Assert(req.URL.Path, Equals, "/charms")
-	c.Assert(req.Form["ws.op"], DeepEquals, []string{"getBranchTips"})
-	c.Assert(req.Form["since"], IsNil)
-
-	// Request must be signed by juju.
-	c.Assert(req.Header.Get("Authorization"), Matches, `.*oauth_consumer_key="juju".*`)
-}

=== removed file 'store/mgo_test.go'
--- store/mgo_test.go	2012-10-30 11:45:32 +0000
+++ store/mgo_test.go	1970-01-01 00:00:00 +0000
@@ -1,95 +0,0 @@
-package store_test
-
-import (
-	"bytes"
-	"labix.org/v2/mgo"
-	. "launchpad.net/gocheck"
-	"os/exec"
-	"time"
-)
-
-// ----------------------------------------------------------------------------
-// The mgo test suite
-
-type MgoSuite struct {
-	Addr    string
-	Session *mgo.Session
-	output  bytes.Buffer
-	server  *exec.Cmd
-}
-
-func (s *MgoSuite) SetUpSuite(c *C) {
-	mgo.SetDebug(true)
-	mgo.SetStats(true)
-	dbdir := c.MkDir()
-	args := []string{
-		"--dbpath", dbdir,
-		"--bind_ip", "127.0.0.1",
-		"--port", "50017",
-		"--nssize", "1",
-		"--noprealloc",
-		"--smallfiles",
-		"--nojournal",
-	}
-	s.server = exec.Command("mongod", args...)
-	s.server.Stdout = &s.output
-	s.server.Stderr = &s.output
-	err := s.server.Start()
-	c.Assert(err, IsNil)
-}
-
-func (s *MgoSuite) TearDownSuite(c *C) {
-	s.server.Process.Kill()
-	s.server.Process.Wait()
-}
-
-func (s *MgoSuite) SetUpTest(c *C) {
-	err := DropAll("localhost:50017")
-	c.Assert(err, IsNil)
-	mgo.SetLogger(c)
-	mgo.ResetStats()
-	s.Addr = "127.0.0.1:50017"
-	s.Session, err = mgo.Dial(s.Addr)
-	c.Assert(err, IsNil)
-}
-
-func (s *MgoSuite) TearDownTest(c *C) {
-	if s.Session != nil {
-		s.Session.Close()
-	}
-	for i := 0; ; i++ {
-		stats := mgo.GetStats()
-		if stats.SocketsInUse == 0 && stats.SocketsAlive == 0 {
-			break
-		}
-		if i == 20 {
-			c.Fatal("Test left sockets in a dirty state")
-		}
-		c.Logf("Waiting for sockets to die: %d in use, %d alive", stats.SocketsInUse, stats.SocketsAlive)
-		time.Sleep(500 * time.Millisecond)
-	}
-}
-
-func DropAll(mongourl string) (err error) {
-	session, err := mgo.Dial(mongourl)
-	if err != nil {
-		return err
-	}
-	defer session.Close()
-
-	names, err := session.DatabaseNames()
-	if err != nil {
-		return err
-	}
-	for _, name := range names {
-		switch name {
-		case "admin", "local", "config":
-		default:
-			err = session.DB(name).DropDatabase()
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}

=== removed file 'store/server.go'
--- store/server.go	2012-10-11 14:52:21 +0000
+++ store/server.go	1970-01-01 00:00:00 +0000
@@ -1,191 +0,0 @@
-package store
-
-import (
-	"encoding/json"
-	"io"
-	"launchpad.net/juju-core/charm"
-	"launchpad.net/juju-core/log"
-	"net/http"
-	"strconv"
-	"strings"
-)
-
-// Server is an http.Handler that serves the HTTP API of juju
-// so that juju clients can retrieve published charms.
-type Server struct {
-	store *Store
-	mux   *http.ServeMux
-}
-
-// New returns a new *Server using store.
-func NewServer(store *Store) (*Server, error) {
-	s := &Server{
-		store: store,
-		mux:   http.NewServeMux(),
-	}
-	s.mux.HandleFunc("/charm-info", func(w http.ResponseWriter, r *http.Request) {
-		s.serveInfo(w, r)
-	})
-	s.mux.HandleFunc("/charm/", func(w http.ResponseWriter, r *http.Request) {
-		s.serveCharm(w, r)
-	})
-	s.mux.HandleFunc("/stats/counter/", func(w http.ResponseWriter, r *http.Request) {
-		s.serveStats(w, r)
-	})
-
-	// This is just a validation key to allow blitz.io to run
-	// performance tests against the site.
-	s.mux.HandleFunc("/mu-35700a31-6bf320ca-a800b670-05f845ee", func(w http.ResponseWriter, r *http.Request) {
-		s.serveBlitzKey(w, r)
-	})
-	return s, nil
-}
-
-// ServeHTTP serves an http request.
-// This method turns *Server into an http.Handler.
-func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	if r.URL.Path == "/" {
-		http.Redirect(w, r, "https://juju.ubuntu.com", http.StatusSeeOther)
-		return
-	}
-	s.mux.ServeHTTP(w, r)
-}
-
-func statsEnabled(req *http.Request) bool {
-	// It's fine to parse the form more than once, and it avoids
-	// bugs from not parsing it.
-	req.ParseForm()
-	return req.Form.Get("stats") != "0"
-}
-
-func charmStatsKey(curl *charm.URL, kind string) []string {
-	if curl.User == "" {
-		return []string{kind, curl.Series, curl.Name}
-	}
-	return []string{kind, curl.Series, curl.Name, curl.User}
-}
-
-func (s *Server) serveInfo(w http.ResponseWriter, r *http.Request) {
-	if r.URL.Path != "/charm-info" {
-		w.WriteHeader(http.StatusNotFound)
-		return
-	}
-	r.ParseForm()
-	response := map[string]*charm.InfoResponse{}
-	for _, url := range r.Form["charms"] {
-		c := &charm.InfoResponse{}
-		response[url] = c
-		curl, err := charm.ParseURL(url)
-		var info *CharmInfo
-		if err == nil {
-			info, err = s.store.CharmInfo(curl)
-		}
-		var skey []string
-		if err == nil {
-			skey = charmStatsKey(curl, "charm-info")
-			c.Sha256 = info.BundleSha256()
-			c.Revision = info.Revision()
-			c.Digest = info.Digest()
-		} else {
-			if err == ErrNotFound {
-				skey = charmStatsKey(curl, "charm-missing")
-			}
-			c.Errors = append(c.Errors, err.Error())
-		}
-		if skey != nil && statsEnabled(r) {
-			go s.store.IncCounter(skey)
-		}
-	}
-	data, err := json.Marshal(response)
-	if err == nil {
-		w.Header().Set("Content-Type", "application/json")
-		_, err = w.Write(data)
-	}
-	if err != nil {
-		log.Printf("store: cannot write content: %v", err)
-		w.WriteHeader(http.StatusInternalServerError)
-		return
-	}
-}
-
-func (s *Server) serveCharm(w http.ResponseWriter, r *http.Request) {
-	if !strings.HasPrefix(r.URL.Path, "/charm/") {
-		panic("serveCharm: bad url")
-	}
-	curl, err := charm.ParseURL("cs:" + r.URL.Path[len("/charm/"):])
-	if err != nil {
-		w.WriteHeader(http.StatusNotFound)
-		return
-	}
-	info, rc, err := s.store.OpenCharm(curl)
-	if err == ErrNotFound {
-		w.WriteHeader(http.StatusNotFound)
-		return
-	}
-	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		log.Printf("store: cannot open charm %q: %v", curl, err)
-		return
-	}
-	if statsEnabled(r) {
-		go s.store.IncCounter(charmStatsKey(curl, "charm-bundle"))
-	}
-	defer rc.Close()
-	w.Header().Set("Connection", "close") // No keep-alive for now.
-	w.Header().Set("Content-Type", "application/octet-stream")
-	w.Header().Set("Content-Length", strconv.FormatInt(info.BundleSize(), 10))
-	_, err = io.Copy(w, rc)
-	if err != nil {
-		log.Printf("store: failed to stream charm %q: %v", curl, err)
-	}
-}
-
-func (s *Server) serveStats(w http.ResponseWriter, r *http.Request) {
-	// TODO: Adopt a smarter mux that simplifies this logic.
-	const dir = "/stats/counter/"
-	if !strings.HasPrefix(r.URL.Path, dir) {
-		panic("bad url")
-	}
-	base := r.URL.Path[len(dir):]
-	if strings.Index(base, "/") > 0 {
-		w.WriteHeader(http.StatusNotFound)
-		return
-	}
-	if base == "" {
-		w.WriteHeader(http.StatusForbidden)
-		return
-	}
-	key := strings.Split(base, ":")
-	prefix := false
-	if key[len(key)-1] == "*" {
-		prefix = true
-		key = key[:len(key)-1]
-		if len(key) == 0 {
-			// No point in counting something unknown.
-			w.WriteHeader(http.StatusForbidden)
-			return
-		}
-	}
-	r.ParseForm()
-	sum, err := s.store.SumCounter(key, prefix)
-	if err != nil {
-		log.Printf("store: cannot sum counter: %v", err)
-		w.WriteHeader(http.StatusInternalServerError)
-		return
-	}
-	data := []byte(strconv.FormatInt(sum, 10))
-	w.Header().Set("Content-Type", "text/plain")
-	w.Header().Set("Content-Length", strconv.Itoa(len(data)))
-	_, err = w.Write(data)
-	if err != nil {
-		log.Printf("store: cannot write content: %v", err)
-		w.WriteHeader(http.StatusInternalServerError)
-	}
-}
-
-func (s *Server) serveBlitzKey(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Connection", "close")
-	w.Header().Set("Content-Type", "text/plain")
-	w.Header().Set("Content-Length", "2")
-	w.Write([]byte("42"))
-}

=== removed file 'store/server_test.go'
--- store/server_test.go	2012-09-05 21:08:26 +0000
+++ store/server_test.go	1970-01-01 00:00:00 +0000
@@ -1,209 +0,0 @@
-package store_test
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	. "launchpad.net/gocheck"
-	"launchpad.net/juju-core/charm"
-	"launchpad.net/juju-core/store"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"strconv"
-	"time"
-)
-
-func (s *StoreSuite) prepareServer(c *C) (*store.Server, *charm.URL) {
-	curl := charm.MustParseURL("cs:oneiric/wordpress")
-	pub, err := s.store.CharmPublisher([]*charm.URL{curl}, "some-digest")
-	c.Assert(err, IsNil)
-	err = pub.Publish(&FakeCharmDir{})
-	c.Assert(err, IsNil)
-
-	server, err := store.NewServer(s.store)
-	c.Assert(err, IsNil)
-	return server, curl
-}
-
-func (s *StoreSuite) TestServerCharmInfo(c *C) {
-	server, curl := s.prepareServer(c)
-	req, err := http.NewRequest("GET", "/charm-info", nil)
-	c.Assert(err, IsNil)
-
-	var tests = []struct{ url, sha, digest, err string }{
-		{curl.String(), fakeRevZeroSha, "some-digest", ""},
-		{"cs:oneiric/non-existent", "", "", "entry not found"},
-		{"cs:bad", "", "", `charm URL without series: "cs:bad"`},
-	}
-
-	for _, t := range tests {
-		req.Form = url.Values{"charms": []string{t.url}}
-		rec := httptest.NewRecorder()
-		server.ServeHTTP(rec, req)
-
-		expected := make(map[string]interface{})
-		if t.sha != "" {
-			expected[t.url] = map[string]interface{}{
-				"revision": float64(0),
-				"sha256":   t.sha,
-				"digest":   t.digest,
-			}
-		} else {
-			expected[t.url] = map[string]interface{}{
-				"revision": float64(0),
-				"errors":   []interface{}{t.err},
-			}
-		}
-		obtained := map[string]interface{}{}
-		err = json.NewDecoder(rec.Body).Decode(&obtained)
-		c.Assert(err, IsNil)
-		c.Assert(obtained, DeepEquals, expected)
-		c.Assert(rec.Header().Get("Content-Type"), Equals, "application/json")
-	}
-
-	s.checkCounterSum(c, []string{"charm-info", curl.Series, curl.Name}, false, 1)
-	s.checkCounterSum(c, []string{"charm-missing", "oneiric", "non-existent"}, false, 1)
-}
-
-// checkCounterSum checks that statistics are properly collected.
-// It retries a few times as they are generally collected in background.
-func (s *StoreSuite) checkCounterSum(c *C, key []string, prefix bool, expected int64) {
-	var sum int64
-	var err error
-	for retry := 0; retry < 10; retry++ {
-		time.Sleep(1e8)
-		sum, err = s.store.SumCounter(key, prefix)
-		c.Assert(err, IsNil)
-		if sum == expected {
-			if expected == 0 && retry < 2 {
-				continue // Wait a bit to make sure.
-			}
-			return
-		}
-	}
-	c.Errorf("counter sum for %#v is %d, want %d", key, sum, expected)
-}
-
-func (s *StoreSuite) TestCharmStreaming(c *C) {
-	server, curl := s.prepareServer(c)
-
-	req, err := http.NewRequest("GET", "/charm/"+curl.String()[3:], nil)
-	c.Assert(err, IsNil)
-	rec := httptest.NewRecorder()
-	server.ServeHTTP(rec, req)
-
-	data, err := ioutil.ReadAll(rec.Body)
-	c.Assert(string(data), Equals, "charm-revision-0")
-
-	c.Assert(rec.Header().Get("Connection"), Equals, "close")
-	c.Assert(rec.Header().Get("Content-Type"), Equals, "application/octet-stream")
-	c.Assert(rec.Header().Get("Content-Length"), Equals, "16")
-
-	// Check that it was accounted for in statistics.
-	s.checkCounterSum(c, []string{"charm-bundle", curl.Series, curl.Name}, false, 1)
-}
-
-func (s *StoreSuite) TestDisableStats(c *C) {
-	server, curl := s.prepareServer(c)
-
-	req, err := http.NewRequest("GET", "/charm-info", nil)
-	c.Assert(err, IsNil)
-	req.Form = url.Values{"charms": []string{curl.String()}, "stats": []string{"0"}}
-	rec := httptest.NewRecorder()
-	server.ServeHTTP(rec, req)
-	c.Assert(rec.Code, Equals, 200)
-
-	req, err = http.NewRequest("GET", "/charm/"+curl.String()[3:], nil)
-	c.Assert(err, IsNil)
-	req.Form = url.Values{"stats": []string{"0"}}
-	rec = httptest.NewRecorder()
-	server.ServeHTTP(rec, req)
-	c.Assert(rec.Code, Equals, 200)
-
-	// No statistics should have been collected given the use of stats=0.
-	for _, prefix := range []string{"charm-info", "charm-bundle", "charm-missing"} {
-		s.checkCounterSum(c, []string{prefix}, true, 0)
-	}
-}
-
-func (s *StoreSuite) TestServerStatus(c *C) {
-	server, err := store.NewServer(s.store)
-	c.Assert(err, IsNil)
-	tests := []struct {
-		path string
-		code int
-	}{
-		{"/charm-info/any", 404},
-		{"/charm/bad-url", 404},
-		{"/charm/bad-series/wordpress", 404},
-		{"/stats/counter/", 403},
-		{"/stats/counter/*", 403},
-		{"/stats/counter/any/", 404},
-		{"/stats/", 404},
-		{"/stats/any", 404},
-	}
-	for _, test := range tests {
-		req, err := http.NewRequest("GET", test.path, nil)
-		c.Assert(err, IsNil)
-		rec := httptest.NewRecorder()
-		server.ServeHTTP(rec, req)
-		c.Assert(rec.Code, Equals, test.code, Commentf("Path: %s", test.path))
-	}
-}
-
-func (s *StoreSuite) TestRootRedirect(c *C) {
-	server, err := store.NewServer(s.store)
-	c.Assert(err, IsNil)
-	req, err := http.NewRequest("GET", "/", nil)
-	c.Assert(err, IsNil)
-	rec := httptest.NewRecorder()
-	server.ServeHTTP(rec, req)
-	c.Assert(rec.Code, Equals, 303)
-	c.Assert(rec.Header().Get("Location"), Equals, "https://juju.ubuntu.com")
-}
-
-func (s *StoreSuite) TestStatsCounter(c *C) {
-	for _, key := range [][]string{{"a", "b"}, {"a", "b"}, {"a"}} {
-		err := s.store.IncCounter(key)
-		c.Assert(err, IsNil)
-	}
-
-	server, _ := s.prepareServer(c)
-
-	expected := map[string]string{
-		"a:b": "2",
-		"a:*": "3",
-		"a":   "1",
-	}
-
-	for counter, n := range expected {
-		req, err := http.NewRequest("GET", "/stats/counter/"+counter, nil)
-		c.Assert(err, IsNil)
-		rec := httptest.NewRecorder()
-		server.ServeHTTP(rec, req)
-
-		data, err := ioutil.ReadAll(rec.Body)
-		c.Assert(string(data), Equals, n)
-
-		c.Assert(rec.Header().Get("Content-Type"), Equals, "text/plain")
-		c.Assert(rec.Header().Get("Content-Length"), Equals, strconv.Itoa(len(n)))
-	}
-}
-
-func (s *StoreSuite) TestBlitzKey(c *C) {
-	server, _ := s.prepareServer(c)
-
-	// This is just a validation key to allow blitz.io to run
-	// performance tests against the site.
-	req, err := http.NewRequest("GET", "/mu-35700a31-6bf320ca-a800b670-05f845ee", nil)
-	c.Assert(err, IsNil)
-	rec := httptest.NewRecorder()
-	server.ServeHTTP(rec, req)
-
-	data, err := ioutil.ReadAll(rec.Body)
-	c.Assert(string(data), Equals, "42")
-
-	c.Assert(rec.Header().Get("Connection"), Equals, "close")
-	c.Assert(rec.Header().Get("Content-Type"), Equals, "text/plain")
-	c.Assert(rec.Header().Get("Content-Length"), Equals, "2")
-}

=== removed file 'store/store.go'
--- store/store.go	2012-10-11 17:40:17 +0000
+++ store/store.go	1970-01-01 00:00:00 +0000
@@ -1,774 +0,0 @@
-// The store package is capable of storing and updating charms in a MongoDB
-// database, as well as maintaining further information about them such as
-// the VCS revision the charm was loaded from and the URLs for the charms.
-package store
-
-import (
-	"crypto/sha256"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"hash"
-	"io"
-	"labix.org/v2/mgo"
-	"labix.org/v2/mgo/bson"
-	"launchpad.net/juju-core/charm"
-	"launchpad.net/juju-core/log"
-	"sort"
-	"strconv"
-	"sync"
-	"time"
-)
-
-// The following MongoDB collections are currently used:
-//
-//     juju.events        - Log of events relating to the lifecycle of charms
-//     juju.charms        - Information about the stored charms
-//     juju.charmfs.*     - GridFS with the charm files
-//     juju.locks         - Has unique keys with url of updating charms
-//     juju.stat.counters - Counters for statistics
-//     juju.stat.tokens   - Tokens used in statistics counter keys
-
-var (
-	ErrUpdateConflict  = errors.New("charm update in progress")
-	ErrRedundantUpdate = errors.New("charm is up-to-date")
-	ErrNotFound        = errors.New("entry not found")
-)
-
-const (
-	UpdateTimeout = 600e9
-)
-
-// Store holds a connection to a charm store.
-type Store struct {
-	session *storeSession
-
-	// Cache for statistics key words (two generations).
-	cacheMu       sync.RWMutex
-	statsTokenNew map[string]int
-	statsTokenOld map[string]int
-}
-
-// Open creates a new session with the store. It connects to the MongoDB
-// server at the given address (as expected by the Mongo function in the
-// labix.org/v2/mgo package).
-func Open(mongoAddr string) (store *Store, err error) {
-	log.Printf("store: Store opened. Connecting to: %s", mongoAddr)
-	store = &Store{}
-	session, err := mgo.Dial(mongoAddr)
-	if err != nil {
-		log.Printf("store: Error connecting to MongoDB: %v", err)
-		return nil, err
-	}
-
-	store = &Store{session: &storeSession{session}}
-
-	// Ignore error. It'll always fail after created.
-	// TODO Check the error once mgo hands it to us.
-	_ = store.session.DB("juju").Run(bson.D{{"create", "stat.counters"}, {"autoIndexId", false}}, nil)
-
-	if err := store.ensureIndexes(); err != nil {
-		session.Close()
-		return nil, err
-	}
-
-	// Put the used socket back in the pool.
-	session.Refresh()
-	return store, nil
-}
-
-func (s *Store) ensureIndexes() error {
-	session := s.session
-	indexes := []struct {
-		c *mgo.Collection
-		i mgo.Index
-	}{{
-		session.StatCounters(),
-		mgo.Index{Key: []string{"k", "t"}, Unique: true},
-	}, {
-		session.StatTokens(),
-		mgo.Index{Key: []string{"t"}, Unique: true},
-	}, {
-		session.Charms(),
-		mgo.Index{Key: []string{"urls", "revision"}, Unique: true},
-	}, {
-		session.Events(),
-		mgo.Index{Key: []string{"urls", "digest"}},
-	}}
-	for _, idx := range indexes {
-		err := idx.c.EnsureIndex(idx.i)
-		if err != nil {
-			log.Printf("store: Error ensuring stat.counters index: %v", err)
-			return err
-		}
-	}
-	return nil
-}
-
-// Close terminates the connection with the store.
-func (s *Store) Close() {
-	s.session.Close()
-}
-
-// statsKey returns the compound statistics identifier that represents key.
-// If write is true, the identifier will be created if necessary.
-// Identifiers have a form similar to "ab:c:def:", where each section is a
-// base-32 number that represents the respective word in key. This form
-// allows efficiently indexing and searching for prefixes, while detaching
-// the key content and size from the actual words used in key.
-func (s *Store) statsKey(session *storeSession, key []string, write bool) (string, error) {
-	if len(key) == 0 {
-		return "", fmt.Errorf("store: empty statistics key")
-	}
-	tokens := session.StatTokens()
-	skey := make([]byte, 0, len(key)*4)
-	// Retry limit is mainly to prevent infinite recursion in edge cases,
-	// such as if the database is ever run in read-only mode.
-	// The logic below should deteministically stop in normal scenarios.
-	var err error
-	for i, retry := 0, 30; i < len(key) && retry > 0; retry-- {
-		err = nil
-		id, found := s.statsTokenId(key[i])
-		if !found {
-			var t struct {
-				Id    int    "_id"
-				Token string "t"
-			}
-			err = tokens.Find(bson.D{{"t", key[i]}}).One(&t)
-			if err == mgo.ErrNotFound {
-				if !write {
-					return "", ErrNotFound
-				}
-				t.Id, err = tokens.Count()
-				if err != nil {
-					continue
-				}
-				t.Id++
-				t.Token = key[i]
-				err = tokens.Insert(&t)
-			}
-			if err != nil {
-				continue
-			}
-			s.cacheStatsTokenId(t.Token, t.Id)
-			id = t.Id
-		}
-		skey = strconv.AppendInt(skey, int64(id), 32)
-		skey = append(skey, ':')
-		i++
-	}
-	if err != nil {
-		return "", err
-	}
-	return string(skey), nil
-}
-
-const statsTokenCacheSize = 512
-
-// cacheStatsTokenId adds the id for token into the cache.
-// The cache has two generations so that the least frequently used
-// tokens are evicted regularly.
-func (s *Store) cacheStatsTokenId(token string, id int) {
-	s.cacheMu.Lock()
-	defer s.cacheMu.Unlock()
-	// Can't possibly be >, but reviews want it for defensiveness.
-	if len(s.statsTokenNew) >= statsTokenCacheSize {
-		s.statsTokenOld = s.statsTokenNew
-		s.statsTokenNew = nil
-	}
-	if s.statsTokenNew == nil {
-		s.statsTokenNew = make(map[string]int, statsTokenCacheSize)
-	}
-	s.statsTokenNew[token] = id
-}
-
-// statsTokenId returns the id for token from the cache, if found.
-func (s *Store) statsTokenId(token string) (id int, found bool) {
-	s.cacheMu.RLock()
-	id, found = s.statsTokenNew[token]
-	if found {
-		s.cacheMu.RUnlock()
-		return
-	}
-	id, found = s.statsTokenOld[token]
-	s.cacheMu.RUnlock()
-	if found {
-		s.cacheStatsTokenId(token, id)
-	}
-	return
-}
-
-var counterEpoch = time.Date(2012, 1, 1, 0, 0, 0, 0, time.UTC).Unix()
-
-// IncCounter increases by one the counter associated with the composed key.
-func (s *Store) IncCounter(key []string) error {
-	session := s.session.Copy()
-	defer session.Close()
-
-	skey, err := s.statsKey(session, key, true)
-	if err != nil {
-		return err
-	}
-
-	t := time.Now().UTC()
-	// Round to the start of the minute so we get one document per minute at most.
-	t = t.Add(-time.Duration(t.Second()) * time.Second)
-	counters := session.StatCounters()
-	_, err = counters.Upsert(bson.D{{"k", skey}, {"t", int32(t.Unix() - counterEpoch)}}, bson.D{{"$inc", bson.D{{"c", 1}}}})
-	return err
-}
-
-// SumCounter returns the sum of all the counters that exactly match key,
-// or that are prefixed by it if prefix is true.
-func (s *Store) SumCounter(key []string, prefix bool) (count int64, err error) {
-	session := s.session.Copy()
-	defer session.Close()
-
-	skey, err := s.statsKey(session, key, false)
-	if err == ErrNotFound {
-		return 0, nil
-	}
-	if err != nil {
-		return 0, err
-	}
-
-	var regex string
-	if prefix {
-		regex = "^" + skey
-	} else {
-		regex = "^" + skey + "$"
-	}
-
-	job := mgo.MapReduce{
-		Map:    "function() { emit('count', this.c); }",
-		Reduce: "function(key, values) { return Array.sum(values); }",
-	}
-	var result []struct{ Value int64 }
-	counters := session.StatCounters()
-	_, err = counters.Find(bson.D{{"k", bson.D{{"$regex", regex}}}}).MapReduce(&job, &result)
-	if len(result) > 0 {
-		return result[0].Value, err
-	}
-	return 0, err
-}
-
-// A CharmPublisher is responsible for importing a charm dir onto the store.
-type CharmPublisher struct {
-	revision int
-	w        *charmWriter
-}
-
-// Revision returns the revision that will be assigned to the published charm.
-func (p *CharmPublisher) Revision() int {
-	return p.revision
-}
-
-// CharmDir matches the part of the interface of *charm.Dir that is necessary
-// to publish a charm. Using this interface rather than *charm.Dir directly
-// makes testing some aspects of the store possible.
-type CharmDir interface {
-	Meta() *charm.Meta
-	Config() *charm.Config
-	SetRevision(revision int)
-	BundleTo(w io.Writer) error
-}
-
-// Statically ensure that *charm.Dir is indeed a CharmDir.
-var _ CharmDir = (*charm.Dir)(nil)
-
-// Publish bundles charm and writes it to the store. The written charm
-// bundle will have its revision set to the result of Revision.
-// Publish must be called only once for a CharmPublisher.
-func (p *CharmPublisher) Publish(charm CharmDir) error {
-	w := p.w
-	if w == nil {
-		panic("CharmPublisher already published a charm")
-	}
-	p.w = nil
-	w.charm = charm
-	// TODO: Refactor to BundleTo(w, revision)
-	charm.SetRevision(p.revision)
-	err := charm.BundleTo(w)
-	if err == nil {
-		err = w.finish()
-	} else {
-		w.abort()
-	}
-	return err
-}
-
-// CharmPublisher returns a new CharmPublisher for importing a charm that
-// will be made available in the store at all of the provided URLs.
-// The digest parameter must contain the unique identifier that
-// represents the charm data being imported (e.g. the VCS revision sha1).
-// ErrRedundantUpdate is returned if all of the provided urls are
-// already associated to that digest.
-func (s *Store) CharmPublisher(urls []*charm.URL, digest string) (p *CharmPublisher, err error) {
-	log.Printf("store: Trying to add charms %v with key %q...", urls, digest)
-	if err = mustLackRevision("CharmPublisher", urls...); err != nil {
-		return
-	}
-	session := s.session.Copy()
-	defer session.Close()
-
-	maxRev := -1
-	newKey := false
-	charms := session.Charms()
-	doc := charmDoc{}
-	for i := range urls {
-		urlStr := urls[i].String()
-		err = charms.Find(bson.D{{"urls", urlStr}}).Sort("-revision").One(&doc)
-		if err == mgo.ErrNotFound {
-			log.Printf("store: Charm %s not yet in the store.", urls[i])
-			newKey = true
-			continue
-		}
-		if doc.Digest != digest {
-			log.Printf("store: Charm %s is out of date with revision key %q.", urlStr, digest)
-			newKey = true
-		}
-		if err != nil {
-			log.Printf("store: Unknown error looking for charm %s: %s", urlStr, err)
-			return
-		}
-		if doc.Revision > maxRev {
-			maxRev = doc.Revision
-		}
-	}
-	if !newKey {
-		log.Printf("store: All charms have revision key %q. Nothing to update.", digest)
-		err = ErrRedundantUpdate
-		return
-	}
-	revision := maxRev + 1
-	log.Printf("store: Preparing writer to add charms with revision %d.", revision)
-	w := &charmWriter{
-		store:    s,
-		urls:     urls,
-		revision: revision,
-		digest:   digest,
-	}
-	return &CharmPublisher{revision, w}, nil
-}
-
-// charmWriter is an io.Writer that writes charm bundles to the charms GridFS.
-type charmWriter struct {
-	store    *Store
-	session  *storeSession
-	file     *mgo.GridFile
-	sha256   hash.Hash
-	charm    CharmDir
-	urls     []*charm.URL
-	revision int
-	digest   string
-}
-
-// Write creates an entry in the charms GridFS when first called,
-// and streams all written data into it.
-func (w *charmWriter) Write(data []byte) (n int, err error) {
-	if w.file == nil {
-		w.session = w.store.session.Copy()
-		w.file, err = w.session.CharmFS().Create("")
-		if err != nil {
-			log.Printf("store: Failed to create GridFS file: %v", err)
-			return 0, err
-		}
-		w.sha256 = sha256.New()
-		log.Printf("store: Creating GridFS file with id %q...", w.file.Id().(bson.ObjectId).Hex())
-	}
-	_, err = w.sha256.Write(data)
-	if err != nil {
-		panic("hash.Hash should never error")
-	}
-	return w.file.Write(data)
-}
-
-// abort cancels the charm writing.
-func (w *charmWriter) abort() {
-	if w.file != nil {
-		// Ignore error. Already aborting due to a preceding bad situation
-		// elsewhere. This error is not important right now.
-		_ = w.file.Close()
-		w.session.Close()
-	}
-}
-
-// finish completes the charm writing process and inserts the final metadata.
-// After it completes the charm will be available for consumption.
-func (w *charmWriter) finish() error {
-	if w.file == nil {
-		return nil
-	}
-	defer w.session.Close()
-	id := w.file.Id()
-	size := w.file.Size()
-	err := w.file.Close()
-	if err != nil {
-		log.Printf("store: Failed to close GridFS file: %v", err)
-		return err
-	}
-	charms := w.session.Charms()
-	sha256 := hex.EncodeToString(w.sha256.Sum(nil))
-	charm := charmDoc{
-		w.urls,
-		w.revision,
-		w.digest,
-		sha256,
-		size,
-		id.(bson.ObjectId),
-		w.charm.Meta(),
-		w.charm.Config(),
-	}
-	if err = charms.Insert(&charm); err != nil {
-		err = maybeConflict(err)
-		log.Printf("store: Failed to insert new revision of charm %v: %v", w.urls, err)
-		return err
-	}
-	return nil
-}
-
-type CharmInfo struct {
-	revision int
-	digest   string
-	sha256   string
-	size     int64
-	fileId   bson.ObjectId
-	meta     *charm.Meta
-	config   *charm.Config
-}
-
-// Statically ensure CharmInfo is a charm.Charm.
-var _ charm.Charm = (*CharmInfo)(nil)
-
-// Revision returns the store charm's revision.
-func (ci *CharmInfo) Revision() int {
-	return ci.revision
-}
-
-// BundleSha256 returns the sha256 checksum for the stored charm bundle.
-func (ci *CharmInfo) BundleSha256() string {
-	return ci.sha256
-}
-
-// BundleSize returns the size for the stored charm bundle.
-func (ci *CharmInfo) BundleSize() int64 {
-	return ci.size
-}
-
-// Digest returns the unique identifier that represents the charm
-// data imported. This is typically set to the VCS revision digest.
-func (ci *CharmInfo) Digest() string {
-	return ci.digest
-}
-
-// Meta returns the charm.Meta details for the stored charm.
-func (ci *CharmInfo) Meta() *charm.Meta {
-	return ci.meta
-}
-
-// Config returns the charm.Config details for the stored charm.
-func (ci *CharmInfo) Config() *charm.Config {
-	return ci.config
-}
-
-// CharmInfo retrieves the CharmInfo value for the charm at url.
-func (s *Store) CharmInfo(url *charm.URL) (info *CharmInfo, err error) {
-	session := s.session.Copy()
-	defer session.Close()
-
-	log.Debugf("store: Retrieving charm info for %s", url)
-	rev := url.Revision
-	url = url.WithRevision(-1)
-
-	charms := session.Charms()
-	var cdoc charmDoc
-	var qdoc interface{}
-	if rev == -1 {
-		qdoc = bson.D{{"urls", url}}
-	} else {
-		qdoc = bson.D{{"urls", url}, {"revision", rev}}
-	}
-	err = charms.Find(qdoc).Sort("-revision").One(&cdoc)
-	if err != nil {
-		log.Printf("store: Failed to find charm %s: %v", url, err)
-		return nil, ErrNotFound
-	}
-	info = &CharmInfo{
-		cdoc.Revision,
-		cdoc.Digest,
-		cdoc.Sha256,
-		cdoc.Size,
-		cdoc.FileId,
-		cdoc.Meta,
-		cdoc.Config,
-	}
-	return info, nil
-}
-
-// OpenCharm opens for reading via rc the charm currently available at url.
-// rc must be closed after dealing with it or resources will leak.
-func (s *Store) OpenCharm(url *charm.URL) (info *CharmInfo, rc io.ReadCloser, err error) {
-	log.Debugf("store: Opening charm %s", url)
-	info, err = s.CharmInfo(url)
-	if err != nil {
-		return nil, nil, err
-	}
-	session := s.session.Copy()
-	file, err := session.CharmFS().OpenId(info.fileId)
-	if err != nil {
-		log.Printf("store: Failed to open GridFS file for charm %s: %v", url, err)
-		session.Close()
-		return nil, nil, err
-	}
-	rc = &reader{session, file}
-	return
-}
-
-type reader struct {
-	session *storeSession
-	file    *mgo.GridFile
-}
-
-// Read consumes data from the opened charm.
-func (r *reader) Read(buf []byte) (n int, err error) {
-	return r.file.Read(buf)
-}
-
-// Close closes the opened charm and frees associated resources.
-func (r *reader) Close() error {
-	err := r.file.Close()
-	r.session.Close()
-	return err
-}
-
-// charmDoc represents the document stored in MongoDB for a charm.
-type charmDoc struct {
-	URLs     []*charm.URL
-	Revision int
-	Digest   string
-	Sha256   string
-	Size     int64
-	FileId   bson.ObjectId
-	Meta     *charm.Meta
-	Config   *charm.Config
-}
-
-// LockUpdates acquires a server-side lock for updating a single charm
-// that is supposed to be made available in all of the provided urls.
-// If the lock can't be acquired in any of the urls, an error will be
-// immediately returned.
-// In the usual case, any locking done is undone when an error happens,
-// or when l.Unlock is called. If something else goes wrong, the locks
-// will also expire after the period defined in UpdateTimeout.
-func (s *Store) LockUpdates(urls []*charm.URL) (l *UpdateLock, err error) {
-	session := s.session.Copy()
-	keys := make([]string, len(urls))
-	for i := range urls {
-		keys[i] = urls[i].String()
-	}
-	sort.Strings(keys)
-	l = &UpdateLock{keys, session.Locks(), bson.Now()}
-	if err = l.tryLock(); err != nil {
-		session.Close()
-		return nil, err
-	}
-	return l, nil
-}
-
-// UpdateLock represents an acquired update lock over a set of charm URLs.
-type UpdateLock struct {
-	keys  []string
-	locks *mgo.Collection
-	time  time.Time
-}
-
-// Unlock removes the previously acquired server-side lock that prevents
-// other processes from attempting to update a set of charm URLs.
-func (l *UpdateLock) Unlock() {
-	log.Debugf("store: Unlocking charms for future updates: %v", l.keys)
-	defer l.locks.Database.Session.Close()
-	for i := len(l.keys) - 1; i >= 0; i-- {
-		// Using time below ensures only the proper lock is removed.
-		// Can't do much about errors here. Locks will expire anyway.
-		l.locks.Remove(bson.D{{"_id", l.keys[i]}, {"time", l.time}})
-	}
-}
-
-// tryLock tries locking l.keys, one at a time, and succeeds only if it
-// can lock all of them in order. The keys should be pre-sorted so that
-// two-way conflicts can't happen. If any of the keys fail to be locked,
-// and expiring the old lock doesn't work, tryLock undoes all previous
-// locks and aborts with an error.
-func (l *UpdateLock) tryLock() error {
-	for i, key := range l.keys {
-		log.Debugf("store: Trying to lock charm %s for updates...", key)
-		doc := bson.D{{"_id", key}, {"time", l.time}}
-		err := l.locks.Insert(doc)
-		if err == nil {
-			log.Debugf("store: Charm %s is now locked for updates.", key)
-			continue
-		}
-		if lerr, ok := err.(*mgo.LastError); ok && lerr.Code == 11000 {
-			log.Debugf("store: Charm %s is locked. Trying to expire lock.", key)
-			l.tryExpire(key)
-			err = l.locks.Insert(doc)
-			if err == nil {
-				log.Debugf("store: Charm %s is now locked for updates.", key)
-				continue
-			}
-		}
-		// Couldn't lock everyone. Undo previous locks.
-		for j := i - 1; j >= 0; j-- {
-			// Using time below should be unnecessary, but it's an extra check.
-			// Can't do anything about errors here. Lock will expire anyway.
-			l.locks.Remove(bson.D{{"_id", l.keys[j]}, {"time", l.time}})
-		}
-		err = maybeConflict(err)
-		log.Printf("store: Can't lock charms %v for updating: %v", l.keys, err)
-		return err
-	}
-	return nil
-}
-
-// tryExpire attempts to remove outdated locks from the database.
-func (l *UpdateLock) tryExpire(key string) {
-	// Ignore errors. If nothing happens the key will continue locked.
-	l.locks.Remove(bson.D{{"_id", key}, {"time", bson.D{{"$lt", bson.Now().Add(-UpdateTimeout)}}}})
-}
-
-// maybeConflict returns an ErrUpdateConflict if err is a mgo
-// insert conflict LastError, or err itself otherwise.
-func maybeConflict(err error) error {
-	if lerr, ok := err.(*mgo.LastError); ok && lerr.Code == 11000 {
-		return ErrUpdateConflict
-	}
-	return err
-}
-
-// storeSession wraps a mgo.Session ands adds a few convenience methods.
-type storeSession struct {
-	*mgo.Session
-}
-
-// Copy copies the storeSession and its underlying mgo session.
-func (s *storeSession) Copy() *storeSession {
-	return &storeSession{s.Session.Copy()}
-}
-
-// Charms returns the mongo collection where charms are stored.
-func (s *storeSession) Charms() *mgo.Collection {
-	return s.DB("juju").C("charms")
-}
-
-// Charms returns a mgo.GridFS to read and write charms.
-func (s *storeSession) CharmFS() *mgo.GridFS {
-	return s.DB("juju").GridFS("charmfs")
-}
-
-// Events returns the mongo collection where charm events are stored.
-func (s *storeSession) Events() *mgo.Collection {
-	return s.DB("juju").C("events")
-}
-
-// Locks returns the mongo collection where charm locks are stored.
-func (s *storeSession) Locks() *mgo.Collection {
-	return s.DB("juju").C("locks")
-}
-
-// StatTokens returns the mongo collection for storing key tokens
-// for statistics collection.
-func (s *storeSession) StatTokens() *mgo.Collection {
-	return s.DB("juju").C("stat.tokens")
-}
-
-// StatCounters returns the mongo collection for counter values.
-func (s *storeSession) StatCounters() *mgo.Collection {
-	return s.DB("juju").C("stat.counters")
-}
-
-type CharmEventKind int
-
-const (
-	EventPublished CharmEventKind = iota + 1
-	EventPublishError
-
-	EventKindCount
-)
-
-func (k CharmEventKind) String() string {
-	switch k {
-	case EventPublished:
-		return "published"
-	case EventPublishError:
-		return "publish-error"
-	}
-	panic(fmt.Errorf("unknown charm event kind %d", k))
-}
-
-// CharmEvent is a record for an event relating to one or more charm URLs.
-type CharmEvent struct {
-	Kind     CharmEventKind
-	Digest   string
-	Revision int
-	URLs     []*charm.URL
-	Errors   []string `bson:",omitempty"`
-	Warnings []string `bson:",omitempty"`
-	Time     time.Time
-}
-
-// LogCharmEvent records an event related to one or more charm URLs.
-func (s *Store) LogCharmEvent(event *CharmEvent) (err error) {
-	log.Printf("store: Adding charm event for %v with key %q: %s", event.URLs, event.Digest, event.Kind)
-	if err = mustLackRevision("LogCharmEvent", event.URLs...); err != nil {
-		return
-	}
-	session := s.session.Copy()
-	defer session.Close()
-	if event.Kind == 0 || event.Digest == "" || len(event.URLs) == 0 {
-		return fmt.Errorf("LogCharmEvent: need valid Kind, Digest and URLs")
-	}
-	if event.Time.IsZero() {
-		event.Time = time.Now()
-	}
-	events := session.Events()
-	return events.Insert(event)
-}
-
-// CharmEvent returns the most recent event associated with url
-// and digest.  If the specified event isn't found the error
-// ErrUnknownChange will be returned.
-func (s *Store) CharmEvent(url *charm.URL, digest string) (*CharmEvent, error) {
-	// TODO: It'd actually make sense to find the charm event after the
-	// revision id, but since we don't care about that now, just make sure
-	// we don't write bad code.
-	if err := mustLackRevision("CharmEvent", url); err != nil {
-		return nil, err
-	}
-	session := s.session.Copy()
-	defer session.Close()
-
-	events := session.Events()
-	event := &CharmEvent{Digest: digest}
-	query := events.Find(bson.D{{"urls", url}, {"digest", digest}})
-	query.Sort("-time")
-	err := query.One(&event)
-	if err == mgo.ErrNotFound {
-		return nil, ErrNotFound
-	}
-	if err != nil {
-		return nil, err
-	}
-	return event, nil
-}
-
-// mustLackRevision returns an error if any of the urls has a revision.
-func mustLackRevision(context string, urls ...*charm.URL) error {
-	for _, url := range urls {
-		if url.Revision != -1 {
-			err := fmt.Errorf("%s: got charm URL with revision: %s", context, url)
-			log.Printf("store: %v", err)
-			return err
-		}
-	}
-	return nil
-}

=== removed file 'store/store_test.go'
--- store/store_test.go	2012-11-20 07:18:32 +0000
+++ store/store_test.go	1970-01-01 00:00:00 +0000
@@ -1,608 +0,0 @@
-package store_test
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"labix.org/v2/mgo/bson"
-	. "launchpad.net/gocheck"
-	"launchpad.net/juju-core/charm"
-	"launchpad.net/juju-core/log"
-	"launchpad.net/juju-core/store"
-	"launchpad.net/juju-core/testing"
-	"strconv"
-	"sync"
-	stdtesting "testing"
-	"time"
-)
-
-func Test(t *stdtesting.T) {
-	TestingT(t)
-}
-
-var _ = Suite(&StoreSuite{})
-var _ = Suite(&TrivialSuite{})
-
-type StoreSuite struct {
-	MgoSuite
-	testing.HTTPSuite
-	store *store.Store
-}
-
-type TrivialSuite struct{}
-
-func (s *StoreSuite) SetUpSuite(c *C) {
-	s.MgoSuite.SetUpSuite(c)
-	s.HTTPSuite.SetUpSuite(c)
-}
-
-func (s *StoreSuite) TearDownSuite(c *C) {
-	s.HTTPSuite.TearDownSuite(c)
-	s.MgoSuite.TearDownSuite(c)
-}
-
-func (s *StoreSuite) SetUpTest(c *C) {
-	s.MgoSuite.SetUpTest(c)
-	var err error
-	s.store, err = store.Open(s.Addr)
-	c.Assert(err, IsNil)
-	log.Target = c
-	log.Debug = true
-}
-
-func (s *StoreSuite) TearDownTest(c *C) {
-	s.HTTPSuite.TearDownTest(c)
-	if s.store != nil {
-		s.store.Close()
-	}
-	s.MgoSuite.TearDownTest(c)
-}
-
-// FakeCharmDir is a charm that implements the interface that the
-// store publisher cares about.
-type FakeCharmDir struct {
-	revision interface{} // so we can tell if it's not set.
-	error    string
-}
-
-func (d *FakeCharmDir) Meta() *charm.Meta {
-	return &charm.Meta{
-		Name:        "fakecharm",
-		Summary:     "Fake charm for testing purposes.",
-		Description: "This is a fake charm for testing purposes.\n",
-		Provides:    make(map[string]charm.Relation),
-		Requires:    make(map[string]charm.Relation),
-		Peers:       make(map[string]charm.Relation),
-	}
-}
-
-func (d *FakeCharmDir) Config() *charm.Config {
-	return &charm.Config{make(map[string]charm.Option)}
-}
-
-func (d *FakeCharmDir) SetRevision(revision int) {
-	d.revision = revision
-}
-
-func (d *FakeCharmDir) BundleTo(w io.Writer) error {
-	if d.error == "beforeWrite" {
-		return fmt.Errorf(d.error)
-	}
-	_, err := w.Write([]byte(fmt.Sprintf("charm-revision-%v", d.revision)))
-	if d.error == "afterWrite" {
-		return fmt.Errorf(d.error)
-	}
-	return err
-}
-
-func (s *StoreSuite) TestCharmPublisherWithRevisionedURL(c *C) {
-	urls := []*charm.URL{charm.MustParseURL("cs:oneiric/wordpress-0")}
-	pub, err := s.store.CharmPublisher(urls, "some-digest")
-	c.Assert(err, ErrorMatches, "CharmPublisher: got charm URL with revision: cs:oneiric/wordpress-0")
-	c.Assert(pub, IsNil)
-}
-
-func (s *StoreSuite) TestCharmPublisher(c *C) {
-	urlA := charm.MustParseURL("cs:oneiric/wordpress-a")
-	urlB := charm.MustParseURL("cs:oneiric/wordpress-b")
-	urls := []*charm.URL{urlA, urlB}
-
-	pub, err := s.store.CharmPublisher(urls, "some-digest")
-	c.Assert(err, IsNil)
-	c.Assert(pub.Revision(), Equals, 0)
-
-	err = pub.Publish(testing.Charms.ClonedDir(c.MkDir(), "series", "dummy"))
-	c.Assert(err, IsNil)
-
-	for _, url := range urls {
-		info, rc, err := s.store.OpenCharm(url)
-		c.Assert(err, IsNil)
-		c.Assert(info.Revision(), Equals, 0)
-		c.Assert(info.Digest(), Equals, "some-digest")
-		data, err := ioutil.ReadAll(rc)
-		c.Check(err, IsNil)
-		err = rc.Close()
-		c.Assert(err, IsNil)
-		bundle, err := charm.ReadBundleBytes(data)
-		c.Assert(err, IsNil)
-
-		// The same information must be available by reading the
-		// full charm data...
-		c.Assert(bundle.Meta().Name, Equals, "dummy")
-		c.Assert(bundle.Config().Options["title"].Default, Equals, "My Title")
-
-		// ... and the queriable details.
-		c.Assert(info.Meta().Name, Equals, "dummy")
-		c.Assert(info.Config().Options["title"].Default, Equals, "My Title")
-
-		info2, err := s.store.CharmInfo(url)
-		c.Assert(err, IsNil)
-		c.Assert(info2, DeepEquals, info)
-	}
-}
-
-func (s *StoreSuite) TestCharmPublishError(c *C) {
-	url := charm.MustParseURL("cs:oneiric/wordpress")
-	urls := []*charm.URL{url}
-
-	// Publish one successfully to bump the revision so we can
-	// make sure it is being correctly set below.
-	pub, err := s.store.CharmPublisher(urls, "one-digest")
-	c.Assert(err, IsNil)
-	c.Assert(pub.Revision(), Equals, 0)
-	err = pub.Publish(&FakeCharmDir{})
-	c.Assert(err, IsNil)
-
-	pub, err = s.store.CharmPublisher(urls, "another-digest")
-	c.Assert(err, IsNil)
-	c.Assert(pub.Revision(), Equals, 1)
-	err = pub.Publish(&FakeCharmDir{error: "beforeWrite"})
-	c.Assert(err, ErrorMatches, "beforeWrite")
-
-	pub, err = s.store.CharmPublisher(urls, "another-digest")
-	c.Assert(err, IsNil)
-	c.Assert(pub.Revision(), Equals, 1)
-	err = pub.Publish(&FakeCharmDir{error: "afterWrite"})
-	c.Assert(err, ErrorMatches, "afterWrite")
-
-	// Still at the original charm revision that succeeded first.
-	info, err := s.store.CharmInfo(url)
-	c.Assert(err, IsNil)
-	c.Assert(info.Revision(), Equals, 0)
-	c.Assert(info.Digest(), Equals, "one-digest")
-}
-
-func (s *StoreSuite) TestCharmInfoNotFound(c *C) {
-	info, err := s.store.CharmInfo(charm.MustParseURL("cs:oneiric/wordpress"))
-	c.Assert(err, Equals, store.ErrNotFound)
-	c.Assert(info, IsNil)
-}
-
-func (s *StoreSuite) TestRevisioning(c *C) {
-	urlA := charm.MustParseURL("cs:oneiric/wordpress-a")
-	urlB := charm.MustParseURL("cs:oneiric/wordpress-b")
-	urls := []*charm.URL{urlA, urlB}
-
-	tests := []struct {
-		urls []*charm.URL
-		data string
-	}{
-		{urls[0:], "charm-revision-0"},
-		{urls[1:], "charm-revision-1"},
-		{urls[0:], "charm-revision-2"},
-	}
-
-	for i, t := range tests {
-		pub, err := s.store.CharmPublisher(t.urls, fmt.Sprintf("digest-%d", i))
-		c.Assert(err, IsNil)
-		c.Assert(pub.Revision(), Equals, i)
-
-		err = pub.Publish(&FakeCharmDir{})
-		c.Assert(err, IsNil)
-	}
-
-	for i, t := range tests {
-		for _, url := range t.urls {
-			url = url.WithRevision(i)
-			info, rc, err := s.store.OpenCharm(url)
-			c.Assert(err, IsNil)
-			data, err := ioutil.ReadAll(rc)
-			cerr := rc.Close()
-			c.Assert(info.Revision(), Equals, i)
-			c.Assert(url.Revision, Equals, i) // Untouched.
-			c.Assert(cerr, IsNil)
-			c.Assert(string(data), Equals, string(t.data))
-			c.Assert(err, IsNil)
-		}
-	}
-
-	info, rc, err := s.store.OpenCharm(urlA.WithRevision(1))
-	c.Assert(err, Equals, store.ErrNotFound)
-	c.Assert(info, IsNil)
-	c.Assert(rc, IsNil)
-}
-
-func (s *StoreSuite) TestLockUpdates(c *C) {
-	urlA := charm.MustParseURL("cs:oneiric/wordpress-a")
-	urlB := charm.MustParseURL("cs:oneiric/wordpress-b")
-	urls := []*charm.URL{urlA, urlB}
-
-	// Lock update of just B to force a partial conflict.
-	lock1, err := s.store.LockUpdates(urls[1:])
-	c.Assert(err, IsNil)
-
-	// Partially conflicts with locked update above.
-	lock2, err := s.store.LockUpdates(urls)
-	c.Check(err, Equals, store.ErrUpdateConflict)
-	c.Check(lock2, IsNil)
-
-	lock1.Unlock()
-
-	// Trying again should work since lock1 was released.
-	lock3, err := s.store.LockUpdates(urls)
-	c.Assert(err, IsNil)
-	lock3.Unlock()
-}
-
-func (s *StoreSuite) TestLockUpdatesExpires(c *C) {
-	urlA := charm.MustParseURL("cs:oneiric/wordpress-a")
-	urlB := charm.MustParseURL("cs:oneiric/wordpress-b")
-	urls := []*charm.URL{urlA, urlB}
-
-	// Initiate an update of B only to force a partial conflict.
-	lock1, err := s.store.LockUpdates(urls[1:])
-	c.Assert(err, IsNil)
-
-	// Hack time to force an expiration.
-	locks := s.Session.DB("juju").C("locks")
-	selector := bson.M{"_id": urlB.String()}
-	update := bson.M{"time": bson.Now().Add(-store.UpdateTimeout - 10e9)}
-	err = locks.Update(selector, update)
-	c.Check(err, IsNil)
-
-	// Works due to expiration of previous lock.
-	lock2, err := s.store.LockUpdates(urls)
-	c.Assert(err, IsNil)
-	defer lock2.Unlock()
-
-	// The expired lock was forcefully killed. Unlocking it must
-	// not interfere with lock2 which is still alive.
-	lock1.Unlock()
-
-	// The above statement was a NOOP and lock2 is still in effect,
-	// so attempting another lock must necessarily fail.
-	lock3, err := s.store.LockUpdates(urls)
-	c.Check(err == store.ErrUpdateConflict, Equals, true)
-	c.Check(lock3, IsNil)
-}
-
-func (s *StoreSuite) TestConflictingUpdate(c *C) {
-	// This test checks that if for whatever reason the locking
-	// safety-net fails, adding two charms in parallel still
-	// results in a sane outcome.
-	url := charm.MustParseURL("cs:oneiric/wordpress")
-	urls := []*charm.URL{url}
-
-	pub1, err := s.store.CharmPublisher(urls, "some-digest")
-	c.Assert(err, IsNil)
-	c.Assert(pub1.Revision(), Equals, 0)
-
-	pub2, err := s.store.CharmPublisher(urls, "some-digest")
-	c.Assert(err, IsNil)
-	c.Assert(pub2.Revision(), Equals, 0)
-
-	// The first publishing attempt should work.
-	err = pub2.Publish(&FakeCharmDir{})
-	c.Assert(err, IsNil)
-
-	// Attempting to finish the second attempt should break,
-	// since it lost the race and the given revision is already
-	// in place.
-	err = pub1.Publish(&FakeCharmDir{})
-	c.Assert(err, Equals, store.ErrUpdateConflict)
-}
-
-func (s *StoreSuite) TestRedundantUpdate(c *C) {
-	urlA := charm.MustParseURL("cs:oneiric/wordpress-a")
-	urlB := charm.MustParseURL("cs:oneiric/wordpress-b")
-	urls := []*charm.URL{urlA, urlB}
-
-	pub, err := s.store.CharmPublisher(urls, "digest-0")
-	c.Assert(err, IsNil)
-	c.Assert(pub.Revision(), Equals, 0)
-	err = pub.Publish(&FakeCharmDir{})
-	c.Assert(err, IsNil)
-
-	// All charms are already on digest-0.
-	pub, err = s.store.CharmPublisher(urls, "digest-0")
-	c.Assert(err, ErrorMatches, "charm is up-to-date")
-	c.Assert(err, Equals, store.ErrRedundantUpdate)
-	c.Assert(pub, IsNil)
-
-	// Now add a second revision just for wordpress-b.
-	pub, err = s.store.CharmPublisher(urls[1:], "digest-1")
-	c.Assert(err, IsNil)
-	c.Assert(pub.Revision(), Equals, 1)
-	err = pub.Publish(&FakeCharmDir{})
-	c.Assert(err, IsNil)
-
-	// Same digest bumps revision because one of them was old.
-	pub, err = s.store.CharmPublisher(urls, "digest-1")
-	c.Assert(err, IsNil)
-	c.Assert(pub.Revision(), Equals, 2)
-	err = pub.Publish(&FakeCharmDir{})
-	c.Assert(err, IsNil)
-}
-
-const fakeRevZeroSha = "319095521ac8a62fa1e8423351973512ecca8928c9f62025e37de57c9ef07a53"
-
-func (s *StoreSuite) TestCharmBundleData(c *C) {
-	url := charm.MustParseURL("cs:oneiric/wordpress")
-	urls := []*charm.URL{url}
-
-	pub, err := s.store.CharmPublisher(urls, "key")
-	c.Assert(err, IsNil)
-	c.Assert(pub.Revision(), Equals, 0)
-
-	err = pub.Publish(&FakeCharmDir{})
-	c.Assert(err, IsNil)
-
-	info, rc, err := s.store.OpenCharm(url)
-	c.Assert(err, IsNil)
-	c.Check(info.BundleSha256(), Equals, fakeRevZeroSha)
-	c.Check(info.BundleSize(), Equals, int64(len("charm-revision-0")))
-	err = rc.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *StoreSuite) TestLogCharmEventWithRevisionedURL(c *C) {
-	url := charm.MustParseURL("cs:oneiric/wordpress-0")
-	event := &store.CharmEvent{
-		Kind:   store.EventPublishError,
-		Digest: "some-digest",
-		URLs:   []*charm.URL{url},
-	}
-	err := s.store.LogCharmEvent(event)
-	c.Assert(err, ErrorMatches, "LogCharmEvent: got charm URL with revision: cs:oneiric/wordpress-0")
-
-	// This may work in the future, but not now.
-	event, err = s.store.CharmEvent(url, "some-digest")
-	c.Assert(err, ErrorMatches, "CharmEvent: got charm URL with revision: cs:oneiric/wordpress-0")
-	c.Assert(event, IsNil)
-}
-
-func (s *StoreSuite) TestLogCharmEvent(c *C) {
-	url1 := charm.MustParseURL("cs:oneiric/wordpress")
-	url2 := charm.MustParseURL("cs:oneiric/mysql")
-	urls := []*charm.URL{url1, url2}
-
-	event1 := &store.CharmEvent{
-		Kind:     store.EventPublished,
-		Revision: 42,
-		Digest:   "revKey1",
-		URLs:     urls,
-		Warnings: []string{"A warning."},
-		Time:     time.Unix(1, 0),
-	}
-	event2 := &store.CharmEvent{
-		Kind:     store.EventPublished,
-		Revision: 42,
-		Digest:   "revKey2",
-		URLs:     urls,
-		Time:     time.Unix(1, 0),
-	}
-	event3 := &store.CharmEvent{
-		Kind:   store.EventPublishError,
-		Digest: "revKey2",
-		Errors: []string{"An error."},
-		URLs:   urls[:1],
-	}
-
-	for _, event := range []*store.CharmEvent{event1, event2, event3} {
-		err := s.store.LogCharmEvent(event)
-		c.Assert(err, IsNil)
-	}
-
-	events := s.Session.DB("juju").C("events")
-	var s1, s2 map[string]interface{}
-
-	err := events.Find(bson.M{"digest": "revKey1"}).One(&s1)
-	c.Assert(err, IsNil)
-	c.Assert(s1["kind"], Equals, int(store.EventPublished))
-	c.Assert(s1["urls"], DeepEquals, []interface{}{"cs:oneiric/wordpress", "cs:oneiric/mysql"})
-	c.Assert(s1["warnings"], DeepEquals, []interface{}{"A warning."})
-	c.Assert(s1["errors"], IsNil)
-	c.Assert(s1["time"], DeepEquals, time.Unix(1, 0))
-
-	err = events.Find(bson.M{"digest": "revKey2", "kind": store.EventPublishError}).One(&s2)
-	c.Assert(err, IsNil)
-	c.Assert(s2["urls"], DeepEquals, []interface{}{"cs:oneiric/wordpress"})
-	c.Assert(s2["warnings"], IsNil)
-	c.Assert(s2["errors"], DeepEquals, []interface{}{"An error."})
-	c.Assert(s2["time"].(time.Time).After(bson.Now().Add(-10e9)), Equals, true)
-
-	// Mongo stores timestamps in milliseconds, so chop
-	// off the extra bits for comparison.
-	event3.Time = time.Unix(0, event3.Time.UnixNano()/1e6*1e6)
-
-	event, err := s.store.CharmEvent(urls[0], "revKey2")
-	c.Assert(err, IsNil)
-	c.Assert(event, DeepEquals, event3)
-
-	event, err = s.store.CharmEvent(urls[1], "revKey1")
-	c.Assert(err, IsNil)
-	c.Assert(event, DeepEquals, event1)
-
-	event, err = s.store.CharmEvent(urls[1], "revKeyX")
-	c.Assert(err, Equals, store.ErrNotFound)
-	c.Assert(event, IsNil)
-}
-
-func (s *StoreSuite) TestCounters(c *C) {
-	sum, err := s.store.SumCounter([]string{"a"}, false)
-	c.Assert(err, IsNil)
-	c.Assert(sum, Equals, int64(0))
-
-	for i := 0; i < 10; i++ {
-		err := s.store.IncCounter([]string{"a", "b", "c"})
-		c.Assert(err, IsNil)
-	}
-	for i := 0; i < 7; i++ {
-		s.store.IncCounter([]string{"a", "b"})
-		c.Assert(err, IsNil)
-	}
-	for i := 0; i < 3; i++ {
-		s.store.IncCounter([]string{"a", "z", "b"})
-		c.Assert(err, IsNil)
-	}
-
-	tests := []struct {
-		key    []string
-		prefix bool
-		result int64
-	}{
-		{[]string{"a", "b", "c"}, false, 10},
-		{[]string{"a", "b"}, false, 7},
-		{[]string{"a", "z", "b"}, false, 3},
-		{[]string{"a", "b", "c"}, true, 10},
-		{[]string{"a", "b"}, true, 17},
-		{[]string{"a"}, true, 20},
-		{[]string{"b"}, true, 0},
-	}
-
-	for _, t := range tests {
-		c.Logf("Test: %#v\n", t)
-		sum, err := s.store.SumCounter(t.key, t.prefix)
-		c.Assert(err, IsNil)
-		c.Assert(sum, Equals, t.result)
-	}
-
-	// High-level interface works. Now check that the data is
-	// stored correctly.
-	counters := s.Session.DB("juju").C("stat.counters")
-	docs1, err := counters.Count()
-	c.Assert(err, IsNil)
-	if docs1 != 3 && docs1 != 4 {
-		fmt.Errorf("Expected 3 or 4 docs in counters collection, got %d", docs1)
-	}
-
-	// Hack times so that the next operation adds another document.
-	err = counters.Update(nil, bson.D{{"$set", bson.D{{"t", 1}}}})
-	c.Check(err, IsNil)
-
-	err = s.store.IncCounter([]string{"a", "b", "c"})
-	c.Assert(err, IsNil)
-
-	docs2, err := counters.Count()
-	c.Assert(err, IsNil)
-	c.Assert(docs2, Equals, docs1+1)
-
-	sum, err = s.store.SumCounter([]string{"a", "b", "c"}, false)
-	c.Assert(err, IsNil)
-	c.Assert(sum, Equals, int64(11))
-
-	sum, err = s.store.SumCounter([]string{"a"}, true)
-	c.Assert(err, IsNil)
-	c.Assert(sum, Equals, int64(21))
-}
-
-func (s *StoreSuite) TestCountersReadOnlySum(c *C) {
-	// Summing up an unknown key shouldn't add the key to the database.
-	sum, err := s.store.SumCounter([]string{"a", "b", "c"}, false)
-	c.Assert(err, IsNil)
-	c.Assert(sum, Equals, int64(0))
-
-	tokens := s.Session.DB("juju").C("stat.tokens")
-	n, err := tokens.Count()
-	c.Assert(err, IsNil)
-	c.Assert(n, Equals, 0)
-}
-
-func (s *StoreSuite) TestCountersTokenCaching(c *C) {
-	sum, err := s.store.SumCounter([]string{"a"}, false)
-	c.Assert(err, IsNil)
-	c.Assert(sum, Equals, int64(0))
-
-	const genSize = 512
-
-	// All of these will be cached, as we have two generations
-	// of genSize entries each.
-	for i := 0; i < genSize*2; i++ {
-		err := s.store.IncCounter([]string{strconv.Itoa(i)})
-		c.Assert(err, IsNil)
-	}
-
-	// Now go behind the scenes and corrupt all the tokens.
-	tokens := s.Session.DB("juju").C("stat.tokens")
-	iter := tokens.Find(nil).Iter()
-	var t struct {
-		Id    int    "_id"
-		Token string "t"
-	}
-	for iter.Next(&t) {
-		err := tokens.UpdateId(t.Id, bson.M{"$set": bson.M{"t": "corrupted" + t.Token}})
-		c.Assert(err, IsNil)
-	}
-	c.Assert(iter.Err(), IsNil)
-
-	// We can consult the counters for the cached entries still.
-	// First, check that the newest generation is good.
-	for i := genSize; i < genSize*2; i++ {
-		n, err := s.store.SumCounter([]string{strconv.Itoa(i)}, false)
-		c.Assert(err, IsNil)
-		c.Assert(n, Equals, int64(1))
-	}
-
-	// Now, we can still access a single entry of the older generation,
-	// but this will cause the generations to flip and thus the rest
-	// of the old generation will go away as the top half of the
-	// entries is turned into the old generation.
-	n, err := s.store.SumCounter([]string{"0"}, false)
-	c.Assert(err, IsNil)
-	c.Assert(n, Equals, int64(1))
-
-	// Now we've lost access to the rest of the old generation.
-	for i := 1; i < genSize; i++ {
-		n, err := s.store.SumCounter([]string{strconv.Itoa(i)}, false)
-		c.Assert(err, IsNil)
-		c.Assert(n, Equals, int64(0))
-	}
-
-	// But we still have all of the top half available since it was
-	// moved into the old generation.
-	for i := genSize; i < genSize*2; i++ {
-		n, err := s.store.SumCounter([]string{strconv.Itoa(i)}, false)
-		c.Assert(err, IsNil)
-		c.Assert(n, Equals, int64(1))
-	}
-}
-
-func (s *StoreSuite) TestCounterTokenUniqueness(c *C) {
-	var wg0, wg1 sync.WaitGroup
-	wg0.Add(10)
-	wg1.Add(10)
-	for i := 0; i < 10; i++ {
-		go func() {
-			wg0.Done()
-			wg0.Wait()
-			defer wg1.Done()
-			err := s.store.IncCounter([]string{"a"})
-			c.Check(err, IsNil)
-		}()
-	}
-	wg1.Wait()
-
-	sum, err := s.store.SumCounter([]string{"a"}, false)
-	c.Assert(err, IsNil)
-	c.Assert(sum, Equals, int64(10))
-}
-
-func (s *TrivialSuite) TestEventString(c *C) {
-	c.Assert(store.EventPublished, Matches, "published")
-	c.Assert(store.EventPublishError, Matches, "publish-error")
-	for kind := store.CharmEventKind(1); kind < store.EventKindCount; kind++ {
-		// This guarantees the switch in String is properly
-		// updated with new event kinds.
-		c.Assert(kind.String(), Matches, "[a-z-]+")
-	}
-}