func (a *Api) RepoDeletePackage(repoName, packageRef string) error { collection := a.Ctx().CollectionFactory().LocalRepoCollection() collection.Lock() defer collection.Unlock() repo, err := collection.ByName(repoName) if err != nil { return err } err = collection.LoadComplete(repo) if err != nil { return err } list, err := deb.NewPackageListFromRefList(repo.RefList(), a.Ctx().CollectionFactory().PackageCollection(), nil) if err != nil { return err } pkg, err := a.Ctx().CollectionFactory().PackageCollection().ByKey([]byte(packageRef)) if err != nil { return err } list.Remove(pkg) repo.UpdateRefList(deb.NewPackageRefListFromPackageList(list)) return collection.Update(repo) }
func aptlyRepoRemove(cmd *commander.Command, args []string) error { var err error if len(args) < 2 { cmd.Usage() return commander.ErrCommandError } name := args[0] repo, err := context.CollectionFactory().LocalRepoCollection().ByName(name) if err != nil { return fmt.Errorf("unable to remove: %s", err) } err = context.CollectionFactory().LocalRepoCollection().LoadComplete(repo) if err != nil { return fmt.Errorf("unable to remove: %s", err) } context.Progress().Printf("Loading packages...\n") list, err := deb.NewPackageListFromRefList(repo.RefList(), context.CollectionFactory().PackageCollection(), context.Progress()) if err != nil { return fmt.Errorf("unable to load packages: %s", err) } queries := make([]deb.PackageQuery, len(args)-1) for i := 0; i < len(args)-1; i++ { queries[i], err = query.Parse(args[i+1]) if err != nil { return fmt.Errorf("unable to remove: %s", err) } } list.PrepareIndex() toRemove, err := list.Filter(queries, false, nil, 0, nil) if err != nil { return fmt.Errorf("unable to remove: %s", err) } toRemove.ForEach(func(p *deb.Package) error { list.Remove(p) context.Progress().ColoredPrintf("@r[-]@| %s removed", p) return nil }) if context.Flags().Lookup("dry-run").Value.Get().(bool) { context.Progress().Printf("\nChanges not saved, as dry run has been requested.\n") } else { repo.UpdateRefList(deb.NewPackageRefListFromPackageList(list)) err = context.CollectionFactory().LocalRepoCollection().Update(repo) if err != nil { return fmt.Errorf("unable to save: %s", err) } } return err }
func (a *Api) RepoAddFile(repoName, fileName string, removeAfter, forceReplace bool) (*aptly.RecordingResultReporter, []string, error) { verifier := &utils.GpgVerifier{} collection := a.Ctx().CollectionFactory().LocalRepoCollection() collection.Lock() defer collection.Unlock() repo, err := collection.ByName(repoName) if err != nil { return nil, []string{}, err } err = collection.LoadComplete(repo) if err != nil { return nil, []string{}, err } var reporter = &aptly.RecordingResultReporter{ Warnings: []string{}, AddedLines: []string{}, RemovedLines: []string{}, } var packageFiles, failedFiles []string packageFiles, failedFiles = deb.CollectPackageFiles([]string{fileName}, reporter) list, err := deb.NewPackageListFromRefList(repo.RefList(), a.Ctx().CollectionFactory().PackageCollection(), nil) if err != nil { return nil, []string{}, err } var processedFiles, failedFiles2 []string processedFiles, failedFiles2, err = deb.ImportPackageFiles(list, packageFiles, forceReplace, verifier, a.Ctx().PackagePool(), a.Ctx().CollectionFactory().PackageCollection(), reporter, nil) failedFiles = append(failedFiles, failedFiles2...) if err != nil { return nil, []string{}, err } repo.UpdateRefList(deb.NewPackageRefListFromPackageList(list)) err = collection.Update(repo) if err != nil { return nil, []string{}, err } processedFiles = utils.StrSliceDeduplicate(processedFiles) if removeAfter { for _, file := range processedFiles { os.Remove(file) } } if failedFiles == nil { failedFiles = []string{} } return reporter, failedFiles, nil }
func (a *Api) SnapshotCreate(snapshotName, description string, sourceSnapshots []string, packageRefs []string) (*deb.Snapshot, error) { var err error snapshotCollection := a.Ctx().CollectionFactory().SnapshotCollection() snapshotCollection.Lock() defer snapshotCollection.Unlock() sources := make([]*deb.Snapshot, len(sourceSnapshots)) for i := range sourceSnapshots { sources[i], err = snapshotCollection.ByName(sourceSnapshots[i]) if err != nil { return nil, err } err = snapshotCollection.LoadComplete(sources[i]) if err != nil { return nil, err } } list := deb.NewPackageList() // verify package refs and build package list for _, ref := range packageRefs { var p *deb.Package p, err = a.Ctx().CollectionFactory().PackageCollection().ByKey([]byte(ref)) if err != nil { if err == database.ErrNotFound { return nil, fmt.Errorf("package %s: %s", ref, err) } else { return nil, err } } err = list.Add(p) if err != nil { return nil, err } } snapshot := deb.NewSnapshotFromRefList(snapshotName, sources, deb.NewPackageRefListFromPackageList(list), description) err = snapshotCollection.Add(snapshot) if err != nil { return nil, err } return snapshot, nil }
// POST /repos/:name/file/:dir func apiReposPackageFromDir(c *gin.Context) { forceReplace := c.Request.URL.Query().Get("forceReplace") == "1" noRemove := c.Request.URL.Query().Get("noRemove") == "1" if !verifyDir(c) { return } fileParam := c.Params.ByName("file") if fileParam != "" && !verifyPath(fileParam) { c.Fail(400, fmt.Errorf("wrong file")) return } collection := context.CollectionFactory().LocalRepoCollection() collection.Lock() defer collection.Unlock() repo, err := collection.ByName(c.Params.ByName("name")) if err != nil { c.Fail(404, err) return } err = collection.LoadComplete(repo) if err != nil { c.Fail(500, err) return } verifier := &utils.GpgVerifier{} var ( sources []string packageFiles, failedFiles []string processedFiles, failedFiles2 []string reporter = &aptly.RecordingResultReporter{ Warnings: []string{}, AddedLines: []string{}, RemovedLines: []string{}, } list *deb.PackageList ) if fileParam == "" { sources = []string{filepath.Join(context.UploadPath(), c.Params.ByName("dir"))} } else { sources = []string{filepath.Join(context.UploadPath(), c.Params.ByName("dir"), c.Params.ByName("file"))} } packageFiles, failedFiles = deb.CollectPackageFiles(sources, reporter) list, err = deb.NewPackageListFromRefList(repo.RefList(), context.CollectionFactory().PackageCollection(), nil) if err != nil { c.Fail(500, fmt.Errorf("unable to load packages: %s", err)) return } processedFiles, failedFiles2, err = deb.ImportPackageFiles(list, packageFiles, forceReplace, verifier, context.PackagePool(), context.CollectionFactory().PackageCollection(), reporter, nil) failedFiles = append(failedFiles, failedFiles2...) if err != nil { c.Fail(500, fmt.Errorf("unable to import package files: %s", err)) return } repo.UpdateRefList(deb.NewPackageRefListFromPackageList(list)) err = context.CollectionFactory().LocalRepoCollection().Update(repo) if err != nil { c.Fail(500, fmt.Errorf("unable to save: %s", err)) return } if !noRemove { processedFiles = utils.StrSliceDeduplicate(processedFiles) for _, file := range processedFiles { err := os.Remove(file) if err != nil { reporter.Warning("unable to remove file %s: %s", file, err) } } // atempt to remove dir, if it fails, that's fine: probably it's not empty os.Remove(filepath.Join(context.UploadPath(), c.Params.ByName("dir"))) } if failedFiles == nil { failedFiles = []string{} } c.JSON(200, gin.H{ "Report": reporter, "FailedFiles": failedFiles, }) }
// Handler for both add and delete func apiReposPackagesAddDelete(c *gin.Context, cb func(list *deb.PackageList, p *deb.Package) error) { var b struct { PackageRefs []string } if !c.Bind(&b) { return } collection := context.CollectionFactory().LocalRepoCollection() collection.Lock() defer collection.Unlock() repo, err := collection.ByName(c.Params.ByName("name")) if err != nil { c.Fail(404, err) return } err = collection.LoadComplete(repo) if err != nil { c.Fail(500, err) return } list, err := deb.NewPackageListFromRefList(repo.RefList(), context.CollectionFactory().PackageCollection(), nil) if err != nil { c.Fail(500, err) return } // verify package refs and build package list for _, ref := range b.PackageRefs { var p *deb.Package p, err = context.CollectionFactory().PackageCollection().ByKey([]byte(ref)) if err != nil { if err == database.ErrNotFound { c.Fail(404, fmt.Errorf("package %s: %s", ref, err)) } else { c.Fail(500, err) } return } err = cb(list, p) if err != nil { c.Fail(400, err) return } } repo.UpdateRefList(deb.NewPackageRefListFromPackageList(list)) err = context.CollectionFactory().LocalRepoCollection().Update(repo) if err != nil { c.Fail(500, fmt.Errorf("unable to save: %s", err)) return } c.JSON(200, repo) }
func aptlyRepoInclude(cmd *commander.Command, args []string) error { var err error if len(args) < 1 { cmd.Usage() return commander.ErrCommandError } verifier, err := getVerifier(context.Flags()) if err != nil { return fmt.Errorf("unable to initialize GPG verifier: %s", err) } if verifier == nil { verifier = &utils.GpgVerifier{} } forceReplace := context.Flags().Lookup("force-replace").Value.Get().(bool) acceptUnsigned := context.Flags().Lookup("accept-unsigned").Value.Get().(bool) ignoreSignatures := context.Flags().Lookup("ignore-signatures").Value.Get().(bool) noRemoveFiles := context.Flags().Lookup("no-remove-files").Value.Get().(bool) repoTemplate, err := template.New("repo").Parse(context.Flags().Lookup("repo").Value.Get().(string)) if err != nil { return fmt.Errorf("error parsing -repo template: %s", err) } uploaders := (*deb.Uploaders)(nil) uploadersFile := context.Flags().Lookup("uploaders-file").Value.Get().(string) if uploadersFile != "" { uploaders, err = deb.NewUploadersFromFile(uploadersFile) if err != nil { return err } for i := range uploaders.Rules { uploaders.Rules[i].CompiledCondition, err = query.Parse(uploaders.Rules[i].Condition) if err != nil { return fmt.Errorf("error parsing query %s: %s", uploaders.Rules[i].Condition, err) } } } reporter := &aptly.ConsoleResultReporter{Progress: context.Progress()} var changesFiles, failedFiles, processedFiles []string changesFiles, failedFiles = deb.CollectChangesFiles(args, reporter) for _, path := range changesFiles { var changes *deb.Changes changes, err = deb.NewChanges(path) if err != nil { failedFiles = append(failedFiles, path) reporter.Warning("unable to process file %s: %s", path, err) continue } err = changes.VerifyAndParse(acceptUnsigned, ignoreSignatures, verifier) if err != nil { failedFiles = append(failedFiles, path) reporter.Warning("unable to process file %s: %s", changes.ChangesName, err) changes.Cleanup() continue } err = changes.Prepare() if err != nil { failedFiles = append(failedFiles, path) reporter.Warning("unable to process file %s: %s", changes.ChangesName, err) changes.Cleanup() continue } repoName := &bytes.Buffer{} err = repoTemplate.Execute(repoName, changes.Stanza) if err != nil { return fmt.Errorf("error applying template to repo: %s", err) } context.Progress().Printf("Loading repository %s for changes file %s...\n", repoName.String(), changes.ChangesName) repo, err := context.CollectionFactory().LocalRepoCollection().ByName(repoName.String()) if err != nil { failedFiles = append(failedFiles, path) reporter.Warning("unable to process file %s: %s", changes.ChangesName, err) changes.Cleanup() continue } currentUploaders := uploaders if repo.Uploaders != nil { currentUploaders = repo.Uploaders for i := range currentUploaders.Rules { currentUploaders.Rules[i].CompiledCondition, err = query.Parse(currentUploaders.Rules[i].Condition) if err != nil { return fmt.Errorf("error parsing query %s: %s", currentUploaders.Rules[i].Condition, err) } } } if currentUploaders != nil { if err = currentUploaders.IsAllowed(changes); err != nil { failedFiles = append(failedFiles, path) reporter.Warning("changes file skipped due to uploaders config: %s, keys %#v: %s", changes.ChangesName, changes.SignatureKeys, err) changes.Cleanup() continue } } err = context.CollectionFactory().LocalRepoCollection().LoadComplete(repo) if err != nil { return fmt.Errorf("unable to load repo: %s", err) } list, err := deb.NewPackageListFromRefList(repo.RefList(), context.CollectionFactory().PackageCollection(), context.Progress()) if err != nil { return fmt.Errorf("unable to load packages: %s", err) } packageFiles, _ := deb.CollectPackageFiles([]string{changes.TempDir}, reporter) var restriction deb.PackageQuery restriction, err = changes.PackageQuery() if err != nil { failedFiles = append(failedFiles, path) reporter.Warning("unable to process file %s: %s", changes.ChangesName, err) changes.Cleanup() continue } var processedFiles2, failedFiles2 []string processedFiles2, failedFiles2, err = deb.ImportPackageFiles(list, packageFiles, forceReplace, verifier, context.PackagePool(), context.CollectionFactory().PackageCollection(), reporter, restriction) if err != nil { return fmt.Errorf("unable to import package files: %s", err) } repo.UpdateRefList(deb.NewPackageRefListFromPackageList(list)) err = context.CollectionFactory().LocalRepoCollection().Update(repo) if err != nil { return fmt.Errorf("unable to save: %s", err) } err = changes.Cleanup() if err != nil { return err } for _, file := range failedFiles2 { failedFiles = append(failedFiles, filepath.Join(changes.BasePath, filepath.Base(file))) } for _, file := range processedFiles2 { processedFiles = append(processedFiles, filepath.Join(changes.BasePath, filepath.Base(file))) } processedFiles = append(processedFiles, path) } if !noRemoveFiles { processedFiles = utils.StrSliceDeduplicate(processedFiles) for _, file := range processedFiles { err := os.Remove(file) if err != nil { return fmt.Errorf("unable to remove file: %s", err) } } } if len(failedFiles) > 0 { context.Progress().ColoredPrintf("@y[!]@| @!Some files were skipped due to errors:@|") for _, file := range failedFiles { context.Progress().ColoredPrintf(" %s", file) } return fmt.Errorf("some files failed to be added") } return err }
// POST /api/snapshots func apiSnapshotsCreate(c *gin.Context) { var ( err error snapshot *deb.Snapshot ) var b struct { Name string `binding:"required"` Description string SourceSnapshots []string PackageRefs []string } if !c.Bind(&b) { return } if b.Description == "" { if len(b.SourceSnapshots)+len(b.PackageRefs) == 0 { b.Description = "Created as empty" } } snapshotCollection := context.CollectionFactory().SnapshotCollection() snapshotCollection.Lock() defer snapshotCollection.Unlock() sources := make([]*deb.Snapshot, len(b.SourceSnapshots)) for i := range b.SourceSnapshots { sources[i], err = snapshotCollection.ByName(b.SourceSnapshots[i]) if err != nil { c.Fail(404, err) return } err = snapshotCollection.LoadComplete(sources[i]) if err != nil { c.Fail(500, err) return } } list := deb.NewPackageList() // verify package refs and build package list for _, ref := range b.PackageRefs { var p *deb.Package p, err = context.CollectionFactory().PackageCollection().ByKey([]byte(ref)) if err != nil { if err == database.ErrNotFound { c.Fail(404, fmt.Errorf("package %s: %s", ref, err)) } else { c.Fail(500, err) } return } err = list.Add(p) if err != nil { c.Fail(400, err) return } } snapshot = deb.NewSnapshotFromRefList(b.Name, sources, deb.NewPackageRefListFromPackageList(list), b.Description) err = snapshotCollection.Add(snapshot) if err != nil { c.Fail(400, err) return } c.JSON(201, snapshot) }
func aptlyRepoMoveCopyImport(cmd *commander.Command, args []string) error { var err error if len(args) < 3 { cmd.Usage() return commander.ErrCommandError } command := cmd.Name() dstRepo, err := context.CollectionFactory().LocalRepoCollection().ByName(args[1]) if err != nil { return fmt.Errorf("unable to %s: %s", command, err) } err = context.CollectionFactory().LocalRepoCollection().LoadComplete(dstRepo) if err != nil { return fmt.Errorf("unable to %s: %s", command, err) } var ( srcRefList *deb.PackageRefList srcRepo *deb.LocalRepo ) if command == "copy" || command == "move" { srcRepo, err = context.CollectionFactory().LocalRepoCollection().ByName(args[0]) if err != nil { return fmt.Errorf("unable to %s: %s", command, err) } if srcRepo.UUID == dstRepo.UUID { return fmt.Errorf("unable to %s: source and destination are the same", command) } err = context.CollectionFactory().LocalRepoCollection().LoadComplete(srcRepo) if err != nil { return fmt.Errorf("unable to %s: %s", command, err) } srcRefList = srcRepo.RefList() } else if command == "import" { var srcRemoteRepo *deb.RemoteRepo srcRemoteRepo, err = context.CollectionFactory().RemoteRepoCollection().ByName(args[0]) if err != nil { return fmt.Errorf("unable to %s: %s", command, err) } err = context.CollectionFactory().RemoteRepoCollection().LoadComplete(srcRemoteRepo) if err != nil { return fmt.Errorf("unable to %s: %s", command, err) } if srcRemoteRepo.RefList() == nil { return fmt.Errorf("unable to %s: mirror not updated", command) } srcRefList = srcRemoteRepo.RefList() } else { panic("unexpected command") } context.Progress().Printf("Loading packages...\n") dstList, err := deb.NewPackageListFromRefList(dstRepo.RefList(), context.CollectionFactory().PackageCollection(), context.Progress()) if err != nil { return fmt.Errorf("unable to load packages: %s", err) } srcList, err := deb.NewPackageListFromRefList(srcRefList, context.CollectionFactory().PackageCollection(), context.Progress()) if err != nil { return fmt.Errorf("unable to load packages: %s", err) } srcList.PrepareIndex() var architecturesList []string withDeps := context.flags.Lookup("with-deps").Value.Get().(bool) if withDeps { dstList.PrepareIndex() // Calculate architectures if len(context.ArchitecturesList()) > 0 { architecturesList = context.ArchitecturesList() } else { architecturesList = dstList.Architectures(false) } sort.Strings(architecturesList) if len(architecturesList) == 0 { return fmt.Errorf("unable to determine list of architectures, please specify explicitly") } } toProcess, err := srcList.Filter(args[2:], withDeps, dstList, context.DependencyOptions(), architecturesList) if err != nil { return fmt.Errorf("unable to %s: %s", command, err) } var verb string if command == "move" { verb = "moved" } else if command == "copy" { verb = "copied" } else if command == "import" { verb = "imported" } err = toProcess.ForEach(func(p *deb.Package) error { err = dstList.Add(p) if err != nil { return err } if command == "move" { srcList.Remove(p) } context.Progress().ColoredPrintf("@g[o]@| %s %s", p, verb) return nil }) if err != nil { return fmt.Errorf("unable to %s: %s", command, err) } if context.flags.Lookup("dry-run").Value.Get().(bool) { context.Progress().Printf("\nChanges not saved, as dry run has been requested.\n") } else { dstRepo.UpdateRefList(deb.NewPackageRefListFromPackageList(dstList)) err = context.CollectionFactory().LocalRepoCollection().Update(dstRepo) if err != nil { return fmt.Errorf("unable to save: %s", err) } if command == "move" { srcRepo.UpdateRefList(deb.NewPackageRefListFromPackageList(srcList)) err = context.CollectionFactory().LocalRepoCollection().Update(srcRepo) if err != nil { return fmt.Errorf("unable to save: %s", err) } } } return err }
func aptlyRepoAdd(cmd *commander.Command, args []string) error { var err error if len(args) < 2 { cmd.Usage() return err } name := args[0] verifier := &utils.GpgVerifier{} repo, err := context.CollectionFactory().LocalRepoCollection().ByName(name) if err != nil { return fmt.Errorf("unable to add: %s", err) } err = context.CollectionFactory().LocalRepoCollection().LoadComplete(repo) if err != nil { return fmt.Errorf("unable to add: %s", err) } context.Progress().Printf("Loading packages...\n") list, err := deb.NewPackageListFromRefList(repo.RefList(), context.CollectionFactory().PackageCollection(), context.Progress()) if err != nil { return fmt.Errorf("unable to load packages: %s", err) } packageFiles := []string{} for _, location := range args[1:] { info, err2 := os.Stat(location) if err2 != nil { context.Progress().ColoredPrintf("@y[!]@| @!Unable to process %s: %s@|", location, err2) continue } if info.IsDir() { err2 = filepath.Walk(location, func(path string, info os.FileInfo, err3 error) error { if err3 != nil { return err3 } if info.IsDir() { return nil } if strings.HasSuffix(info.Name(), ".deb") || strings.HasSuffix(info.Name(), ".dsc") { packageFiles = append(packageFiles, path) } return nil }) } else { if strings.HasSuffix(info.Name(), ".deb") || strings.HasSuffix(info.Name(), ".dsc") { packageFiles = append(packageFiles, location) } else { context.Progress().ColoredPrintf("@y[!]@| @!Unknwon file extenstion: %s@|", location) continue } } } processedFiles := []string{} sort.Strings(packageFiles) for _, file := range packageFiles { var ( stanza deb.Stanza p *deb.Package ) candidateProcessedFiles := []string{} isSourcePackage := strings.HasSuffix(file, ".dsc") if isSourcePackage { stanza, err = deb.GetControlFileFromDsc(file, verifier) if err == nil { stanza["Package"] = stanza["Source"] delete(stanza, "Source") p, err = deb.NewSourcePackageFromControlFile(stanza) } } else { stanza, err = deb.GetControlFileFromDeb(file) p = deb.NewPackageFromControlFile(stanza) } if err != nil { context.Progress().ColoredPrintf("@y[!]@| @!Unable to read file %s: %s@|", file, err) continue } var checksums utils.ChecksumInfo checksums, err = utils.ChecksumsForFile(file) if err != nil { return err } if isSourcePackage { p.UpdateFiles(append(p.Files(), deb.PackageFile{Filename: filepath.Base(file), Checksums: checksums})) } else { p.UpdateFiles([]deb.PackageFile{deb.PackageFile{Filename: filepath.Base(file), Checksums: checksums}}) } err = context.PackagePool().Import(file, checksums.MD5) if err != nil { context.Progress().ColoredPrintf("@y[!]@| @!Unable to import file %s into pool: %s@|", file, err) continue } candidateProcessedFiles = append(candidateProcessedFiles, file) // go over all files, except for the last one (.dsc/.deb itself) for _, f := range p.Files() { if filepath.Base(f.Filename) == filepath.Base(file) { continue } sourceFile := filepath.Join(filepath.Dir(file), filepath.Base(f.Filename)) err = context.PackagePool().Import(sourceFile, f.Checksums.MD5) if err != nil { context.Progress().ColoredPrintf("@y[!]@| @!Unable to import file %s into pool: %s@|", sourceFile, err) break } candidateProcessedFiles = append(candidateProcessedFiles, sourceFile) } if err != nil { // some files haven't been imported continue } err = context.CollectionFactory().PackageCollection().Update(p) if err != nil { context.Progress().ColoredPrintf("@y[!]@| @!Unable to save package %s: %s@|", p, err) continue } err = list.Add(p) if err != nil { context.Progress().ColoredPrintf("@y[!]@| @!Unable to add package to repo %s: %s@|", p, err) continue } context.Progress().ColoredPrintf("@g[+]@| %s added@|", p) processedFiles = append(processedFiles, candidateProcessedFiles...) } repo.UpdateRefList(deb.NewPackageRefListFromPackageList(list)) err = context.CollectionFactory().LocalRepoCollection().Update(repo) if err != nil { return fmt.Errorf("unable to save: %s", err) } if context.flags.Lookup("remove-files").Value.Get().(bool) { processedFiles = utils.StrSliceDeduplicate(processedFiles) for _, file := range processedFiles { err := os.Remove(file) if err != nil { return fmt.Errorf("unable to remove file: %s", err) } } } return err }
func aptlyRepoAdd(cmd *commander.Command, args []string) error { var err error if len(args) < 2 { cmd.Usage() return commander.ErrCommandError } name := args[0] verifier := &utils.GpgVerifier{} repo, err := context.CollectionFactory().LocalRepoCollection().ByName(name) if err != nil { return fmt.Errorf("unable to add: %s", err) } err = context.CollectionFactory().LocalRepoCollection().LoadComplete(repo) if err != nil { return fmt.Errorf("unable to add: %s", err) } context.Progress().Printf("Loading packages...\n") list, err := deb.NewPackageListFromRefList(repo.RefList(), context.CollectionFactory().PackageCollection(), context.Progress()) if err != nil { return fmt.Errorf("unable to load packages: %s", err) } forceReplace := context.Flags().Lookup("force-replace").Value.Get().(bool) var packageFiles, failedFiles []string packageFiles, failedFiles = deb.CollectPackageFiles(args[1:], &aptly.ConsoleResultReporter{Progress: context.Progress()}) var processedFiles, failedFiles2 []string processedFiles, failedFiles2, err = deb.ImportPackageFiles(list, packageFiles, forceReplace, verifier, context.PackagePool(), context.CollectionFactory().PackageCollection(), &aptly.ConsoleResultReporter{Progress: context.Progress()}, nil) failedFiles = append(failedFiles, failedFiles2...) if err != nil { return fmt.Errorf("unable to import package files: %s", err) } repo.UpdateRefList(deb.NewPackageRefListFromPackageList(list)) err = context.CollectionFactory().LocalRepoCollection().Update(repo) if err != nil { return fmt.Errorf("unable to save: %s", err) } if context.Flags().Lookup("remove-files").Value.Get().(bool) { processedFiles = utils.StrSliceDeduplicate(processedFiles) for _, file := range processedFiles { err := os.Remove(file) if err != nil { return fmt.Errorf("unable to remove file: %s", err) } } } if len(failedFiles) > 0 { context.Progress().ColoredPrintf("@y[!]@| @!Some files were skipped due to errors:@|") for _, file := range failedFiles { context.Progress().ColoredPrintf(" %s", file) } return fmt.Errorf("some files failed to be added") } return err }