devfile 0.0.9.pre.alpha1-aarch64-linux → 0.0.28.pre.alpha1-aarch64-linux

data/ext/main.go

@@ -30,6 +30,8 @@ func main() {
 		content, err = getService(devfile, args[3], args[4], args[5], args[6])
 	case "ingress":
 		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":
 		content, err = getAll(devfile, args[3], args[4], args[5], args[6], args[7], args[8], args[9])
 	case "flatten":
@@ -62,8 +64,8 @@ func getDeployment(devfile, name, namespace, labelsStr, annotationsStr, replicas
 	if err != nil {
 		return "", err
 	}
-	if exists == false {
-		return "", err
+	if !exists {
+		return "", nil
 	}
 	labels, err := unmarshalKeyValuePair(labelsStr)
 	if err != nil {
@@ -97,8 +99,8 @@ func getService(devfile, name, namespace, labelsStr, annotationsStr string) (str
 	if err != nil {
 		return "", err
 	}
-	if exists == false {
-		return "", err
+	if !exists {
+		return "", nil
 	}
 	labels, err := unmarshalKeyValuePair(labelsStr)
 	if err != nil {
@@ -128,8 +130,8 @@ func getIngress(devfile, name, namespace, labelsStr, annotationsStr, domainTempl
 	if err != nil {
 		return "", err
 	}
-	if exists == false {
-		return "", err
+	if !exists {
+		return "", nil
 	}
 	labels, err := unmarshalKeyValuePair(labelsStr)
 	if err != nil {
@@ -155,7 +157,7 @@ func getIngress(devfile, name, namespace, labelsStr, annotationsStr, domainTempl
 	return content, nil
 }
 
-func getAll(devfile string, name, namespace, labelsStr, annotationsStr, replicas, domainTemplate, ingressClass string) (string, error) {
+func getPVC(devfile, name, namespace, labelsStr, annotationsStr string) (string, error) {
 	d, err := parseDevfile(devfile)
 	if err != nil {
 		return "", err
@@ -164,9 +166,44 @@ func getAll(devfile string, name, namespace, labelsStr, annotationsStr, replicas
 	if err != nil {
 		return "", err
 	}
-	if exists == false {
+	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 content, nil
+}
+
+func getAll(devfile string, name, namespace, labelsStr, annotationsStr, replicas, domainTemplate, ingressClass 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
@@ -195,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,79 +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, pvcNamePrefix string) ([]corev1.Volume, 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, err
+		return nil, nil, err
+	}
+
+	options.ComponentOptions = common.ComponentOptions{
+		ComponentType: devfileApiV1Alpha2.VolumeComponentType,
 	}
-	volumeComponents, err := d.devfileObj.Data.GetDevfileVolumeComponents(common.DevfileOptions{})
+	volumeComponent, err := devfileObj.Data.GetComponents(options)
 	if err != nil {
-		return nil, err
+		return nil, 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
+	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 {
-			// 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))
+			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, volName, 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, 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:   "",
 					},
 					)
 				}
@@ -82,33 +111,12 @@ func addVolumeMountToContainers(containers []corev1.Container, initContainers []
 	}
 }
 
-// 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,
-			},
-		},
+// 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
 }

data/lib/devfile.rb

@@ -4,58 +4,56 @@ require 'open3'
 
 # Module that works with the Devfile standard
 module Devfile
+  class CliError < StandardError; end
+
   # Set of services to parse a devfile and output k8s manifests
   class Parser
     FILE_PATH = File.expand_path('./../bin/devfile', File.dirname(__FILE__))
+    DEVFILE_GEMSPEC = Gem.loaded_specs['devfile']
+    SYSTEM_PLATFORM = "#{Gem::Platform.local.cpu}-#{Gem::Platform.local.os}"
 
     class << self
       def get_deployment(devfile, name, namespace, labels, annotations, replicas)
-        stdout, stderr, status = Open3.capture3(
-          "#{FILE_PATH} deployment '#{devfile}' #{name} #{namespace} '#{labels}' '#{annotations}' #{replicas}"
-        )
-
-        raise stderr unless status.success?
-
-        stdout
+        call('deployment', devfile, name, namespace, labels, annotations, replicas)
       end
 
       def get_service(devfile, name, namespace, labels, annotations)
-        stdout, stderr, status = Open3.capture3(
-          "#{FILE_PATH} service '#{devfile}' #{name} #{namespace} '#{labels}' '#{annotations}'"
-        )
-
-        raise stderr unless status.success?
-
-        stdout
+        call('service', devfile, name, namespace, labels, annotations)
       end
 
       def get_ingress(devfile, name, namespace, labels, annotations, domain_template, ingress_class)
-        stdout, stderr, status = Open3.capture3(
-          "#{FILE_PATH} ingress '#{devfile}' #{name} #{namespace} '#{labels}' '#{annotations}' #{domain_template} #{ingress_class}"
-        )
-
-        raise stderr unless status.success?
+        call('ingress', devfile, name, namespace, labels, annotations, domain_template, ingress_class)
+      end
 
-        stdout
+      def get_pvc(devfile, name, namespace, labels, annotations)
+        call('deployment', devfile, name, namespace, labels, annotations)
       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}"
-        )
-
-        raise stderr unless status.success?
-
-        stdout
+        call('all', devfile, name, namespace, labels, annotations, replicas, domain_template, ingress_class)
       end
 
       def flatten(devfile)
-        stdout, stderr, status = Open3.capture3("#{FILE_PATH} flatten '#{devfile}'")
+        call('flatten', devfile)
+      end
+
+      private
 
-        raise stderr unless status.success?
+      def call(*cmd)
+        warn_for_ruby_platform
+
+        stdout, stderr, status = Open3.capture3({}, FILE_PATH, *cmd.map(&:to_s))
+
+        raise(CliError, stderr) unless status.success?
 
         stdout
       end
+
+      def warn_for_ruby_platform
+        return unless DEVFILE_GEMSPEC && DEVFILE_GEMSPEC.platform == 'ruby' && SYSTEM_PLATFORM != 'arm64-darwin'
+
+        warn "devfile-gem only supports os: darwin and architecture: arm64 for 'ruby' platform"
+      end
     end
   end
 end

metadata

@@ -1,17 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: devfile
 version: !ruby/object:Gem::Version
-  version: 0.0.9.pre.alpha1
+  version: 0.0.28.pre.alpha1
 platform: aarch64-linux
 authors:
 - GitLab
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-18 00:00:00.000000000 Z
+date: 2024-09-12 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: []
@@ -27,8 +30,8 @@ homepage: https://gitlab.com
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://gitlab.com/gitlab-org/remote-development/devfile-gem
-post_install_message: 
+  source_code_uri: https://gitlab.com/gitlab-org/ruby/gems/devfile-gem
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -43,8 +46,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.2.33
-signing_key: 
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Parse and generate kubernetes manifests from a Devfile
 test_files: []