devfile 0.0.14.pre.alpha1-x86_64-linux → 0.0.16.pre.alpha1-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 383ba06875e6f3c5ffa91aff57a88957b18486ac4bc08e18503a7e23e2386c0c
-  data.tar.gz: 80a6afb162202a4717312ef2b561c21e906a2753db9e6d530762129e83814306
+  metadata.gz: ff38ff84a177544e4bd30d98b0f75d6a655daccf0f7b44942160f29ca4d8d143
+  data.tar.gz: 7a460f3565984f03c050919155ab79fcdc13bc8e0ca998af30506cfb2050761e
 SHA512:
-  metadata.gz: 6d2f882ed4c62d2ed9f22a72e1d5d75cd6832fa847c4aad0059ff9a593fc7b8ac76df9f5f8c0fcb833053e5fc0fb53c9bbf111b706955f7a43cdc0dd186aa2b0
-  data.tar.gz: 523d788b7ce4dd99681a14bddd3789d1f854d27fc8ae7fb4cbe0a03ce01adacbae534e096431d73d19112530defc52c7b09983430821683dfaa83edfcbdc52ed
+  metadata.gz: 943bfb70fa0edc820d4749403208291532a9d11a0252e9a912397cb1879c939f39edd24731390ce55f0e166b1f8bf4cd6219c46eba527d292f8530eee711a7d1
+  data.tar.gz: 748ba009bc1185ecb4c811d518006dc58028743a87cae79dddb04cac9c30101f65f5b9d850be0c25684f3dc06823d040fdba2ad4ea06c0b4e09755995c5f3a15

data/ext/devfile.go

