func aptlySnapshotPull(cmd *commander.Command, args []string) error { var err error if len(args) < 4 { cmd.Usage() return commander.ErrCommandError } noDeps := context.Flags().Lookup("no-deps").Value.Get().(bool) noRemove := context.Flags().Lookup("no-remove").Value.Get().(bool) allMatches := context.Flags().Lookup("all-matches").Value.Get().(bool) // Load <name> snapshot snapshot, err := context.CollectionFactory().SnapshotCollection().ByName(args[0]) if err != nil { return fmt.Errorf("unable to pull: %s", err) } err = context.CollectionFactory().SnapshotCollection().LoadComplete(snapshot) if err != nil { return fmt.Errorf("unable to pull: %s", err) } // Load <source> snapshot source, err := context.CollectionFactory().SnapshotCollection().ByName(args[1]) if err != nil { return fmt.Errorf("unable to pull: %s", err) } err = context.CollectionFactory().SnapshotCollection().LoadComplete(source) if err != nil { return fmt.Errorf("unable to pull: %s", err) } context.Progress().Printf("Dependencies would be pulled into snapshot:\n %s\nfrom snapshot:\n %s\nand result would be saved as new snapshot %s.\n", snapshot, source, args[2]) // Convert snapshot to package list context.Progress().Printf("Loading packages (%d)...\n", snapshot.RefList().Len()+source.RefList().Len()) packageList, err := deb.NewPackageListFromRefList(snapshot.RefList(), context.CollectionFactory().PackageCollection(), context.Progress()) if err != nil { return fmt.Errorf("unable to load packages: %s", err) } sourcePackageList, err := deb.NewPackageListFromRefList(source.RefList(), context.CollectionFactory().PackageCollection(), context.Progress()) if err != nil { return fmt.Errorf("unable to load packages: %s", err) } context.Progress().Printf("Building indexes...\n") packageList.PrepareIndex() sourcePackageList.PrepareIndex() // Calculate architectures var architecturesList []string if len(context.ArchitecturesList()) > 0 { architecturesList = context.ArchitecturesList() } else { architecturesList = packageList.Architectures(false) } sort.Strings(architecturesList) if len(architecturesList) == 0 { return fmt.Errorf("unable to determine list of architectures, please specify explicitly") } // Build architecture query: (arch == "i386" | arch == "amd64" | ...) var archQuery deb.PackageQuery = &deb.FieldQuery{Field: "$Architecture", Relation: deb.VersionEqual, Value: ""} for _, arch := range architecturesList { archQuery = &deb.OrQuery{L: &deb.FieldQuery{Field: "$Architecture", Relation: deb.VersionEqual, Value: arch}, R: archQuery} } // Initial queries out of arguments queries := make([]deb.PackageQuery, len(args)-3) for i, arg := range args[3:] { queries[i], err = query.Parse(arg) if err != nil { return fmt.Errorf("unable to parse query: %s", err) } // Add architecture filter queries[i] = &deb.AndQuery{L: queries[i], R: archQuery} } // Filter with dependencies as requested result, err := sourcePackageList.Filter(queries, !noDeps, packageList, context.DependencyOptions(), architecturesList) if err != nil { return fmt.Errorf("unable to pull: %s", err) } result.PrepareIndex() alreadySeen := map[string]bool{} result.ForEachIndexed(func(pkg *deb.Package) error { key := pkg.Architecture + "_" + pkg.Name _, seen := alreadySeen[key] // If we haven't seen such name-architecture pair and were instructed to remove, remove it if !noRemove && !seen { // Remove all packages with the same name and architecture pS := packageList.Search(deb.Dependency{Architecture: pkg.Architecture, Pkg: pkg.Name}, true) for _, p := range pS { packageList.Remove(p) context.Progress().ColoredPrintf("@r[-]@| %s removed", p) } } // If !allMatches, add only first matching name-arch package if !seen || allMatches { packageList.Add(pkg) context.Progress().ColoredPrintf("@g[+]@| %s added", pkg) } alreadySeen[key] = true return nil }) alreadySeen = nil if context.Flags().Lookup("dry-run").Value.Get().(bool) { context.Progress().Printf("\nNot creating snapshot, as dry run was requested.\n") } else { // Create <destination> snapshot destination := deb.NewSnapshotFromPackageList(args[2], []*deb.Snapshot{snapshot, source}, packageList, fmt.Sprintf("Pulled into '%s' with '%s' as source, pull request was: '%s'", snapshot.Name, source.Name, strings.Join(args[3:], " "))) err = context.CollectionFactory().SnapshotCollection().Add(destination) if err != nil { return fmt.Errorf("unable to create snapshot: %s", err) } context.Progress().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 aptlySnapshotCreate(cmd *commander.Command, args []string) error { var ( err error snapshot *deb.Snapshot ) if len(args) == 4 && args[1] == "from" && args[2] == "mirror" { // aptly snapshot create snap from mirror mirror var repo *deb.RemoteRepo repoName, snapshotName := args[3], args[0] repo, err = context.CollectionFactory().RemoteRepoCollection().ByName(repoName) if err != nil { return fmt.Errorf("unable to create snapshot: %s", err) } err = context.CollectionFactory().RemoteRepoCollection().LoadComplete(repo) if err != nil { return fmt.Errorf("unable to create snapshot: %s", err) } snapshot, err = deb.NewSnapshotFromRepository(snapshotName, repo) if err != nil { return fmt.Errorf("unable to create snapshot: %s", err) } } else if len(args) == 4 && args[1] == "from" && args[2] == "repo" { // aptly snapshot create snap from repo repo var repo *deb.LocalRepo localRepoName, snapshotName := args[3], args[0] repo, err = context.CollectionFactory().LocalRepoCollection().ByName(localRepoName) if err != nil { return fmt.Errorf("unable to create snapshot: %s", err) } err = context.CollectionFactory().LocalRepoCollection().LoadComplete(repo) if err != nil { return fmt.Errorf("unable to create snapshot: %s", err) } snapshot, err = deb.NewSnapshotFromLocalRepo(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 := deb.NewPackageList() snapshot = deb.NewSnapshotFromPackageList(snapshotName, nil, packageList, "Created as empty") } else { cmd.Usage() return err } err = context.CollectionFactory().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 aptlySnapshotPull(cmd *commander.Command, args []string) error { var err error if len(args) < 4 { cmd.Usage() return commander.ErrCommandError } noDeps := context.flags.Lookup("no-deps").Value.Get().(bool) noRemove := context.flags.Lookup("no-remove").Value.Get().(bool) // Load <name> snapshot snapshot, err := context.CollectionFactory().SnapshotCollection().ByName(args[0]) if err != nil { return fmt.Errorf("unable to pull: %s", err) } err = context.CollectionFactory().SnapshotCollection().LoadComplete(snapshot) if err != nil { return fmt.Errorf("unable to pull: %s", err) } // Load <source> snapshot source, err := context.CollectionFactory().SnapshotCollection().ByName(args[1]) if err != nil { return fmt.Errorf("unable to pull: %s", err) } err = context.CollectionFactory().SnapshotCollection().LoadComplete(source) if err != nil { return fmt.Errorf("unable to pull: %s", err) } context.Progress().Printf("Dependencies would be pulled into snapshot:\n %s\nfrom snapshot:\n %s\nand result would be saved as new snapshot %s.\n", snapshot, source, args[2]) // Convert snapshot to package list context.Progress().Printf("Loading packages (%d)...\n", snapshot.RefList().Len()+source.RefList().Len()) packageList, err := deb.NewPackageListFromRefList(snapshot.RefList(), context.CollectionFactory().PackageCollection(), context.Progress()) if err != nil { return fmt.Errorf("unable to load packages: %s", err) } sourcePackageList, err := deb.NewPackageListFromRefList(source.RefList(), context.CollectionFactory().PackageCollection(), context.Progress()) if err != nil { return fmt.Errorf("unable to load packages: %s", err) } context.Progress().Printf("Building indexes...\n") packageList.PrepareIndex() sourcePackageList.PrepareIndex() // Calculate architectures var architecturesList []string if len(context.ArchitecturesList()) > 0 { architecturesList = context.ArchitecturesList() } else { architecturesList = packageList.Architectures(false) } sort.Strings(architecturesList) if len(architecturesList) == 0 { return fmt.Errorf("unable to determine list of architectures, please specify explicitly") } // Initial dependencies out of arguments initialDependencies := make([]deb.Dependency, len(args)-3) for i, arg := range args[3:] { initialDependencies[i], err = deb.ParseDependency(arg) if err != nil { return fmt.Errorf("unable to parse argument: %s", err) } } // Perform pull for _, arch := range architecturesList { dependencies := make([]deb.Dependency, len(initialDependencies), 2*len(initialDependencies)) for i := range dependencies { dependencies[i] = initialDependencies[i] dependencies[i].Architecture = arch } // Go over list of initial dependencies + list of dependencies found for i := 0; i < len(dependencies); i++ { dep := dependencies[i] // Search for package that can satisfy dependencies pkg := sourcePackageList.Search(dep) if pkg == nil { context.Progress().ColoredPrintf("@y[!]@| @!Dependency %s can't be satisfied with source %s@|", &dep, source) continue } if !noRemove { // Remove all packages with the same name and architecture for p := packageList.Search(deb.Dependency{Architecture: pkg.Architecture, Pkg: pkg.Name}); p != nil; { packageList.Remove(p) context.Progress().ColoredPrintf("@r[-]@| %s removed", p) p = packageList.Search(deb.Dependency{Architecture: pkg.Architecture, Pkg: pkg.Name}) } } // Add new discovered package packageList.Add(pkg) context.Progress().ColoredPrintf("@g[+]@| %s added", pkg) if noDeps { continue } // Find missing dependencies for single added package pL := deb.NewPackageList() pL.Add(pkg) var missing []deb.Dependency missing, err = pL.VerifyDependencies(context.DependencyOptions(), []string{arch}, packageList, nil) if err != nil { context.Progress().ColoredPrintf("@y[!]@| @!Error while verifying dependencies for pkg %s: %s@|", pkg, err) } // Append missing dependencies to the list of dependencies to satisfy for _, misDep := range missing { found := false for _, d := range dependencies { if d == misDep { found = true break } } if !found { dependencies = append(dependencies, misDep) } } } } if context.flags.Lookup("dry-run").Value.Get().(bool) { context.Progress().Printf("\nNot creating snapshot, as dry run was requested.\n") } else { // Create <destination> snapshot destination := deb.NewSnapshotFromPackageList(args[2], []*deb.Snapshot{snapshot, source}, packageList, fmt.Sprintf("Pulled into '%s' with '%s' as source, pull request was: '%s'", snapshot.Name, source.Name, strings.Join(args[3:], " "))) err = context.CollectionFactory().SnapshotCollection().Add(destination) if err != nil { return fmt.Errorf("unable to create snapshot: %s", err) } context.Progress().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 aptlySnapshotFilter(cmd *commander.Command, args []string) error { var err error if len(args) < 3 { cmd.Usage() return commander.ErrCommandError } withDeps := context.Flags().Lookup("with-deps").Value.Get().(bool) // Load <source> snapshot source, err := context.CollectionFactory().SnapshotCollection().ByName(args[0]) if err != nil { return fmt.Errorf("unable to filter: %s", err) } err = context.CollectionFactory().SnapshotCollection().LoadComplete(source) if err != nil { return fmt.Errorf("unable to filter: %s", err) } // Convert snapshot to package list context.Progress().Printf("Loading packages (%d)...\n", source.RefList().Len()) packageList, err := deb.NewPackageListFromRefList(source.RefList(), context.CollectionFactory().PackageCollection(), context.Progress()) if err != nil { return fmt.Errorf("unable to load packages: %s", err) } context.Progress().Printf("Building indexes...\n") packageList.PrepareIndex() // Calculate architectures var architecturesList []string if len(context.ArchitecturesList()) > 0 { architecturesList = context.ArchitecturesList() } else { architecturesList = packageList.Architectures(false) } sort.Strings(architecturesList) if len(architecturesList) == 0 && withDeps { return fmt.Errorf("unable to determine list of architectures, please specify explicitly") } // Initial queries out of arguments queries := make([]deb.PackageQuery, len(args)-2) for i, arg := range args[2:] { queries[i], err = query.Parse(arg) if err != nil { return fmt.Errorf("unable to parse query: %s", err) } } // Filter with dependencies as requested result, err := packageList.Filter(queries, withDeps, nil, context.DependencyOptions(), architecturesList) if err != nil { return fmt.Errorf("unable to filter: %s", err) } // Create <destination> snapshot destination := deb.NewSnapshotFromPackageList(args[1], []*deb.Snapshot{source}, result, fmt.Sprintf("Filtered '%s', query was: '%s'", source.Name, strings.Join(args[2:], " "))) err = context.CollectionFactory().SnapshotCollection().Add(destination) if err != nil { return fmt.Errorf("unable to create snapshot: %s", err) } context.Progress().Printf("\nSnapshot %s successfully filtered.\nYou can run 'aptly publish snapshot %s' to publish snapshot as Debian repository.\n", destination.Name, destination.Name) return err }