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
}