Add Support for Devfile V2

pkg/devfile/parser/context/apiVersion.go

@@ -19,19 +19,34 @@ func (d *DevfileCtx) SetDevfileAPIVersion() error {
 		return errors.Wrapf(err, "failed to decode devfile json")
 	}
 
-	// Get "apiVersion" value from the map
-	apiVersion, ok := r["apiVersion"]
-	if !ok {
-		return fmt.Errorf("apiVersion not present in devfile")
-	}
+	var apiVer string
+
+	// Get "apiVersion" value from map for devfile V1
+	apiVersion, okApi := r["apiVersion"]
+
+	// Get "schemaVersion" value from map for devfile V2
+	schemaVersion, okSchema := r["schemaVersion"]
+
+	if okApi {
+		apiVer = apiVersion.(string)
+		// apiVersion cannot be empty
+		if apiVer == "" {
+			return fmt.Errorf("apiVersion in devfile cannot be empty")
+		}
+
+	} else if okSchema {
+		apiVer = schemaVersion.(string)
+		// SchemaVersion cannot be empty
+		if schemaVersion.(string) == "" {
+			return fmt.Errorf("schemaVersion in devfile cannot be empty")
+		}
+	} else {
+		return fmt.Errorf("apiVersion or schemaVersion not present in devfile")
 
-	// apiVersion cannot be empty
-	if apiVersion.(string) == "" {
-		return fmt.Errorf("apiVersion in devfile cannot be empty")
 	}
 
 	// Successful
-	d.apiVersion = apiVersion.(string)
+	d.apiVersion = apiVer
 	klog.V(4).Infof("devfile apiVersion: '%s'", d.apiVersion)
 	return nil
 }

pkg/devfile/parser/context/apiVersion_test.go

