func aptlyMirrorList(cmd *commander.Command, args []string) error { var err error if len(args) != 0 { cmd.Usage() return err } repoCollection := debian.NewRemoteRepoCollection(context.database) if repoCollection.Len() > 0 { fmt.Printf("List of mirrors:\n") repos := make(sort.StringSlice, repoCollection.Len()) i := 0 repoCollection.ForEach(func(repo *debian.RemoteRepo) error { repos[i] = repo.String() i++ return nil }) sort.Strings(repos) 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 aptlySnapshotList(cmd *commander.Command, args []string) error { var err error if len(args) != 0 { cmd.Usage() return err } snapshotCollection := debian.NewSnapshotCollection(context.database) if snapshotCollection.Len() > 0 { fmt.Printf("List of snapshots:\n") snapshots := make(sort.StringSlice, snapshotCollection.Len()) i := 0 snapshotCollection.ForEach(func(snapshot *debian.Snapshot) error { snapshots[i] = snapshot.String() i++ return nil }) sort.Strings(snapshots) 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 aptlySnapshotShow(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return err } name := args[0] snapshotCollection := debian.NewSnapshotCollection(context.database) snapshot, err := snapshotCollection.ByName(name) if err != nil { return fmt.Errorf("unable to show: %s", err) } err = 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 := cmd.Flag.Lookup("with-packages").Value.Get().(bool) if withPackages { ListPackagesRefList(snapshot.RefList()) } return err }
func aptlyMirrorCreate(cmd *commander.Command, args []string) error { var err error if len(args) < 3 { cmd.Usage() return err } downloadSources := utils.Config.DownloadSourcePackages || cmd.Flag.Lookup("with-sources").Value.Get().(bool) repo, err := debian.NewRemoteRepo(args[0], args[1], args[2], args[3:], context.architecturesList, downloadSources) if err != nil { return fmt.Errorf("unable to create mirror: %s", err) } verifier, err := getVerifier(cmd) 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) } repoCollection := debian.NewRemoteRepoCollection(context.database) err = repoCollection.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 aptlyRepoShow(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return err } name := args[0] localRepoCollection := debian.NewLocalRepoCollection(context.database) repo, err := localRepoCollection.ByName(name) if err != nil { return fmt.Errorf("unable to show: %s", err) } err = 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("Number of packages: %d\n", repo.NumPackages()) withPackages := cmd.Flag.Lookup("with-packages").Value.Get().(bool) if withPackages { ListPackagesRefList(repo.RefList()) } return err }
func aptlyMirrorCreate(cmd *commander.Command, args []string) { if len(args) < 3 { cmd.Usage() return } var architectures []string archs := cmd.Flag.Lookup("architecture").Value.String() if len(archs) > 0 { architectures = strings.Split(archs, ",") } repo, err := debian.NewRemoteRepo(args[0], args[1], args[2], args[3:], architectures) if err != nil { log.Fatalf("Unable to create mirror: %s", err) } err = repo.Fetch(context.downloader) if err != nil { log.Fatalf("Unable to fetch mirror: %s", err) } repoCollection := debian.NewRemoteRepoCollection(context.database) err = repoCollection.Add(repo) if err != nil { log.Fatalf("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) }
func aptlyMirrorUpdate(cmd *commander.Command, args []string) { if len(args) != 1 { cmd.Usage() return } name := args[0] repoCollection := debian.NewRemoteRepoCollection(context.database) repo, err := repoCollection.ByName(name) if err != nil { log.Fatalf("Unable to update: %s", err) } err = repoCollection.LoadComplete(repo) if err != nil { log.Fatalf("Unable to update: %s", err) } err = repo.Fetch(context.downloader) if err != nil { log.Fatalf("Unable to update: %s", err) } err = repo.Download(context.downloader, context.database, context.packageRepository) if err != nil { log.Fatalf("Unable to update: %s", err) } err = repoCollection.Update(repo) if err != nil { log.Fatalf("Unable to update: %s", err) } }
func aptlyPublishDrop(cmd *commander.Command, args []string) error { var err error if len(args) < 1 || len(args) > 2 { cmd.Usage() return err } distribution := args[0] prefix := "." if len(args) == 2 { prefix = args[1] } publishedCollecton := debian.NewPublishedRepoCollection(context.database) err = publishedCollecton.Remove(context.packageRepository, prefix, distribution) if err != nil { return fmt.Errorf("unable to remove: %s", err) } fmt.Printf("\nPublished repositroy has been removed successfully.\n") return err }
func lbpkr_run_cmd_rpm(cmd *commander.Command, args []string) error { var err error siteroot := cmd.Flag.Lookup("siteroot").Value.Get().(string) debug := cmd.Flag.Lookup("v").Value.Get().(bool) switch len(args) { case 0: cmd.Usage() return fmt.Errorf("lbpkr: invalid number of arguments. expected at least one argument. got=%d (%v)", len(args), args, ) } cfg := NewConfig(siteroot) ctx, err := New(cfg, Debug(debug)) if err != nil { return err } defer ctx.Close() err = ctx.Rpm(args...) return err }
func aptlyRepoList(cmd *commander.Command, args []string) error { var err error if len(args) != 0 { cmd.Usage() return err } localRepoCollection := debian.NewLocalRepoCollection(context.database) if localRepoCollection.Len() > 0 { fmt.Printf("List of mirrors:\n") repos := make([]string, localRepoCollection.Len()) i := 0 localRepoCollection.ForEach(func(repo *debian.LocalRepo) error { err := localRepoCollection.LoadComplete(repo) if err != nil { return err } repos[i] = fmt.Sprintf(" * %s (packages: %d)", repo.String(), repo.NumPackages()) i++ return nil }) sort.Strings(repos) 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 lbpkr_run_cmd_repo_ls(cmd *commander.Command, args []string) error { var err error debug := cmd.Flag.Lookup("v").Value.Get().(bool) siteroot := cmd.Flag.Lookup("siteroot").Value.Get().(string) switch len(args) { case 0: default: cmd.Usage() return fmt.Errorf("lbpkr: invalid number of arguments. expected n=0. got=%d (%v)", len(args), args, ) } cfg := NewConfig(siteroot) ctx, err := New(cfg, Debug(debug)) if err != nil { return err } defer ctx.Close() err = ctx.ListRepositories() return err }
func lbpkr_run_cmd_provides(cmd *commander.Command, args []string) error { var err error siteroot := cmd.Flag.Lookup("siteroot").Value.Get().(string) debug := cmd.Flag.Lookup("v").Value.Get().(bool) filename := "" switch len(args) { case 1: filename = args[0] default: cmd.Usage() return fmt.Errorf("lbpkr: invalid number of arguments. expected n=1. got=%d (%v)", len(args), args, ) } cfg := NewConfig(siteroot) ctx, err := New(cfg, Debug(debug)) if err != nil { return err } defer ctx.Close() _, err = ctx.Provides(filename) return err }
func lbpkr_run_cmd_remove(cmd *commander.Command, args []string) error { var err error siteroot := cmd.Flag.Lookup("siteroot").Value.Get().(string) debug := cmd.Flag.Lookup("v").Value.Get().(bool) force := cmd.Flag.Lookup("force").Value.Get().(bool) dry := cmd.Flag.Lookup("dry-run").Value.Get().(bool) rpms := make([][3]string, 0) switch len(args) { case 0: cmd.Usage() return fmt.Errorf("lbpkr: invalid number of arguments (got=%d)", len(args)) default: re := regexp.MustCompile(`(.*)-([\d\.]+)-(\d)$`) for _, name := range args { rpmname := name version := "" release := "" match := re.FindAllStringSubmatch(rpmname, -1) if len(match) == 1 { m := match[0] switch len(m) { case 2: rpmname = m[1] case 3: rpmname = m[1] version = m[2] case 4: rpmname = m[1] version = m[2] release = m[3] } } rpms = append(rpms, [3]string{rpmname, version, release}) } } cfg := NewConfig(siteroot) ctx, err := New(cfg, Debug(debug), EnableForce(force), EnableDryRun(dry)) if err != nil { return err } defer ctx.Close() str := []string{} for _, s := range rpms { str = append(str, fmt.Sprintf("%s %s %s", s[0], s[1], s[2])) } plural := "" if len(rpms) > 1 { plural = "s" } ctx.msg.Infof("removing RPM%s:\n%v\n", plural, strings.Join(str, "\n")) err = ctx.RemoveRPM(rpms, force) return err }
func aptlySnapshotDrop(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return err } name := args[0] snapshotCollection := debian.NewSnapshotCollection(context.database) snapshot, err := snapshotCollection.ByName(name) if err != nil { return fmt.Errorf("unable to drop: %s", err) } publishedRepoCollection := debian.NewPublishedRepoCollection(context.database) published := publishedRepoCollection.BySnapshot(snapshot) if len(published) > 0 { fmt.Printf("Snapshot `%s` is published currently:\n", snapshot.Name) for _, repo := range published { err = publishedRepoCollection.LoadComplete(repo, snapshotCollection) 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 := cmd.Flag.Lookup("force").Value.Get().(bool) if !force { snapshots := 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 = 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 aptlyRepoRemove(cmd *commander.Command, args []string) error { var err error if len(args) < 2 { cmd.Usage() return err } name := args[0] localRepoCollection := debian.NewLocalRepoCollection(context.database) repo, err := localRepoCollection.ByName(name) if err != nil { return fmt.Errorf("unable to remove: %s", err) } err = localRepoCollection.LoadComplete(repo) if err != nil { return fmt.Errorf("unable to remove: %s", err) } context.progress.Printf("Loading packages...\n") packageCollection := debian.NewPackageCollection(context.database) list, err := debian.NewPackageListFromRefList(repo.RefList(), packageCollection) if err != nil { return fmt.Errorf("unable to load packages: %s", err) } list.PrepareIndex() toRemove, err := list.Filter(args[1:], false, nil, 0, nil) if err != nil { return fmt.Errorf("unable to remove: %s", err) } toRemove.ForEach(func(p *debian.Package) error { list.Remove(p) context.progress.ColoredPrintf("@r[-]@| %s removed", p) return nil }) if cmd.Flag.Lookup("dry-run").Value.Get().(bool) { context.progress.Printf("\nChanges not saved, as dry run has been requested.\n") } else { repo.UpdateRefList(debian.NewPackageRefListFromPackageList(list)) err = localRepoCollection.Update(repo) if err != nil { return fmt.Errorf("unable to save: %s", err) } } return err }
func aptlyMirrorShow(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return err } name := args[0] repoCollection := debian.NewRemoteRepoCollection(context.database) repo, err := repoCollection.ByName(name) if err != nil { return fmt.Errorf("unable to show: %s", err) } err = repoCollection.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.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 := cmd.Flag.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 lbpkr_run_cmd_install_project(cmd *commander.Command, args []string) error { var err error siteroot := cmd.Flag.Lookup("siteroot").Value.Get().(string) debug := cmd.Flag.Lookup("v").Value.Get().(bool) force := cmd.Flag.Lookup("force").Value.Get().(bool) dry := cmd.Flag.Lookup("dry-run").Value.Get().(bool) archs := cmd.Flag.Lookup("platforms").Value.Get().(string) nodeps := cmd.Flag.Lookup("nodeps").Value.Get().(bool) justdb := cmd.Flag.Lookup("justdb").Value.Get().(bool) projname := "" version := "" release := "" switch len(args) { case 0: cmd.Usage() return fmt.Errorf("lbpkr: invalid number of arguments (got=%d)", len(args)) case 1: projname = args[0] case 2: projname = args[0] version = args[1] case 3: projname = args[0] version = args[1] release = args[2] default: return fmt.Errorf("lbpkr: invalid number of arguments. expected n=1|2|3. got=%d (%v)", len(args), args, ) } cfg := NewConfig(siteroot) ctx, err := New( cfg, Debug(debug), EnableForce(force), EnableDryRun(dry), EnableNoDeps(nodeps), EnableJustDb(justdb), ) if err != nil { return err } defer ctx.Close() ctx.msg.Infof("installing project %s %s %s\n", projname, version, release) err = ctx.InstallProject(projname, version, release, archs) return err }
func aptlyMirrorList(cmd *commander.Command, args []string) { if len(args) != 0 { cmd.Usage() return } fmt.Printf("List of mirrors:\n") repoCollection := debian.NewRemoteRepoCollection(context.database) repoCollection.ForEach(func(repo *debian.RemoteRepo) { fmt.Printf(" * %s\n", repo) }) fmt.Printf("\nTo get more information about repository, run `aptly mirror show <name>`.\n") }
func lbpkr_run_cmd_deps(cmd *commander.Command, args []string) error { var err error debug := cmd.Flag.Lookup("v").Value.Get().(bool) siteroot := cmd.Flag.Lookup("siteroot").Value.Get().(string) dmax := cmd.Flag.Lookup("maxdepth").Value.Get().(int) name := "" vers := "" release := "" switch len(args) { case 1: name = args[0] case 2: name = args[0] vers = args[1] case 3: name = args[0] vers = args[1] release = args[2] default: cmd.Usage() return fmt.Errorf("lbpkr: invalid number of arguments. expected n=1|2|3. got=%d (%v)", len(args), args, ) } cfg := NewConfig(siteroot) ctx, err := New(cfg, Debug(debug)) if err != nil { return err } defer ctx.Close() pkg, err := ctx.Client().FindLatestProvider(name, vers, release) if err != nil { return err } _, err = ctx.ListPackageDeps(pkg.Name(), pkg.Version(), pkg.Release(), dmax) if err != nil { return err } return err }
func aptlySnapshotCreate(cmd *commander.Command, args []string) error { var ( err error snapshot *debian.Snapshot ) if len(args) == 4 && args[1] == "from" && args[2] == "mirror" { // aptly snapshot create snap from mirror mirror repoName, snapshotName := args[3], args[0] repoCollection := debian.NewRemoteRepoCollection(context.database) repo, err := repoCollection.ByName(repoName) if err != nil { return fmt.Errorf("unable to create snapshot: %s", err) } err = repoCollection.LoadComplete(repo) if err != nil { return fmt.Errorf("unable to create snapshot: %s", err) } snapshot, err = debian.NewSnapshotFromRepository(snapshotName, repo) if err != nil { return fmt.Errorf("unable to create snapshot: %s", err) } } else if len(args) == 2 && args[1] == "empty" { // aptly snapshot create snap empty snapshotName := args[0] packageList := debian.NewPackageList() snapshot = debian.NewSnapshotFromPackageList(snapshotName, nil, packageList, "Created as empty") } else { cmd.Usage() return err } snapshotCollection := debian.NewSnapshotCollection(context.database) err = snapshotCollection.Add(snapshot) if err != nil { return fmt.Errorf("unable to add snapshot: %s", err) } fmt.Printf("\nSnapshot %s successfully created.\nYou can run 'aptly publish snapshot %s' to publish snapshot as Debian repository.\n", snapshot.Name, snapshot.Name) return err }
func runDiskConvert(cmd *commander.Command, args []string) { if len(args) != 2 { cmd.Usage() return } if diskVolume > 254 { log.Fatalf("disk volume must be 0-254, got %d", diskVolume) } nyb, err := disk.DiskFromFile(args[0], byte(diskVolume)) if err != nil { log.Fatal(err) } if err = disk.DiskToFile(args[1], nyb); err != nil { log.Fatal(err) } }
func aptlySnapshotMerge(cmd *commander.Command, args []string) error { var err error if len(args) < 2 { cmd.Usage() return err } snapshotCollection := debian.NewSnapshotCollection(context.database) sources := make([]*debian.Snapshot, len(args)-1) for i := 0; i < len(args)-1; i++ { sources[i], err = snapshotCollection.ByName(args[i+1]) if err != nil { return fmt.Errorf("unable to load snapshot: %s", err) } err = snapshotCollection.LoadComplete(sources[i]) if err != nil { return fmt.Errorf("unable to load snapshot: %s", err) } } result := sources[0].RefList() for i := 1; i < len(sources); i++ { result = result.Merge(sources[i].RefList(), true) } sourceDescription := make([]string, len(sources)) for i, s := range sources { sourceDescription[i] = fmt.Sprintf("'%s'", s.Name) } // Create <destination> snapshot destination := debian.NewSnapshotFromRefList(args[0], sources, result, fmt.Sprintf("Merged from sources: %s", strings.Join(sourceDescription, ", "))) err = 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 aptlyMirrorUpdate(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return err } name := args[0] repoCollection := debian.NewRemoteRepoCollection(context.database) repo, err := repoCollection.ByName(name) if err != nil { return fmt.Errorf("unable to update: %s", err) } err = repoCollection.LoadComplete(repo) if err != nil { return fmt.Errorf("unable to update: %s", err) } ignoreMismatch := cmd.Flag.Lookup("ignore-checksums").Value.Get().(bool) verifier, err := getVerifier(cmd) 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) } packageCollection := debian.NewPackageCollection(context.database) err = repo.Download(context.downloader, packageCollection, context.packageRepository, ignoreMismatch) if err != nil { return fmt.Errorf("unable to update: %s", err) } err = repoCollection.Update(repo) if err != nil { return fmt.Errorf("unable to update: %s", err) } fmt.Printf("\nMirror `%s` has been successfully updated.\n", repo.Name) return err }
func aptlyRepoCreate(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return err } repo := debian.NewLocalRepo(args[0], cmd.Flag.Lookup("comment").Value.String()) localRepoCollection := debian.NewLocalRepoCollection(context.database) err = 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 runDisasm(cmd *commander.Command, args []string) { if len(args) != 1 { cmd.Usage() return } bytes, err := ioutil.ReadFile(args[0]) if err != nil { log.Fatal(err) } if len(bytes) > 0x10000 { log.Fatalf("File %s is %04X bytes long, which is more than $10000.", args[0], len(bytes)) } if int(disasmAddress)+len(bytes) > 0x10000 { log.Fatalf("Starting address ($%04X) + file length ($%04X) = $%X, which is > $10000", disasmAddress, len(bytes), int(disasmAddress)+len(bytes)) } asm.DisasmBlock(bytes, uint16(disasmAddress), os.Stdout) }
func aptlyPublishList(cmd *commander.Command, args []string) error { var err error if len(args) != 0 { cmd.Usage() return err } publishedCollecton := debian.NewPublishedRepoCollection(context.database) snapshotCollection := debian.NewSnapshotCollection(context.database) if publishedCollecton.Len() == 0 { fmt.Printf("No snapshots have been published. Publish a snapshot by running `aptly publish snapshot ...`.\n") return err } published := make([]string, 0, publishedCollecton.Len()) err = publishedCollecton.ForEach(func(repo *debian.PublishedRepo) error { err := publishedCollecton.LoadComplete(repo, snapshotCollection) if err != nil { return err } published = append(published, repo.String()) return nil }) if err != nil { return fmt.Errorf("unable to load list of repos: %s", err) } sort.Strings(published) fmt.Printf("Published repositories:\n") for _, description := range published { fmt.Printf(" * %s\n", description) } return err }
func lbpkr_run_cmd_list(cmd *commander.Command, args []string) error { var err error siteroot := cmd.Flag.Lookup("siteroot").Value.Get().(string) debug := cmd.Flag.Lookup("v").Value.Get().(bool) name := "" vers := "" release := "" switch len(args) { case 0: name = "" case 1: name = args[0] case 2: name = args[0] vers = args[1] case 3: name = args[0] vers = args[1] release = args[2] default: cmd.Usage() return fmt.Errorf("lbpkr: invalid number of arguments. expected n=0|1|2|3. got=%d (%v)", len(args), args, ) } cfg := NewConfig(siteroot) ctx, err := New(cfg, Debug(debug)) if err != nil { return err } defer ctx.Close() _, err = ctx.ListPackages(name, vers, release) return err }
func aptlyMirrorDrop(cmd *commander.Command, args []string) error { var err error if len(args) != 1 { cmd.Usage() return err } name := args[0] repoCollection := debian.NewRemoteRepoCollection(context.database) repo, err := repoCollection.ByName(name) if err != nil { return fmt.Errorf("unable to drop: %s", err) } force := cmd.Flag.Lookup("force").Value.Get().(bool) if !force { snapshotCollection := debian.NewSnapshotCollection(context.database) snapshots := 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 = repoCollection.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 aptlyMirrorShow(cmd *commander.Command, args []string) { if len(args) != 1 { cmd.Usage() return } name := args[0] repoCollection := debian.NewRemoteRepoCollection(context.database) repo, err := repoCollection.ByName(name) if err != nil { log.Fatalf("Unable to show: %s", err) } err = repoCollection.LoadComplete(repo) if err != nil { log.Fatalf("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, ", ")) 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 name, value := range repo.Meta { fmt.Printf("%s: %s\n", name, value) } }
func aptlyRepoMoveCopyImport(cmd *commander.Command, args []string) error { var err error if len(args) < 3 { cmd.Usage() return err } command := cmd.Name() localRepoCollection := debian.NewLocalRepoCollection(context.database) dstRepo, err := localRepoCollection.ByName(args[1]) if err != nil { return fmt.Errorf("unable to %s: %s", command, err) } err = localRepoCollection.LoadComplete(dstRepo) if err != nil { return fmt.Errorf("unable to %s: %s", command, err) } var ( srcRefList *debian.PackageRefList srcRepo *debian.LocalRepo ) if command == "copy" || command == "move" { srcRepo, err = 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 = localRepoCollection.LoadComplete(srcRepo) if err != nil { return fmt.Errorf("unable to %s: %s", command, err) } srcRefList = srcRepo.RefList() } else if command == "import" { repoCollection := debian.NewRemoteRepoCollection(context.database) srcRepo, err := repoCollection.ByName(args[0]) if err != nil { return fmt.Errorf("unable to %s: %s", command, err) } err = repoCollection.LoadComplete(srcRepo) if err != nil { return fmt.Errorf("unable to %s: %s", command, err) } if srcRepo.RefList() == nil { return fmt.Errorf("unable to %s: mirror not updated", command) } srcRefList = srcRepo.RefList() } else { panic("unexpected command") } context.progress.Printf("Loading packages...\n") packageCollection := debian.NewPackageCollection(context.database) dstList, err := debian.NewPackageListFromRefList(dstRepo.RefList(), packageCollection) if err != nil { return fmt.Errorf("unable to load packages: %s", err) } srcList, err := debian.NewPackageListFromRefList(srcRefList, packageCollection) if err != nil { return fmt.Errorf("unable to load packages: %s", err) } srcList.PrepareIndex() var architecturesList []string withDeps := cmd.Flag.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 *debian.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 cmd.Flag.Lookup("dry-run").Value.Get().(bool) { context.progress.Printf("\nChanges not saved, as dry run has been requested.\n") } else { dstRepo.UpdateRefList(debian.NewPackageRefListFromPackageList(dstList)) err = localRepoCollection.Update(dstRepo) if err != nil { return fmt.Errorf("unable to save: %s", err) } if command == "move" { srcRepo.UpdateRefList(debian.NewPackageRefListFromPackageList(srcList)) err = localRepoCollection.Update(srcRepo) if err != nil { return fmt.Errorf("unable to save: %s", err) } } } return err }