Major change: published repo now supports multiple components <> snapshots (local repos). #36

deb/publish.go

@@ -17,6 +17,15 @@ import (
 	"time"
 )
 
+type repoSourceItem struct {
+	// Pointer to snapshot if SourceKind == "snapshot"
+	snapshot *Snapshot
+	// Pointer to local repo if SourceKind == "local"
+	localRepo *LocalRepo
+	// Package references is SourceKind == "local"
+	packageRefs *PackageRefList
+}
+
 // PublishedRepo is a published for http/ftp representation of snapshot as Debian repository
 type PublishedRepo struct {
 	// Internal unique ID
@@ -24,55 +33,169 @@ type PublishedRepo struct {
 	// Prefix & distribution should be unique across all published repositories
 	Prefix       string
 	Distribution string
-	Component    string
 	Origin       string
 	Label        string
 	// Architectures is a list of all architectures published
 	Architectures []string
 	// SourceKind is "local"/"repo"
 	SourceKind string
+
+	// Map of sources by each component: component name -> source UUID
+	Sources map[string]string
+
+	// Legacy fields for compatibily with old published repositories (< 0.6)
+	Component string
 	// SourceUUID is UUID of either snapshot or local repo
 	SourceUUID string `codec:"SnapshotUUID"`
 
-	// Pointer to snapshot if SourceKind == "snapshot"
+	// Map of component to source items
-	snapshot *Snapshot
+	sourceItems map[string]repoSourceItem
-	// Pointer to local repo if SourceKind == "local"
+
-	localRepo *LocalRepo
-	// Package references is SourceKind == "local"
-	packageRefs *PackageRefList
 	// True if repo is being re-published
 	rePublishing bool
 }
 
+// walkUpTree goes from source in the tree of source snapshots/mirrors/local repos
+// gathering information about declared components and distributions
+func walkUpTree(source interface{}, collectionFactory *CollectionFactory) (rootDistributions []string, rootComponents []string) {
+	var (
+		head    interface{}
+		current = []interface{}{source}
+	)
+
+	rootComponents = []string{}
+	rootDistributions = []string{}
+
+	// walk up the tree from current source up to roots (local or remote repos)
+	// and collect information about distribution and components
+	for len(current) > 0 {
+		head, current = current[0], current[1:]
+
+		if snapshot, ok := head.(*Snapshot); ok {
+			for _, uuid := range snapshot.SourceIDs {
+				if snapshot.SourceKind == "repo" {
+					remoteRepo, err := collectionFactory.RemoteRepoCollection().ByUUID(uuid)
+					if err != nil {
+						continue
+					}
+					current = append(current, remoteRepo)
+				} else if snapshot.SourceKind == "local" {
+					localRepo, err := collectionFactory.LocalRepoCollection().ByUUID(uuid)
+					if err != nil {
+						continue
+					}
+					current = append(current, localRepo)
+				} else if snapshot.SourceKind == "snapshot" {
+					snap, err := collectionFactory.SnapshotCollection().ByUUID(uuid)
+					if err != nil {
+						continue
+					}
+					current = append(current, snap)
+				}
+			}
+		} else if localRepo, ok := head.(*LocalRepo); ok {
+			if localRepo.DefaultDistribution != "" {
+				rootDistributions = append(rootDistributions, localRepo.DefaultDistribution)
+			}
+			if localRepo.DefaultComponent != "" {
+				rootComponents = append(rootComponents, localRepo.DefaultComponent)
+			}
+		} else if remoteRepo, ok := head.(*RemoteRepo); ok {
+			if remoteRepo.Distribution != "" {
+				rootDistributions = append(rootDistributions, remoteRepo.Distribution)
+			}
+			rootComponents = append(rootComponents, remoteRepo.Components...)
+		} else {
+			panic("unknown type")
+		}
+	}
+
+	return
+}
+
 // NewPublishedRepo creates new published repository
 //
 // prefix specifies publishing prefix
-// distribution, component and architectures are user-defined properties
+// distribution and architectures are user-defined properties
-// source could either be *Snapshot or *LocalRepo
+// components & sources are lists of component to source mapping (*Snapshot or *LocalRepo)
-func NewPublishedRepo(prefix string, distribution string, component string, architectures []string, source interface{}, collectionFactory *CollectionFactory) (*PublishedRepo, error) {
+func NewPublishedRepo(prefix string, distribution string, architectures []string,
-	var ok bool
+	components []string, sources []interface{}, collectionFactory *CollectionFactory) (*PublishedRepo, error) {
-
 	result := &PublishedRepo{
 		UUID:          uuid.New(),
 		Architectures: architectures,
+		Sources:       make(map[string]string),
+		sourceItems:   make(map[string]repoSourceItem),
 	}
 
-	// figure out source
+	if len(sources) == 0 {
-	result.snapshot, ok = source.(*Snapshot)
+		panic("publish with empty sources")
+	}
+
+	if len(sources) != len(components) {
+		panic("sources and components should be equal in size")
+	}
+
+	var (
+		discoveredDistributions = []string{}
+		source                  interface{}
+		component               string
+		snapshot                *Snapshot
+		localRepo               *LocalRepo
+		ok                      bool
+	)
+
+	// get first source
+	source = sources[0]
+
+	// figure out source kind
+	snapshot, ok = source.(*Snapshot)
 	if ok {
 		result.SourceKind = "snapshot"
-		result.SourceUUID = result.snapshot.UUID
 	} else {
-		result.localRepo, ok = source.(*LocalRepo)
+		localRepo, ok = source.(*LocalRepo)
 		if ok {
 			result.SourceKind = "local"
-			result.SourceUUID = result.localRepo.UUID
-			result.packageRefs = result.localRepo.RefList()
 		} else {
 			panic("unknown source kind")
 		}
 	}
 
+	for i := range sources {
+		component, source = components[i], sources[i]
+		if distribution == "" || component == "" {
+			rootDistributions, rootComponents := walkUpTree(source, collectionFactory)
+			if distribution == "" {
+				discoveredDistributions = append(discoveredDistributions, rootDistributions...)
+			}
+			if component == "" {
+				sort.Strings(rootComponents)
+				if len(rootComponents) > 0 && rootComponents[0] == rootComponents[len(rootComponents)-1] {
+					component = rootComponents[0]
+				} else if len(sources) == 1 {
+					// only if going from one source, assume default component "main"
+					component = "main"
+				} else {
+					return nil, fmt.Errorf("unable to figure out component name for %s", source)
+				}
+			}
+		}
+
+		_, exists := result.Sources[component]
+		if exists {
+			return nil, fmt.Errorf("duplicate component name: %s", component)
+		}
+
+		if result.SourceKind == "snapshot" {
+			snapshot = source.(*Snapshot)
+			result.Sources[component] = snapshot.UUID
+			result.sourceItems[component] = repoSourceItem{snapshot: snapshot}
+		} else if result.SourceKind == "local" {
+			localRepo = source.(*LocalRepo)
+			result.Sources[component] = localRepo.UUID
+			result.sourceItems[component] = repoSourceItem{localRepo: localRepo, packageRefs: localRepo.RefList()}
+		}
+	}
+
 	// clean & verify prefix
 	prefix = filepath.Clean(prefix)
 	if strings.HasPrefix(prefix, "/") {
@@ -91,106 +214,58 @@ func NewPublishedRepo(prefix string, distribution string, component string, arch
 
 	result.Prefix = prefix
 
-	// guessing distribution & component
+	// guessing distribution
-	if component == "" || distribution == "" {
+	if distribution == "" {
-		var (
+		sort.Strings(discoveredDistributions)
-			head              interface{}
+		if len(discoveredDistributions) > 0 && discoveredDistributions[0] == discoveredDistributions[len(discoveredDistributions)-1] {
-			current           = []interface{}{source}
+			distribution = discoveredDistributions[0]
-			rootComponents    = []string{}
+		} else {
-			rootDistributions = []string{}
+			return nil, fmt.Errorf("unable to guess distribution name, please specify explicitly")
-		)
-
-		// walk up the tree from current source up to roots (local or remote repos)
-		// and collect information about distribution and components
-		for len(current) > 0 {
-			head, current = current[0], current[1:]
-
-			if snapshot, ok := head.(*Snapshot); ok {
-				for _, uuid := range snapshot.SourceIDs {
-					if snapshot.SourceKind == "repo" {
-						remoteRepo, err := collectionFactory.RemoteRepoCollection().ByUUID(uuid)
-						if err != nil {
-							continue
-						}
-						current = append(current, remoteRepo)
-					} else if snapshot.SourceKind == "local" {
-						localRepo, err := collectionFactory.LocalRepoCollection().ByUUID(uuid)
-						if err != nil {
-							continue
-						}
-						current = append(current, localRepo)
-					} else if snapshot.SourceKind == "snapshot" {
-						snap, err := collectionFactory.SnapshotCollection().ByUUID(uuid)
-						if err != nil {
-							continue
-						}
-						current = append(current, snap)
-					}
-				}
-			} else if localRepo, ok := head.(*LocalRepo); ok {
-				if localRepo.DefaultDistribution != "" {
-					rootDistributions = append(rootDistributions, localRepo.DefaultDistribution)
-				}
-				if localRepo.DefaultComponent != "" {
-					rootComponents = append(rootComponents, localRepo.DefaultComponent)
-				}
-			} else if remoteRepo, ok := head.(*RemoteRepo); ok {
-				if remoteRepo.Distribution != "" {
-					rootDistributions = append(rootDistributions, remoteRepo.Distribution)
-				}
-				rootComponents = append(rootComponents, remoteRepo.Components...)
-			} else {
-				panic("unknown type")
-			}
-		}
-
-		if distribution == "" {
-			sort.Strings(rootDistributions)
-			if len(rootDistributions) > 0 && rootDistributions[0] == rootDistributions[len(rootDistributions)-1] {
-				distribution = rootDistributions[0]
-			} else {
-				return nil, fmt.Errorf("unable to guess distribution name, please specify explicitly")
-			}
-		}
-
-		if component == "" {
-			sort.Strings(rootComponents)
-			if len(rootComponents) > 0 && rootComponents[0] == rootComponents[len(rootComponents)-1] {
-				component = rootComponents[0]
-			} else {
-				component = "main"
-			}
 		}
 	}
 
-	result.Distribution, result.Component = distribution, component
+	result.Distribution = distribution
 
 	return result, nil
 }
 
 // String returns human-readable represenation of PublishedRepo
 func (p *PublishedRepo) String() string {
-	var source string
+	var sources = []string{}
 
-	if p.snapshot != nil {
+	for component, item := range p.sourceItems {
-		source = p.snapshot.String()
+		var source string
-	} else if p.localRepo != nil {
+
-		source = p.localRepo.String()
+		if item.snapshot != nil {
-	} else {
+			source = item.snapshot.String()
-		panic("no snapshot/localRepo")
+		} else if item.localRepo != nil {
+			source = item.localRepo.String()
+		} else {
+			panic("no snapshot/localRepo")
+		}
+
+		sources = append(sources, fmt.Sprintf("{%s: %s}", component, source))
 	}
 
 	var extra string
 
 	if p.Origin != "" {
-		extra += fmt.Sprintf(", origin: %s", p.Origin)
+		extra += fmt.Sprintf("origin: %s", p.Origin)
 	}
 
 	if p.Label != "" {
-		extra += fmt.Sprintf(", label: %s", p.Label)
+		if extra != "" {
+			extra += ", "
+		}
+		extra += fmt.Sprintf("label: %s", p.Label)
 	}
 
-	return fmt.Sprintf("%s/%s (%s%s) [%s] publishes %s", p.Prefix, p.Distribution, p.Component, extra, strings.Join(p.Architectures, ", "), source)
+	if extra != "" {
+		extra = " (" + extra + ")"
+	}
+
+	return fmt.Sprintf("%s/%s%s [%s] publishes %s", p.Prefix, p.Distribution, extra, strings.Join(p.Architectures, ", "),
+		strings.Join(sources, ", "))
 }
 
 // Key returns unique key identifying PublishedRepo
@@ -199,37 +274,53 @@ func (p *PublishedRepo) Key() []byte {
 }
 
 // RefKey is a unique id for package reference list
-func (p *PublishedRepo) RefKey() []byte {
+func (p *PublishedRepo) RefKey(component string) []byte {
-	return []byte("E" + p.UUID)
+	return []byte("E" + p.UUID + component)
 }
 
 // RefList returns list of package refs in local repo
-func (p *PublishedRepo) RefList() *PackageRefList {
+func (p *PublishedRepo) RefList(component string) *PackageRefList {
+	item := p.sourceItems[component]
 	if p.SourceKind == "local" {
-		return p.packageRefs
+		return item.packageRefs
 	}
 	if p.SourceKind == "snapshot" {
-		return p.snapshot.RefList()
+		return item.snapshot.RefList()
 	}
 	panic("unknown source")
 }
 
-func (p *PublishedRepo) UpdateLocalRepo() {
+// Components returns sorted list of published repo components
+func (p *PublishedRepo) Components() []string {
+	result := make([]string, 0, len(p.Sources))
+	for component := range p.Sources {
+		result = append(result, component)
+	}
+
+	sort.Strings(result)
+	return result
+}
+
+// UpdateLocalRepo updates content from local repo in component
+func (p *PublishedRepo) UpdateLocalRepo(component string) {
+	item := p.sourceItems[component]
 	if p.SourceKind != "local" {
 		panic("not local repo publish")
 	}
 
-	p.packageRefs = p.localRepo.RefList()
+	item.packageRefs = item.localRepo.RefList()
 	p.rePublishing = true
 }
 
-func (p *PublishedRepo) UpdateSnapshot(snapshot *Snapshot) {
+// UpdateSnapshot switches snapshot for component
+func (p *PublishedRepo) UpdateSnapshot(component string, snapshot *Snapshot) {
+	item := p.sourceItems[component]
 	if p.SourceKind != "snapshot" {
 		panic("not snapshot publish")
 	}
 
-	p.snapshot = snapshot
+	item.snapshot = snapshot
-	p.SourceUUID = snapshot.UUID
+	p.Sources[component] = snapshot.UUID
 	p.rePublishing = true
 }
 
@@ -256,6 +347,13 @@ func (p *PublishedRepo) Decode(input []byte) error {
 		p.SourceKind = "snapshot"
 	}
 
+	// <0.6 aptly used single SourceUUID + Component instead of Sources
+	if p.Component != "" && p.SourceUUID != "" && len(p.Sources) == 0 {
+		p.Sources = map[string]string{p.Component: p.SourceUUID}
+		p.Component = ""
+		p.SourceUUID = ""
+	}
+
 	return nil
 }
 
@@ -276,15 +374,21 @@ func (p *PublishedRepo) Publish(packagePool aptly.PackagePool, publishedStorage
 		progress.Printf("Loading packages...\n")
 	}
 
-	// Load all packages
+	lists := map[string]*PackageList{}
-	list, err := NewPackageListFromRefList(p.RefList(), collectionFactory.PackageCollection(), progress)
+
-	if err != nil {
+	for component := range p.sourceItems {
-		return fmt.Errorf("unable to load packages: %s", err)
+		// Load all packages
+		lists[component], err = NewPackageListFromRefList(p.RefList(component), collectionFactory.PackageCollection(), progress)
+		if err != nil {
+			return fmt.Errorf("unable to load packages: %s", err)
+		}
 	}
 
 	if !p.rePublishing {
 		if len(p.Architectures) == 0 {
-			p.Architectures = list.Architectures(true)
+			for _, list := range lists {
+				p.Architectures = append(p.Architectures, list.Architectures(true)...)
+			}
 		}
 
 		if len(p.Architectures) == 0 {
@@ -306,105 +410,107 @@ func (p *PublishedRepo) Publish(packagePool aptly.PackagePool, publishedStorage
 		progress.Printf("Generating metadata files and linking package files...\n")
 	}
 
-	// For all architectures, generate release file
+	for component, list := range lists {
-	for _, arch := range p.Architectures {
+		// For all architectures, generate packages/sources files
-		if progress != nil {
+		for _, arch := range p.Architectures {
-			progress.InitBar(int64(list.Len()), false)
-		}
-
-		var relativePath string
-		if arch == "source" {
-			relativePath = filepath.Join(p.Component, "source", "Sources")
-		} else {
-			relativePath = filepath.Join(p.Component, fmt.Sprintf("binary-%s", arch), "Packages")
-		}
-		err = publishedStorage.MkDir(filepath.Dir(filepath.Join(basePath, relativePath)))
-		if err != nil {
-			return err
-		}
-
-		var packagesFile *os.File
-		packagesFile, err = publishedStorage.CreateFile(filepath.Join(basePath, relativePath+suffix))
-		if err != nil {
-			return fmt.Errorf("unable to creates Packages file: %s", err)
-		}
-
-		if suffix != "" {
-			renameMap[filepath.Join(basePath, relativePath+suffix)] = filepath.Join(basePath, relativePath)
-		}
-
-		bufWriter := bufio.NewWriter(packagesFile)
-
-		err = list.ForEach(func(pkg *Package) error {
 			if progress != nil {
-				progress.AddBar(1)
+				progress.InitBar(int64(list.Len()), false)
-			}
-			if pkg.MatchesArchitecture(arch) {
-				err = pkg.LinkFromPool(publishedStorage, packagePool, p.Prefix, p.Component)
-				if err != nil {
-					return err
-				}
-
-				err = pkg.Stanza().WriteTo(bufWriter)
-				if err != nil {
-					return err
-				}
-				err = bufWriter.WriteByte('\n')
-				if err != nil {
-					return err
-				}
-
-				pkg.files = nil
-				pkg.deps = nil
-				pkg.extra = nil
-
 			}
 
-			return nil
+			var relativePath string
-		})
+			if arch == "source" {
+				relativePath = filepath.Join(component, "source", "Sources")
+			} else {
+				relativePath = filepath.Join(component, fmt.Sprintf("binary-%s", arch), "Packages")
+			}
+			err = publishedStorage.MkDir(filepath.Dir(filepath.Join(basePath, relativePath)))
+			if err != nil {
+				return err
+			}
 
-		if err != nil {
+			var packagesFile *os.File
-			return fmt.Errorf("unable to process packages: %s", err)
+			packagesFile, err = publishedStorage.CreateFile(filepath.Join(basePath, relativePath+suffix))
-		}
+			if err != nil {
+				return fmt.Errorf("unable to creates Packages file: %s", err)
+			}
 
-		err = bufWriter.Flush()
+			if suffix != "" {
-		if err != nil {
+				renameMap[filepath.Join(basePath, relativePath+suffix)] = filepath.Join(basePath, relativePath)
-			return fmt.Errorf("unable to write Packages file: %s", err)
+			}
-		}
 
-		err = utils.CompressFile(packagesFile)
+			bufWriter := bufio.NewWriter(packagesFile)
-		if err != nil {
-			return fmt.Errorf("unable to compress Packages files: %s", err)
-		}
 
-		if suffix != "" {
+			err = list.ForEach(func(pkg *Package) error {
-			renameMap[filepath.Join(basePath, relativePath+suffix+".gz")] = filepath.Join(basePath, relativePath+".gz")
+				if progress != nil {
-			renameMap[filepath.Join(basePath, relativePath+suffix+".bz2")] = filepath.Join(basePath, relativePath+".bz2")
+					progress.AddBar(1)
-		}
+				}
+				if pkg.MatchesArchitecture(arch) {
+					err = pkg.LinkFromPool(publishedStorage, packagePool, p.Prefix, component)
+					if err != nil {
+						return err
+					}
 
-		packagesFile.Close()
+					err = pkg.Stanza().WriteTo(bufWriter)
+					if err != nil {
+						return err
+					}
+					err = bufWriter.WriteByte('\n')
+					if err != nil {
+						return err
+					}
 
-		var checksumInfo utils.ChecksumInfo
+					pkg.files = nil
-		checksumInfo, err = publishedStorage.ChecksumsForFile(filepath.Join(basePath, relativePath+suffix))
+					pkg.deps = nil
-		if err != nil {
+					pkg.extra = nil
-			return fmt.Errorf("unable to collect checksums: %s", err)
-		}
-		generatedFiles[relativePath] = checksumInfo
 
-		checksumInfo, err = publishedStorage.ChecksumsForFile(filepath.Join(basePath, relativePath+suffix+".gz"))
+				}
-		if err != nil {
-			return fmt.Errorf("unable to collect checksums: %s", err)
-		}
-		generatedFiles[relativePath+".gz"] = checksumInfo
 
-		checksumInfo, err = publishedStorage.ChecksumsForFile(filepath.Join(basePath, relativePath+suffix+".bz2"))
+				return nil
-		if err != nil {
+			})
-			return fmt.Errorf("unable to collect checksums: %s", err)
-		}
-		generatedFiles[relativePath+".bz2"] = checksumInfo
 
-		if progress != nil {
+			if err != nil {
-			progress.ShutdownBar()
+				return fmt.Errorf("unable to process packages: %s", err)
+			}
+
+			err = bufWriter.Flush()
+			if err != nil {
+				return fmt.Errorf("unable to write Packages file: %s", err)
+			}
+
+			err = utils.CompressFile(packagesFile)
+			if err != nil {
+				return fmt.Errorf("unable to compress Packages files: %s", err)
+			}
+
+			if suffix != "" {
+				renameMap[filepath.Join(basePath, relativePath+suffix+".gz")] = filepath.Join(basePath, relativePath+".gz")
+				renameMap[filepath.Join(basePath, relativePath+suffix+".bz2")] = filepath.Join(basePath, relativePath+".bz2")
+			}
+
+			packagesFile.Close()
+
+			var checksumInfo utils.ChecksumInfo
+			checksumInfo, err = publishedStorage.ChecksumsForFile(filepath.Join(basePath, relativePath+suffix))
+			if err != nil {
+				return fmt.Errorf("unable to collect checksums: %s", err)
+			}
+			generatedFiles[relativePath] = checksumInfo
+
+			checksumInfo, err = publishedStorage.ChecksumsForFile(filepath.Join(basePath, relativePath+suffix+".gz"))
+			if err != nil {
+				return fmt.Errorf("unable to collect checksums: %s", err)
+			}
+			generatedFiles[relativePath+".gz"] = checksumInfo
+
+			checksumInfo, err = publishedStorage.ChecksumsForFile(filepath.Join(basePath, relativePath+suffix+".bz2"))
+			if err != nil {
+				return fmt.Errorf("unable to collect checksums: %s", err)
+			}
+			generatedFiles[relativePath+".bz2"] = checksumInfo
+
+			if progress != nil {
+				progress.ShutdownBar()
+			}
 		}
 	}
 
@@ -421,13 +527,14 @@ func (p *PublishedRepo) Publish(packagePool aptly.PackagePool, publishedStorage
 	}
 	release["Codename"] = p.Distribution
 	release["Date"] = time.Now().UTC().Format("Mon, 2 Jan 2006 15:04:05 MST")
-	release["Components"] = p.Component
 	release["Architectures"] = strings.Join(utils.StrSlicesSubstract(p.Architectures, []string{"source"}), " ")
 	release["Description"] = " Generated by aptly\n"
 	release["MD5Sum"] = "\n"
 	release["SHA1"] = "\n"
 	release["SHA256"] = "\n"
 
+	release["Components"] = strings.Join(p.Components(), " ")
+
 	for path, info := range generatedFiles {
 		release["MD5Sum"] += fmt.Sprintf(" %s %8d %s\n", info.MD5, info.Size, path)
 		release["SHA1"] += fmt.Sprintf(" %s %8d %s\n", info.SHA1, info.Size, path)
@@ -494,7 +601,8 @@ 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, removePoolComponent bool, progress aptly.Progress) error {
+func (p *PublishedRepo) RemoveFiles(publishedStorage aptly.PublishedStorage, removePrefix bool,
+	removePoolComponents []string, progress aptly.Progress) error {
 	// I. Easy: remove whole prefix (meta+packages)
 	if removePrefix {
 		err := publishedStorage.RemoveDirs(filepath.Join(p.Prefix, "dists"), progress)
@@ -512,15 +620,13 @@ func (p *PublishedRepo) RemoveFiles(publishedStorage aptly.PublishedStorage, rem
 	}
 
 	// III. Complex: there are no other publishes with the same prefix + component
-	if removePoolComponent {
+	for _, component := range removePoolComponents {
-		err = publishedStorage.RemoveDirs(filepath.Join(p.Prefix, "pool", p.Component), progress)
+		err = publishedStorage.RemoveDirs(filepath.Join(p.Prefix, "pool", component), progress)
 		if err != nil {
 			return err
 		}
-	} else {
-		/// IV: Hard: should have removed published files from the pool + component
-		/// that are unique to this published repo
 	}
+
 	return nil
 }
 
@@ -585,42 +691,74 @@ func (collection *PublishedRepoCollection) Update(repo *PublishedRepo) (err erro
 	}
 
 	if repo.SourceKind == "local" {
-		err = collection.db.Put(repo.RefKey(), repo.packageRefs.Encode())
+		for component, item := range repo.sourceItems {
+			err = collection.db.Put(repo.RefKey(component), item.packageRefs.Encode())
+			if err != nil {
+				return
+			}
+		}
 	}
 	return
 }
 
 // LoadComplete loads additional information for remote repo
 func (collection *PublishedRepoCollection) LoadComplete(repo *PublishedRepo, collectionFactory *CollectionFactory) (err error) {
+	repo.sourceItems = make(map[string]repoSourceItem)
+
 	if repo.SourceKind == "snapshot" {
-		repo.snapshot, err = collectionFactory.SnapshotCollection().ByUUID(repo.SourceUUID)
+		for component, sourceUUID := range repo.Sources {
-		if err != nil {
+			item := repoSourceItem{}
-			return
+
+			item.snapshot, err = collectionFactory.SnapshotCollection().ByUUID(sourceUUID)
+			if err != nil {
+				return
+			}
+			err = collectionFactory.SnapshotCollection().LoadComplete(item.snapshot)
+			if err != nil {
+				return
+			}
+
+			repo.sourceItems[component] = item
 		}
-		err = collectionFactory.SnapshotCollection().LoadComplete(repo.snapshot)
 	} else if repo.SourceKind == "local" {
-		repo.localRepo, err = collectionFactory.LocalRepoCollection().ByUUID(repo.SourceUUID)
+		for component, sourceUUID := range repo.Sources {
-		if err != nil {
+			item := repoSourceItem{}
-			return
-		}
-		err = collectionFactory.LocalRepoCollection().LoadComplete(repo.localRepo)
-		if err != nil {
-			return
-		}
 
-		var encoded []byte
+			item.localRepo, err = collectionFactory.LocalRepoCollection().ByUUID(sourceUUID)
-		encoded, err = collection.db.Get(repo.RefKey())
+			if err != nil {
-		if err != nil {
+				return
-			return err
+			}
-		}
+			err = collectionFactory.LocalRepoCollection().LoadComplete(item.localRepo)
+			if err != nil {
+				return
+			}
 
-		repo.packageRefs = &PackageRefList{}
+			var encoded []byte
-		err = repo.packageRefs.Decode(encoded)
+			encoded, err = collection.db.Get(repo.RefKey(component))
+			if err != nil {
+				// < 0.6 saving w/o component name
+				if err == database.ErrNotFound && len(repo.Sources) == 1 {
+					encoded, err = collection.db.Get(repo.RefKey(""))
+				}
+
+				if err != nil {
+					return
+				}
+			}
+
+			item.packageRefs = &PackageRefList{}
+			err = item.packageRefs.Decode(encoded)
+			if err != nil {
+				return
+			}
+
+			repo.sourceItems[component] = item
+		}
 	} else {
 		panic("unknown SourceKind")
 	}
 
-	return err
+	return
 }
 
 // ByPrefixDistribution looks up repository by prefix & distribution
@@ -647,8 +785,17 @@ func (collection *PublishedRepoCollection) ByUUID(uuid string) (*PublishedRepo,
 func (collection *PublishedRepoCollection) BySnapshot(snapshot *Snapshot) []*PublishedRepo {
 	result := make([]*PublishedRepo, 0)
 	for _, r := range collection.list {
-		if r.SourceKind == "snapshot" && r.SourceUUID == snapshot.UUID {
+		if r.SourceKind == "snapshot" {
-			result = append(result, r)
+			if r.SourceUUID == snapshot.UUID {
+				result = append(result, r)
+			}
+
+			for _, sourceUUID := range r.Sources {
+				if sourceUUID == snapshot.UUID {
+					result = append(result, r)
+					break
+				}
+			}
 		}
 	}
 	return result
@@ -658,8 +805,17 @@ func (collection *PublishedRepoCollection) BySnapshot(snapshot *Snapshot) []*Pub
 func (collection *PublishedRepoCollection) ByLocalRepo(repo *LocalRepo) []*PublishedRepo {
 	result := make([]*PublishedRepo, 0)
 	for _, r := range collection.list {
-		if r.SourceKind == "local" && r.SourceUUID == repo.UUID {
+		if r.SourceKind == "local" {
-			result = append(result, r)
+			if r.SourceUUID == repo.UUID {
+				result = append(result, r)
+			}
+
+			for _, sourceUUID := range r.Sources {
+				if sourceUUID == repo.UUID {
+					result = append(result, r)
+					break
+				}
+			}
 		}
 	}
 	return result
@@ -683,60 +839,81 @@ func (collection *PublishedRepoCollection) Len() int {
 }
 
 // CleanupPrefixComponentFiles removes all unreferenced files in published storage under prefix/component pair
-func (collection *PublishedRepoCollection) CleanupPrefixComponentFiles(prefix, component string,
+func (collection *PublishedRepoCollection) CleanupPrefixComponentFiles(prefix string, components []string,
 	publishedStorage aptly.PublishedStorage, collectionFactory *CollectionFactory, progress aptly.Progress) error {
 
 	var err error
-	referencedFiles := []string{}
+	referencedFiles := map[string][]string{}
 
 	if progress != nil {
-		progress.Printf("Cleaning up prefix %#v component %#v...\n", prefix, component)
+		progress.Printf("Cleaning up prefix %#v components %#v...\n", prefix, components)
 	}
 
 	for _, r := range collection.list {
-		if r.Prefix == prefix && r.Component == component {
+		if r.Prefix == prefix {
+			matches := false
+
+			repoComponents := r.Components()
+
+			for _, component := range components {
+				if utils.StrSliceHasItem(repoComponents, component) {
+					matches = true
+					break
+				}
+			}
+
+			if !matches {
+				continue
+			}
+
 			err = collection.LoadComplete(r, collectionFactory)
 			if err != nil {
 				return err
 			}
 
-			packageList, err := NewPackageListFromRefList(r.RefList(), collectionFactory.PackageCollection(), progress)
+			for _, component := range components {
-			if err != nil {
+				if utils.StrSliceHasItem(repoComponents, component) {
-				return err
+					packageList, err := NewPackageListFromRefList(r.RefList(component), collectionFactory.PackageCollection(), progress)
+					if err != nil {
+						return err
+					}
+
+					packageList.ForEach(func(p *Package) error {
+						poolDir, err := p.PoolDirectory()
+						if err != nil {
+							return err
+						}
+
+						for _, f := range p.Files() {
+							referencedFiles[component] = append(referencedFiles[component], filepath.Join(poolDir, f.Filename))
+						}
+
+						return nil
+					})
+				}
 			}
-
-			packageList.ForEach(func(p *Package) error {
-				poolDir, err := p.PoolDirectory()
-				if err != nil {
-					return err
-				}
-
-				for _, f := range p.Files() {
-					referencedFiles = append(referencedFiles, filepath.Join(poolDir, f.Filename))
-				}
-
-				return nil
-			})
 		}
 	}
 
-	sort.Strings(referencedFiles)
+	for _, component := range components {
+		sort.Strings(referencedFiles[component])
 
-	rootPath := filepath.Join(prefix, "pool", component)
+		rootPath := filepath.Join(prefix, "pool", component)
-	existingFiles, err := publishedStorage.Filelist(rootPath)
+		existingFiles, err := publishedStorage.Filelist(rootPath)
-	if err != nil {
-		return err
-	}
-
-	sort.Strings(existingFiles)
-
-	filesToDelete := utils.StrSlicesSubstract(existingFiles, referencedFiles)
-
-	for _, file := range filesToDelete {
-		err = publishedStorage.Remove(filepath.Join(rootPath, file))
 		if err != nil {
 			return err
 		}
+
+		sort.Strings(existingFiles)
+
+		filesToDelete := utils.StrSlicesSubstract(existingFiles, referencedFiles[component])
+
+		for _, file := range filesToDelete {
+			err = publishedStorage.Remove(filepath.Join(rootPath, file))
+			if err != nil {
+				return err
+			}
+		}
 	}
 
 	return nil
@@ -751,7 +928,8 @@ func (collection *PublishedRepoCollection) Remove(publishedStorage aptly.Publish
 	}
 
 	removePrefix := true
-	removePoolComponent := true
+	removePoolComponents := repo.Components()
+	cleanComponents := []string{}
 	repoPosition := -1
 
 	for i, r := range collection.list {
@@ -761,13 +939,18 @@ func (collection *PublishedRepoCollection) Remove(publishedStorage aptly.Publish
 		}
 		if r.Prefix == repo.Prefix {
 			removePrefix = false
-			if r.Component == repo.Component {
+
-				removePoolComponent = false
+			rComponents := r.Components()
+			for _, component := range rComponents {
+				if utils.StrSliceHasItem(removePoolComponents, component) {
+					removePoolComponents = utils.StrSlicesSubstract(removePoolComponents, []string{component})
+					cleanComponents = append(cleanComponents, component)
+				}
 			}
 		}
 	}
 
-	err = repo.RemoveFiles(publishedStorage, removePrefix, removePoolComponent, progress)
+	err = repo.RemoveFiles(publishedStorage, removePrefix, removePoolComponents, progress)
 	if err != nil {
 		return err
 	}
@@ -775,8 +958,8 @@ 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]
 
-	if !removePrefix && !removePoolComponent {
+	if len(cleanComponents) > 0 {
-		err = collection.CleanupPrefixComponentFiles(repo.Prefix, repo.Component, publishedStorage, collectionFactory, progress)
+		err = collection.CleanupPrefixComponentFiles(repo.Prefix, cleanComponents, publishedStorage, collectionFactory, progress)
 		if err != nil {
 			return err
 		}
@@ -786,5 +969,13 @@ func (collection *PublishedRepoCollection) Remove(publishedStorage aptly.Publish
 	if err != nil {
 		return err
 	}
-	return collection.db.Delete(repo.RefKey())
+
+	for _, component := range repo.Components() {
+		err = collection.db.Delete(repo.RefKey(component))
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
 }

deb/publish_test.go

@@ -1,10 +1,12 @@
 package deb
 
 import (
+	"bytes"
 	"errors"
 	"github.com/smira/aptly/aptly"
 	"github.com/smira/aptly/database"
 	"github.com/smira/aptly/files"
+	"github.com/ugorji/go/codec"
 	. "launchpad.net/gocheck"
 	"os"
 	"path/filepath"
@@ -84,9 +86,9 @@ func (s *PublishedRepoSuite) SetUpTest(c *C) {
 	s.packageCollection.Update(s.p2)
 	s.packageCollection.Update(s.p3)
 
-	s.repo, _ = NewPublishedRepo("ppa", "squeeze", "main", nil, s.snapshot, s.factory)
+	s.repo, _ = NewPublishedRepo("ppa", "squeeze", nil, []string{"main"}, []interface{}{s.snapshot}, s.factory)
 
-	s.repo2, _ = NewPublishedRepo("ppa", "maverick", "main", nil, s.localRepo, s.factory)
+	s.repo2, _ = NewPublishedRepo("ppa", "maverick", nil, []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)
@@ -100,17 +102,19 @@ func (s *PublishedRepoSuite) TearDownTest(c *C) {
 }
 
 func (s *PublishedRepoSuite) TestNewPublishedRepo(c *C) {
-	c.Check(s.repo.snapshot, Equals, s.snapshot)
+	c.Check(s.repo.sourceItems["main"].snapshot, Equals, s.snapshot)
 	c.Check(s.repo.SourceKind, Equals, "snapshot")
-	c.Check(s.repo.SourceUUID, Equals, s.snapshot.UUID)
+	c.Check(s.repo.Sources["main"], Equals, s.snapshot.UUID)
+	c.Check(s.repo.Components(), DeepEquals, []string{"main"})
 
-	c.Check(s.repo2.localRepo, Equals, s.localRepo)
+	c.Check(s.repo2.sourceItems["main"].localRepo, Equals, s.localRepo)
 	c.Check(s.repo2.SourceKind, Equals, "local")
-	c.Check(s.repo2.SourceUUID, Equals, s.localRepo.UUID)
+	c.Check(s.repo2.Sources["main"], Equals, s.localRepo.UUID)
-	c.Check(s.repo2.packageRefs.Len(), Equals, 3)
+	c.Check(s.repo2.sourceItems["main"].packageRefs.Len(), Equals, 3)
+	c.Check(s.repo2.Components(), DeepEquals, []string{"main"})
 
-	c.Check(s.repo.RefList().Len(), Equals, 3)
+	c.Check(s.repo.RefList("main").Len(), Equals, 3)
-	c.Check(s.repo2.RefList().Len(), Equals, 3)
+	c.Check(s.repo2.RefList("main").Len(), Equals, 3)
 }
 
 func (s *PublishedRepoSuite) TestPrefixNormalization(c *C) {
@@ -169,7 +173,7 @@ func (s *PublishedRepoSuite) TestPrefixNormalization(c *C) {
 			errorExpected: "invalid prefix .*",
 		},
 	} {
-		repo, err := NewPublishedRepo(t.prefix, "squeeze", "main", nil, 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 {
@@ -179,37 +183,37 @@ func (s *PublishedRepoSuite) TestPrefixNormalization(c *C) {
 }
 
 func (s *PublishedRepoSuite) TestDistributionComponentGuessing(c *C) {
-	repo, err := NewPublishedRepo("ppa", "", "", nil, 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.Component, Equals, "main")
+	c.Check(repo.Components(), DeepEquals, []string{"main"})
 
-	repo, err = NewPublishedRepo("ppa", "wheezy", "", nil, 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.Component, Equals, "main")
+	c.Check(repo.Components(), DeepEquals, []string{"main"})
 
-	repo, err = NewPublishedRepo("ppa", "", "non-free", nil, 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.Component, Equals, "non-free")
+	c.Check(repo.Components(), DeepEquals, []string{"non-free"})
 
-	repo, err = NewPublishedRepo("ppa", "squeeze", "", nil, 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.Component, Equals, "main")
+	c.Check(repo.Components(), DeepEquals, []string{"main"})
 
-	repo, err = NewPublishedRepo("ppa", "", "main", nil, 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, 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.Component, Equals, "contrib")
+	c.Check(repo.Components(), DeepEquals, []string{"contrib"})
 }
 
 func (s *PublishedRepoSuite) TestPublish(c *C) {
@@ -265,21 +269,21 @@ func (s *PublishedRepoSuite) TestPublishLocalRepo(c *C) {
 
 func (s *PublishedRepoSuite) TestString(c *C) {
 	c.Check(s.repo.String(), Equals,
-		"ppa/squeeze (main) [] publishes [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze")
+		"ppa/squeeze [] publishes {main: [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze}")
 	c.Check(s.repo2.String(), Equals,
-		"ppa/maverick (main) [] publishes [local1]: comment1")
+		"ppa/maverick [] publishes {main: [local1]: comment1}")
-	repo, _ := NewPublishedRepo("", "squeeze", "main", []string{"s390"}, s.snapshot, s.factory)
+	repo, _ := NewPublishedRepo("", "squeeze", []string{"s390"}, []string{"main"}, []interface{}{s.snapshot}, s.factory)
 	c.Check(repo.String(), Equals,
-		"./squeeze (main) [s390] publishes [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze")
+		"./squeeze [s390] publishes {main: [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze}")
-	repo, _ = NewPublishedRepo("", "squeeze", "main", []string{"i386", "amd64"}, s.snapshot, s.factory)
+	repo, _ = NewPublishedRepo("", "squeeze", []string{"i386", "amd64"}, []string{"main"}, []interface{}{s.snapshot}, s.factory)
 	c.Check(repo.String(), Equals,
-		"./squeeze (main) [i386, amd64] publishes [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze")
+		"./squeeze [i386, amd64] publishes {main: [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze}")
 	repo.Origin = "myorigin"
 	c.Check(repo.String(), Equals,
-		"./squeeze (main, origin: myorigin) [i386, amd64] publishes [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze")
+		"./squeeze (origin: myorigin) [i386, amd64] publishes {main: [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze}")
 	repo.Label = "mylabel"
 	c.Check(repo.String(), Equals,
-		"./squeeze (main, origin: myorigin, label: mylabel) [i386, amd64] publishes [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze")
+		"./squeeze (origin: myorigin, label: mylabel) [i386, amd64] publishes {main: [snap]: Snapshot from mirror [yandex]: http://mirror.yandex.ru/debian/ squeeze}")
 }
 
 func (s *PublishedRepoSuite) TestKey(c *C) {
@@ -287,7 +291,8 @@ func (s *PublishedRepoSuite) TestKey(c *C) {
 }
 
 func (s *PublishedRepoSuite) TestRefKey(c *C) {
-	c.Check(s.repo.RefKey(), DeepEquals, []byte("E"+s.repo.UUID))
+	c.Check(s.repo.RefKey(""), DeepEquals, []byte("E"+s.repo.UUID))
+	c.Check(s.repo.RefKey("main"), DeepEquals, []byte("E"+s.repo.UUID+"main"))
 }
 
 func (s *PublishedRepoSuite) TestEncodeDecode(c *C) {
@@ -295,7 +300,7 @@ func (s *PublishedRepoSuite) TestEncodeDecode(c *C) {
 	repo := &PublishedRepo{}
 	err := repo.Decode(encoded)
 
-	s.repo.snapshot = nil
+	s.repo.sourceItems = nil
 	c.Assert(err, IsNil)
 	c.Assert(repo, DeepEquals, s.repo)
 
@@ -303,8 +308,7 @@ func (s *PublishedRepoSuite) TestEncodeDecode(c *C) {
 	repo2 := &PublishedRepo{}
 	err = repo2.Decode(encoded2)
 
-	s.repo2.localRepo = nil
+	s.repo2.sourceItems = nil
-	s.repo2.packageRefs = nil
 	c.Assert(err, IsNil)
 	c.Assert(repo2, DeepEquals, s.repo2)
 }
@@ -337,10 +341,10 @@ func (s *PublishedRepoCollectionSuite) SetUpTest(c *C) {
 	s.localRepo = NewLocalRepo("local1", "comment1")
 	s.factory.LocalRepoCollection().Add(s.localRepo)
 
-	s.repo1, _ = NewPublishedRepo("ppa", "anaconda", "main", []string{}, s.snap1, s.factory)
+	s.repo1, _ = NewPublishedRepo("ppa", "anaconda", []string{}, []string{"main"}, []interface{}{s.snap1}, s.factory)
-	s.repo2, _ = NewPublishedRepo("", "anaconda", "main", []string{}, s.snap2, s.factory)
+	s.repo2, _ = NewPublishedRepo("", "anaconda", []string{}, []string{"main"}, []interface{}{s.snap2}, s.factory)
-	s.repo3, _ = NewPublishedRepo("ppa", "anaconda", "main", []string{}, s.snap2, s.factory)
+	s.repo3, _ = NewPublishedRepo("ppa", "anaconda", []string{}, []string{"main"}, []interface{}{s.snap2}, s.factory)
-	s.repo4, _ = NewPublishedRepo("ppa", "precise", "main", []string{}, s.localRepo, s.factory)
+	s.repo4, _ = NewPublishedRepo("ppa", "precise", []string{}, []string{"main"}, []interface{}{s.localRepo}, s.factory)
 
 	s.collection = s.factory.PublishedRepoCollection()
 }
@@ -398,18 +402,61 @@ func (s *PublishedRepoCollectionSuite) TestUpdateLoadComplete(c *C) {
 	collection := NewPublishedRepoCollection(s.db)
 	r, err := collection.ByPrefixDistribution("ppa", "anaconda")
 	c.Assert(err, IsNil)
-	c.Assert(r.snapshot, IsNil)
+	c.Assert(r.sourceItems["main"].snapshot, IsNil)
 	c.Assert(s.collection.LoadComplete(r, s.factory), IsNil)
-	c.Assert(r.snapshot.UUID, Equals, s.repo1.snapshot.UUID)
+	c.Assert(r.Sources["main"], Equals, s.repo1.sourceItems["main"].snapshot.UUID)
-	c.Assert(r.RefList().Len(), Equals, 0)
+	c.Assert(r.RefList("main").Len(), Equals, 0)
 
 	r, err = collection.ByPrefixDistribution("ppa", "precise")
 	c.Assert(err, IsNil)
-	c.Assert(r.localRepo, IsNil)
+	c.Assert(r.sourceItems["main"].localRepo, IsNil)
 	c.Assert(s.collection.LoadComplete(r, s.factory), IsNil)
-	c.Assert(r.localRepo.UUID, Equals, s.repo4.localRepo.UUID)
+	c.Assert(r.sourceItems["main"].localRepo.UUID, Equals, s.repo4.sourceItems["main"].localRepo.UUID)
-	c.Assert(r.packageRefs.Len(), Equals, 0)
+	c.Assert(r.sourceItems["main"].packageRefs.Len(), Equals, 0)
-	c.Assert(r.RefList().Len(), Equals, 0)
+	c.Assert(r.RefList("main").Len(), Equals, 0)
+}
+
+func (s *PublishedRepoCollectionSuite) TestLoadPre0_6(c *C) {
+	type oldPublishedRepo struct {
+		UUID          string
+		Prefix        string
+		Distribution  string
+		Origin        string
+		Label         string
+		Architectures []string
+		SourceKind    string
+		Component     string
+		SourceUUID    string `codec:"SnapshotUUID"`
+	}
+
+	old := oldPublishedRepo{
+		UUID:          s.repo1.UUID,
+		Prefix:        "ppa",
+		Distribution:  "anaconda",
+		Architectures: []string{"i386"},
+		SourceKind:    "local",
+		Component:     "contrib",
+		SourceUUID:    s.localRepo.UUID,
+	}
+
+	var buf bytes.Buffer
+
+	encoder := codec.NewEncoder(&buf, &codec.MsgpackHandle{})
+	encoder.Encode(&old)
+
+	c.Assert(s.db.Put(s.repo1.Key(), buf.Bytes()), IsNil)
+	c.Assert(s.db.Put(s.repo1.RefKey(""), s.localRepo.RefList().Encode()), IsNil)
+
+	collection := NewPublishedRepoCollection(s.db)
+	repo, err := collection.ByPrefixDistribution("ppa", "anaconda")
+	c.Check(err, IsNil)
+	c.Check(repo.Component, Equals, "")
+	c.Check(repo.SourceUUID, Equals, "")
+	c.Check(repo.Sources, DeepEquals, map[string]string{"contrib": s.localRepo.UUID})
+
+	c.Check(collection.LoadComplete(repo, s.factory), IsNil)
+	c.Check(repo.sourceItems["contrib"].localRepo.UUID, Equals, s.localRepo.UUID)
+	c.Check(repo.RefList("contrib").Len(), Equals, 0)
 }
 
 func (s *PublishedRepoCollectionSuite) TestForEachAndLen(c *C) {
@@ -472,10 +519,10 @@ func (s *PublishedRepoRemoveSuite) SetUpTest(c *C) {
 
 	s.snapshotCollection.Add(s.snap1)
 
-	s.repo1, _ = NewPublishedRepo("ppa", "anaconda", "main", []string{}, s.snap1, s.factory)
+	s.repo1, _ = NewPublishedRepo("ppa", "anaconda", []string{}, []string{"main"}, []interface{}{s.snap1}, s.factory)
-	s.repo2, _ = NewPublishedRepo("", "anaconda", "main", []string{}, s.snap1, s.factory)
+	s.repo2, _ = NewPublishedRepo("", "anaconda", []string{}, []string{"main"}, []interface{}{s.snap1}, s.factory)
-	s.repo3, _ = NewPublishedRepo("ppa", "meduza", "main", []string{}, s.snap1, s.factory)
+	s.repo3, _ = NewPublishedRepo("ppa", "meduza", []string{}, []string{"main"}, []interface{}{s.snap1}, s.factory)
-	s.repo4, _ = NewPublishedRepo("ppa", "osminog", "contrib", []string{}, s.snap1, s.factory)
+	s.repo4, _ = NewPublishedRepo("ppa", "osminog", []string{}, []string{"contrib"}, []interface{}{s.snap1}, s.factory)
 
 	s.collection = s.factory.PublishedRepoCollection()
 	s.collection.Add(s.repo1)
@@ -499,7 +546,7 @@ func (s *PublishedRepoRemoveSuite) TearDownTest(c *C) {
 }
 
 func (s *PublishedRepoRemoveSuite) TestRemoveFilesOnlyDist(c *C) {
-	s.repo1.RemoveFiles(s.publishedStorage, false, false, nil)
+	s.repo1.RemoveFiles(s.publishedStorage, 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)
@@ -511,7 +558,7 @@ func (s *PublishedRepoRemoveSuite) TestRemoveFilesOnlyDist(c *C) {
 }
 
 func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithPool(c *C) {
-	s.repo1.RemoveFiles(s.publishedStorage, false, true, nil)
+	s.repo1.RemoveFiles(s.publishedStorage, 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)
@@ -523,7 +570,7 @@ func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithPool(c *C) {
 }
 
 func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithPrefix(c *C) {
-	s.repo1.RemoveFiles(s.publishedStorage, true, true, nil)
+	s.repo1.RemoveFiles(s.publishedStorage, 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))
@@ -535,7 +582,7 @@ func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithPrefix(c *C) {
 }
 
 func (s *PublishedRepoRemoveSuite) TestRemoveFilesWithPrefixRoot(c *C) {
-	s.repo2.RemoveFiles(s.publishedStorage, true, true, nil)
+	s.repo2.RemoveFiles(s.publishedStorage, 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)