From a8cf83774ad38adb60c549dabecc5e4bc93fb9d4 Mon Sep 17 00:00:00 2001 From: Andrey Smirnov Date: Tue, 8 Apr 2014 11:58:32 +0400 Subject: [PATCH] PublishedRepo remembers RefList is has been published with. #8 --- deb/publish.go | 64 +++++++++++++++++++++++++++++++++++++-------- deb/publish_test.go | 29 ++++++++++++++++++++ 2 files changed, 82 insertions(+), 11 deletions(-) diff --git a/deb/publish.go b/deb/publish.go index cbc8aa51..69cce207 100644 --- a/deb/publish.go +++ b/deb/publish.go @@ -32,8 +32,9 @@ type PublishedRepo struct { // SourceUUID is UUID of either snapshot or local repo SourceUUID string `codec:"SnapshotUUID"` - snapshot *Snapshot - localRepo *LocalRepo + snapshot *Snapshot + localRepo *LocalRepo + packageRefs *PackageRefList } // NewPublishedRepo creates new published repository @@ -59,6 +60,7 @@ func NewPublishedRepo(prefix string, distribution string, component string, arch if ok { result.SourceKind = "local" result.SourceUUID = result.localRepo.UUID + result.packageRefs = result.localRepo.RefList() } else { panic("unknown source kind") } @@ -179,6 +181,19 @@ func (p *PublishedRepo) Key() []byte { return []byte("U" + p.Prefix + ">>" + p.Distribution) } +// RefKey is a unique id for package reference list +func (p *PublishedRepo) RefKey() []byte { + return []byte("E" + p.UUID) +} + +// RefList returns list of package refs in local repo +func (p *PublishedRepo) RefList() *PackageRefList { + if p.SourceKind == "local" { + return p.packageRefs + } + return p.snapshot.RefList() +} + // Encode does msgpack encoding of PublishedRepo func (p *PublishedRepo) Encode() []byte { var buf bytes.Buffer @@ -206,7 +221,8 @@ func (p *PublishedRepo) Decode(input []byte) error { } // Publish publishes snapshot (repository) contents, links package files, generates Packages & Release files, signs them -func (p *PublishedRepo) Publish(packagePool aptly.PackagePool, publishedStorage aptly.PublishedStorage, collectionFactory *CollectionFactory, signer utils.Signer, progress aptly.Progress) error { +func (p *PublishedRepo) Publish(packagePool aptly.PackagePool, publishedStorage aptly.PublishedStorage, + collectionFactory *CollectionFactory, signer utils.Signer, progress aptly.Progress) error { err := publishedStorage.MkDir(filepath.Join(p.Prefix, "pool")) if err != nil { return err @@ -489,22 +505,44 @@ func (collection *PublishedRepoCollection) CheckDuplicate(repo *PublishedRepo) * } // Update stores updated information about repo in DB -func (collection *PublishedRepoCollection) Update(repo *PublishedRepo) error { - err := collection.db.Put(repo.Key(), repo.Encode()) +func (collection *PublishedRepoCollection) Update(repo *PublishedRepo) (err error) { + err = collection.db.Put(repo.Key(), repo.Encode()) if err != nil { - return err + return } - return nil + + if repo.SourceKind == "local" { + err = collection.db.Put(repo.RefKey(), repo.packageRefs.Encode()) + } + return } // LoadComplete loads additional information for remote repo -func (collection *PublishedRepoCollection) LoadComplete(repo *PublishedRepo, collectionFactory *CollectionFactory) error { - var err error - +func (collection *PublishedRepoCollection) LoadComplete(repo *PublishedRepo, collectionFactory *CollectionFactory) (err error) { if repo.SourceKind == "snapshot" { repo.snapshot, err = collectionFactory.SnapshotCollection().ByUUID(repo.SourceUUID) + if err != nil { + return + } + err = collectionFactory.SnapshotCollection().LoadComplete(repo.snapshot) } else if repo.SourceKind == "local" { repo.localRepo, err = collectionFactory.LocalRepoCollection().ByUUID(repo.SourceUUID) + if err != nil { + return + } + err = collectionFactory.LocalRepoCollection().LoadComplete(repo.localRepo) + if err != nil { + return + } + + var encoded []byte + encoded, err = collection.db.Get(repo.RefKey()) + if err != nil { + return err + } + + repo.packageRefs = &PackageRefList{} + err = repo.packageRefs.Decode(encoded) } else { panic("unknown SourceKind") } @@ -603,5 +641,9 @@ func (collection *PublishedRepoCollection) Remove(publishedStorage aptly.Publish collection.list[len(collection.list)-1], collection.list[repoPosition], collection.list = nil, collection.list[len(collection.list)-1], collection.list[:len(collection.list)-1] - return collection.db.Delete(repo.Key()) + err = collection.db.Delete(repo.Key()) + if err != nil { + return err + } + return collection.db.Delete(repo.RefKey()) } diff --git a/deb/publish_test.go b/deb/publish_test.go index 33e23c75..6307d7f9 100644 --- a/deb/publish_test.go +++ b/deb/publish_test.go @@ -99,6 +99,20 @@ func (s *PublishedRepoSuite) TearDownTest(c *C) { s.db.Close() } +func (s *PublishedRepoSuite) TestNewPublishedRepo(c *C) { + c.Check(s.repo.snapshot, Equals, s.snapshot) + c.Check(s.repo.SourceKind, Equals, "snapshot") + c.Check(s.repo.SourceUUID, Equals, s.snapshot.UUID) + + c.Check(s.repo2.localRepo, Equals, s.localRepo) + c.Check(s.repo2.SourceKind, Equals, "local") + c.Check(s.repo2.SourceUUID, Equals, s.localRepo.UUID) + c.Check(s.repo2.packageRefs.Len(), Equals, 3) + + c.Check(s.repo.RefList().Len(), Equals, 3) + c.Check(s.repo2.RefList().Len(), Equals, 3) +} + func (s *PublishedRepoSuite) TestPrefixNormalization(c *C) { for _, t := range []struct { @@ -266,6 +280,10 @@ func (s *PublishedRepoSuite) TestKey(c *C) { c.Check(s.repo.Key(), DeepEquals, []byte("Uppa>>squeeze")) } +func (s *PublishedRepoSuite) TestRefKey(c *C) { + c.Check(s.repo.RefKey(), DeepEquals, []byte("E"+s.repo.UUID)) +} + func (s *PublishedRepoSuite) TestEncodeDecode(c *C) { encoded := s.repo.Encode() repo := &PublishedRepo{} @@ -280,6 +298,7 @@ func (s *PublishedRepoSuite) TestEncodeDecode(c *C) { err = repo2.Decode(encoded2) s.repo2.localRepo = nil + s.repo2.packageRefs = nil c.Assert(err, IsNil) c.Assert(repo2, DeepEquals, s.repo2) } @@ -376,12 +395,15 @@ func (s *PublishedRepoCollectionSuite) TestUpdateLoadComplete(c *C) { c.Assert(r.snapshot, IsNil) c.Assert(s.collection.LoadComplete(r, s.factory), IsNil) c.Assert(r.snapshot.UUID, Equals, s.repo1.snapshot.UUID) + c.Assert(r.RefList().Len(), Equals, 0) r, err = collection.ByPrefixDistribution("ppa", "precise") c.Assert(err, IsNil) c.Assert(r.localRepo, IsNil) c.Assert(s.collection.LoadComplete(r, s.factory), IsNil) c.Assert(r.localRepo.UUID, Equals, s.repo4.localRepo.UUID) + c.Assert(r.packageRefs.Len(), Equals, 0) + c.Assert(r.RefList().Len(), Equals, 0) } func (s *PublishedRepoCollectionSuite) TestForEachAndLen(c *C) { @@ -413,6 +435,13 @@ func (s *PublishedRepoCollectionSuite) TestBySnapshot(c *C) { c.Check(s.collection.BySnapshot(s.snap2), DeepEquals, []*PublishedRepo{s.repo2}) } +func (s *PublishedRepoCollectionSuite) TestByLocalRepo(c *C) { + c.Check(s.collection.Add(s.repo1), IsNil) + c.Check(s.collection.Add(s.repo4), IsNil) + + c.Check(s.collection.ByLocalRepo(s.localRepo), DeepEquals, []*PublishedRepo{s.repo4}) +} + type PublishedRepoRemoveSuite struct { PackageListMixinSuite db database.Storage