1 files changed, 116 insertions, 56 deletions

diff --git a/pkg/domain/infra/abi/generate.go b/pkg/domain/infra/abi/generate.go
index 94f649e15..b0853b554 100644
--- a/pkg/domain/infra/abi/generate.go
+++ b/pkg/domain/infra/abi/generate.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"strings"
 
 	"github.com/containers/podman/v3/libpod"
 	"github.com/containers/podman/v3/libpod/define"
@@ -43,120 +44,174 @@ func (ic *ContainerEngine) GenerateSystemd(ctx context.Context, nameOrID string,
 
 func (ic *ContainerEngine) GenerateKube(ctx context.Context, nameOrIDs []string, options entities.GenerateKubeOptions) (*entities.GenerateKubeReport, error) {
 	var (
-		pods         []*libpod.Pod
-		ctrs         []*libpod.Container
-		kubePods     []*k8sAPI.Pod
-		kubeServices []k8sAPI.Service
-		content      []byte
+		pods       []*libpod.Pod
+		ctrs       []*libpod.Container
+		vols       []*libpod.Volume
+		podContent [][]byte
+		content    [][]byte
 	)
+
+	// Lookup for podman objects.
 	for _, nameOrID := range nameOrIDs {
-		// Get the container in question
+		// Let's assume it's a container, so get the container.
 		ctr, err := ic.Libpod.LookupContainer(nameOrID)
 		if err != nil {
-			pod, err := ic.Libpod.LookupPod(nameOrID)
-			if err != nil {
+			if !strings.Contains(err.Error(), "no such container") {
 				return nil, err
 			}
-			pods = append(pods, pod)
 		} else {
 			if len(ctr.Dependencies()) > 0 {
 				return nil, errors.Wrapf(define.ErrNotImplemented, "containers with dependencies")
 			}
-			// we cannot deal with ctrs already in a pod
+			// 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)
+			continue
+		}
+
+		// Maybe it's a pod.
+		pod, err := ic.Libpod.LookupPod(nameOrID)
+		if err != nil {
+			if !strings.Contains(err.Error(), "no such pod") {
+				return nil, err
+			}
+		} else {
+			pods = append(pods, pod)
+			continue
+		}
+
+		// Or volume.
+		vol, err := ic.Libpod.LookupVolume(nameOrID)
+		if err != nil {
+			if !strings.Contains(err.Error(), "no such volume") {
+				return nil, err
+			}
+		} else {
+			vols = append(vols, vol)
+			continue
 		}
+
+		// If it reaches here is because the name or id did not exist.
+		return nil, errors.Errorf("Name or ID %q not found", nameOrID)
 	}
 
-	// check our inputs
-	if len(pods) > 0 && len(ctrs) > 0 {
-		return nil, errors.New("cannot generate pods and containers at the same time")
+	// Generate kube persistent volume claims from volumes.
+	if len(vols) >= 1 {
+		pvs, err := getKubePVCs(vols)
+		if err != nil {
+			return nil, err
+		}
+
+		content = append(content, pvs...)
 	}
 
+	// Generate kube pods and services from pods.
 	if len(pods) >= 1 {
 		pos, svcs, err := getKubePods(pods, options.Service)
 		if err != nil {
 			return nil, err
 		}
 
-		kubePods = append(kubePods, pos...)
+		podContent = append(podContent, pos...)
 		if options.Service {
-			kubeServices = append(kubeServices, svcs...)
+			content = append(content, svcs...)
 		}
-	} else {
+	}
+
+	// Generate the kube pods from containers.
+	if len(ctrs) >= 1 {
 		po, err := libpod.GenerateForKube(ctrs)
 		if err != nil {
 			return nil, err
 		}
 
-		kubePods = append(kubePods, po)
+		b, err := generateKubeYAML(po)
+		if err != nil {
+			return nil, err
+		}
+
+		podContent = append(podContent, b)
 		if options.Service {
-			kubeServices = append(kubeServices, libpod.GenerateKubeServiceFromV1Pod(po, []k8sAPI.ServicePort{}))
+			b, err := generateKubeYAML(libpod.GenerateKubeServiceFromV1Pod(po, []k8sAPI.ServicePort{}))
+			if err != nil {
+				return nil, err
+			}
+			content = append(content, b)
 		}
 	}
 
-	content, err := generateKubeOutput(kubePods, kubeServices, options.Service)
+	// Content order is based on helm install order (secret, persistentVolumeClaim, service, pod).
+	content = append(content, podContent...)
+
+	// Generate kube YAML file from all kube kinds.
+	k, err := generateKubeOutput(content)
 	if err != nil {
 		return nil, err
 	}
 
-	return &entities.GenerateKubeReport{Reader: bytes.NewReader(content)}, nil
+	return &entities.GenerateKubeReport{Reader: bytes.NewReader(k)}, nil
 }
 
-func getKubePods(pods []*libpod.Pod, getService bool) ([]*k8sAPI.Pod, []k8sAPI.Service, error) {
-	kubePods := make([]*k8sAPI.Pod, 0)
-	kubeServices := make([]k8sAPI.Service, 0)
+// getKubePods returns kube pod and service YAML files from podman pods.
+func getKubePods(pods []*libpod.Pod, getService bool) ([][]byte, [][]byte, error) {
+	pos := [][]byte{}
+	svcs := [][]byte{}
 
 	for _, p := range pods {
-		po, svc, err := p.GenerateForKube()
+		po, sp, err := p.GenerateForKube()
+		if err != nil {
+			return nil, nil, err
+		}
+
+		b, err := generateKubeYAML(po)
 		if err != nil {
 			return nil, nil, err
 		}
+		pos = append(pos, b)
 
-		kubePods = append(kubePods, po)
 		if getService {
-			kubeServices = append(kubeServices, libpod.GenerateKubeServiceFromV1Pod(po, svc))
+			b, err := generateKubeYAML(libpod.GenerateKubeServiceFromV1Pod(po, sp))
+			if err != nil {
+				return nil, nil, err
+			}
+			svcs = append(svcs, b)
 		}
 	}
 
-	return kubePods, kubeServices, nil
+	return pos, svcs, nil
 }
 
-func generateKubeOutput(kubePods []*k8sAPI.Pod, kubeServices []k8sAPI.Service, hasService bool) ([]byte, error) {
-	output := make([]byte, 0)
-	marshalledPods := make([]byte, 0)
-	marshalledServices := make([]byte, 0)
+// getKubePVCs returns kube persistent volume claim YAML files from podman volumes.
+func getKubePVCs(volumes []*libpod.Volume) ([][]byte, error) {
+	pvs := [][]byte{}
 
-	for i, p := range kubePods {
-		if i != 0 {
-			marshalledPods = append(marshalledPods, []byte("---\n")...)
-		}
-
-		b, err := yaml.Marshal(p)
+	for _, v := range volumes {
+		b, err := generateKubeYAML(v.GenerateForKube())
 		if err != nil {
 			return nil, err
 		}
-
-		marshalledPods = append(marshalledPods, b...)
+		pvs = append(pvs, b)
 	}
 
-	if hasService {
-		for i, s := range kubeServices {
-			if i != 0 {
-				marshalledServices = append(marshalledServices, []byte("---\n")...)
-			}
-
-			b, err := yaml.Marshal(s)
-			if err != nil {
-				return nil, err
-			}
+	return pvs, nil
+}
 
-			marshalledServices = append(marshalledServices, b...)
-		}
+// generateKubeYAML marshalls a kube kind into a YAML file.
+func generateKubeYAML(kubeKind interface{}) ([]byte, error) {
+	b, err := yaml.Marshal(kubeKind)
+	if err != nil {
+		return nil, err
 	}
 
+	return b, nil
+}
+
+// generateKubeOutput generates kube YAML file containing multiple kube kinds.
+func generateKubeOutput(content [][]byte) ([]byte, error) {
+	output := make([]byte, 0)
+
 	header := `# Generation of Kubernetes YAML is still under development!
 #
 # Save the output of this file and use kubectl create -f to import
@@ -169,13 +224,18 @@ func generateKubeOutput(kubePods []*k8sAPI.Pod, kubeServices []k8sAPI.Service, h
 		return nil, err
 	}
 
+	// Add header to kube YAML file.
 	output = append(output, []byte(fmt.Sprintf(header, podmanVersion.Version))...)
-	// kube generate order is based on helm install order (service, pod...)
-	if hasService {
-		output = append(output, marshalledServices...)
-		output = append(output, []byte("---\n")...)
+
+	// kube generate order is based on helm install order (secret, persistentVolume, service, pod...).
+	// Add kube kinds.
+	for i, b := range content {
+		if i != 0 {
+			output = append(output, []byte("---\n")...)
+		}
+
+		output = append(output, b...)
 	}
-	output = append(output, marshalledPods...)
 
 	return output, nil
 }