Merge pull request #8581 from baude/kubegen

generate kube on multiple containers

cmd/podman/generate/kube.go

@@ -17,16 +17,16 @@ import (
 var (
 	kubeOptions     = entities.GenerateKubeOptions{}
 	kubeFile        = ""
-	kubeDescription = `Command generates Kubernetes pod and service YAML (v1 specification) from a Podman container or pod.
+	kubeDescription = `Command generates Kubernetes pod and service YAML (v1 specification) from Podman containers or a pod.
 
 Whether the input is for a container or pod, Podman will always generate the specification as a pod.`
 
 	kubeCmd = &cobra.Command{
-		Use:               "kube [options] CONTAINER | POD",
+		Use:               "kube [options] CONTAINER... | POD",
 		Short:             "Generate Kubernetes YAML from a container or pod.",
 		Long:              kubeDescription,
 		RunE:              kube,
-		Args:              cobra.ExactArgs(1),
+		Args:              cobra.MinimumNArgs(1),
 		ValidArgsFunction: common.AutocompleteContainersAndPods,
 		Example: `podman generate kube ctrID
   podman generate kube podID
@@ -51,7 +51,7 @@ func init() {
 }
 
 func kube(cmd *cobra.Command, args []string) error {
-	report, err := registry.ContainerEngine().GenerateKube(registry.GetContext(), args[0], kubeOptions)
+	report, err := registry.ContainerEngine().GenerateKube(registry.GetContext(), args, kubeOptions)
 	if err != nil {
 		return err
 	}

docs/source/markdown/podman-generate-kube.1.md

@@ -3,12 +3,12 @@
 podman-generate-kube - Generate Kubernetes YAML based on a pod or container
 
 ## SYNOPSIS
-**podman generate kube** [*options*] *container* | *pod*
+**podman generate kube** [*options*] *container...* | *pod*
 
 ## DESCRIPTION
-**podman generate kube** will generate Kubernetes Pod YAML (v1 specification) from a Podman container or pod. Whether
-the input is for a container or pod, Podman will always generate the specification as a Pod. The input may be in the form
-of a pod or container name or ID.
+**podman generate kube** will generate Kubernetes Pod YAML (v1 specification) from Podman one or more containers or a single pod. Whether
+the input is for containers or a pod, Podman will always generate the specification as a Pod. The input may be in the form
+of a pod or one or more container names or IDs.
 
 Note that the generated Kubernetes YAML file can be used to re-run the deployment via podman-play-kube(1).
 

libpod/kube.go

@@ -21,9 +21,9 @@ import (
 
 // GenerateForKube takes a slice of libpod containers and generates
 // one v1.Pod description that includes just a single container.
-func (c *Container) GenerateForKube() (*v1.Pod, error) {
+func GenerateForKube(ctrs []*Container) (*v1.Pod, error) {
 	// Generate the v1.Pod yaml description
-	return simplePodWithV1Container(c)
+	return simplePodWithV1Containers(ctrs)
 }
 
 // GenerateForKube takes a slice of libpod containers and generates
@@ -236,14 +236,20 @@ func addContainersAndVolumesToPodObject(containers []v1.Container, volumes []v1.
 	return &p
 }
 
-// simplePodWithV1Container is a function used by inspect when kube yaml needs to be generated
+// simplePodWithV1Containers is a function used by inspect when kube yaml needs to be generated
 // for a single container.  we "insert" that container description in a pod.
-func simplePodWithV1Container(ctr *Container) (*v1.Pod, error) {
-	kubeCtr, kubeVols, err := containerToV1Container(ctr)
-	if err != nil {
-		return nil, err
+func simplePodWithV1Containers(ctrs []*Container) (*v1.Pod, error) {
+	kubeCtrs := make([]v1.Container, 0, len(ctrs))
+	kubeVolumes := make([]v1.Volume, 0)
+	for _, ctr := range ctrs {
+		kubeCtr, kubeVols, err := containerToV1Container(ctr)
+		if err != nil {
+			return nil, err
+		}
+		kubeCtrs = append(kubeCtrs, kubeCtr)
+		kubeVolumes = append(kubeVolumes, kubeVols...)
 	}
-	return addContainersAndVolumesToPodObject([]v1.Container{kubeCtr}, kubeVols, ctr.Name()), nil
+	return addContainersAndVolumesToPodObject(kubeCtrs, kubeVolumes, strings.ReplaceAll(ctrs[0].Name(), "_", "")), nil
 
 }
 
@@ -294,6 +300,12 @@ func containerToV1Container(c *Container) (v1.Container, []v1.Volume, error) {
 	_, image := c.Image()
 	kubeContainer.Image = image
 	kubeContainer.Stdin = c.Stdin()
+
+	// prepend the entrypoint of the container to command
+	if ep := c.Entrypoint(); len(c.Entrypoint()) > 0 {
+		ep = append(ep, containerCommands...)
+		containerCommands = ep
+	}
 	kubeContainer.Command = containerCommands
 	// TODO need to figure out how we handle command vs entry point.  Kube appears to prefer entrypoint.
 	// right now we just take the container's command

pkg/api/handlers/libpod/generate.go

@@ -60,7 +60,8 @@ func GenerateKube(w http.ResponseWriter, r *http.Request) {
 	runtime := r.Context().Value("runtime").(*libpod.Runtime)
 	decoder := r.Context().Value("decoder").(*schema.Decoder)
 	query := struct {
-		Service bool `schema:"service"`
+		Names   []string `schema:"names"`
+		Service bool     `schema:"service"`
 	}{
 		// Defaults would go here.
 	}
@@ -73,7 +74,7 @@ func GenerateKube(w http.ResponseWriter, r *http.Request) {
 
 	containerEngine := abi.ContainerEngine{Libpod: runtime}
 	options := entities.GenerateKubeOptions{Service: query.Service}
-	report, err := containerEngine.GenerateKube(r.Context(), utils.GetName(r), options)
+	report, err := containerEngine.GenerateKube(r.Context(), query.Names, options)
 	if err != nil {
 		utils.Error(w, "Something went wrong.", http.StatusInternalServerError, errors.Wrap(err, "error generating YAML"))
 		return

pkg/api/server/register_generate.go

@@ -70,17 +70,19 @@ func (s *APIServer) registerGenerateHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/InternalError"
 	r.HandleFunc(VersionedPath("/libpod/generate/{name:.*}/systemd"), s.APIHandler(libpod.GenerateSystemd)).Methods(http.MethodGet)
 
-	// swagger:operation GET /libpod/generate/{name:.*}/kube libpod libpodGenerateKube
+	// swagger:operation GET /libpod/generate/kube libpod libpodGenerateKube
 	// ---
 	// tags:
 	//  - containers
 	//  - pods
 	// summary: Generate a Kubernetes YAML file.
 	// description: Generate Kubernetes YAML based on a pod or container.
 	// parameters:
-	//  - in: path
-	//    name: name:.*
-	//    type: string
+	//  - in: query
+	//    name: names
+	//    type: array
+	//    items:
+	//       type: string
 	//    required: true
 	//    description: Name or ID of the container or pod.
 	//  - in: query
@@ -98,6 +100,6 @@ func (s *APIServer) registerGenerateHandlers(r *mux.Router) error {
 	//      format: binary
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/libpod/generate/{name:.*}/kube"), s.APIHandler(libpod.GenerateKube)).Methods(http.MethodGet)
+	r.HandleFunc(VersionedPath("/libpod/generate/kube"), s.APIHandler(libpod.GenerateKube)).Methods(http.MethodGet)
 	return nil
 }

pkg/bindings/generate/generate.go

@@ -2,6 +2,7 @@ package generate
 
 import (
 	"context"
+	"errors"
 	"net/http"
 	"net/url"
 	"strconv"
@@ -37,15 +38,21 @@ func Systemd(ctx context.Context, nameOrID string, options entities.GenerateSyst
 	return report, response.Process(&report.Units)
 }
 
-func Kube(ctx context.Context, nameOrID string, options entities.GenerateKubeOptions) (*entities.GenerateKubeReport, error) {
+func Kube(ctx context.Context, nameOrIDs []string, options entities.GenerateKubeOptions) (*entities.GenerateKubeReport, error) {
 	conn, err := bindings.GetClient(ctx)
 	if err != nil {
 		return nil, err
 	}
+	if len(nameOrIDs) < 1 {
+		return nil, errors.New("must provide the name or ID of one container or pod")
+	}
 	params := url.Values{}
+	for _, name := range nameOrIDs {
+		params.Add("names", name)
+	}
 	params.Set("service", strconv.FormatBool(options.Service))
 
-	response, err := conn.DoRequest(nil, http.MethodGet, "/generate/%s/kube", params, nil, nameOrID)
+	response, err := conn.DoRequest(nil, http.MethodGet, "/generate/kube", params, nil)
 	if err != nil {
 		return nil, err
 	}

pkg/domain/entities/engine_container.go

@@ -46,7 +46,7 @@ type ContainerEngine interface {
 	ContainerWait(ctx context.Context, namesOrIds []string, options WaitOptions) ([]WaitReport, error)
 	Events(ctx context.Context, opts EventsOptions) error
 	GenerateSystemd(ctx context.Context, nameOrID string, opts GenerateSystemdOptions) (*GenerateSystemdReport, error)
-	GenerateKube(ctx context.Context, nameOrID string, opts GenerateKubeOptions) (*GenerateKubeReport, error)
+	GenerateKube(ctx context.Context, nameOrIDs []string, opts GenerateKubeOptions) (*GenerateKubeReport, error)
 	SystemPrune(ctx context.Context, options SystemPruneOptions) (*SystemPruneReport, error)
 	HealthCheckRun(ctx context.Context, nameOrID string, options HealthCheckOptions) (*define.HealthCheckResults, error)
 	Info(ctx context.Context) (*define.Info, error)

pkg/domain/infra/abi/generate.go

@@ -41,28 +41,48 @@ func (ic *ContainerEngine) GenerateSystemd(ctx context.Context, nameOrID string,
 	return &entities.GenerateSystemdReport{Units: units}, nil
 }
 
-func (ic *ContainerEngine) GenerateKube(ctx context.Context, nameOrID string, options entities.GenerateKubeOptions) (*entities.GenerateKubeReport, error) {
+func (ic *ContainerEngine) GenerateKube(ctx context.Context, nameOrIDs []string, options entities.GenerateKubeOptions) (*entities.GenerateKubeReport, error) {
 	var (
-		pod          *libpod.Pod
+		pods         []*libpod.Pod
 		podYAML      *k8sAPI.Pod
 		err          error
-		ctr          *libpod.Container
+		ctrs         []*libpod.Container
 		servicePorts []k8sAPI.ServicePort
 		serviceYAML  k8sAPI.Service
 	)
-	// Get the container in question.
-	ctr, err = ic.Libpod.LookupContainer(nameOrID)
-	if err != nil {
-		pod, err = ic.Libpod.LookupPod(nameOrID)
+	for _, nameOrID := range nameOrIDs {
+		// Get the container in question
+		ctr, err := ic.Libpod.LookupContainer(nameOrID)
 		if err != nil {
-			return nil, err
+			pod, err := ic.Libpod.LookupPod(nameOrID)
+			if err != nil {
+				return nil, err
+			}
+			pods = append(pods, pod)
+			if len(pods) > 1 {
+				return nil, errors.New("can only generate single pod at a time")
+			}
+		} else {
+			if len(ctr.Dependencies()) > 0 {
+				return nil, errors.Wrapf(define.ErrNotImplemented, "containers with dependencies")
+			}
+			// we cannot deal with ctrs already in a pod
+			if len(ctr.PodID()) > 0 {
+				return nil, errors.Errorf("container %s is associated with pod %s: use generate on the pod itself", ctr.ID(), ctr.PodID())
+			}
+			ctrs = append(ctrs, ctr)
 		}
-		podYAML, servicePorts, err = pod.GenerateForKube()
+	}
+
+	// check our inputs
+	if len(pods) > 0 && len(ctrs) > 0 {
+		return nil, errors.New("cannot generate pods and containers at the same time")
+	}
+
+	if len(pods) == 1 {
+		podYAML, servicePorts, err = pods[0].GenerateForKube()
 	} else {
-		if len(ctr.Dependencies()) > 0 {
-			return nil, errors.Wrapf(define.ErrNotImplemented, "containers with dependencies")
-		}
-		podYAML, err = ctr.GenerateForKube()
+		podYAML, err = libpod.GenerateForKube(ctrs)
 	}
 	if err != nil {
 		return nil, err
@@ -72,15 +92,15 @@ func (ic *ContainerEngine) GenerateKube(ctx context.Context, nameOrID string, op
 		serviceYAML = libpod.GenerateKubeServiceFromV1Pod(podYAML, servicePorts)
 	}
 
-	content, err := generateKubeOutput(podYAML, &serviceYAML)
+	content, err := generateKubeOutput(podYAML, &serviceYAML, options.Service)
 	if err != nil {
 		return nil, err
 	}
 
 	return &entities.GenerateKubeReport{Reader: bytes.NewReader(content)}, nil
 }
 
-func generateKubeOutput(podYAML *k8sAPI.Pod, serviceYAML *k8sAPI.Service) ([]byte, error) {
+func generateKubeOutput(podYAML *k8sAPI.Pod, serviceYAML *k8sAPI.Service, hasService bool) ([]byte, error) {
 	var (
 		output            []byte
 		marshalledPod     []byte
@@ -93,7 +113,7 @@ func generateKubeOutput(podYAML *k8sAPI.Pod, serviceYAML *k8sAPI.Service) ([]byt
 		return nil, err
 	}
 
-	if serviceYAML != nil {
+	if hasService {
 		marshalledService, err = yaml.Marshal(serviceYAML)
 		if err != nil {
 			return nil, err
@@ -114,7 +134,7 @@ func generateKubeOutput(podYAML *k8sAPI.Pod, serviceYAML *k8sAPI.Service) ([]byt
 
 	output = append(output, []byte(fmt.Sprintf(header, podmanVersion.Version))...)
 	output = append(output, marshalledPod...)
-	if serviceYAML != nil {
+	if hasService {
 		output = append(output, []byte("---\n")...)
 		output = append(output, marshalledService...)
 	}

pkg/domain/infra/tunnel/generate.go

@@ -11,6 +11,6 @@ func (ic *ContainerEngine) GenerateSystemd(ctx context.Context, nameOrID string,
 	return generate.Systemd(ic.ClientCxt, nameOrID, options)
 }
 
-func (ic *ContainerEngine) GenerateKube(ctx context.Context, nameOrID string, options entities.GenerateKubeOptions) (*entities.GenerateKubeReport, error) {
-	return generate.Kube(ic.ClientCxt, nameOrID, options)
+func (ic *ContainerEngine) GenerateKube(ctx context.Context, nameOrIDs []string, options entities.GenerateKubeOptions) (*entities.GenerateKubeReport, error) {
+	return generate.Kube(ic.ClientCxt, nameOrIDs, options)
 }

test/apiv2/25-containersMore.at

@@ -65,13 +65,13 @@ t GET libpod/containers/json?last=1 200 \
 
 cid=$(jq -r '.[0].Id' <<<"$output")
 
-t GET libpod/generate/$cid/kube 200
+t GET libpod/generate/kube?names=$cid 200
 like "$output" ".*apiVersion:.*" "Check generated kube yaml - apiVersion"
 like "$output" ".*kind:\\sPod.*" "Check generated kube yaml - kind: Pod"
 like "$output" ".*metadata:.*" "Check generated kube yaml - metadata"
 like "$output" ".*spec:.*" "Check generated kube yaml - spec"
 
-t GET libpod/generate/$cid/kube?service=true 200
+t GET "libpod/generate/kube?service=true&names=$cid" 200
 like "$output" ".*apiVersion:.*" "Check generated kube yaml(service=true) - apiVersion"
 like "$output" ".*kind:\\sPod.*" "Check generated kube yaml(service=true) - kind: Pod"
 like "$output" ".*metadata:.*" "Check generated kube yaml(service=true) - metadata"

test/e2e/generate_kube_test.go

@@ -469,4 +469,74 @@ var _ = Describe("Podman generate kube", func() {
 		Expect(inspect.ExitCode()).To(Equal(0))
 		Expect(inspect.OutputToString()).To(ContainSubstring(`"pid"`))
 	})
+
+	It("podman generate kube multiple pods should fail", func() {
+		pod1 := podmanTest.Podman([]string{"run", "-dt", "--pod", "new:pod1", ALPINE, "top"})
+		pod1.WaitWithDefaultTimeout()
+		Expect(pod1.ExitCode()).To(Equal(0))
+
+		pod2 := podmanTest.Podman([]string{"run", "-dt", "--pod", "new:pod2", ALPINE, "top"})
+		pod2.WaitWithDefaultTimeout()
+		Expect(pod2.ExitCode()).To(Equal(0))
+
+		kube := podmanTest.Podman([]string{"generate", "kube", "pod1", "pod2"})
+		kube.WaitWithDefaultTimeout()
+		Expect(kube.ExitCode()).ToNot(Equal(0))
+	})
+
+	It("podman generate kube with pods and containers should fail", func() {
+		pod1 := podmanTest.Podman([]string{"run", "-dt", "--pod", "new:pod1", ALPINE, "top"})
+		pod1.WaitWithDefaultTimeout()
+		Expect(pod1.ExitCode()).To(Equal(0))
+
+		pod2 := podmanTest.Podman([]string{"run", "-dt", "--name", "top", ALPINE, "top"})
+		pod2.WaitWithDefaultTimeout()
+		Expect(pod2.ExitCode()).To(Equal(0))
+
+		kube := podmanTest.Podman([]string{"generate", "kube", "pod1", "top"})
+		kube.WaitWithDefaultTimeout()
+		Expect(kube.ExitCode()).ToNot(Equal(0))
+	})
+
+	It("podman generate kube with containers in a pod should fail", func() {
+		pod1 := podmanTest.Podman([]string{"pod", "create", "--name", "pod1"})
+		pod1.WaitWithDefaultTimeout()
+		Expect(pod1.ExitCode()).To(Equal(0))
+
+		con := podmanTest.Podman([]string{"run", "-dt", "--pod", "pod1", "--name", "top", ALPINE, "top"})
+		con.WaitWithDefaultTimeout()
+		Expect(con.ExitCode()).To(Equal(0))
+
+		kube := podmanTest.Podman([]string{"generate", "kube", "top"})
+		kube.WaitWithDefaultTimeout()
+		Expect(kube.ExitCode()).ToNot(Equal(0))
+	})
+
+	It("podman generate kube with multiple containers", func() {
+		con1 := podmanTest.Podman([]string{"run", "-dt", "--name", "con1", ALPINE, "top"})
+		con1.WaitWithDefaultTimeout()
+		Expect(con1.ExitCode()).To(Equal(0))
+
+		con2 := podmanTest.Podman([]string{"run", "-dt", "--name", "con2", ALPINE, "top"})
+		con2.WaitWithDefaultTimeout()
+		Expect(con2.ExitCode()).To(Equal(0))
+
+		kube := podmanTest.Podman([]string{"generate", "kube", "con1", "con2"})
+		kube.WaitWithDefaultTimeout()
+		Expect(kube.ExitCode()).To(Equal(0))
+	})
+
+	It("podman generate kube with containers in a pod should fail", func() {
+		pod1 := podmanTest.Podman([]string{"run", "-dt", "--pod", "new:pod1", "--name", "top1", ALPINE, "top"})
+		pod1.WaitWithDefaultTimeout()
+		Expect(pod1.ExitCode()).To(Equal(0))
+
+		pod2 := podmanTest.Podman([]string{"run", "-dt", "--pod", "new:pod2", "--name", "top2", ALPINE, "top"})
+		pod2.WaitWithDefaultTimeout()
+		Expect(pod2.ExitCode()).To(Equal(0))
+
+		kube := podmanTest.Podman([]string{"generate", "kube", "pod1", "pod2"})
+		kube.WaitWithDefaultTimeout()
+		Expect(kube.ExitCode()).ToNot(Equal(0))
+	})
 })