func aptlyMirrorCreate(cmd *commander.Command, args []string) error { var err error if !(len(args) == 2 && strings.HasPrefix(args[1], "ppa:") || len(args) >= 3) { cmd.Usage() return commander.ErrCommandError } downloadSources := LookupOption(context.Config().DownloadSourcePackages, context.Flags(), "with-sources") downloadUdebs := context.Flags().Lookup("with-udebs").Value.Get().(bool) var ( mirrorName, archiveURL, distribution string components []string ) mirrorName = args[0] if len(args) == 2 { archiveURL, distribution, components, err = deb.ParsePPA(args[1], context.Config()) if err != nil { return err } } else { archiveURL, distribution, components = args[1], args[2], args[3:] } repo, err := deb.NewRemoteRepo(mirrorName, archiveURL, distribution, components, context.ArchitecturesList(), downloadSources, downloadUdebs) if err != nil { return fmt.Errorf("unable to create mirror: %s", err) } repo.Filter = context.Flags().Lookup("filter").Value.String() repo.FilterWithDeps = context.Flags().Lookup("filter-with-deps").Value.Get().(bool) repo.SkipComponentCheck = context.Flags().Lookup("force-components").Value.Get().(bool) if repo.Filter != "" { _, err = query.Parse(repo.Filter) if err != nil { return fmt.Errorf("unable to create mirror: %s", err) } } verifier, err := getVerifier(context.Flags()) if err != nil { return fmt.Errorf("unable to initialize GPG verifier: %s", err) } err = repo.Fetch(context.Downloader(), verifier) if err != nil { return fmt.Errorf("unable to fetch mirror: %s", err) } err = context.CollectionFactory().RemoteRepoCollection().Add(repo) if err != nil { return fmt.Errorf("unable to add mirror: %s", err) } fmt.Printf("\nMirror %s successfully added.\nYou can run 'aptly mirror update %s' to download repository contents.\n", repo, repo.Name) return err }
func aptlySnapshotShow(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return err } name := args[0] snapshot, err := context.CollectionFactory().SnapshotCollection().ByName(name) if err != nil { return fmt.Errorf("unable to show: %s", err) } err = context.CollectionFactory().SnapshotCollection().LoadComplete(snapshot) if err != nil { return fmt.Errorf("unable to show: %s", err) } fmt.Printf("Name: %s\n", snapshot.Name) fmt.Printf("Created At: %s\n", snapshot.CreatedAt.Format("2006-01-02 15:04:05 MST")) fmt.Printf("Description: %s\n", snapshot.Description) fmt.Printf("Number of packages: %d\n", snapshot.NumPackages()) withPackages := context.flags.Lookup("with-packages").Value.Get().(bool) if withPackages { ListPackagesRefList(snapshot.RefList()) } return err }
func aptlyRepoShow(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return commander.ErrCommandError } name := args[0] repo, err := context.CollectionFactory().LocalRepoCollection().ByName(name) if err != nil { return fmt.Errorf("unable to show: %s", err) } err = context.CollectionFactory().LocalRepoCollection().LoadComplete(repo) if err != nil { return fmt.Errorf("unable to show: %s", err) } fmt.Printf("Name: %s\n", repo.Name) fmt.Printf("Comment: %s\n", repo.Comment) fmt.Printf("Default Distribution: %s\n", repo.DefaultDistribution) fmt.Printf("Default Component: %s\n", repo.DefaultComponent) fmt.Printf("Number of packages: %d\n", repo.NumPackages()) withPackages := context.flags.Lookup("with-packages").Value.Get().(bool) if withPackages { ListPackagesRefList(repo.RefList()) } return err }
func aptlyMirrorShow(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return commander.ErrCommandError } name := args[0] repo, err := context.CollectionFactory().RemoteRepoCollection().ByName(name) if err != nil { return fmt.Errorf("unable to show: %s", err) } err = context.CollectionFactory().RemoteRepoCollection().LoadComplete(repo) if err != nil { return fmt.Errorf("unable to show: %s", err) } fmt.Printf("Name: %s\n", repo.Name) fmt.Printf("Archive Root URL: %s\n", repo.ArchiveRoot) fmt.Printf("Distribution: %s\n", repo.Distribution) fmt.Printf("Components: %s\n", strings.Join(repo.Components, ", ")) fmt.Printf("Architectures: %s\n", strings.Join(repo.Architectures, ", ")) downloadSources := "no" if repo.DownloadSources { downloadSources = "yes" } fmt.Printf("Download Sources: %s\n", downloadSources) if repo.Filter != "" { fmt.Printf("Filter: %s\n", repo.Filter) filterWithDeps := "no" if repo.FilterWithDeps { filterWithDeps = "yes" } fmt.Printf("Filter With Deps: %s\n", filterWithDeps) } if repo.LastDownloadDate.IsZero() { fmt.Printf("Last update: never\n") } else { fmt.Printf("Last update: %s\n", repo.LastDownloadDate.Format("2006-01-02 15:04:05 MST")) fmt.Printf("Number of packages: %d\n", repo.NumPackages()) } fmt.Printf("\nInformation from release file:\n") for _, k := range utils.StrMapSortedKeys(repo.Meta) { fmt.Printf("%s: %s\n", k, repo.Meta[k]) } withPackages := context.flags.Lookup("with-packages").Value.Get().(bool) if withPackages { if repo.LastDownloadDate.IsZero() { fmt.Printf("Unable to show package list, mirror hasn't been downloaded yet.\n") } else { ListPackagesRefList(repo.RefList()) } } return err }
func aptlyRepoCreate(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return commander.ErrCommandError } repo := deb.NewLocalRepo(args[0], context.Flags().Lookup("comment").Value.String()) repo.DefaultDistribution = context.Flags().Lookup("distribution").Value.String() repo.DefaultComponent = context.Flags().Lookup("component").Value.String() uploadersFile := context.Flags().Lookup("uploaders-file").Value.Get().(string) if uploadersFile != "" { repo.Uploaders, err = deb.NewUploadersFromFile(uploadersFile) if err != nil { return err } } err = context.CollectionFactory().LocalRepoCollection().Add(repo) if err != nil { return fmt.Errorf("unable to add local repo: %s", err) } fmt.Printf("\nLocal repo %s successfully added.\nYou can run 'aptly repo add %s ...' to add packages to repository.\n", repo, repo.Name) return err }
func aptlyPublishDrop(cmd *commander.Command, args []string) error { var err error if len(args) < 1 || len(args) > 2 { cmd.Usage() return commander.ErrCommandError } distribution := args[0] param := "." if len(args) == 2 { param = args[1] } storage, prefix := deb.ParsePrefix(param) err = context.CollectionFactory().PublishedRepoCollection().Remove(context, storage, prefix, distribution, context.CollectionFactory(), context.Progress(), context.Flags().Lookup("force-drop").Value.Get().(bool)) if err != nil { return fmt.Errorf("unable to remove: %s", err) } context.Progress().Printf("\nPublished repository has been removed successfully.\n") return err }
func run(cmd *commander.Command) (returnCode int) { defer func() { if r := recover(); r != nil { fatal, ok := r.(*ctx.FatalError) if !ok { panic(r) } fmt.Fprintln(os.Stderr, "ERROR:", fatal.Message) returnCode = fatal.ReturnCode } }() returnCode = 0 flags, _, err := cmd.ParseFlags([]string{"-config", "conf/slapt.conf"}) if err != nil { ctx.Fatal(err) } err = initCtx(flags) if err != nil { ctx.Fatal(err) } defer shutdownContext() context.UpdateFlags(flags) err = http.ListenAndServe("localhost:8080", web.Router(context)) if err != nil { ctx.Fatal(fmt.Errorf("unable to serve: %s", err)) } return }
func aptlySnapshotRename(cmd *commander.Command, args []string) error { var ( err error snapshot *deb.Snapshot ) if len(args) != 2 { cmd.Usage() return commander.ErrCommandError } oldName, newName := args[0], args[1] snapshot, err = context.CollectionFactory().SnapshotCollection().ByName(oldName) if err != nil { return fmt.Errorf("unable to rename: %s", err) } _, err = context.CollectionFactory().SnapshotCollection().ByName(newName) if err == nil { return fmt.Errorf("unable to rename: snapshot %s already exists", newName) } snapshot.Name = newName err = context.CollectionFactory().SnapshotCollection().Update(snapshot) if err != nil { return fmt.Errorf("unable to rename: %s", err) } fmt.Printf("\nSnapshot %s -> %s has been successfully renamed.\n", oldName, newName) return err }
func aptlyPublishUpdate(cmd *commander.Command, args []string) error { var err error if len(args) < 1 || len(args) > 2 { cmd.Usage() return commander.ErrCommandError } distribution := args[0] prefix := "." if len(args) == 2 { prefix = args[1] } var published *deb.PublishedRepo published, err = context.CollectionFactory().PublishedRepoCollection().ByPrefixDistribution(prefix, distribution) if err != nil { return fmt.Errorf("unable to update: %s", err) } if published.SourceKind != "local" { return fmt.Errorf("unable to update: not a local repository publish") } err = context.CollectionFactory().PublishedRepoCollection().LoadComplete(published, context.CollectionFactory()) if err != nil { return fmt.Errorf("unable to update: %s", err) } components := published.Components() for _, component := range components { published.UpdateLocalRepo(component) } signer, err := getSigner(context.flags) if err != nil { return fmt.Errorf("unable to initialize GPG signer: %s", err) } err = published.Publish(context.PackagePool(), context.PublishedStorage(), context.CollectionFactory(), signer, context.Progress()) if err != nil { return fmt.Errorf("unable to publish: %s", err) } err = context.CollectionFactory().PublishedRepoCollection().Update(published) if err != nil { return fmt.Errorf("unable to save to DB: %s", err) } err = context.CollectionFactory().PublishedRepoCollection().CleanupPrefixComponentFiles(published.Prefix, components, context.PublishedStorage(), context.CollectionFactory(), context.Progress()) if err != nil { return fmt.Errorf("unable to update: %s", err) } context.Progress().Printf("\nPublish for local repo %s has been successfully updated.\n", published.String()) return err }
func aptlyMirrorRename(cmd *commander.Command, args []string) error { var ( err error repo *deb.RemoteRepo ) if len(args) != 2 { cmd.Usage() return commander.ErrCommandError } oldName, newName := args[0], args[1] repo, err = context.CollectionFactory().RemoteRepoCollection().ByName(oldName) if err != nil { return fmt.Errorf("unable to rename: %s", err) } _, err = context.CollectionFactory().RemoteRepoCollection().ByName(newName) if err == nil { return fmt.Errorf("unable to rename: mirror %s already exists", newName) } repo.Name = newName err = context.CollectionFactory().RemoteRepoCollection().Update(repo) if err != nil { return fmt.Errorf("unable to rename: %s", err) } fmt.Printf("\nMirror %s -> %s has been successfully renamed.\n", oldName, newName) return err }
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 aptlyMirrorEdit(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return commander.ErrCommandError } repo, err := context.CollectionFactory().RemoteRepoCollection().ByName(args[0]) if err != nil { return fmt.Errorf("unable to edit: %s", err) } err = repo.CheckLock() if err != nil { return fmt.Errorf("unable to edit: %s", err) } context.Flags().Visit(func(flag *flag.Flag) { switch flag.Name { case "filter": repo.Filter = flag.Value.String() case "filter-with-deps": repo.FilterWithDeps = flag.Value.Get().(bool) case "with-sources": repo.DownloadSources = flag.Value.Get().(bool) case "with-udebs": repo.DownloadUdebs = flag.Value.Get().(bool) } }) if repo.IsFlat() && repo.DownloadUdebs { return fmt.Errorf("unable to edit: flat mirrors don't support udebs") } if repo.Filter != "" { _, err = query.Parse(repo.Filter) if err != nil { return fmt.Errorf("unable to edit: %s", err) } } if context.GlobalFlags().Lookup("architectures").Value.String() != "" { repo.Architectures = context.ArchitecturesList() err = repo.Fetch(context.Downloader(), nil) if err != nil { return fmt.Errorf("unable to edit: %s", err) } } err = context.CollectionFactory().RemoteRepoCollection().Update(repo) if err != nil { return fmt.Errorf("unable to edit: %s", err) } fmt.Printf("Mirror %s successfully updated.\n", repo) return err }
func aptlySnapshotMerge(cmd *commander.Command, args []string) error { var err error if len(args) < 2 { cmd.Usage() return commander.ErrCommandError } sources := make([]*deb.Snapshot, len(args)-1) for i := 0; i < len(args)-1; i++ { sources[i], err = context.CollectionFactory().SnapshotCollection().ByName(args[i+1]) if err != nil { return fmt.Errorf("unable to load snapshot: %s", err) } err = context.CollectionFactory().SnapshotCollection().LoadComplete(sources[i]) if err != nil { return fmt.Errorf("unable to load snapshot: %s", err) } } latest := context.Flags().Lookup("latest").Value.Get().(bool) noRemove := context.Flags().Lookup("no-remove").Value.Get().(bool) if noRemove && latest { return fmt.Errorf("-no-remove and -latest can't be specified together") } overrideMatching := !latest && !noRemove result := sources[0].RefList() for i := 1; i < len(sources); i++ { result = result.Merge(sources[i].RefList(), overrideMatching, false) } if latest { result.FilterLatestRefs() } sourceDescription := make([]string, len(sources)) for i, s := range sources { sourceDescription[i] = fmt.Sprintf("'%s'", s.Name) } // Create <destination> snapshot destination := deb.NewSnapshotFromRefList(args[0], sources, result, fmt.Sprintf("Merged from sources: %s", strings.Join(sourceDescription, ", "))) err = context.CollectionFactory().SnapshotCollection().Add(destination) if err != nil { return fmt.Errorf("unable to create snapshot: %s", err) } fmt.Printf("\nSnapshot %s successfully created.\nYou can run 'aptly publish snapshot %s' to publish snapshot as Debian repository.\n", destination.Name, destination.Name) return err }
func aptlyVersion(cmd *commander.Command, args []string) error { if len(args) != 0 { cmd.Usage() return commander.ErrCommandError } fmt.Printf("aptly version: %s\n", aptly.Version) return nil }
func aptlyMirrorUpdate(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return commander.ErrCommandError } name := args[0] repo, err := context.CollectionFactory().RemoteRepoCollection().ByName(name) if err != nil { return fmt.Errorf("unable to update: %s", err) } err = context.CollectionFactory().RemoteRepoCollection().LoadComplete(repo) if err != nil { return fmt.Errorf("unable to update: %s", err) } ignoreMismatch := context.flags.Lookup("ignore-checksums").Value.Get().(bool) verifier, err := getVerifier(context.flags) if err != nil { return fmt.Errorf("unable to initialize GPG verifier: %s", err) } err = repo.Fetch(context.Downloader(), verifier) if err != nil { return fmt.Errorf("unable to update: %s", err) } var filterQuery deb.PackageQuery if repo.Filter != "" { filterQuery, err = query.Parse(repo.Filter) if err != nil { return fmt.Errorf("unable to update: %s", err) } } err = repo.Download(context.Progress(), context.Downloader(), context.CollectionFactory(), context.PackagePool(), ignoreMismatch, context.DependencyOptions(), filterQuery) if err != nil { return fmt.Errorf("unable to update: %s", err) } err = context.CollectionFactory().RemoteRepoCollection().Update(repo) if err != nil { return fmt.Errorf("unable to update: %s", err) } context.Progress().Printf("\nMirror `%s` has been successfully updated.\n", repo.Name) return err }
func aptlyPublishList(cmd *commander.Command, args []string) error { var err error if len(args) != 0 { cmd.Usage() return commander.ErrCommandError } raw := cmd.Flag.Lookup("raw").Value.Get().(bool) published := make([]string, 0, context.CollectionFactory().PublishedRepoCollection().Len()) err = context.CollectionFactory().PublishedRepoCollection().ForEach(func(repo *deb.PublishedRepo) error { err := context.CollectionFactory().PublishedRepoCollection().LoadComplete(repo, context.CollectionFactory()) if err != nil { return err } if raw { published = append(published, fmt.Sprintf("%s %s", repo.StoragePrefix(), repo.Distribution)) } else { published = append(published, repo.String()) } return nil }) if err != nil { return fmt.Errorf("unable to load list of repos: %s", err) } context.CloseDatabase() sort.Strings(published) if raw { for _, info := range published { fmt.Printf("%s\n", info) } } else { if len(published) == 0 { fmt.Printf("No snapshots/local repos have been published. Publish a snapshot by running `aptly publish snapshot ...`.\n") return err } fmt.Printf("Published repositories:\n") for _, description := range published { fmt.Printf(" * %s\n", description) } } return err }
// aptly db recover func aptlyDbRecover(cmd *commander.Command, args []string) error { var err error if len(args) != 0 { cmd.Usage() return commander.ErrCommandError } context.Progress().Printf("Recovering database...\n") err = database.RecoverDB(context.DBPath()) return err }
func aptlySnapshotDrop(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return commander.ErrCommandError } name := args[0] snapshot, err := context.CollectionFactory().SnapshotCollection().ByName(name) if err != nil { return fmt.Errorf("unable to drop: %s", err) } published := context.CollectionFactory().PublishedRepoCollection().BySnapshot(snapshot) if len(published) > 0 { fmt.Printf("Snapshot `%s` is published currently:\n", snapshot.Name) for _, repo := range published { err = context.CollectionFactory().PublishedRepoCollection().LoadComplete(repo, context.CollectionFactory()) if err != nil { return fmt.Errorf("unable to load published: %s", err) } fmt.Printf(" * %s\n", repo) } return fmt.Errorf("unable to drop: snapshot is published") } force := context.flags.Lookup("force").Value.Get().(bool) if !force { snapshots := context.CollectionFactory().SnapshotCollection().BySnapshotSource(snapshot) if len(snapshots) > 0 { fmt.Printf("Snapshot `%s` was used as a source in following snapshots:\n", snapshot.Name) for _, snap := range snapshots { fmt.Printf(" * %s\n", snap) } return fmt.Errorf("won't delete snapshot that was used as source for other snapshots, use -force to override") } } err = context.CollectionFactory().SnapshotCollection().Drop(snapshot) if err != nil { return fmt.Errorf("unable to drop: %s", err) } fmt.Printf("Snapshot `%s` has been dropped.\n", snapshot.Name) return err }
func aptlyPackageShow(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return commander.ErrCommandError } q, err := query.Parse(args[0]) if err != nil { return fmt.Errorf("unable to show: %s", err) } withFiles := context.flags.Lookup("with-files").Value.Get().(bool) withReferences := context.flags.Lookup("with-references").Value.Get().(bool) w := bufio.NewWriter(os.Stdout) result := q.Query(context.CollectionFactory().PackageCollection()) err = result.ForEach(func(p *deb.Package) error { p.Stanza().WriteTo(w) w.Flush() fmt.Printf("\n") if withFiles { fmt.Printf("Files in the pool:\n") for _, f := range p.Files() { path, err := context.PackagePool().Path(f.Filename, f.Checksums.MD5) if err != nil { return err } fmt.Printf(" %s\n", path) } fmt.Printf("\n") } if withReferences { fmt.Printf("References to package:\n") printReferencesTo(p) fmt.Printf("\n") } return nil }) if err != nil { return fmt.Errorf("unable to show: %s", err) } return err }
func aptlyRepoDrop(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return err } name := args[0] repo, err := context.CollectionFactory().LocalRepoCollection().ByName(name) if err != nil { return fmt.Errorf("unable to drop: %s", err) } published := context.CollectionFactory().PublishedRepoCollection().ByLocalRepo(repo) if len(published) > 0 { fmt.Printf("Local repo `%s` is published currently:\n", repo.Name) for _, repo := range published { err = context.CollectionFactory().PublishedRepoCollection().LoadComplete(repo, context.CollectionFactory()) if err != nil { return fmt.Errorf("unable to load published: %s", err) } fmt.Printf(" * %s\n", repo) } return fmt.Errorf("unable to drop: local repo is published") } force := context.flags.Lookup("force").Value.Get().(bool) if !force { snapshots := context.CollectionFactory().SnapshotCollection().ByLocalRepoSource(repo) if len(snapshots) > 0 { fmt.Printf("Local repo `%s` was used to create following snapshots:\n", repo.Name) for _, snapshot := range snapshots { fmt.Printf(" * %s\n", snapshot) } return fmt.Errorf("won't delete local repo with snapshots, use -force to override") } } err = context.CollectionFactory().LocalRepoCollection().Drop(repo) if err != nil { return fmt.Errorf("unable to drop: %s", err) } fmt.Printf("Local repo `%s` has been removed.\n", repo.Name) return err }
func aptlyRepoEdit(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return commander.ErrCommandError } repo, err := context.CollectionFactory().LocalRepoCollection().ByName(args[0]) if err != nil { return fmt.Errorf("unable to edit: %s", err) } err = context.CollectionFactory().LocalRepoCollection().LoadComplete(repo) if err != nil { return fmt.Errorf("unable to edit: %s", err) } var uploadersFile *string context.Flags().Visit(func(flag *flag.Flag) { switch flag.Name { case "comment": repo.Comment = flag.Value.String() case "distribution": repo.DefaultDistribution = flag.Value.String() case "component": repo.DefaultComponent = flag.Value.String() case "uploaders-file": uploadersFile = pointer.ToString(flag.Value.String()) } }) if uploadersFile != nil { if *uploadersFile != "" { repo.Uploaders, err = deb.NewUploadersFromFile(*uploadersFile) if err != nil { return err } } else { repo.Uploaders = nil } } err = context.CollectionFactory().LocalRepoCollection().Update(repo) if err != nil { return fmt.Errorf("unable to edit: %s", err) } fmt.Printf("Local repo %s successfully updated.\n", repo) return err }
func aptlyRepoList(cmd *commander.Command, args []string) error { var err error if len(args) != 0 { cmd.Usage() return commander.ErrCommandError } raw := cmd.Flag.Lookup("raw").Value.Get().(bool) repos := make([]string, context.CollectionFactory().LocalRepoCollection().Len()) i := 0 context.CollectionFactory().LocalRepoCollection().ForEach(func(repo *deb.LocalRepo) error { if raw { repos[i] = repo.Name } else { err := context.CollectionFactory().LocalRepoCollection().LoadComplete(repo) if err != nil { return err } repos[i] = fmt.Sprintf(" * %s (packages: %d)", repo.String(), repo.NumPackages()) } i++ return nil }) context.CloseDatabase() sort.Strings(repos) if raw { for _, repo := range repos { fmt.Printf("%s\n", repo) } } else { if len(repos) > 0 { fmt.Printf("List of local repos:\n") for _, repo := range repos { fmt.Println(repo) } fmt.Printf("\nTo get more information about local repository, run `aptly repo show <name>`.\n") } else { fmt.Printf("No local repositories found, create one with `aptly repo create ...`.\n") } } return err }
func aptlySnapshotList(cmd *commander.Command, args []string) error { var err error if len(args) != 0 { cmd.Usage() return commander.ErrCommandError } raw := cmd.Flag.Lookup("raw").Value.Get().(bool) sortMethodString := cmd.Flag.Lookup("sort").Value.Get().(string) snapshotsToSort := &snapshotListToSort{} snapshotsToSort.list = make([]*deb.Snapshot, context.CollectionFactory().SnapshotCollection().Len()) snapshotsToSort.sortMethod, err = parseSortMethod(sortMethodString) if err != nil { return err } i := 0 context.CollectionFactory().SnapshotCollection().ForEach(func(snapshot *deb.Snapshot) error { snapshotsToSort.list[i] = snapshot i++ return nil }) sort.Sort(snapshotsToSort) if raw { for _, snapshot := range snapshotsToSort.list { fmt.Printf("%s\n", snapshot.Name) } } else { if len(snapshotsToSort.list) > 0 { fmt.Printf("List of snapshots:\n") for _, snapshot := range snapshotsToSort.list { fmt.Printf(" * %s\n", snapshot.String()) } fmt.Printf("\nTo get more information about snapshot, run `aptly snapshot show <name>`.\n") } else { fmt.Printf("\nNo snapshots found, create one with `aptly snapshot create...`.\n") } } return err }
func aptlySnapshotList(cmd *commander.Command, args []string) error { var err error if len(args) != 0 { cmd.Usage() return err } raw := cmd.Flag.Lookup("raw").Value.Get().(bool) snapshots := make([]string, context.CollectionFactory().SnapshotCollection().Len()) i := 0 context.CollectionFactory().SnapshotCollection().ForEach(func(snapshot *deb.Snapshot) error { if raw { snapshots[i] = snapshot.Name } else { snapshots[i] = snapshot.String() } i++ return nil }) sort.Strings(snapshots) if raw { for _, snapshot := range snapshots { fmt.Printf("%s\n", snapshot) } } else { if len(snapshots) > 0 { fmt.Printf("List of snapshots:\n") for _, snapshot := range snapshots { fmt.Printf(" * %s\n", snapshot) } fmt.Printf("\nTo get more information about snapshot, run `aptly snapshot show <name>`.\n") } else { fmt.Printf("\nNo snapshots found, create one with `aptly snapshot create...`.\n") } } return err }
func aptlyMirrorDrop(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return commander.ErrCommandError } name := args[0] repo, err := context.CollectionFactory().RemoteRepoCollection().ByName(name) if err != nil { return fmt.Errorf("unable to drop: %s", err) } err = repo.CheckLock() if err != nil { return fmt.Errorf("unable to drop: %s", err) } force := context.Flags().Lookup("force").Value.Get().(bool) if !force { snapshots := context.CollectionFactory().SnapshotCollection().ByRemoteRepoSource(repo) if len(snapshots) > 0 { fmt.Printf("Mirror `%s` was used to create following snapshots:\n", repo.Name) for _, snapshot := range snapshots { fmt.Printf(" * %s\n", snapshot) } return fmt.Errorf("won't delete mirror with snapshots, use -force to override") } } err = context.CollectionFactory().RemoteRepoCollection().Drop(repo) if err != nil { return fmt.Errorf("unable to drop: %s", err) } fmt.Printf("Mirror `%s` has been removed.\n", repo.Name) return err }
func aptlyPackageSearch(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return commander.ErrCommandError } q, err := query.Parse(args[0]) if err != nil { return fmt.Errorf("unable to search: %s", err) } result := q.Query(context.CollectionFactory().PackageCollection()) result.ForEach(func(p *deb.Package) error { context.Progress().Printf("%s\n", p) return nil }) return err }
func aptlyMirrorList(cmd *commander.Command, args []string) error { var err error if len(args) != 0 { cmd.Usage() return err } raw := cmd.Flag.Lookup("raw").Value.Get().(bool) repos := make([]string, context.CollectionFactory().RemoteRepoCollection().Len()) i := 0 context.CollectionFactory().RemoteRepoCollection().ForEach(func(repo *deb.RemoteRepo) error { if raw { repos[i] = repo.Name } else { repos[i] = repo.String() } i++ return nil }) sort.Strings(repos) if raw { for _, repo := range repos { fmt.Printf("%s\n", repo) } } else { if len(repos) > 0 { fmt.Printf("List of mirrors:\n") for _, repo := range repos { fmt.Printf(" * %s\n", repo) } fmt.Printf("\nTo get more information about mirror, run `aptly mirror show <name>`.\n") } else { fmt.Printf("No mirrors found, create one with `aptly mirror create ...`.\n") } } return err }
func aptlyAPIServe(cmd *commander.Command, args []string) error { var ( err error ) if len(args) != 0 { cmd.Usage() return commander.ErrCommandError } listen := context.Flags().Lookup("listen").Value.String() fmt.Printf("\nStarting web server at: %s (press Ctrl+C to quit)...\n", listen) err = http.ListenAndServe(listen, api.Router(context)) if err != nil { return fmt.Errorf("unable to serve: %s", err) } return err }
func aptlyPackageSearch(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return commander.ErrCommandError } q, err := query.Parse(args[0]) if err != nil { return fmt.Errorf("unable to search: %s", err) } result := q.Query(context.CollectionFactory().PackageCollection()) if result.Len() == 0 { return fmt.Errorf("no results") } format := context.Flags().Lookup("format").Value.String() PrintPackageList(result, format) return err }
func aptlySnapshotList(cmd *commander.Command, args []string) error { var err error if len(args) != 0 { cmd.Usage() return commander.ErrCommandError } raw := cmd.Flag.Lookup("raw").Value.Get().(bool) sortMethodString := cmd.Flag.Lookup("sort").Value.Get().(string) collection := context.CollectionFactory().SnapshotCollection() if raw { collection.ForEachSorted(sortMethodString, func(snapshot *deb.Snapshot) error { fmt.Printf("%s\n", snapshot.Name) return nil }) } else { if collection.Len() > 0 { fmt.Printf("List of snapshots:\n") err = collection.ForEachSorted(sortMethodString, func(snapshot *deb.Snapshot) error { fmt.Printf(" * %s\n", snapshot.String()) return nil }) if err != nil { return err } fmt.Printf("\nTo get more information about snapshot, run `aptly snapshot show <name>`.\n") } else { fmt.Printf("\nNo snapshots found, create one with `aptly snapshot create...`.\n") } } return err }