@@ -32,7 +32,7 @@ func TestSetDevfileAPIVersion(t *testing.T) {
 			name:    "apiVersion not present",
 			rawJson: []byte(emptyJson),
 			want:    "",
-			wantErr: fmt.Errorf("apiVersion not present in devfile"),
+			wantErr: fmt.Errorf("apiVersion or schemaVersion not present in devfile"),
 		},
 		{
 			name:    "apiVersion empty",

pkg/devfile/parser/data/1.0.0/components.go

@@ -1,21 +1,37 @@
 package version100
 
 import (
-	"strings"
-
 	"github.com/openshift/odo/pkg/devfile/parser/data/common"
 )
 
-// GetComponents returns the slice of DevfileComponent objects parsed from the Devfile
+func (d *Devfile100) GetMetadata() common.DevfileMetadata {
+	// No GenerateName field in V2
+	return common.DevfileMetadata{
+		Name: *d.Metadata.Name,
+		//Version: No field in V1
+	}
+}
+
+/// GetComponents returns the slice of DevfileComponent objects parsed from the Devfile
 func (d *Devfile100) GetComponents() []common.DevfileComponent {
-	return d.Components
+	var comps []common.DevfileComponent
+	for _, v := range d.Components {
+		comps = append(comps, convertV1ComponentToCommon(v))
+	}
+	return comps
 }
 
 // GetAliasedComponents returns the slice of DevfileComponent objects that each have an alias
 func (d *Devfile100) GetAliasedComponents() []common.DevfileComponent {
+	// TODO(adi): we might not need this for V2 as name is a required field now.
+	var comps []common.DevfileComponent
+	for _, v := range d.Components {
+		comps = append(comps, convertV1ComponentToCommon(v))
+	}
+
 	var aliasedComponents = []common.DevfileComponent{}
-	for _, comp := range d.Components {
-		if comp.Alias != nil {
+	for _, comp := range comps {
+		if comp.Container.Name != "" {
 			aliasedComponents = append(aliasedComponents, comp)
 		}
 	}
@@ -24,17 +40,157 @@ func (d *Devfile100) GetAliasedComponents() []common.DevfileComponent {
 
 // GetProjects returns the slice of DevfileProject objects parsed from the Devfile
 func (d *Devfile100) GetProjects() []common.DevfileProject {
-	return d.Projects
+
+	var projects []common.DevfileProject
+	for _, v := range d.Projects {
+		// We are only supporting ProjectType git in V1
+		if v.Source.Type == ProjectTypeGit {
+			projects = append(projects, convertV1ProjectToCommon(v))
+		}
+	}
+
+	return projects
 }
 
 // GetCommands returns the slice of DevfileCommand objects parsed from the Devfile
 func (d *Devfile100) GetCommands() []common.DevfileCommand {
+
 	var commands []common.DevfileCommand
+	for _, v := range d.Commands {
+		cmd := convertV1CommandToCommon(v)
 
-	for _, command := range d.Commands {
-		command.Name = strings.ToLower(command.Name)
-		commands = append(commands, command)
+		commands = append(commands, cmd)
 	}
 
 	return commands
 }
+
+func (d *Devfile100) GetParent() common.DevfileParent {
+	return common.DevfileParent{}
+
+}
+
+func (d *Devfile100) GetEvents() common.DevfileEvents {
+	return common.DevfileEvents{}
+
+}
+
+func convertV1CommandToCommon(c Command) (d common.DevfileCommand) {
+	var exec common.Exec
+
+	for _, action := range c.Actions {
+
+		if *action.Type == DevfileCommandTypeExec {
+			exec = common.Exec{
+				Attributes:  c.Attributes,
+				CommandLine: *action.Command,
+				Component:   *action.Component,
+				Group:       getGroup(c.Name),
+				Id:          c.Name,
+				WorkingDir:  action.Workdir,
+				// Env:
+				// Label:
+			}
+		}
+
+	}
+
+	// TODO: Previewurl
+	return common.DevfileCommand{
+		//TODO(adi): Type
+		Exec: &exec,
+	}
+}
+
+func convertV1ComponentToCommon(c Component) (d common.DevfileComponent) {
+
+	var endpoints []*common.Endpoint
+	for _, v := range c.ComponentDockerimage.Endpoints {
+		endpoints = append(endpoints, convertV1EndpointsToCommon(v))
+	}
+
+	var envs []*common.Env
+	for _, v := range c.ComponentDockerimage.Env {
+		envs = append(envs, convertV1EnvToCommon(v))
+	}
+
+	var volumes []*common.VolumeMount
+	for _, v := range c.ComponentDockerimage.Volumes {
+		volumes = append(volumes, convertV1VolumeToCommon(v))
+	}
+
+	container := common.Container{
+		Name:         *c.Alias,
+		Endpoints:    endpoints,
+		Env:          envs,
+		Image:        *c.ComponentDockerimage.Image,
+		MemoryLimit:  *c.ComponentDockerimage.MemoryLimit,
+		MountSources: c.MountSources,
+		VolumeMounts: volumes,
+		// SourceMapping: Not present in V1
+	}
+
+	d = common.DevfileComponent{Container: &container}
+
+	return d
+}
+
+func convertV1EndpointsToCommon(e DockerimageEndpoint) *common.Endpoint {
+	return &common.Endpoint{
+		// Attributes:
+		// Configuration:
+		Name:       *e.Name,
+		TargetPort: *e.Port,
+	}
+}
+
+func convertV1EnvToCommon(e DockerimageEnv) *common.Env {
+	return &common.Env{
+		Name:  *e.Name,
+		Value: *e.Value,
+	}
+}
+
+func convertV1VolumeToCommon(v DockerimageVolume) *common.VolumeMount {
+	return &common.VolumeMount{
+		Name: *v.Name,
+		Path: *v.ContainerPath,
+	}
+}
+
+func convertV1ProjectToCommon(p Project) common.DevfileProject {
+
+	git := common.Git{
+		Branch:            *p.Source.Branch,
+		Location:          p.Source.Location,
+		SparseCheckoutDir: *p.Source.SparseCheckoutDir,
+		StartPoint:        *p.Source.StartPoint,
+	}
+
+	return common.DevfileProject{
+		ClonePath: p.ClonePath,
+		Name:      p.Name,
+		Git:       &git,
+	}
+
+}
+
+func getGroup(name string) *common.Group {
+	var kind common.DevfileCommandGroupType
+
+	switch name {
+	case "devRun":
+		kind = common.RunCommandGroupType
+	case "devBuild":
+		kind = common.BuildCommandGroupType
+	case "devInit":
+		kind = common.InitCommandGroupType
+	default:
+		kind = ""
+	}
+
+	return &common.Group{
+		// TODO(adi): IsDefault:
+		Kind: kind,
+	}
+}