devfile 0.0.2.pre.alpha1 → 0.0.4.pre.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b5ccb630f8c382fdec4a27c4d68f09f10630fd51f517e2cde323cfc02bfef22
-  data.tar.gz: e4933a597caaeb4ea040b8045a623e4e359912dbb8da5fc229ae7c51d5af7e17
+  metadata.gz: 68fe0dafd8b89c774342888d1a56ee69357492ef1f7c800695c2cf0e160fc40d
+  data.tar.gz: ed969d122de436b5d6ad9dec8385e92623921f888ee7ab7b29d882c3abb5dc6b
 SHA512:
-  metadata.gz: d414b0f161daccc339bc8f95fa145c935aaa0b3b2ac950ce4f3046e517a58a8c9903fd5c7c3485b9aa8ce4a08055fd710892412609ece2e9300940d5b03b7f38
-  data.tar.gz: 458502ef4f3178ab10d54c982c438baa17b2848b3ab881e5508e74658cc1a9348dfc88e1220db5c3741d9e503745ee9a661909834fc06b0949e5718e07b1d5a0
+  metadata.gz: 914809b92174b11f397c3218ca2d7b12ffbad7abba4a6489864a90df0fcb13a72b9711c87dc538a560718db823ac8475fff3221bdd6137b5e477795d5c49b866
+  data.tar.gz: a462a444b95b7cbe6fd76fb375a58384dbac3870fee69487273d8c46b61941f8b3cbabad844e3f6d1ec3deb25f3738f0fdb468f95ca99177c05becc2bf0b0674

data/ext/devfile.go

@@ -4,37 +4,42 @@ import "C"
 import (
 	"bytes"
 	"fmt"
-
-	"github.com/devfile/library/pkg/devfile/generator"
-	"github.com/devfile/library/pkg/devfile/parser"
-	"github.com/devfile/library/pkg/devfile/parser/data/v2/common"
+	"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"
 	networkingv1 "k8s.io/api/networking/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/cli-runtime/pkg/printers"
-)
-
-const (
-	defaultIngressClass = "ingress-nginx"
+	"sigs.k8s.io/yaml"
 )
 
 type Devfile struct {
 	devfileObj parser.DevfileObj
 }
 
-func (d Devfile) getDeployment(name, namespace string) (runtime.Object, error) {
+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)
+	if err != nil {
+		return nil, err
+	}
 
 	deployParams := generator.DeploymentParams{
-		TypeMeta:   generator.GetTypeMeta("Deployment", "apps/v1"),
-		ObjectMeta: generator.GetObjectMeta(name, namespace, map[string]string{}, make(map[string]string)),
-		Containers: containers,
-		PodSelectorLabels: map[string]string{
-			"name": name,
-		},
+		TypeMeta:          generator.GetTypeMeta("Deployment", "apps/v1"),
+		ObjectMeta:        generator.GetObjectMeta(name, namespace, labels, annotations),
+		InitContainers:    initContainers,
+		Containers:        containers,
+		Volumes:           volumes,
+		PodSelectorLabels: labels,
+		Replicas:          pointerTo(int32(replicas)),
 	}
 
 	deployment, err := generator.GetDeployment(d.devfileObj, deployParams)
@@ -45,13 +50,11 @@ func (d Devfile) getDeployment(name, namespace string) (runtime.Object, error) {
 	return deployment, err
 }
 
