devfile 0.0.6.pre.alpha1-x86_64-linux → 0.0.12.pre.alpha1-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb435b8f1497c4dbfbb5f8baa9cb61823eeae8d555a7a71a80d041dda1f4b537
-  data.tar.gz: ce594d2dc04ffaa2a0e63257c6251b5ca41be907bcecb1ffd804afe48f478fab
+  metadata.gz: 1cc3363280657ceecbb55931395fc354e8d13cb814c2a83b11dd679e0a67edd6
+  data.tar.gz: b8bdad6991ddc7a87cd72c49fc2d684f8fe055245ae8747136e08df8608a7bd0
 SHA512:
-  metadata.gz: 60c599546b8e91f593d9400a79c39f87f3e07c3660649d254d3f587078cafdd3daeab8bfac632900680834b32524b1ac735e5e26dcd0a44fbcbc75ffdc928339
-  data.tar.gz: 5f69f2979faf1a0900be36a467ec4c70636892b11b6107dae73f5ca7c603922d8f1e760013a0eeac7cfce842f8e0fe69a4fd5405b5616f074d85fa66a7197a48
+  metadata.gz: 928d238a1651d90afb2d1e81e8eafbfbbbb421487a51a21eba8b5262f6649619fcedcbc25ea1bcb4db2632e6e011491eb3abc41bd4736fc3540f2c14fe3b6ef6
+  data.tar.gz: 2dec36f8b4bd994a41cc3b20c2fb7099b54558dc1864dcd80b13594a036d84c55932d688dc595b38652c0479329e616ee92090f09a8fb0388877b638d1213a47

data/ext/devfile.go

@@ -1,15 +1,19 @@
 package main
 