@@ -2,6 +2,8 @@ package main
 
 import (
 	"bytes"
+	"fmt"
+	"sort"
 	"strconv"
 	"text/template"
 
@@ -22,21 +24,14 @@ type Devfile struct {
 	devfileObj parser.DevfileObj
 }
 
-type pvcOptions struct {
-	Name string
-	Size string
+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, 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)
+	containers, initContainers, volumes, _, err := d.getContainersAndVolumes(name)
 	if err != nil {
 		return nil, err
 	}
@@ -152,29 +147,24 @@ func (d Devfile) getIngress(name, namespace string, labels, annotations map[stri
 }
 
 func (d Devfile) getPVC(name, namespace string, labels, annotations map[string]string) ([]*corev1.PersistentVolumeClaim, error) {
-	containers, err := generator.GetContainers(d.devfileObj, common.DevfileOptions{})
+	_, _, volumes, volumeNameToVolumeOptions, err := d.getContainersAndVolumes(name)
 	if err != nil {
 		return nil, err
 	}
-	initContainers, err := generator.GetInitContainers(d.devfileObj)
-	if err != nil {
-		return nil, err
-	}
-	_, pvcNameToPvcOptions, err := d.getVolumesAndVolumeMounts(containers, initContainers, name)
-	if err != nil {
-		return nil, err
-	}
-
 	pvcs := make([]*corev1.PersistentVolumeClaim, 0)
-	for _, options := range pvcNameToPvcOptions {
-		quantity, err := resource.ParseQuantity(options.Size)
+	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:        options.Name,
+				Name:        volumeOptions.Info.PVCName,
 				Namespace:   namespace,
 				Labels:      labels,
 				Annotations: annotations,
@@ -222,6 +212,75 @@ func (d Devfile) getAll(name, namespace string, labels, annotations map[string]s
 	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...)
+
+	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)
+	updatedAllContainers, volumes, err := 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
+	})
+
+	updatedContainers := make([]corev1.Container, 0)
+	updatedInitContainers := make([]corev1.Container, 0)
+	for _, updated := range updatedAllContainers {
+		sort.SliceStable(updated.VolumeMounts, func(i, j int) bool {
+			return updated.VolumeMounts[i].Name < updated.VolumeMounts[j].Name
+		})
+		for _, container := range containers {
+			if updated.Name == container.Name {
+				updatedContainers = append(updatedContainers, updated)
+			}
+		}
+		for _, initContainer := range initContainers {
+			if updated.Name == initContainer.Name {
+				updatedInitContainers = append(updatedInitContainers, updated)
+			}
+		}
+	}
+
+	return updatedContainers, updatedInitContainers, volumes, volumeNameToVolumeOptions, nil
+}
+
 func (d Devfile) hasContainerComponents() (bool, error) {
 	containers, err := generator.GetContainers(d.devfileObj, common.DevfileOptions{})
 	if err != nil {
@@ -233,8 +292,12 @@ func (d Devfile) hasContainerComponents() (bool, error) {
 	return false, nil
 }
 
-func (d Devfile) getFlattenedDevfileContent() string {
-	return string(d.devfileObj.Ctx.GetDevfileContent())
+func (d Devfile) getFlattenedDevfileContent() (string, error) {
+	b, err := yaml.Marshal(d.devfileObj.Data)
+	if err != nil {
+		return "", err
+	}
+	return string(b), nil
 }
 
 func parseDevfile(content string) (Devfile, error) {

data/ext/go.mod

@@ -1,8 +1,9 @@
 module gitlab-org/remote-development/devfile-gem
 
-go 1.18
+go 1.19
 
 require (
+	github.com/devfile/api/v2 v2.2.0
 	github.com/devfile/library/v2 v2.2.0
 	k8s.io/api v0.26.1
 	k8s.io/apimachinery v0.26.1
@@ -19,7 +20,6 @@ require (
 	github.com/cespare/xxhash/v2 v2.1.2 // indirect
 	github.com/containerd/containerd v1.5.9 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/devfile/api/v2 v2.2.0 // indirect
 	github.com/devfile/registry-support/index/generator v0.0.0-20221018203505-df96d34d4273 // indirect
 	github.com/devfile/registry-support/registry-library v0.0.0-20221018213054-47b3ffaeadba // indirect
 	github.com/docker/cli v20.10.11+incompatible // indirect

data/ext/main.go

@@ -232,7 +232,10 @@ func flatten(devfile string) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	flattenedDevfile := d.getFlattenedDevfileContent()
+	flattenedDevfile, err := d.getFlattenedDevfileContent()
+	if err != nil {
+		return "", err
+	}
 	content, err := marshalDevfile(flattenedDevfile)
 	if err != nil {
 		return "", err

data/ext/volume.go

@@ -1,83 +1,108 @@
 package main
 
 import (
-	"fmt"
+	devfileApiV1Alpha2 "github.com/devfile/api/v2/pkg/apis/workspaces/v1alpha2"
 	"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"
 	corev1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/api/resource"
 	"strings"
 )
 
-func (d Devfile) getVolumesAndVolumeMounts(containers []corev1.Container, initContainers []corev1.Container, volumeNamePrefix string) ([]corev1.Volume, map[string]pvcOptions, error) {
-	containerComponents, err := d.devfileObj.Data.GetDevfileContainerComponents(common.DevfileOptions{})
+// There's a bug in the devfile library
+// When a container component which has events and commands attached to it, becomes a init container, the name is
+// init container is a concatenation of component name, event/command.
+// However, when generating containerNameToMountPaths, we are using the component name
+// And in addVolumeMountToContainers, we are comparing the container name with a component name
+// For init containers this will not match
+// Temporary fix is to use a string prefix check in addVolumeMountToContainers and return the updatedAllContainers from
+// getVolumesAndVolumeMounts
+// TODO: This might not be a perfect fix because maybe a string prefix match can have undesirable effects.
+// issue: https://gitlab.com/gitlab-org/gitlab/-/issues/408950
+
+// getVolumesAndVolumeMounts gets the PVC volumes and updates the containers with the volume mounts.
+func getVolumesAndVolumeMounts(devfileObj parser.DevfileObj, volumeParams generator.VolumeParams, options common.DevfileOptions) ([]corev1.Container, []corev1.Volume, error) {
+	options.ComponentOptions = common.ComponentOptions{
+		ComponentType: devfileApiV1Alpha2.ContainerComponentType,
+	}
+	containerComponents, err := devfileObj.Data.GetComponents(options)
 	if err != nil {
 		return nil, nil, err
 	}
-	volumeComponents, err := d.devfileObj.Data.GetDevfileVolumeComponents(common.DevfileOptions{})
+
+	options.ComponentOptions = common.ComponentOptions{
+		ComponentType: devfileApiV1Alpha2.VolumeComponentType,
+	}
+	volumeComponent, err := devfileObj.Data.GetComponents(options)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	var volumes []corev1.Volume
-	pvcNameToPvcOptions := map[string]pvcOptions{}
-	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, nil, err
+	var pvcVols []corev1.Volume
+	for volName, volInfo := range volumeParams.VolumeNameToVolumeInfo {
+		emptyDirVolume := false
+		for _, volumeComp := range volumeComponent {
+			if volumeComp.Name == volName && *volumeComp.Volume.Ephemeral {
+				emptyDirVolume = true
+				break
 			}
-			volumes = append(volumes, emptyDir)
+		}
+
+		// if `ephemeral=true`, a volume with emptyDir should be created
+		if emptyDirVolume {
+			pvcVols = append(pvcVols, getEmptyDirSource(volInfo.VolumeName))
 		} else {
-			pvcName := fmt.Sprintf("%s-%s", volumeNamePrefix, volumeComponent.Name)
-			pvcNameToPvcOptions[volumeComponent.Name] = pvcOptions{
-				Name: pvcName,
-				Size: volumeComponent.Volume.Size,
-			}
-			volumes = append(volumes, getPersistentVolumeClaim(volName, pvcName))
+			pvcVols = append(pvcVols, getPVCSource(volInfo.VolumeName, volInfo.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))
+					containerNameToMountPaths[containerComp.Name] = append(containerNameToMountPaths[containerComp.Name], getVolumeMountPath(volumeMount))
 				}
 			}
 		}
 
-		addVolumeMountToContainers(containers, initContainers, volumeComponent.Name, containerNameToMountPaths)
+		addVolumeMountToContainers(volumeParams.Containers, volInfo.VolumeName, containerNameToMountPaths)
 	}
+	return volumeParams.Containers, pvcVols, nil
+}
+
+// getPVCSource gets a pvc type volume with the given volume name and pvc name.
+func getPVCSource(volumeName, pvcName string) corev1.Volume {
 
-	return volumes, pvcNameToPvcOptions, nil
+	return corev1.Volume{
+		Name: volumeName,
+		VolumeSource: corev1.VolumeSource{
+			PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{
+				ClaimName: pvcName,
+			},
+		},
+	}
 }
 
-// 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) {
+// getEmptyDirSource gets a volume with emptyDir
+func getEmptyDirSource(volumeName string) corev1.Volume {
+	return corev1.Volume{
+		Name: volumeName,
+		VolumeSource: corev1.VolumeSource{
+			EmptyDir: &corev1.EmptyDirVolumeSource{},
+		},
+	}
+}
 
+// addVolumeMountToContainers adds the Volume Mounts in containerNameToMountPaths to the containers for a given volumeName.
+// containerNameToMountPaths is a map of a container name to an array of its Mount Paths.
+func addVolumeMountToContainers(containers []corev1.Container, volumeName string, containerNameToMountPaths map[string][]string) {
 	for containerName, mountPaths := range containerNameToMountPaths {
 		for i := range containers {
-			if containers[i].Name == containerName {
+			if strings.HasPrefix(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:   "",
 					},
 					)
 				}
@@ -86,33 +111,12 @@ func addVolumeMountToContainers(containers []corev1.Container, initContainers []
 	}
 }
 
-// getPersistentVolumeClaim gets a pvc type volume with the given volume name and pvc name.
-func getPersistentVolumeClaim(volumeName, pvcName string) corev1.Volume {
-
-	return corev1.Volume{
-		Name: volumeName,
-		VolumeSource: corev1.VolumeSource{
-			PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{
-				ClaimName: pvcName,
-			},
-		},
+// getVolumeMountPath gets the volume mount's path.
+func getVolumeMountPath(volumeMount devfileApiV1Alpha2.VolumeMount) string {
+	// if there is no volume mount path, default to volume mount name as per devfile schema
+	if volumeMount.Path == "" {
+		volumeMount.Path = "/" + volumeMount.Name
 	}
-}
-
-// 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
+	return volumeMount.Path
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: devfile
 version: !ruby/object:Gem::Version
-  version: 0.0.14.pre.alpha1
+  version: 0.0.16.pre.alpha1
 platform: x86_64-linux
 authors:
 - GitLab
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-26 00:00:00.000000000 Z
+date: 2023-05-05 00:00:00.000000000 Z
 dependencies: []
 description: Library used to generate kubernetes manifests from a Devfile.
 email: