diff --git a/aptly/interfaces.go b/aptly/interfaces.go index 6b04d95a..9e9f88dc 100644 --- a/aptly/interfaces.go +++ b/aptly/interfaces.go @@ -47,6 +47,12 @@ type LocalPublishedStorage interface { PublicPath() string } +// PublishedStorageProvider is a thing that returns PublishedStorage by name +type PublishedStorageProvider interface { + // GetPublishedStorage returns PublishedStorage by name + GetPublishedStorage(name string) PublishedStorage +} + // Progress is a progress displaying entity, it allows progress bars & simple prints type Progress interface { // Writer interface to support progress bar ticking diff --git a/deb/publish.go b/deb/publish.go index f0b2f51b..385d87f5 100644 --- a/deb/publish.go +++ b/deb/publish.go @@ -31,7 +31,8 @@ type repoSourceItem struct { type PublishedRepo struct { // Internal unique ID UUID string - // Prefix & distribution should be unique across all published repositories + // Storage & Prefix & distribution should be unique across all published repositories + Storage string Prefix string Distribution string Origin string @@ -116,13 +117,15 @@ func walkUpTree(source interface{}, collectionFactory *CollectionFactory) (rootD // NewPublishedRepo creates new published repository // +// storage is PublishedStorage name // prefix specifies publishing prefix // distribution and architectures are user-defined properties // components & sources are lists of component to source mapping (*Snapshot or *LocalRepo) -func NewPublishedRepo(prefix string, distribution string, architectures []string, +func NewPublishedRepo(storage, prefix, distribution string, architectures []string, components []string, sources []interface{}, collectionFactory *CollectionFactory) (*PublishedRepo, error) { result := &PublishedRepo{ UUID: uuid.New(), + Storage: storage, Architectures: architectures, Sources: make(map[string]string), sourceItems: make(map[string]repoSourceItem), @@ -266,13 +269,22 @@ func (p *PublishedRepo) String() string { extra = " (" + extra + ")" } - return fmt.Sprintf("%s/%s%s [%s] publishes %s", p.Prefix, p.Distribution, extra, strings.Join(p.Architectures, ", "), + return fmt.Sprintf("%s/%s%s [%s] publishes %s", p.StoragePrefix(), p.Distribution, extra, strings.Join(p.Architectures, ", "), strings.Join(sources, ", ")) } +// StoragePrefix returns combined storage & prefix for the repo +func (p *PublishedRepo) StoragePrefix() string { + result := p.Prefix + if p.Storage != "" { + result = p.Storage + ":" + p.Prefix + } + return result +} + // Key returns unique key identifying PublishedRepo func (p *PublishedRepo) Key() []byte { - return []byte("U" + p.Prefix + ">>" + p.Distribution) + return []byte("U" + p.StoragePrefix() + ">>" + p.Distribution) } // RefKey is a unique id for package reference list @@ -380,8 +392,10 @@ func (p *PublishedRepo) GetLabel() string { } // Publish publishes snapshot (repository) contents, links package files, generates Packages & Release files, signs them -func (p *PublishedRepo) Publish(packagePool aptly.PackagePool, publishedStorage aptly.PublishedStorage, +func (p *PublishedRepo) Publish(packagePool aptly.PackagePool, publishedStorageProvider aptly.PublishedStorageProvider, collectionFactory *CollectionFactory, signer utils.Signer, progress aptly.Progress) error { + publishedStorage := publishedStorageProvider.GetPublishedStorage(p.Storage) + err := publishedStorage.MkDir(filepath.Join(p.Prefix, "pool")) if err != nil { return err @@ -689,8 +703,10 @@ func (p *PublishedRepo) Publish(packagePool aptly.PackagePool, publishedStorage // RemoveFiles removes files that were created by Publish // // It can remove prefix fully, and part of pool (for specific component) -func (p *PublishedRepo) RemoveFiles(publishedStorage aptly.PublishedStorage, removePrefix bool, +func (p *PublishedRepo) RemoveFiles(publishedStorageProvider aptly.PublishedStorageProvider, removePrefix bool, removePoolComponents []string, progress aptly.Progress) error { + publishedStorage := publishedStorageProvider.GetPublishedStorage(p.Storage) + // I. Easy: remove whole prefix (meta+packages) if removePrefix { err := publishedStorage.RemoveDirs(filepath.Join(p.Prefix, "dists"), progress) @@ -748,7 +764,7 @@ func NewPublishedRepoCollection(db database.Storage) *PublishedRepoCollection { // Add appends new repo to collection and saves it func (collection *PublishedRepoCollection) Add(repo *PublishedRepo) error { if collection.CheckDuplicate(repo) != nil { - return fmt.Errorf("published repo with prefix/distribution %s/%s already exists", repo.Prefix, repo.Distribution) + return fmt.Errorf("published repo with storage/prefix/distribution %s/%s/%s already exists", repo.Storage, repo.Prefix, repo.Distribution) } err := collection.Update(repo) @@ -763,7 +779,7 @@ func (collection *PublishedRepoCollection) Add(repo *PublishedRepo) error { // CheckDuplicate verifies that there's no published repo with the same name func (collection *PublishedRepoCollection) CheckDuplicate(repo *PublishedRepo) *PublishedRepo { for _, r := range collection.list { - if r.Prefix == repo.Prefix && r.Distribution == repo.Distribution { + if r.Prefix == repo.Prefix && r.Distribution == repo.Distribution && r.Storage == repo.Storage { return r } } @@ -849,14 +865,14 @@ func (collection *PublishedRepoCollection) LoadComplete(repo *PublishedRepo, col return } -// ByPrefixDistribution looks up repository by prefix & distribution -func (collection *PublishedRepoCollection) ByPrefixDistribution(prefix, distribution string) (*PublishedRepo, error) { +// ByPrefixDistribution looks up repository by storage, prefix & distribution +func (collection *PublishedRepoCollection) ByStoragePrefixDistribution(storage, prefix, distribution string) (*PublishedRepo, error) { for _, r := range collection.list { - if r.Prefix == prefix && r.Distribution == distribution { + if r.Prefix == prefix && r.Distribution == distribution && r.Storage == storage { return r, nil } } - return nil, fmt.Errorf("published repo with prefix/distribution %s/%s not found", prefix, distribution) + return nil, fmt.Errorf("published repo with storage/prefix/distribution %s/%s/%s not found", storage, prefix, distribution) } // ByUUID looks up repository by uuid @@ -1008,9 +1024,9 @@ func (collection *PublishedRepoCollection) CleanupPrefixComponentFiles(prefix st } // Remove removes published repository, cleaning up directories, files -func (collection *PublishedRepoCollection) Remove(publishedStorage aptly.PublishedStorage, prefix, distribution string, - collectionFactory *CollectionFactory, progress aptly.Progress) error { - repo, err := collection.ByPrefixDistribution(prefix, distribution) +func (collection *PublishedRepoCollection) Remove(publishedStorageProvider aptly.PublishedStorageProvider, + storage, prefix, distribution string, collectionFactory *CollectionFactory, progress aptly.Progress) error { + repo, err := collection.ByStoragePrefixDistribution(storage, prefix, distribution) if err != nil { return err } @@ -1025,7 +1041,7 @@ func (collection *PublishedRepoCollection) Remove(publishedStorage aptly.Publish repoPosition = i continue } - if r.Prefix == repo.Prefix { + if r.Storage == repo.Storage && r.Prefix == repo.Prefix { removePrefix = false rComponents := r.Components() @@ -1038,7 +1054,7 @@ func (collection *PublishedRepoCollection) Remove(publishedStorage aptly.Publish } } - err = repo.RemoveFiles(publishedStorage, removePrefix, removePoolComponents, progress) + err = repo.RemoveFiles(publishedStorageProvider, removePrefix, removePoolComponents, progress) if err != nil { return err } @@ -1047,7 +1063,8 @@ func (collection *PublishedRepoCollection) Remove(publishedStorage aptly.Publish nil, collection.list[len(collection.list)-1], collection.list[:len(collection.list)-1] if len(cleanComponents) > 0 { - err = collection.CleanupPrefixComponentFiles(repo.Prefix, cleanComponents, publishedStorage, collectionFactory, progress) + err = collection.CleanupPrefixComponentFiles(repo.Prefix, cleanComponents, + publishedStorageProvider.GetPublishedStorage(storage), collectionFactory, progress) if err != nil { return err } diff --git a/deb/publish_test.go b/deb/publish_test.go index 87b0f3aa..30a8d638 100644 --- a/deb/publish_test.go +++ b/deb/publish_test.go @@ -3,6 +3,7 @@ package deb import ( "bytes" "errors" + "fmt" "github.com/smira/aptly/aptly" "github.com/smira/aptly/database" "github.com/smira/aptly/files" @@ -46,17 +47,30 @@ func (n *NullSigner) ClearSign(source string, destination string) error { return ioutil.WriteFile(destination, []byte{}, 0644) } +type FakeStorageProvider struct { + storages map[string]aptly.PublishedStorage +} + +func (p *FakeStorageProvider) GetPublishedStorage(name string) aptly.PublishedStorage { + storage, ok := p.storages[name] + if !ok { + panic(fmt.Sprintf("unknown storage: %#v", name)) + } + return storage +} + type PublishedRepoSuite struct { PackageListMixinSuite - repo, repo2, repo3, repo4 *PublishedRepo - root string - publishedStorage *files.PublishedStorage - packagePool aptly.PackagePool - localRepo *LocalRepo - snapshot, snapshot2 *Snapshot - db database.Storage - factory *CollectionFactory - packageCollection *PackageCollection + repo, repo2, repo3, repo4, repo5 *PublishedRepo + root, root2 string + provider *FakeStorageProvider + publishedStorage, publishedStorage2 *files.PublishedStorage + packagePool aptly.PackagePool + localRepo *LocalRepo + snapshot, snapshot2 *Snapshot + db database.Storage + factory *CollectionFactory + packageCollection *PackageCollection } var _ = Suite(&PublishedRepoSuite{}) @@ -69,6 +83,11 @@ func (s *PublishedRepoSuite) SetUpTest(c *C) { s.root = c.MkDir() s.publishedStorage = files.NewPublishedStorage(s.root) + s.root2 = c.MkDir() + s.publishedStorage2 = files.NewPublishedStorage(s.root2) + s.provider = &FakeStorageProvider{map[string]aptly.PublishedStorage{ + "": s.publishedStorage, + "files:other": s.publishedStorage2}} s.packagePool = files.NewPackagePool(s.root) repo, _ := NewRemoteRepo("yandex", "http://mirror.yandex.ru/debian/", "squeeze", []string{"main"}, []string{}, false) @@ -90,13 +109,15 @@ func (s *PublishedRepoSuite) SetUpTest(c *C) { s.packageCollection.Update(s.p2) s.packageCollection.Update(s.p3) - s.repo, _ = NewPublishedRepo("ppa", "squeeze", nil, []string{"main"}, []interface{}{s.snapshot}, s.factory) + s.repo, _ = NewPublishedRepo("", "ppa", "squeeze", nil, []string{"main"}, []interface{}{s.snapshot}, s.factory) - s.repo2, _ = NewPublishedRepo("ppa", "maverick", nil, []string{"main"}, []interface{}{s.localRepo}, s.factory) + s.repo2, _ = NewPublishedRepo("", "ppa", "maverick", nil, []string{"main"}, []interface{}{s.localRepo}, s.factory) - s.repo3, _ = NewPublishedRepo("linux", "natty", nil, []string{"main", "contrib"}, []interface{}{s.snapshot, s.snapshot2}, s.factory) + s.repo3, _ = NewPublishedRepo("", "linux", "natty", nil, []string{"main", "contrib"}, []interface{}{s.snapshot, s.snapshot2}, s.factory) - s.repo4, _ = NewPublishedRepo("ppa", "maverick", []string{"source"}, []string{"main"}, []interface{}{s.localRepo}, s.factory) + s.repo4, _ = NewPublishedRepo("", "ppa", "maverick", []string{"source"}, []string{"main"}, []interface{}{s.localRepo}, s.factory) + + s.repo5, _ = NewPublishedRepo("files:other", "ppa", "maverick", []string{"source"}, []string{"main"}, []interface{}{s.localRepo}, s.factory) poolPath, _ := s.packagePool.Path(s.p1.Files()[0].Filename, s.p1.Files()[0].Checksums.MD5) err := os.MkdirAll(filepath.Dir(poolPath), 0755) @@ -133,15 +154,15 @@ func (s *PublishedRepoSuite) TestNewPublishedRepo(c *C) { c.Check(s.repo3.RefList("main").Len(), Equals, 3) c.Check(s.repo3.RefList("contrib").Len(), Equals, 3) - c.Check(func() { NewPublishedRepo(".", "a", nil, nil, nil, s.factory) }, PanicMatches, "publish with empty sources") + c.Check(func() { NewPublishedRepo("", ".", "a", nil, nil, nil, s.factory) }, PanicMatches, "publish with empty sources") c.Check(func() { - NewPublishedRepo(".", "a", nil, []string{"main"}, []interface{}{s.snapshot, s.snapshot2}, s.factory) + NewPublishedRepo("", ".", "a", nil, []string{"main"}, []interface{}{s.snapshot, s.snapshot2}, s.factory) }, PanicMatches, "sources and components should be equal in size") c.Check(func() { - NewPublishedRepo(".", "a", nil, []string{"main", "contrib"}, []interface{}{s.localRepo, s.snapshot2}, s.factory) + NewPublishedRepo("", ".", "a", nil, []string{"main", "contrib"}, []interface{}{s.localRepo, s.snapshot2}, s.factory) }, PanicMatches, "interface conversion:.*") - _, err := NewPublishedRepo(".", "a", nil, []string{"main", "main"}, []interface{}{s.snapshot, s.snapshot2}, s.factory) + _, err := NewPublishedRepo("", ".", "a", nil, []string{"main", "main"}, []interface{}{s.snapshot, s.snapshot2}, s.factory) c.Check(err, ErrorMatches, "duplicate component name: main") } @@ -201,7 +222,7 @@ func (s *PublishedRepoSuite) TestPrefixNormalization(c *C) { errorExpected: "invalid prefix .*", }, } { - repo, err := NewPublishedRepo(t.prefix, "squeeze", nil, []string{"main"}, []interface{}{s.snapshot}, s.factory) + repo, err := NewPublishedRepo("", t.prefix, "squeeze", nil, []string{"main"}, []interface{}{s.snapshot}, s.factory) if t.errorExpected != "" { c.Check(err, ErrorMatches, t.errorExpected) } else { @@ -211,49 +232,49 @@ func (s *PublishedRepoSuite) TestPrefixNormalization(c *C) { } func (s *PublishedRepoSuite) TestDistributionComponentGuessing(c *C) { - repo, err := NewPublishedRepo("ppa", "", nil, []string{""}, []interface{}{s.snapshot}, s.factory) + repo, err := NewPublishedRepo("", "ppa", "", nil, []string{""}, []interface{}{s.snapshot}, s.factory) c.Check(err, IsNil) c.Check(repo.Distribution, Equals, "squeeze") c.Check(repo.Components(), DeepEquals, []string{"main"}) - repo, err = NewPublishedRepo("ppa", "wheezy", nil, []string{""}, []interface{}{s.snapshot}, s.factory) + repo, err = NewPublishedRepo("", "ppa", "wheezy", nil, []string{""}, []interface{}{s.snapshot}, s.factory) c.Check(err, IsNil) c.Check(repo.Distribution, Equals, "wheezy") c.Check(repo.Components(), DeepEquals, []string{"main"}) - repo, err = NewPublishedRepo("ppa", "", nil, []string{"non-free"}, []interface{}{s.snapshot}, s.factory) + repo, err = NewPublishedRepo("", "ppa", "", nil, []string{"non-free"}, []interface{}{s.snapshot}, s.factory) c.Check(err, IsNil) c.Check(repo.Distribution, Equals, "squeeze") c.Check(repo.Components(), DeepEquals, []string{"non-free"}) - repo, err = NewPublishedRepo("ppa", "squeeze", nil, []string{""}, []interface{}{s.localRepo}, s.factory) + repo, err = NewPublishedRepo("", "ppa", "squeeze", nil, []string{""}, []interface{}{s.localRepo}, s.factory) c.Check(err, IsNil) c.Check(repo.Distribution, Equals, "squeeze") c.Check(repo.Components(), DeepEquals, []string{"main"}) - repo, err = NewPublishedRepo("ppa", "", nil, []string{"main"}, []interface{}{s.localRepo}, s.factory) + repo, err = NewPublishedRepo("", "ppa", "", nil, []string{"main"}, []interface{}{s.localRepo}, s.factory) c.Check(err, ErrorMatches, "unable to guess distribution name, please specify explicitly") s.localRepo.DefaultDistribution = "precise" s.localRepo.DefaultComponent = "contrib" s.factory.LocalRepoCollection().Update(s.localRepo) - repo, err = NewPublishedRepo("ppa", "", nil, []string{""}, []interface{}{s.localRepo}, s.factory) + repo, err = NewPublishedRepo("", "ppa", "", nil, []string{""}, []interface{}{s.localRepo}, s.factory) c.Check(err, IsNil) c.Check(repo.Distribution, Equals, "precise") c.Check(repo.Components(), DeepEquals, []string{"contrib"}) - repo, err = NewPublishedRepo("ppa", "", nil, []string{"", "contrib"}, []interface{}{s.snapshot, s.snapshot2}, s.factory) + repo, err = NewPublishedRepo("", "ppa", "", nil, []string{"", "contrib"}, []interface{}{s.snapshot, s.snapshot2}, s.factory) c.Check(err, IsNil) c.Check(repo.Distribution, Equals, "squeeze") c.Check(repo.Components(), DeepEquals, []string{"contrib", "main"}) - repo, err = NewPublishedRepo("ppa", "", nil, []string{"", ""}, []interface{}{s.snapshot, s.snapshot2}, s.factory) + repo, err = NewPublishedRepo("", "ppa", "", nil, []string{"", ""}, []interface{}{s.snapshot, s.snapshot2}, s.factory) c.Check(err, ErrorMatches, "duplicate component name: main") } func (s *PublishedRepoSuite) TestPublish(c *C) { - err := s.repo.Publish(s.packagePool, s.publishedStorage, s.factory, &NullSigner{}, nil) + err := s.repo.Publish(s.packagePool, s.provider, s.factory, &NullSigner{}, nil) c.Assert(err, IsNil) c.Check(s.repo.Architectures, DeepEquals, []string{"i386"}) @@ -300,7 +321,7 @@ func (s *PublishedRepoSuite) TestPublish(c *C) { } func (s *PublishedRepoSuite) TestPublishNoSigner(c *C) { - err := s.repo.Publish(s.packagePool, s.publishedStorage, s.factory, nil, nil) + err := s.repo.Publish(s.packagePool, s.provider, s.factory, nil, nil) c.Assert(err, IsNil) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/squeeze/Release"), PathExists) @@ -308,7 +329,7 @@ func (s *PublishedRepoSuite) TestPublishNoSigner(c *C) { } func (s *PublishedRepoSuite) TestPublishLocalRepo(c *C) { - err := s.repo2.Publish(s.packagePool, s.publishedStorage, s.factory, nil, nil) + err := s.repo2.Publish(s.packagePool, s.provider, s.factory, nil, nil) c.Assert(err, IsNil) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/maverick/Release"), PathExists) @@ -316,22 +337,30 @@ func (s *PublishedRepoSuite) TestPublishLocalRepo(c *C) { } func (s *PublishedRepoSuite) TestPublishLocalSourceRepo(c *C) { - err := s.repo4.Publish(s.packagePool, s.publishedStorage, s.factory, nil, nil) + err := s.repo4.Publish(s.packagePool, s.provider, s.factory, nil, nil) c.Assert(err, IsNil) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/maverick/Release"), PathExists) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/maverick/main/source/Release"), PathExists) } +func (s *PublishedRepoSuite) TestPublishOtherStorage(c *C) { + err := s.repo5.Publish(s.packagePool, s.provider, s.factory, nil, nil) + c.Assert(err, IsNil) + + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/dists/maverick/Release"), PathExists) + c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/maverick/Release"), Not(PathExists)) +} + func (s *PublishedRepoSuite) TestString(c *C) { c.Check(s.repo.String(), Equals, "ppa/squeeze [] publishes {main: [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze}") c.Check(s.repo2.String(), Equals, "ppa/maverick [] publishes {main: [local1]: comment1}") - repo, _ := NewPublishedRepo("", "squeeze", []string{"s390"}, []string{"main"}, []interface{}{s.snapshot}, s.factory) + repo, _ := NewPublishedRepo("", "", "squeeze", []string{"s390"}, []string{"main"}, []interface{}{s.snapshot}, s.factory) c.Check(repo.String(), Equals, "./squeeze [s390] publishes {main: [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze}") - repo, _ = NewPublishedRepo("", "squeeze", []string{"i386", "amd64"}, []string{"main"}, []interface{}{s.snapshot}, s.factory) + repo, _ = NewPublishedRepo("", "", "squeeze", []string{"i386", "amd64"}, []string{"main"}, []interface{}{s.snapshot}, s.factory) c.Check(repo.String(), Equals, "./squeeze [i386, amd64] publishes {main: [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze}") repo.Origin = "myorigin" @@ -342,10 +371,13 @@ func (s *PublishedRepoSuite) TestString(c *C) { "./squeeze (origin: myorigin, label: mylabel) [i386, amd64] publishes {main: [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze}") c.Check(s.repo3.String(), Equals, "linux/natty [] publishes {contrib: [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze}, {main: [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze}") + c.Check(s.repo5.String(), Equals, + "files:other:ppa/maverick [source] publishes {main: [local1]: comment1}") } func (s *PublishedRepoSuite) TestKey(c *C) { c.Check(s.repo.Key(), DeepEquals, []byte("Uppa>>squeeze")) + c.Check(s.repo5.Key(), DeepEquals, []byte("Ufiles:other:ppa>>maverick")) } func (s *PublishedRepoSuite) TestRefKey(c *C) { @@ -373,13 +405,13 @@ func (s *PublishedRepoSuite) TestEncodeDecode(c *C) { type PublishedRepoCollectionSuite struct { PackageListMixinSuite - db database.Storage - factory *CollectionFactory - snapshotCollection *SnapshotCollection - collection *PublishedRepoCollection - snap1, snap2 *Snapshot - localRepo *LocalRepo - repo1, repo2, repo3, repo4 *PublishedRepo + db database.Storage + factory *CollectionFactory + snapshotCollection *SnapshotCollection + collection *PublishedRepoCollection + snap1, snap2 *Snapshot + localRepo *LocalRepo + repo1, repo2, repo3, repo4, repo5 *PublishedRepo } var _ = Suite(&PublishedRepoCollectionSuite{}) @@ -399,10 +431,11 @@ func (s *PublishedRepoCollectionSuite) SetUpTest(c *C) { s.localRepo = NewLocalRepo("local1", "comment1") s.factory.LocalRepoCollection().Add(s.localRepo) - s.repo1, _ = NewPublishedRepo("ppa", "anaconda", []string{}, []string{"main"}, []interface{}{s.snap1}, s.factory) - s.repo2, _ = NewPublishedRepo("", "anaconda", []string{}, []string{"main", "contrib"}, []interface{}{s.snap2, s.snap1}, s.factory) - s.repo3, _ = NewPublishedRepo("ppa", "anaconda", []string{}, []string{"main"}, []interface{}{s.snap2}, s.factory) - s.repo4, _ = NewPublishedRepo("ppa", "precise", []string{}, []string{"main"}, []interface{}{s.localRepo}, s.factory) + s.repo1, _ = NewPublishedRepo("", "ppa", "anaconda", []string{}, []string{"main"}, []interface{}{s.snap1}, s.factory) + s.repo2, _ = NewPublishedRepo("", "", "anaconda", []string{}, []string{"main", "contrib"}, []interface{}{s.snap2, s.snap1}, s.factory) + s.repo3, _ = NewPublishedRepo("", "ppa", "anaconda", []string{}, []string{"main"}, []interface{}{s.snap2}, s.factory) + s.repo4, _ = NewPublishedRepo("", "ppa", "precise", []string{}, []string{"main"}, []interface{}{s.localRepo}, s.factory) + s.repo5, _ = NewPublishedRepo("files:other", "ppa", "precise", []string{}, []string{"main"}, []interface{}{s.localRepo}, s.factory) s.collection = s.factory.PublishedRepoCollection() } @@ -411,8 +444,8 @@ func (s *PublishedRepoCollectionSuite) TearDownTest(c *C) { s.db.Close() } -func (s *PublishedRepoCollectionSuite) TestAddByPrefixDistribution(c *C) { - r, err := s.collection.ByPrefixDistribution("ppa", "anaconda") +func (s *PublishedRepoCollectionSuite) TestAddByStoragePrefixDistribution(c *C) { + r, err := s.collection.ByStoragePrefixDistribution("", "ppa", "anaconda") c.Assert(err, ErrorMatches, "*.not found") c.Assert(s.collection.Add(s.repo1), IsNil) @@ -422,8 +455,9 @@ func (s *PublishedRepoCollectionSuite) TestAddByPrefixDistribution(c *C) { c.Assert(s.collection.Add(s.repo3), ErrorMatches, ".*already exists") c.Assert(s.collection.CheckDuplicate(s.repo3), Equals, s.repo1) c.Assert(s.collection.Add(s.repo4), IsNil) + c.Assert(s.collection.Add(s.repo5), IsNil) - r, err = s.collection.ByPrefixDistribution("ppa", "anaconda") + r, err = s.collection.ByStoragePrefixDistribution("", "ppa", "anaconda") c.Assert(err, IsNil) err = s.collection.LoadComplete(r, s.factory) @@ -431,12 +465,15 @@ func (s *PublishedRepoCollectionSuite) TestAddByPrefixDistribution(c *C) { c.Assert(r.String(), Equals, s.repo1.String()) collection := NewPublishedRepoCollection(s.db) - r, err = collection.ByPrefixDistribution("ppa", "anaconda") + r, err = collection.ByStoragePrefixDistribution("", "ppa", "anaconda") c.Assert(err, IsNil) err = s.collection.LoadComplete(r, s.factory) c.Assert(err, IsNil) c.Assert(r.String(), Equals, s.repo1.String()) + + r, err = s.collection.ByStoragePrefixDistribution("files:other", "ppa", "precise") + c.Check(r.String(), Equals, s.repo5.String()) } func (s *PublishedRepoCollectionSuite) TestByUUID(c *C) { @@ -458,14 +495,14 @@ func (s *PublishedRepoCollectionSuite) TestUpdateLoadComplete(c *C) { c.Assert(s.collection.Update(s.repo4), IsNil) collection := NewPublishedRepoCollection(s.db) - r, err := collection.ByPrefixDistribution("ppa", "anaconda") + r, err := collection.ByStoragePrefixDistribution("", "ppa", "anaconda") c.Assert(err, IsNil) c.Assert(r.sourceItems["main"].snapshot, IsNil) c.Assert(s.collection.LoadComplete(r, s.factory), IsNil) c.Assert(r.Sources["main"], Equals, s.repo1.sourceItems["main"].snapshot.UUID) c.Assert(r.RefList("main").Len(), Equals, 0) - r, err = collection.ByPrefixDistribution("ppa", "precise") + r, err = collection.ByStoragePrefixDistribution("", "ppa", "precise") c.Assert(err, IsNil) c.Assert(r.sourceItems["main"].localRepo, IsNil) c.Assert(s.collection.LoadComplete(r, s.factory), IsNil) @@ -506,7 +543,7 @@ func (s *PublishedRepoCollectionSuite) TestLoadPre0_6(c *C) { c.Assert(s.db.Put(s.repo1.RefKey(""), s.localRepo.RefList().Encode()), IsNil) collection := NewPublishedRepoCollection(s.db) - repo, err := collection.ByPrefixDistribution("ppa", "anaconda") + repo, err := collection.ByStoragePrefixDistribution("", "ppa", "anaconda") c.Check(err, IsNil) c.Check(repo.Component, Equals, "") c.Check(repo.SourceUUID, Equals, "") @@ -549,20 +586,22 @@ func (s *PublishedRepoCollectionSuite) TestBySnapshot(c *C) { 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.Add(s.repo5), IsNil) - c.Check(s.collection.ByLocalRepo(s.localRepo), DeepEquals, []*PublishedRepo{s.repo4}) + c.Check(s.collection.ByLocalRepo(s.localRepo), DeepEquals, []*PublishedRepo{s.repo4, s.repo5}) } type PublishedRepoRemoveSuite struct { PackageListMixinSuite - db database.Storage - factory *CollectionFactory - snapshotCollection *SnapshotCollection - collection *PublishedRepoCollection - root string - publishedStorage *files.PublishedStorage - snap1 *Snapshot - repo1, repo2, repo3, repo4 *PublishedRepo + db database.Storage + factory *CollectionFactory + snapshotCollection *SnapshotCollection + collection *PublishedRepoCollection + root, root2 string + provider *FakeStorageProvider + publishedStorage, publishedStorage2 *files.PublishedStorage + snap1 *Snapshot + repo1, repo2, repo3, repo4, repo5 *PublishedRepo } var _ = Suite(&PublishedRepoRemoveSuite{}) @@ -577,16 +616,18 @@ func (s *PublishedRepoRemoveSuite) SetUpTest(c *C) { s.snapshotCollection.Add(s.snap1) - s.repo1, _ = NewPublishedRepo("ppa", "anaconda", []string{}, []string{"main"}, []interface{}{s.snap1}, s.factory) - s.repo2, _ = NewPublishedRepo("", "anaconda", []string{}, []string{"main"}, []interface{}{s.snap1}, s.factory) - s.repo3, _ = NewPublishedRepo("ppa", "meduza", []string{}, []string{"main"}, []interface{}{s.snap1}, s.factory) - s.repo4, _ = NewPublishedRepo("ppa", "osminog", []string{}, []string{"contrib"}, []interface{}{s.snap1}, s.factory) + s.repo1, _ = NewPublishedRepo("", "ppa", "anaconda", []string{}, []string{"main"}, []interface{}{s.snap1}, s.factory) + s.repo2, _ = NewPublishedRepo("", "", "anaconda", []string{}, []string{"main"}, []interface{}{s.snap1}, s.factory) + s.repo3, _ = NewPublishedRepo("", "ppa", "meduza", []string{}, []string{"main"}, []interface{}{s.snap1}, s.factory) + s.repo4, _ = NewPublishedRepo("", "ppa", "osminog", []string{}, []string{"contrib"}, []interface{}{s.snap1}, s.factory) + s.repo5, _ = NewPublishedRepo("files:other", "ppa", "osminog", []string{}, []string{"contrib"}, []interface{}{s.snap1}, s.factory) s.collection = s.factory.PublishedRepoCollection() s.collection.Add(s.repo1) s.collection.Add(s.repo2) s.collection.Add(s.repo3) s.collection.Add(s.repo4) + s.collection.Add(s.repo5) s.root = c.MkDir() s.publishedStorage = files.NewPublishedStorage(s.root) @@ -597,6 +638,15 @@ func (s *PublishedRepoRemoveSuite) SetUpTest(c *C) { s.publishedStorage.MkDir("ppa/pool/contrib") s.publishedStorage.MkDir("dists/anaconda") s.publishedStorage.MkDir("pool/main") + + s.root2 = c.MkDir() + s.publishedStorage2 = files.NewPublishedStorage(s.root2) + s.publishedStorage2.MkDir("ppa/dists/osminog") + s.publishedStorage2.MkDir("ppa/pool/contrib") + + s.provider = &FakeStorageProvider{map[string]aptly.PublishedStorage{ + "": s.publishedStorage, + "files:other": s.publishedStorage2}} } func (s *PublishedRepoRemoveSuite) TearDownTest(c *C) { @@ -604,7 +654,7 @@ func (s *PublishedRepoRemoveSuite) TearDownTest(c *C) { } func (s *PublishedRepoRemoveSuite) TestRemoveFilesOnlyDist(c *C) { - s.repo1.RemoveFiles(s.publishedStorage, false, []string{}, nil) + s.repo1.RemoveFiles(s.provider, false, []string{}, nil) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/anaconda"), Not(PathExists)) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/meduza"), PathExists) @@ -613,10 +663,12 @@ func (s *PublishedRepoRemoveSuite) TestRemoveFilesOnlyDist(c *C) { c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/pool/contrib"), PathExists) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "dists/anaconda"), PathExists) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "pool/main"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/dists/osminog"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/pool/contrib"), PathExists) } func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithPool(c *C) { - s.repo1.RemoveFiles(s.publishedStorage, false, []string{"main"}, nil) + s.repo1.RemoveFiles(s.provider, false, []string{"main"}, nil) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/anaconda"), Not(PathExists)) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/meduza"), PathExists) @@ -625,10 +677,12 @@ func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithPool(c *C) { c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/pool/contrib"), PathExists) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "dists/anaconda"), PathExists) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "pool/main"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/dists/osminog"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/pool/contrib"), PathExists) } func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithTwoPools(c *C) { - s.repo1.RemoveFiles(s.publishedStorage, false, []string{"main", "contrib"}, nil) + s.repo1.RemoveFiles(s.provider, false, []string{"main", "contrib"}, nil) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/anaconda"), Not(PathExists)) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/meduza"), PathExists) @@ -637,10 +691,12 @@ func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithTwoPools(c *C) { c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/pool/contrib"), Not(PathExists)) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "dists/anaconda"), PathExists) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "pool/main"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/dists/osminog"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/pool/contrib"), PathExists) } func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithPrefix(c *C) { - s.repo1.RemoveFiles(s.publishedStorage, true, []string{"main"}, nil) + s.repo1.RemoveFiles(s.provider, true, []string{"main"}, nil) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/anaconda"), Not(PathExists)) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/meduza"), Not(PathExists)) @@ -649,10 +705,12 @@ func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithPrefix(c *C) { c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/pool/contrib"), Not(PathExists)) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "dists/anaconda"), PathExists) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "pool/main"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/dists/osminog"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/pool/contrib"), PathExists) } func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithPrefixRoot(c *C) { - s.repo2.RemoveFiles(s.publishedStorage, true, []string{"main"}, nil) + s.repo2.RemoveFiles(s.provider, true, []string{"main"}, nil) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/anaconda"), PathExists) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/meduza"), PathExists) @@ -660,17 +718,19 @@ func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithPrefixRoot(c *C) { c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/pool/contrib"), PathExists) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "dists/anaconda"), Not(PathExists)) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "pool/main"), Not(PathExists)) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/dists/osminog"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/pool/contrib"), PathExists) } func (s *PublishedRepoRemoveSuite) TestRemoveRepo1and2(c *C) { - err := s.collection.Remove(s.publishedStorage, "ppa", "anaconda", s.factory, nil) + err := s.collection.Remove(s.provider, "", "ppa", "anaconda", s.factory, nil) c.Check(err, IsNil) - _, err = s.collection.ByPrefixDistribution("ppa", "anaconda") + _, err = s.collection.ByStoragePrefixDistribution("", "ppa", "anaconda") c.Check(err, ErrorMatches, ".*not found") collection := NewPublishedRepoCollection(s.db) - _, err = collection.ByPrefixDistribution("ppa", "anaconda") + _, err = collection.ByStoragePrefixDistribution("", "ppa", "anaconda") c.Check(err, ErrorMatches, ".*not found") c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/anaconda"), Not(PathExists)) @@ -680,11 +740,13 @@ func (s *PublishedRepoRemoveSuite) TestRemoveRepo1and2(c *C) { c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/pool/contrib"), PathExists) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "dists/anaconda"), PathExists) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "pool/main"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/dists/osminog"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/pool/contrib"), PathExists) - err = s.collection.Remove(s.publishedStorage, "ppa", "anaconda", s.factory, nil) + err = s.collection.Remove(s.provider, "", "ppa", "anaconda", s.factory, nil) c.Check(err, ErrorMatches, ".*not found") - err = s.collection.Remove(s.publishedStorage, "ppa", "meduza", s.factory, nil) + err = s.collection.Remove(s.provider, "", "ppa", "meduza", s.factory, nil) c.Check(err, IsNil) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/anaconda"), Not(PathExists)) @@ -694,17 +756,19 @@ func (s *PublishedRepoRemoveSuite) TestRemoveRepo1and2(c *C) { c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/pool/contrib"), PathExists) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "dists/anaconda"), PathExists) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "pool/main"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/dists/osminog"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/pool/contrib"), PathExists) } func (s *PublishedRepoRemoveSuite) TestRemoveRepo3(c *C) { - err := s.collection.Remove(s.publishedStorage, ".", "anaconda", s.factory, nil) + err := s.collection.Remove(s.provider, "", ".", "anaconda", s.factory, nil) c.Check(err, IsNil) - _, err = s.collection.ByPrefixDistribution(".", "anaconda") + _, err = s.collection.ByStoragePrefixDistribution("", ".", "anaconda") c.Check(err, ErrorMatches, ".*not found") collection := NewPublishedRepoCollection(s.db) - _, err = collection.ByPrefixDistribution(".", "anaconda") + _, err = collection.ByStoragePrefixDistribution("", ".", "anaconda") c.Check(err, ErrorMatches, ".*not found") c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/anaconda"), PathExists) @@ -714,4 +778,28 @@ func (s *PublishedRepoRemoveSuite) TestRemoveRepo3(c *C) { c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/pool/contrib"), PathExists) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "dists/"), Not(PathExists)) c.Check(filepath.Join(s.publishedStorage.PublicPath(), "pool/"), Not(PathExists)) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/dists/osminog"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/pool/contrib"), PathExists) +} + +func (s *PublishedRepoRemoveSuite) TestRemoveRepo5(c *C) { + err := s.collection.Remove(s.provider, "files:other", "ppa", "osminog", s.factory, nil) + c.Check(err, IsNil) + + _, err = s.collection.ByStoragePrefixDistribution("files:other", "ppa", "osminog") + c.Check(err, ErrorMatches, ".*not found") + + collection := NewPublishedRepoCollection(s.db) + _, err = collection.ByStoragePrefixDistribution("files:other", "ppa", "osminog") + c.Check(err, ErrorMatches, ".*not found") + + c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/anaconda"), PathExists) + c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/meduza"), PathExists) + c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/dists/osminog"), PathExists) + c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/pool/main"), PathExists) + c.Check(filepath.Join(s.publishedStorage.PublicPath(), "ppa/pool/contrib"), PathExists) + c.Check(filepath.Join(s.publishedStorage.PublicPath(), "dists/"), PathExists) + c.Check(filepath.Join(s.publishedStorage.PublicPath(), "pool/"), PathExists) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/dists/osminog"), Not(PathExists)) + c.Check(filepath.Join(s.publishedStorage2.PublicPath(), "ppa/pool/contrib"), Not(PathExists)) }