-func (d Devfile) getService(name, namespace string) (runtime.Object, error) {
+func (d Devfile) getService(name, namespace string, labels, annotations map[string]string) (runtime.Object, error) {
 	service, err := generator.GetService(d.devfileObj, generator.ServiceParams{
-		TypeMeta:   generator.GetTypeMeta("Service", "v1"),
-		ObjectMeta: generator.GetObjectMeta(name, namespace, map[string]string{}, map[string]string{}),
-		SelectorLabels: map[string]string{
-			"name": name,
-		},
+		TypeMeta:       generator.GetTypeMeta("Service", "v1"),
+		ObjectMeta:     generator.GetObjectMeta(name, namespace, labels, annotations),
+		SelectorLabels: labels,
 	}, common.DevfileOptions{})
 	if err != nil {
 		return nil, err
@@ -60,7 +63,7 @@ func (d Devfile) getService(name, namespace string) (runtime.Object, error) {
 	return service, err
 }
 
-func (d Devfile) getIngress(name, namespace, domain string) (runtime.Object, error) {
+func (d Devfile) getIngress(name, namespace string, labels, annotations map[string]string, domainSuffix, ingressClass string) (runtime.Object, error) {
 	components, err := d.devfileObj.Data.GetDevfileContainerComponents(common.DevfileOptions{})
 	if err != nil {
 		return nil, err
@@ -71,7 +74,7 @@ func (d Devfile) getIngress(name, namespace, domain string) (runtime.Object, err
 
 	for _, component := range components {
 		for _, endpoint := range component.Container.Endpoints {
-			domain := fmt.Sprintf("%d-%v", endpoint.TargetPort, domain)
+			domain := fmt.Sprintf("%d-%s-%s.%s", endpoint.TargetPort, endpoint.Name, name, domainSuffix)
 			hosts = append(hosts, domain)
 			rules = append(rules, networkingv1.IngressRule{
 				Host: domain,
@@ -101,14 +104,21 @@ func (d Devfile) getIngress(name, namespace, domain string) (runtime.Object, err
 		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,
-			Annotations: map[string]string{
-				"kubernetes.io/ingress.class": defaultIngressClass,
-			},
+			Name:        name,
+			Namespace:   namespace,
+			Labels:      labels,
+			Annotations: ingressAnnotations,
 		},
 		Spec: networkingv1.IngressSpec{
 			//TLS: []networkingv1.IngressTLS{
@@ -124,16 +134,16 @@ func (d Devfile) getIngress(name, namespace, domain string) (runtime.Object, err
 	return ingress, nil
 }
 
-func (d Devfile) getAll(name, namespace, domain string) ([]runtime.Object, error) {
-	deployment, err := d.getDeployment(name, namespace)
+func (d Devfile) getAll(name, namespace string, labels, annotations map[string]string, replicas int, domainSuffix, ingressClass string) ([]runtime.Object, error) {
+	deployment, err := d.getDeployment(name, namespace, labels, annotations, replicas)
 	if err != nil {
 		return nil, err
 	}
-	service, err := d.getService(name, namespace)
+	service, err := d.getService(name, namespace, labels, annotations)
 	if err != nil {
 		return nil, err
 	}
-	ingress, err := d.getIngress(name, namespace, domain)
+	ingress, err := d.getIngress(name, namespace, labels, annotations, domainSuffix, ingressClass)
 	if err != nil {
 		return nil, err
 	}
@@ -156,16 +166,17 @@ func (d Devfile) getFlattenedDevfileContent() string {
 	return string(d.devfileObj.Ctx.GetDevfileContent())
 }
 
-func parseDevfile(content string) (parser.DevfileObj, error) {
+func parseDevfile(content string) (Devfile, error) {
 	parserArgs := parser.ParserArgs{
 		Data: []byte(content),
 	}
-
-	devfile, err := parser.ParseDevfile(parserArgs)
-	return devfile, err
+	devfileObj, err := parser.ParseDevfile(parserArgs)
+	return Devfile{
+		devfileObj: devfileObj,
+	}, err
 }
 
-func marshal(objs []runtime.Object) (string, error) {
+func marshalResources(objs []runtime.Object) (string, error) {
 	printer := printers.YAMLPrinter{}
 	dest := bytes.NewBuffer([]byte{})
 	for _, obj := range objs {
@@ -180,6 +191,14 @@ func marshal(objs []runtime.Object) (string, error) {
 	return dest.String(), nil
 }
 
+func marshalDevfile(devfile string) (string, error) {
+	data, err := yaml.JSONToYAML([]byte(devfile))
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
 // since it is not possible to get pointer of a constant directly
 func pointerTo[T any](v T) *T {
 	return &v

data/ext/go.mod

@@ -3,7 +3,9 @@ module gitlab.com/gitlab-org/incubation-engineering/server-runtime/devfilerubyff
 go 1.18
 
 require (
-	github.com/devfile/library v1.3.0
+	github.com/devfile/library/v2 v2.2.0
+	k8s.io/api v0.26.1
+	k8s.io/apimachinery v0.26.1
 	k8s.io/cli-runtime v0.26.1
 )
 
@@ -17,8 +19,8 @@ require (
 	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-20220527155645-8328a8a883be // indirect
-	github.com/devfile/registry-support/registry-library v0.0.0-20220627163229-4aa39fcb0c0a // 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
 	github.com/docker/distribution v2.7.1+incompatible // indirect
 	github.com/docker/docker v20.10.11+incompatible // indirect
@@ -103,9 +105,7 @@ require (
 	gopkg.in/warnings.v0 v0.1.2 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-	k8s.io/api v0.26.1 // indirect
 	k8s.io/apiextensions-apiserver v0.25.0 // indirect
-	k8s.io/apimachinery v0.26.1 // indirect
 	k8s.io/client-go v0.26.1 // indirect
 	k8s.io/klog v1.0.0 // indirect
 	k8s.io/klog/v2 v2.80.1 // indirect

data/ext/go.sum

@@ -292,13 +292,16 @@ github.com/devfile/api/v2 v2.2.0 h1:3Mwl/dtT508oU4pNt/v4G8vqvjoZqi9LOInXCNwKMoc=
 github.com/devfile/api/v2 v2.2.0/go.mod h1:dN7xFrOVG+iPqn4UKGibXLd5oVsdE8XyK9OEb5JL3aI=
 github.com/devfile/library v1.2.1-0.20211104222135-49d635cb492f/go.mod h1:uFZZdTuRqA68FVe/JoJHP92CgINyQkyWnM2Qyiim+50=
 github.com/devfile/library v1.2.1-0.20220308191614-f0f7e11b17de/go.mod h1:GSPfJaBg0+bBjBHbwBE5aerJLH6tWGQu2q2rHYd9czM=
-github.com/devfile/library v1.3.0 h1:bkPcX4RXR0Cr0aJXBvcc04SfEyKJ1gkgNNM1XTCA7Y8=
-github.com/devfile/library v1.3.0/go.mod h1:BbP/cww/WsTcQZ86d2Kd215ku7o7q6wkucP2WigVqmE=
+github.com/devfile/library/v2 v2.0.1/go.mod h1:paJ0PARAVy0br13VpBEQ4fO3rZVDxWtooQ29+23PNBk=
+github.com/devfile/library/v2 v2.2.0 h1:M12ui+ONi4oU0ynJwhWvPs7jaNX6KsUI5gBRyAVQQCs=
+github.com/devfile/library/v2 v2.2.0/go.mod h1:k0dGRv2oJtQkQaCcNSwku2OBM5Xu6fGl1Jsi2fsu/Ps=
 github.com/devfile/registry-support/index/generator v0.0.0-20220222194908-7a90a4214f3e/go.mod h1:iRPBxs+ZjfLEduVXpCCIOzdD2588Zv9OCs/CcXMcCCY=
-github.com/devfile/registry-support/index/generator v0.0.0-20220527155645-8328a8a883be h1:tCdIUbJ1eZV/jRa1gjs3dPZsbTjRibDqwRqIK4HCI9k=
 github.com/devfile/registry-support/index/generator v0.0.0-20220527155645-8328a8a883be/go.mod h1:1fyDJL+fPHtcrYA6yjSVWeLmXmjCNth0d5Rq1rvtryc=
-github.com/devfile/registry-support/registry-library v0.0.0-20220627163229-4aa39fcb0c0a h1:nBOmXUYleKlyYnzbbAgYEaYn4V3ZgXEQ3PN7NlZ8f2k=
+github.com/devfile/registry-support/index/generator v0.0.0-20221018203505-df96d34d4273 h1:DXENQSRTEDsk9com38njPg5511DD12HPIgzyFUErnpM=
+github.com/devfile/registry-support/index/generator v0.0.0-20221018203505-df96d34d4273/go.mod h1:ZJnaSLjTKCvGJhWmYgQoQ1O3g78qBe4Va6ZugLmi4dE=
 github.com/devfile/registry-support/registry-library v0.0.0-20220627163229-4aa39fcb0c0a/go.mod h1:kmEjH5oO465vh36kcYdZLYeG8edVD6N/ZgzyLs1x7qs=
+github.com/devfile/registry-support/registry-library v0.0.0-20221018213054-47b3ffaeadba h1:7Ag9guD3qOSzg3PcbSMqTVHDjqZojqb5JoIIonjRjDQ=
+github.com/devfile/registry-support/registry-library v0.0.0-20221018213054-47b3ffaeadba/go.mod h1:NOtmnbozFn15w/DPD/Urc+KDlNRP4JH5m+KC5GZoAWA=
 github.com/dgrijalva/jwt-go v0.0.0-20170104182250-a601269ab70c/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
@@ -711,6 +714,7 @@ github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRW
 github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw=
 github.com/ncw/swift v1.0.47/go.mod h1:23YIA4yWVnGwv2dQlN4bB7egfYX6YLn0Yo/S6zZO/ZM=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/nsf/jsondiff v0.0.0-20210926074059-1e845ec5d249/go.mod h1:mpRZBD8SJ55OIICQ3iWH0Yz3cjzA61JdqMLoWXeB2+8=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
 github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=

data/ext/main.go

@@ -1,113 +1,203 @@
 package main
 
-/*
-struct result {
-	char *resources;
-	char *flattenedDevfile;
-	char *err;
-};
-*/
-import "C"
-import "k8s.io/apimachinery/pkg/runtime"
+import (
+	"fmt"
+	"k8s.io/apimachinery/pkg/util/yaml"
+	"os"
+	"strconv"
 
-func main() {}
+	"k8s.io/apimachinery/pkg/runtime"
+)
 
-// START C Compatibility
+type Result struct {
+	content string
+	err     error
+}
 
-func NewResult(objs []runtime.Object, flattenedDevfile string, err error) C.struct_result {
-	if err != nil {
-		return C.struct_result{
-			err: C.CString(err.Error()),
-		}
+func main() {
+	args := os.Args
+
+	if len(args) <= 1 {
+		fmt.Fprint(os.Stderr, "Function name and devfile are required")
+		os.Exit(1)
 	}
 
-	resources, err := marshal(objs)
-	r := C.struct_result{
-		resources:        C.CString(resources),
-		flattenedDevfile: C.CString(flattenedDevfile),
-		err:              nil,
+	fnName := os.Args[1]
+	devfile := os.Args[2]
+
+	var result Result
+
+	switch fnName {
+	case "deployment":
+		result = 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])
+	case "ingress":
+		result = getIngress(devfile, args[3], args[4], args[5], args[6], args[7], args[8])
+	case "all":
+		result = getAll(devfile, args[3], args[4], args[5], args[6], args[7], args[8], args[9])
+	case "flatten":
+		result = flatten(devfile)
 	}
-	if err != nil {
-		r.err = C.CString(err.Error())
+
+	if result.err != nil {
+		fmt.Fprint(os.Stderr, result.err)
+		os.Exit(1)
 	}
 
-	return r
+	fmt.Print(result.content)
 }
 
-func InGo(devfile *C.char) (Devfile, error) {
-	rawContent := C.GoString(devfile)
-	devfileObj, err := parseDevfile(rawContent)
-	return Devfile{
-		devfileObj: devfileObj,
-	}, err
+func unmarshalKeyValuePair(data string) (map[string]string, error) {
+	values := map[string]string{}
+	err := yaml.Unmarshal([]byte(data), &values)
+	if err != nil {
+		return nil, err
+	}
+	return values, err
 }
 
-//export getDeployment
-func getDeployment(name *C.char, namespace *C.char, devfile *C.char) C.struct_result {
-	d, err := InGo(devfile)
+func getDeployment(devfile, name, namespace, labelsStr, annotationsStr, replicas string) Result {
+	d, err := parseDevfile(devfile)
 	if err != nil {
-		return NewResult(nil, "", err)
+		return Result{"", err}
 	}
 	exists, err := d.hasContainerComponents()
 	if err != nil {
-		return NewResult(nil, "", err)
+		return Result{"", err}
 	}
 	if exists == false {
-		return NewResult([]runtime.Object{nil}, "", err)
+		return Result{"", err}
+	}
+	labels, err := unmarshalKeyValuePair(labelsStr)
+	if err != nil {
+		return Result{"", err}
+	}
+	annotations, err := unmarshalKeyValuePair(annotationsStr)
+	if err != nil {
+		return Result{"", err}
 	}
-	deployment, err := d.getDeployment(C.GoString(name), C.GoString(namespace))
-	return NewResult([]runtime.Object{deployment}, d.getFlattenedDevfileContent(), err)
+	replicasInt, err := strconv.Atoi(replicas)
+	if err != nil {
+		return Result{"", err}
+	}
+	deployment, err := d.getDeployment(name, namespace, labels, annotations, replicasInt)
+	if err != nil {
+		return Result{"", err}
+	}
+	content, err := marshalResources([]runtime.Object{deployment})
+	if err != nil {
+		return Result{"", err}
+	}
+	return Result{content, nil}
 }
 
-//export getService
-func getService(name *C.char, namespace *C.char, devfile *C.char) C.struct_result {
-	d, err := InGo(devfile)
+func getService(devfile, name, namespace, labelsStr, annotationsStr string) Result {
+	d, err := parseDevfile(devfile)
 	if err != nil {
-		return NewResult(nil, "", err)
+		return Result{"", err}
 	}
 	exists, err := d.hasContainerComponents()
 	if err != nil {
-		return NewResult(nil, "", err)
+		return Result{"", err}
 	}
 	if exists == false {
-		return NewResult([]runtime.Object{nil}, "", err)
+		return Result{"", err}
+	}
+	labels, err := unmarshalKeyValuePair(labelsStr)
+	if err != nil {
+		return Result{"", err}
+	}
+	annotations, err := unmarshalKeyValuePair(annotationsStr)
+	if err != nil {
+		return Result{"", err}
+	}
+	service, err := d.getService(name, namespace, labels, annotations)
+	if err != nil {
+		return Result{"", err}
 	}
-	service, err := d.getService(C.GoString(name), C.GoString(namespace))
-	return NewResult([]runtime.Object{service}, d.getFlattenedDevfileContent(), err)
+	content, err := marshalResources([]runtime.Object{service})
+	if err != nil {
+		return Result{"", err}
+	}
+	return Result{content, nil}
 }
 
-//export getIngress
-func getIngress(name *C.char, namespace *C.char, devfile *C.char, domain *C.char) C.struct_result {
-	d, err := InGo(devfile)
+func getIngress(devfile, name, namespace, labelsStr, annotationsStr, domainSuffix, ingressClass string) Result {
+	d, err := parseDevfile(devfile)
 	if err != nil {
-		return NewResult(nil, "", err)
+		return Result{"", err}
 	}
 	exists, err := d.hasContainerComponents()
 	if err != nil {
-		return NewResult(nil, "", err)
+		return Result{"", err}
 	}
 	if exists == false {
-		return NewResult([]runtime.Object{nil}, "", err)
+		return Result{"", err}
+	}
+	labels, err := unmarshalKeyValuePair(labelsStr)
+	if err != nil {
+		return Result{"", err}
 	}
-	ingress, err := d.getIngress(C.GoString(name), C.GoString(namespace), C.GoString(domain))
-	return NewResult([]runtime.Object{ingress}, d.getFlattenedDevfileContent(), err)
+	annotations, err := unmarshalKeyValuePair(annotationsStr)
+	if err != nil {
+		return Result{"", err}
+	}
+	ingress, err := d.getIngress(name, namespace, labels, annotations, domainSuffix, ingressClass)
+	if err != nil {
+		return Result{"", err}
+	}
+	content, err := marshalResources([]runtime.Object{ingress})
+	if err != nil {
+		return Result{"", err}
+	}
+	return Result{content, nil}
 }
 
-//export getAll
-func getAll(name *C.char, namespace *C.char, devfile *C.char, domain *C.char) C.struct_result {
-	d, err := InGo(devfile)
+func getAll(devfile string, name, namespace, labelsStr, annotationsStr, replicas, domainSuffix, ingressClass string) Result {
+	d, err := parseDevfile(devfile)
 	if err != nil {
-		return NewResult(nil, "", err)
+		return Result{"", err}
 	}
 	exists, err := d.hasContainerComponents()
 	if err != nil {
-		return NewResult(nil, "", err)
+		return Result{"", err}
 	}
 	if exists == false {
-		return NewResult([]runtime.Object{nil}, "", err)
+		return Result{"", err}
 	}
-	resources, err := d.getAll(C.GoString(name), C.GoString(namespace), C.GoString(domain))
-	return NewResult(resources, d.getFlattenedDevfileContent(), err)
+	labels, err := unmarshalKeyValuePair(labelsStr)
+	if err != nil {
+		return Result{"", err}
+	}
+	annotations, err := unmarshalKeyValuePair(annotationsStr)
+	if err != nil {
+		return Result{"", err}
+	}
+	replicasInt, err := strconv.Atoi(replicas)
+	if err != nil {
+		return Result{"", err}
+	}
+	resources, err := d.getAll(name, namespace, labels, annotations, replicasInt, domainSuffix, ingressClass)
+	if err != nil {
+		return Result{"", err}
+	}
+	content, err := marshalResources(resources)
+	if err != nil {
+		return Result{"", err}
+	}
+	return Result{content, nil}
 }
 
-// END C Compatibility
+func flatten(devfile string) Result {
+	d, err := parseDevfile(devfile)
+	if err != nil {
+		return Result{"", err}
+	}
+	flattenedDevfile := d.getFlattenedDevfileContent()
+	content, err := marshalDevfile(flattenedDevfile)
+	if err != nil {
+		return Result{"", err}
+	}
+	return Result{content, nil}
+}

data/ext/volume.go

@@ -0,0 +1,114 @@
+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
+}

data/lib/devfile.rb

@@ -1,49 +1,55 @@
 # frozen_string_literal: true
 
-require 'ffi'
+require 'open3'
 
 # Module that works with the Devfile standard
 module Devfile
-  extend FFI::Library
+  # Set of services to parse a devfile and output k8s manifests
+  class Parser
+    FILE_PATH = File.expand_path('./../bin/devfile', File.dirname(__FILE__))
 
-  ffi_lib File.expand_path('./devfile.so', File.dirname(__FILE__))
+    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}")
 
-  # Result from go containing an error and the result
-  class Result < FFI::Struct
-    layout :resources, :string,
-           :flattenedDevfile, :string,
-           :err, :string
+        raise stderr unless status.success?
 
-    def process
-      raise self[:err] if self[:err]
+        stdout
+      end
 
-      [self[:resources], self[:flattenedDevfile]]
-    end
-  end
+      def get_service(devfile, name, namespace, labels, annotations)
+        stdout, stderr, status = Open3.capture3("#{FILE_PATH} service '#{devfile}' #{name} #{namespace} '#{labels}' '#{annotations}'")
 
-  # Set of services to parse a devfile and output k8s manifests
-  class Parser
-    class << self
-      def get_deployment(name, namespace, devfile)
-        Devfile.getDeployment(name, namespace, devfile).process
+        raise stderr unless status.success?
+
+        stdout
       end
 
-      def get_service(name, namespace, devfile)
-        Devfile.getService(name, namespace, devfile).process
+      def get_ingress(devfile, name, namespace, labels, annotations, domain_suffix, ingress_class)
+        stdout, stderr, status = Open3.capture3("#{FILE_PATH} ingress '#{devfile}' #{name} #{namespace} '#{labels}' '#{annotations}' #{domain_suffix} #{ingress_class}")
+
+        raise stderr unless status.success?
+
+        stdout
       end
 
-      def get_ingress(name, namespace, devfile, domain)
-        Devfile.getIngress(name, namespace, devfile, domain).process
+      def get_all(devfile, name, namespace, labels, annotations, replicas, domain_suffix, ingress_class)
+        stdout, stderr, status = Open3.capture3(
+          "#{FILE_PATH} all '#{devfile}' #{name} #{namespace}  '#{labels}' '#{annotations}' #{replicas} #{domain_suffix} #{ingress_class}"
+        )
+
+        raise stderr unless status.success?
+
+        stdout
       end
 
-      def get_all(name, namespace, devfile, domain)
-        Devfile.getAll(name, namespace, devfile, domain).process
+      def flatten(devfile)
+        stdout, stderr, status = Open3.capture3("#{FILE_PATH} flatten '#{devfile}'")
+
+        raise stderr unless status.success?
+
+        stdout
       end
     end
   end
-
-  attach_function 'getDeployment', %i[string string string], Result.by_value
-  attach_function 'getService', %i[string string string], Result.by_value
-  attach_function 'getIngress', %i[string string string string], Result.by_value
-  attach_function 'getAll', %i[string string string string], Result.by_value
 end

metadata

@@ -1,28 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: devfile
 version: !ruby/object:Gem::Version
-  version: 0.0.2.pre.alpha1
+  version: 0.0.4.pre.alpha1
 platform: ruby
 authors:
 - GitLab
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-20 00:00:00.000000000 Z
+date: 2023-03-08 00:00:00.000000000 Z
 dependencies: []
 description: Library used to generate kubernetes manifests from a Devfile.
 email: spatnaik@gitlab.com
 executables: []
-extensions:
-- "./ext/extconf.rb"
+extensions: []
 extra_rdoc_files: []
 files:
-- "./ext/extconf.rb"
+- bin/devfile
 - ext/devfile.go
-- ext/extconf.rb
 - ext/go.mod
 - ext/go.sum
 - ext/main.go
+- ext/volume.go
 - lib/devfile.rb
 homepage: https://gitlab.com
 licenses:

data/ext/extconf.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-makefile_contents = "all:\n\techo \"Starting...\"\n\ninstall:\n\tgo build -buildmode=c-shared -o ../lib/devfile.so\n\n"
-
-File.write('Makefile', makefile_contents)