-import "C"
 import (
 	"bytes"
+	"fmt"
+	"sort"
 	"strconv"
 	"text/template"
 
 	"github.com/devfile/library/v2/pkg/devfile/generator"
 	"github.com/devfile/library/v2/pkg/devfile/parser"
 	"github.com/devfile/library/v2/pkg/devfile/parser/data/v2/common"
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
 	networkingv1 "k8s.io/api/networking/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/cli-runtime/pkg/printers"
@@ -20,16 +24,14 @@ type Devfile struct {
 	devfileObj parser.DevfileObj
 }
 
-func (d Devfile) getDeployment(name, namespace string, labels, annotations map[string]string, replicas int) (runtime.Object, error) {
-	containers, err := generator.GetContainers(d.devfileObj, common.DevfileOptions{})
-	if err != nil {
-		return nil, err
-	}
-	initContainers, err := generator.GetInitContainers(d.devfileObj)
-	if err != nil {
-		return nil, err
-	}
-	volumes, err := d.getVolumesAndVolumeMounts(containers, initContainers, name)
+type volumeOptions struct {
+	Info        generator.VolumeInfo
+	Size        string
+	IsEphemeral bool
+}
+
+func (d Devfile) getDeployment(name, namespace string, labels, annotations map[string]string, replicas int) (*appsv1.Deployment, error) {
+	containers, initContainers, volumes, _, err := d.getContainersAndVolumes(name)
 	if err != nil {
 		return nil, err
 	}
@@ -52,7 +54,7 @@ func (d Devfile) getDeployment(name, namespace string, labels, annotations map[s
 	return deployment, err
 }
 
-func (d Devfile) getService(name, namespace string, labels, annotations map[string]string) (runtime.Object, error) {
+func (d Devfile) getService(name, namespace string, labels, annotations map[string]string) (*corev1.Service, error) {
 	service, err := generator.GetService(d.devfileObj, generator.ServiceParams{
 		TypeMeta:       generator.GetTypeMeta("Service", "v1"),
 		ObjectMeta:     generator.GetObjectMeta(name, namespace, labels, annotations),
@@ -65,7 +67,12 @@ func (d Devfile) getService(name, namespace string, labels, annotations map[stri
 	return service, err
 }
 
-func (d Devfile) getIngress(name, namespace string, labels, annotations map[string]string, domainTemplate, ingressClass string) (runtime.Object, error) {
+func (d Devfile) getIngress(name, namespace string, labels, annotations map[string]string, domainTemplate, ingressClass string) (*networkingv1.Ingress, error) {
+
+	if ingressClass == "none" {
+		return nil, nil
+	}
+
 	components, err := d.devfileObj.Data.GetDevfileContainerComponents(common.DevfileOptions{})
 	if err != nil {
 		return nil, err
@@ -75,7 +82,10 @@ func (d Devfile) getIngress(name, namespace string, labels, annotations map[stri
 	var rules []networkingv1.IngressRule
 
 	// Create a new template and parse the letter into it.
-	t := template.Must(template.New("domainTemplate").Parse(domainTemplate))
+	t, err := template.New("domainTemplate").Parse(domainTemplate)
+	if err != nil {
+		return nil, err
+	}
 
 	for _, component := range components {
 		for _, endpoint := range component.Container.Endpoints {
@@ -113,23 +123,16 @@ func (d Devfile) getIngress(name, namespace string, labels, annotations map[stri
 		return nil, nil
 	}
 
-	// since annotations is a map, it is passed by reference in go
-	// hence to modify it, create a new copy
-	ingressAnnotations := map[string]string{
-		"kubernetes.io/ingress.class": ingressClass,
-	}
-	for k, v := range annotations {
-		ingressAnnotations[k] = v
-	}
 	ingress := &networkingv1.Ingress{
 		TypeMeta: generator.GetTypeMeta("Ingress", "networking.k8s.io/v1"),
 		ObjectMeta: metav1.ObjectMeta{
 			Name:        name,
 			Namespace:   namespace,
 			Labels:      labels,
-			Annotations: ingressAnnotations,
+			Annotations: annotations,
 		},
 		Spec: networkingv1.IngressSpec{
+			IngressClassName: &ingressClass,
 			//TLS: []networkingv1.IngressTLS{
 			//	{
 			//		Hosts:      hosts,
@@ -143,21 +146,129 @@ func (d Devfile) getIngress(name, namespace string, labels, annotations map[stri
 	return ingress, nil
 }
 
+func (d Devfile) getPVC(name, namespace string, labels, annotations map[string]string) ([]*corev1.PersistentVolumeClaim, error) {
+	_, _, volumes, volumeNameToVolumeOptions, err := d.getContainersAndVolumes(name)
+	if err != nil {
+		return nil, err
+	}
+	pvcs := make([]*corev1.PersistentVolumeClaim, 0)
+	for _, volume := range volumes {
+		volumeOptions := volumeNameToVolumeOptions[volume.Name]
+		if volumeOptions.IsEphemeral {
+			continue
+		}
+		quantity, err := resource.ParseQuantity(volumeOptions.Size)
+		if err != nil {
+			return nil, err
+		}
+		pvcParams := generator.PVCParams{
+			TypeMeta: generator.GetTypeMeta("PersistentVolumeClaim", "v1"),
+			ObjectMeta: metav1.ObjectMeta{
+				Name:        volumeOptions.Info.PVCName,
+				Namespace:   namespace,
+				Labels:      labels,
+				Annotations: annotations,
+			},
+			Quantity: quantity,
+		}
+		pvc := generator.GetPVC(pvcParams)
+		pvcs = append(pvcs, pvc)
+	}
+	return pvcs, nil
+}
+
 func (d Devfile) getAll(name, namespace string, labels, annotations map[string]string, replicas int, domainTemplate, ingressClass string) ([]runtime.Object, error) {
+
+	var result []runtime.Object
+
 	deployment, err := d.getDeployment(name, namespace, labels, annotations, replicas)
 	if err != nil {
 		return nil, err
 	}
+	result = append(result, deployment)
+
 	service, err := d.getService(name, namespace, labels, annotations)
 	if err != nil {
 		return nil, err
 	}
+	result = append(result, service)
+
 	ingress, err := d.getIngress(name, namespace, labels, annotations, domainTemplate, ingressClass)
 	if err != nil {
 		return nil, err
 	}
+	if ingress != nil {
+		result = append(result, ingress)
+	}
+
+	pvcs, err := d.getPVC(name, namespace, labels, annotations)
+	if err != nil {
+		return nil, err
+	}
+	for _, pvc := range pvcs {
+		result = append(result, pvc)
+	}
+
+	return result, nil
+}
+
+func (d Devfile) getContainersAndVolumes(name string) ([]corev1.Container, []corev1.Container, []corev1.Volume, map[string]volumeOptions, error) {
+	containers, err := generator.GetContainers(d.devfileObj, common.DevfileOptions{})
+	if err != nil {
+		return nil, nil, nil, nil, err
+	}
+	initContainers, err := generator.GetInitContainers(d.devfileObj)
+	if err != nil {
+		return nil, nil, nil, nil, err
+	}
+	allContainers := append(containers, initContainers...)
 
-	return []runtime.Object{deployment, service, ingress}, nil
+	volumeComponents, err := d.devfileObj.Data.GetDevfileVolumeComponents(common.DevfileOptions{})
+	if err != nil {
+		return nil, nil, nil, nil, err
+	}
+	volumeNameToVolumeOptions := map[string]volumeOptions{}
+	volumeNameToVolumeInfo := map[string]generator.VolumeInfo{}
+	for _, volumeComponent := range volumeComponents {
+		info := generator.VolumeInfo{
+			PVCName:    fmt.Sprintf("%s-%s", name, volumeComponent.Name),
+			VolumeName: volumeComponent.Name,
+		}
+		volumeNameToVolumeInfo[volumeComponent.Name] = info
+		volumeNameToVolumeOptions[volumeComponent.Name] = volumeOptions{
+			Info:        info,
+			Size:        volumeComponent.Volume.Size,
+			IsEphemeral: *volumeComponent.Volume.Ephemeral,
+		}
+	}
+
+	volumeParams := generator.VolumeParams{
+		Containers:             allContainers,
+		VolumeNameToVolumeInfo: volumeNameToVolumeInfo,
+	}
+	options := common.DevfileOptions{}
+	// "containers" and "initContainers" are updated in place with the volume mounts parameters
+	// after the following function is called
+	volumes, err := generator.GetVolumesAndVolumeMounts(d.devfileObj, volumeParams, options)
+	if err != nil {
+		return nil, nil, nil, nil, err
+	}
+	// sort all volumes and volume mounts in the containers and initContainers
+	// to keep the array order deterministic
+	sort.SliceStable(volumes, func(i, j int) bool {
+		return volumes[i].Name < volumes[j].Name
+	})
+	for _, container := range containers {
+		sort.SliceStable(container.VolumeMounts, func(i, j int) bool {
+			return container.VolumeMounts[i].Name < container.VolumeMounts[j].Name
+		})
+	}
+	for _, initContainer := range initContainers {
+		sort.SliceStable(initContainer.VolumeMounts, func(i, j int) bool {
+			return initContainer.VolumeMounts[i].Name < initContainer.VolumeMounts[j].Name
+		})
+	}
+	return containers, initContainers, volumes, volumeNameToVolumeOptions, nil
 }
 
 func (d Devfile) hasContainerComponents() (bool, error) {

data/ext/go.mod

@@ -1,4 +1,4 @@
-module gitlab.com/gitlab-org/incubation-engineering/server-runtime/devfilerubyffi
+module gitlab-org/remote-development/devfile-gem
 
 go 1.18
 
@@ -7,6 +7,7 @@ require (
 	k8s.io/api v0.26.1
 	k8s.io/apimachinery v0.26.1
 	k8s.io/cli-runtime v0.26.1
+	sigs.k8s.io/yaml v1.3.0
 )
 
 require (
@@ -115,5 +116,4 @@ require (
 	sigs.k8s.io/controller-runtime v0.13.1 // indirect
 	sigs.k8s.io/json v0.0.0-20220713155537-f223a00ba0e2 // indirect
 	sigs.k8s.io/structured-merge-diff/v4 v4.2.3 // indirect
-	sigs.k8s.io/yaml v1.3.0 // indirect
 )

data/ext/main.go

@@ -9,11 +9,6 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 )
 
-type Result struct {
-	content string
-	err     error
-}
-
 func main() {
 	args := os.Args
 
@@ -25,27 +20,30 @@ func main() {
 	fnName := os.Args[1]
 	devfile := os.Args[2]
 
-	var result Result
+	var content string
+	var err error
 
 	switch fnName {
 	case "deployment":
-		result = getDeployment(devfile, args[3], args[4], args[5], args[6], args[7])
+		content, err = getDeployment(devfile, args[3], args[4], args[5], args[6], args[7])
 	case "service":
-		result = getService(devfile, args[3], args[4], args[5], args[6])
+		content, err = getService(devfile, args[3], args[4], args[5], args[6])
 	case "ingress":
-		result = getIngress(devfile, args[3], args[4], args[5], args[6], args[7], args[8])
+		content, err = getIngress(devfile, args[3], args[4], args[5], args[6], args[7], args[8])
+	case "pvc":
+		content, err = getPVC(devfile, args[3], args[4], args[5], args[6])
 	case "all":
-		result = getAll(devfile, args[3], args[4], args[5], args[6], args[7], args[8], args[9])
+		content, err = getAll(devfile, args[3], args[4], args[5], args[6], args[7], args[8], args[9])
 	case "flatten":
-		result = flatten(devfile)
+		content, err = flatten(devfile)
 	}
 
-	if result.err != nil {
-		fmt.Fprint(os.Stderr, result.err)
+	if err != nil {
+		fmt.Fprint(os.Stderr, err)
 		os.Exit(1)
 	}
 
-	fmt.Print(result.content)
+	fmt.Print(content)
 }
 
 func unmarshalKeyValuePair(data string) (map[string]string, error) {
@@ -57,147 +55,187 @@ func unmarshalKeyValuePair(data string) (map[string]string, error) {
 	return values, err
 }
 
-func getDeployment(devfile, name, namespace, labelsStr, annotationsStr, replicas string) Result {
+func getDeployment(devfile, name, namespace, labelsStr, annotationsStr, replicas string) (string, error) {
 	d, err := parseDevfile(devfile)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	exists, err := d.hasContainerComponents()
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
-	if exists == false {
-		return Result{"", err}
+	if !exists {
+		return "", nil
 	}
 	labels, err := unmarshalKeyValuePair(labelsStr)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	annotations, err := unmarshalKeyValuePair(annotationsStr)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	replicasInt, err := strconv.Atoi(replicas)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	deployment, err := d.getDeployment(name, namespace, labels, annotations, replicasInt)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	content, err := marshalResources([]runtime.Object{deployment})
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
-	return Result{content, nil}
+	return content, nil
 }
 
-func getService(devfile, name, namespace, labelsStr, annotationsStr string) Result {
+func getService(devfile, name, namespace, labelsStr, annotationsStr string) (string, error) {
 	d, err := parseDevfile(devfile)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	exists, err := d.hasContainerComponents()
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
-	if exists == false {
-		return Result{"", err}
+	if !exists {
+		return "", nil
 	}
 	labels, err := unmarshalKeyValuePair(labelsStr)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	annotations, err := unmarshalKeyValuePair(annotationsStr)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	service, err := d.getService(name, namespace, labels, annotations)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	content, err := marshalResources([]runtime.Object{service})
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
-	return Result{content, nil}
+	return content, nil
 }
 
-func getIngress(devfile, name, namespace, labelsStr, annotationsStr, domainTemplate, ingressClass string) Result {
+func getIngress(devfile, name, namespace, labelsStr, annotationsStr, domainTemplate, ingressClass string) (string, error) {
 	d, err := parseDevfile(devfile)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	exists, err := d.hasContainerComponents()
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
-	if exists == false {
-		return Result{"", err}
+	if !exists {
+		return "", nil
 	}
 	labels, err := unmarshalKeyValuePair(labelsStr)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	annotations, err := unmarshalKeyValuePair(annotationsStr)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	ingress, err := d.getIngress(name, namespace, labels, annotations, domainTemplate, ingressClass)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
+
+	if ingress == nil {
+		return "", nil
+	}
+
 	content, err := marshalResources([]runtime.Object{ingress})
 	if err != nil {
-		return Result{"", err}
+		return "", err
+	}
+	return content, nil
+}
+
+func getPVC(devfile, name, namespace, labelsStr, annotationsStr string) (string, error) {
+	d, err := parseDevfile(devfile)
+	if err != nil {
+		return "", err
+	}
+	exists, err := d.hasContainerComponents()
+	if err != nil {
+		return "", err
+	}
+	if !exists {
+		return "", nil
+	}
+	labels, err := unmarshalKeyValuePair(labelsStr)
+	if err != nil {
+		return "", err
+	}
+	annotations, err := unmarshalKeyValuePair(annotationsStr)
+	if err != nil {
+		return "", err
+	}
+	pvcs, err := d.getPVC(name, namespace, labels, annotations)
+	if err != nil {
+		return "", err
+	}
+	var result []runtime.Object
+	for _, pvc := range pvcs {
+		result = append(result, pvc)
+	}
+	content, err := marshalResources(result)
+	if err != nil {
+		return "", err
 	}
-	return Result{content, nil}
+	return content, nil
 }
 
-func getAll(devfile string, name, namespace, labelsStr, annotationsStr, replicas, domainTemplate, ingressClass string) Result {
+func getAll(devfile string, name, namespace, labelsStr, annotationsStr, replicas, domainTemplate, ingressClass string) (string, error) {
 	d, err := parseDevfile(devfile)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	exists, err := d.hasContainerComponents()
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
-	if exists == false {
-		return Result{"", err}
+	if !exists {
+		return "", nil
 	}
 	labels, err := unmarshalKeyValuePair(labelsStr)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	annotations, err := unmarshalKeyValuePair(annotationsStr)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	replicasInt, err := strconv.Atoi(replicas)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	resources, err := d.getAll(name, namespace, labels, annotations, replicasInt, domainTemplate, ingressClass)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	content, err := marshalResources(resources)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
-	return Result{content, nil}
+	return content, nil
 }
 
-func flatten(devfile string) Result {
+func flatten(devfile string) (string, error) {
 	d, err := parseDevfile(devfile)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
 	flattenedDevfile := d.getFlattenedDevfileContent()
 	content, err := marshalDevfile(flattenedDevfile)
 	if err != nil {
-		return Result{"", err}
+		return "", err
 	}
-	return Result{content, nil}
+	return content, err
 }

data/lib/devfile.rb

@@ -39,6 +39,16 @@ module Devfile
         stdout
       end
 
+      def get_pvc(devfile, name, namespace, labels, annotations)
+        stdout, stderr, status = Open3.capture3(
+          "#{FILE_PATH} deployment '#{devfile}' #{name} #{namespace} '#{labels}' '#{annotations}'"
+        )
+
+        raise stderr unless status.success?
+
+        stdout
+      end
+
       def get_all(devfile, name, namespace, labels, annotations, replicas, domain_template, ingress_class)
         stdout, stderr, status = Open3.capture3(
           "#{FILE_PATH} all '#{devfile}' #{name} #{namespace}  '#{labels}' '#{annotations}' #{replicas} #{domain_template} #{ingress_class}"

metadata

@@ -1,17 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: devfile
 version: !ruby/object:Gem::Version
-  version: 0.0.6.pre.alpha1
+  version: 0.0.12.pre.alpha1
 platform: x86_64-linux
 authors:
 - GitLab
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-09 00:00:00.000000000 Z
+date: 2023-04-26 00:00:00.000000000 Z
 dependencies: []
 description: Library used to generate kubernetes manifests from a Devfile.
-email: spatnaik@gitlab.com
+email:
+- cwoolley@gitlab.com
+- vtak@gitlab.com
+- spatnaik@gitlab.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -21,7 +24,6 @@ files:
 - ext/go.mod
 - ext/go.sum
 - ext/main.go
-- ext/volume.go
 - lib/devfile.rb
 homepage: https://gitlab.com
 licenses:

data/ext/volume.go

@@ -1,114 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"github.com/devfile/library/v2/pkg/devfile/generator"
-	"github.com/devfile/library/v2/pkg/devfile/parser/data/v2/common"
-	corev1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/api/resource"
-	"strings"
-)
-
-func (d Devfile) getVolumesAndVolumeMounts(containers []corev1.Container, initContainers []corev1.Container, pvcNamePrefix string) ([]corev1.Volume, error) {
-	containerComponents, err := d.devfileObj.Data.GetDevfileContainerComponents(common.DevfileOptions{})
-	if err != nil {
-		return nil, err
-	}
-	volumeComponents, err := d.devfileObj.Data.GetDevfileVolumeComponents(common.DevfileOptions{})
-	if err != nil {
-		return nil, err
-	}
-
-	var volumes []corev1.Volume
-	for _, volumeComponent := range volumeComponents {
-		volName := volumeComponent.Name
-		if bool(*volumeComponent.Volume.Ephemeral) == true {
-			emptyDir, err := getEmptyDir(volName, volumeComponent.Volume.Size)
-			if err != nil {
-				return nil, err
-			}
-			volumes = append(volumes, emptyDir)
-		} else {
-			// TODO: figure this out; how should we pass PVC name? should the object be generated here?
-			pvcName := fmt.Sprintf("%s-%s", pvcNamePrefix, volName)
-			volumes = append(volumes, getPVC(volName, pvcName))
-		}
-		// containerNameToMountPaths is a map of the Devfile container name to their Devfile Volume Mount Paths for a given Volume Name
-		containerNameToMountPaths := make(map[string][]string)
-		for _, containerComp := range containerComponents {
-			for _, volumeMount := range containerComp.Container.VolumeMounts {
-				if volName == volumeMount.Name {
-					containerNameToMountPaths[containerComp.Name] = append(containerNameToMountPaths[containerComp.Name], generator.GetVolumeMountPath(volumeMount))
-				}
-			}
-		}
-
-		addVolumeMountToContainers(containers, initContainers, volName, containerNameToMountPaths)
-	}
-
-	return volumes, nil
-}
-
-// addVolumeMountToContainers adds the Volume Mounts in containerNameToMountPaths to the containers for a given pvc and volumeName
-// containerNameToMountPaths is a map of a container name to an array of its Mount Paths.
-// To be moved to devfile/library.
-func addVolumeMountToContainers(containers []corev1.Container, initContainers []corev1.Container, volumeName string, containerNameToMountPaths map[string][]string) {
-
-	for containerName, mountPaths := range containerNameToMountPaths {
-		for i := range containers {
-			if containers[i].Name == containerName {
-				for _, mountPath := range mountPaths {
-					containers[i].VolumeMounts = append(containers[i].VolumeMounts, corev1.VolumeMount{
-						Name:      volumeName,
-						MountPath: mountPath,
-						SubPath:   "",
-					},
-					)
-				}
-			}
-		}
-		for i := range initContainers {
-			if strings.HasPrefix(initContainers[i].Name, containerName) {
-				for _, mountPath := range mountPaths {
-					initContainers[i].VolumeMounts = append(initContainers[i].VolumeMounts, corev1.VolumeMount{
-						Name:      volumeName,
-						MountPath: mountPath,
-						SubPath:   "",
-					},
-					)
-				}
-			}
-		}
-	}
-}
-
-// getPVC gets a pvc type volume with the given volume name and pvc name.
-func getPVC(volumeName, pvcName string) corev1.Volume {
-
-	return corev1.Volume{
-		Name: volumeName,
-		VolumeSource: corev1.VolumeSource{
-			PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{
-				ClaimName: pvcName,
-			},
-		},
-	}
-}
-
-// getEmptyDir gets an emptyDir type volume with the given volume name and size.
-// size should be parseable as a Kubernetes `Quantity` or an error will be returned
-func getEmptyDir(volumeName string, size string) (corev1.Volume, error) {
-
-	emptyDir := &corev1.EmptyDirVolumeSource{}
-	qty, err := resource.ParseQuantity(size)
-	if err != nil {
-		return corev1.Volume{}, err
-	}
-	emptyDir.SizeLimit = &qty
-	return corev1.Volume{
-		Name: volumeName,
-		VolumeSource: corev1.VolumeSource{
-			EmptyDir: emptyDir,
-		},
-	}, nil
-}