Merge pull request containers#21384 from Luap99/connections

rework system connection and farm storage

cmd/podman/common/completion.go

@@ -837,15 +837,15 @@ func AutoCompleteFarms(cmd *cobra.Command, args []string, toComplete string) ([]
 	if !validCurrentCmdLine(cmd, args, toComplete) {
 		return nil, cobra.ShellCompDirectiveNoFileComp
 	}
-	suggestions := []string{}
-	cfg, err := config.ReadCustomConfig()
+	farms, err := podmanConfig.ContainersConfDefaultsRO.GetAllFarms()
 	if err != nil {
 		cobra.CompErrorln(err.Error())
 		return nil, cobra.ShellCompDirectiveNoFileComp
 	}
 
-	for k := range cfg.Farms.List {
-		suggestions = append(suggestions, k)
+	suggestions := make([]string, 0, len(farms))
+	for _, farm := range farms {
+		suggestions = append(suggestions, farm.Name)
 	}
 
 	return suggestions, cobra.ShellCompDirectiveNoFileComp
@@ -856,16 +856,17 @@ func AutocompleteSystemConnections(cmd *cobra.Command, args []string, toComplete
 	if !validCurrentCmdLine(cmd, args, toComplete) {
 		return nil, cobra.ShellCompDirectiveNoFileComp
 	}
-	suggestions := []string{}
-	cfg, err := config.ReadCustomConfig()
+
+	cons, err := podmanConfig.ContainersConfDefaultsRO.GetAllConnections()
 	if err != nil {
 		cobra.CompErrorln(err.Error())
 		return nil, cobra.ShellCompDirectiveNoFileComp
 	}
 
-	for k, v := range cfg.Engine.ServiceDestinations {
+	suggestions := make([]string, 0, len(cons))
+	for _, con := range cons {
 		// the URI will be show as description in shells like zsh
-		suggestions = append(suggestions, k+"\t"+v.URI)
+		suggestions = append(suggestions, con.Name+"\t"+con.URI)
 	}
 
 	return suggestions, cobra.ShellCompDirectiveNoFileComp

cmd/podman/compose.go

@@ -14,7 +14,6 @@ import (
 	"strings"
 	"text/template"
 
-	"github.com/containers/common/pkg/config"
 	"github.com/containers/podman/v4/cmd/podman/registry"
 	"github.com/containers/podman/v4/pkg/errorhandling"
 	"github.com/containers/podman/v4/pkg/machine"
@@ -114,15 +113,10 @@ func composeDockerHost() (string, error) {
 		return registry.DefaultAPIAddress(), nil
 	}
 
-	cfg, err := config.ReadCustomConfig()
+	// TODO need to add support for --connection and --url
+	connection, err := registry.PodmanConfig().ContainersConfDefaultsRO.GetConnection("", true)
 	if err != nil {
-		return "", err
-	}
-
-	// NOTE: podman --connection=foo and --url=... are injected
-	// into the default connection below in `root.go`.
-	defaultConnection := cfg.Engine.ActiveService
-	if defaultConnection == "" {
+		logrus.Info(err)
 		switch runtime.GOOS {
 		// If no default connection is set on Linux or FreeBSD,
 		// we just use the local socket by default - just as
@@ -137,10 +131,6 @@ func composeDockerHost() (string, error) {
 		}
 	}
 
-	connection, ok := cfg.Engine.ServiceDestinations[defaultConnection]
-	if !ok {
-		return "", fmt.Errorf("internal error: default connection %q not found in database", defaultConnection)
-	}
 	parsedConnection, err := url.Parse(connection.URI)
 	if err != nil {
 		return "", fmt.Errorf("preparing connection to remote machine: %w", err)

cmd/podman/farm/build.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 
 	"github.com/containers/common/pkg/completion"
-	"github.com/containers/common/pkg/config"
 	"github.com/containers/podman/v4/cmd/podman/common"
 	"github.com/containers/podman/v4/cmd/podman/registry"
 	"github.com/containers/podman/v4/cmd/podman/utils"
@@ -50,14 +49,8 @@ func init() {
 	cleanupFlag := "cleanup"
 	flags.BoolVar(&buildOpts.buildOptions.Cleanup, cleanupFlag, false, "Remove built images from farm nodes on success")
 
-	podmanConfig := registry.PodmanConfig()
 	farmFlagName := "farm"
-	// If remote, don't read the client's containers.conf file
-	defaultFarm := ""
-	if !registry.IsRemote() {
-		defaultFarm = podmanConfig.ContainersConfDefaultsRO.Farms.Default
-	}
-	flags.StringVar(&buildOpts.farm, farmFlagName, defaultFarm, "Farm to use for builds")
+	flags.StringVar(&buildOpts.farm, farmFlagName, "", "Farm to use for builds")
 	_ = buildCommand.RegisterFlagCompletionFunc(farmFlagName, common.AutoCompleteFarms)
 
 	localFlagName := "local"
@@ -122,23 +115,9 @@ func build(cmd *cobra.Command, args []string) error {
 	}
 	opts.SkipTLSVerify = !tlsVerify
 
-	cfg, err := config.ReadCustomConfig()
-	if err != nil {
-		return err
-	}
-
-	defaultFarm := cfg.Farms.Default
-	if cmd.Flags().Changed("farm") {
-		f, err := cmd.Flags().GetString("farm")
-		if err != nil {
-			return err
-		}
-		defaultFarm = f
-	}
-
 	localEngine := registry.ImageEngine()
 	ctx := registry.Context()
-	farm, err := farm.NewFarm(ctx, defaultFarm, localEngine, buildOpts.local)
+	farm, err := farm.NewFarm(ctx, buildOpts.farm, localEngine, buildOpts.local)
 	if err != nil {
 		return fmt.Errorf("initializing: %w", err)
 	}

cmd/podman/farm/create.go

@@ -41,43 +41,39 @@ func create(cmd *cobra.Command, args []string) error {
 	farmName := args[0]
 	connections := args[1:]
 
-	cfg, err := config.ReadCustomConfig()
-	if err != nil {
-		return err
-	}
-
-	if _, ok := cfg.Farms.List[farmName]; ok {
-		// if farm exists return an error
-		return fmt.Errorf("farm with name %q already exists", farmName)
-	}
+	err := config.EditConnectionConfig(func(cfg *config.ConnectionsFile) error {
+		if _, ok := cfg.Farm.List[farmName]; ok {
+			// if farm exists return an error
+			return fmt.Errorf("farm with name %q already exists", farmName)
+		}
 
-	// Can create an empty farm without any connections
-	if len(connections) == 0 {
-		cfg.Farms.List[farmName] = []string{}
-	}
+		// Can create an empty farm without any connections
+		if len(connections) == 0 {
+			cfg.Farm.List[farmName] = []string{}
+		}
 
-	for _, c := range connections {
-		if _, ok := cfg.Engine.ServiceDestinations[c]; ok {
-			if slices.Contains(cfg.Farms.List[farmName], c) {
-				// Don't add duplicate connections to a farm
-				continue
+		for _, c := range connections {
+			if _, ok := cfg.Connection.Connections[c]; ok {
+				if slices.Contains(cfg.Farm.List[farmName], c) {
+					// Don't add duplicate connections to a farm
+					continue
+				}
+				cfg.Farm.List[farmName] = append(cfg.Farm.List[farmName], c)
+			} else {
+				return fmt.Errorf("cannot create farm, %q is not a system connection", c)
 			}
-			cfg.Farms.List[farmName] = append(cfg.Farms.List[farmName], c)
-		} else {
-			return fmt.Errorf("cannot create farm, %q is not a system connection", c)
 		}
-	}
 
-	// If this is the first farm being created, set it as the default farm
-	if len(cfg.Farms.List) == 1 {
-		cfg.Farms.Default = farmName
-	}
+		// If this is the first farm being created, set it as the default farm
+		if len(cfg.Farm.List) == 1 {
+			cfg.Farm.Default = farmName
+		}
 
-	err = cfg.Write()
+		return nil
+	})
 	if err != nil {
 		return err
 	}
-
 	fmt.Printf("Farm %q created\n", farmName)
 	return nil
 }

cmd/podman/farm/list.go

@@ -46,50 +46,29 @@ func init() {
 
 	formatFlagName := "format"
 	flags.StringVar(&lsOpts.Format, formatFlagName, "", "Format farm output using Go template")
-	_ = lsCommand.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteFormat(&farmOut{}))
-}
-
-type farmOut struct {
-	Name        string
-	Connections []string
-	Default     bool
+	_ = lsCommand.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteFormat(&config.Farm{}))
 }
 
 func list(cmd *cobra.Command, args []string) error {
-	cfg, err := config.ReadCustomConfig()
-	if err != nil {
-		return err
-	}
-
 	format := lsOpts.Format
 	if format == "" && len(args) > 0 {
 		format = "json"
 	}
 
-	rows := make([]farmOut, 0)
-	for k, v := range cfg.Farms.List {
-		defaultFarm := false
-		if k == cfg.Farms.Default {
-			defaultFarm = true
-		}
-
-		r := farmOut{
-			Name:        k,
-			Connections: v,
-			Default:     defaultFarm,
-		}
-		rows = append(rows, r)
+	farms, err := registry.PodmanConfig().ContainersConfDefaultsRO.GetAllFarms()
+	if err != nil {
+		return err
 	}
 
-	sort.Slice(rows, func(i, j int) bool {
-		return rows[i].Name < rows[j].Name
+	sort.Slice(farms, func(i, j int) bool {
+		return farms[i].Name < farms[j].Name
 	})
 
 	rpt := report.New(os.Stdout, cmd.Name())
 	defer rpt.Flush()
 
 	if report.IsJSON(format) {
-		buf, err := registry.JSONLibrary().MarshalIndent(rows, "", "    ")
+		buf, err := registry.JSONLibrary().MarshalIndent(farms, "", "    ")
 		if err == nil {
 			fmt.Println(string(buf))
 		}
@@ -100,7 +79,7 @@ func list(cmd *cobra.Command, args []string) error {
 		rpt, err = rpt.Parse(report.OriginUser, format)
 	} else {
 		rpt, err = rpt.Parse(report.OriginPodman,
-			"{{range .}}{{.Name}}\t{{.Connections}}\t{{.Default}}\n{{end -}}")
+			"{{range .}}{{.Name}}\t{{.Connections}}\t{{.Default}}\t{{.ReadWrite}}\n{{end -}}")
 	}
 	if err != nil {
 		return err
@@ -111,11 +90,12 @@ func list(cmd *cobra.Command, args []string) error {
 			"Default":     "Default",
 			"Connections": "Connections",
 			"Name":        "Name",
+			"ReadWrite":   "ReadWrite",
 		}})
 		if err != nil {
 			return err
 		}
 	}
 
-	return rpt.Execute(rows)
+	return rpt.Execute(farms)
 }

cmd/podman/farm/remove.go

@@ -43,57 +43,55 @@ func init() {
 }
 
 func rm(cmd *cobra.Command, args []string) error {
-	cfg, err := config.ReadCustomConfig()
-	if err != nil {
-		return err
-	}
-
-	if rmOpts.All {
-		cfg.Farms.List = make(map[string][]string)
-		cfg.Farms.Default = ""
-		if err := cfg.Write(); err != nil {
-			return err
+	deletedFarms := []string{}
+	err := config.EditConnectionConfig(func(cfg *config.ConnectionsFile) error {
+		if rmOpts.All {
+			cfg.Farm.List = make(map[string][]string)
+			cfg.Farm.Default = ""
+			return nil
 		}
-		fmt.Println("All farms have been deleted")
-		return nil
-	}
 
-	// If the --all is not set, we require at least one arg
-	if len(args) == 0 {
-		return errors.New("requires at lease 1 arg(s), received 0")
-	}
+		// If the --all is not set, we require at least one arg
+		if len(args) == 0 {
+			return errors.New("requires at lease 1 arg(s), received 0")
+		}
 
-	if len(cfg.Farms.List) == 0 {
-		return errors.New("no existing farms; nothing to remove")
-	}
+		if len(cfg.Farm.List) == 0 {
+			return errors.New("no existing farms; nothing to remove")
+		}
 
-	deletedFarms := []string{}
-	for _, k := range args {
-		if _, ok := cfg.Farms.List[k]; !ok {
-			logrus.Warnf("farm %q doesn't exist; nothing to remove", k)
-			continue
+		for _, k := range args {
+			if _, ok := cfg.Farm.List[k]; !ok {
+				logrus.Warnf("farm %q doesn't exist; nothing to remove", k)
+				continue
+			}
+			delete(cfg.Farm.List, k)
+			deletedFarms = append(deletedFarms, k)
+			if k == cfg.Farm.Default {
+				cfg.Farm.Default = ""
+			}
 		}
-		delete(cfg.Farms.List, k)
-		deletedFarms = append(deletedFarms, k)
-		if k == cfg.Farms.Default {
-			cfg.Farms.Default = ""
+		// Return error if none of the given farms were deleted
+		if len(deletedFarms) == 0 {
+			return fmt.Errorf("failed to delete farms %q", args)
 		}
-	}
-	// Return error if none of the given farms were deleted
-	if len(deletedFarms) == 0 {
-		return fmt.Errorf("failed to delete farms %q", args)
-	}
 
-	// Set a new default farm if the current default farm has been removed
-	if cfg.Farms.Default == "" && cfg.Farms.List != nil {
-		for k := range cfg.Farms.List {
-			cfg.Farms.Default = k
-			break
+		// Set a new default farm if the current default farm has been removed
+		if cfg.Farm.Default == "" && cfg.Farm.List != nil {
+			for k := range cfg.Farm.List {
+				cfg.Farm.Default = k
+				break
+			}
 		}
-	}
-	if err := cfg.Write(); err != nil {
+		return nil
+	})
+	if err != nil {
 		return err
 	}
+	if rmOpts.All {
+		fmt.Println("All farms have been deleted")
+		return nil
+	}
 
 	for _, k := range deletedFarms {
 		fmt.Printf("Farm %q deleted\n", k)