feat:support env and appenv instruction (#2179)

Author: kakaZhou719

build/kubefile/command/command.go

@@ -34,6 +34,9 @@ const (
 	Label      = "label"
 	Maintainer = "maintainer"
 
+	Env    = "env"
+	AppEnv = "appenv"
+
 	// Deprecated
 	Cmd = "cmd"
 
@@ -73,4 +76,6 @@ var SupportedCommands = map[string]struct{}{
 	CNI:         {},
 	CSI:         {},
 	KUBEVERSION: {},
+	Env:         {},
+	AppEnv:      {},
 }

build/kubefile/parser/kubefile.go

@@ -26,13 +26,13 @@ import (
 	parse2 "github.com/containers/buildah/pkg/parse"
 	"github.com/moby/buildkit/frontend/dockerfile/shell"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-
 	"github.com/sealerio/sealer/build/kubefile/command"
+	v1 "github.com/sealerio/sealer/pkg/define/application/v1"
 	"github.com/sealerio/sealer/pkg/define/application/version"
 	v12 "github.com/sealerio/sealer/pkg/define/image/v1"
 	"github.com/sealerio/sealer/pkg/define/options"
 	"github.com/sealerio/sealer/pkg/imageengine"
+	"github.com/sirupsen/logrus"
 )
 
 // LegacyContext stores legacy information during the process of parsing.
@@ -58,6 +58,17 @@ type KubefileResult struct {
 	// LAUNCH ["myapp1","myapp2"]
 	LaunchedAppNames []string
 
+	// GlobalEnv is a set of key value pair.
+	// set to sealer image some default parameters which is in global level.
+	// user could overwrite it through v2.ClusterSpec at run stage.
+	GlobalEnv map[string]string
+
+	// AppEnv is a set of key value pair.
+	// it is app level, only this app will be aware of its existence,
+	// it is used to render app files, or as an environment variable for app startup and deletion commands
+	// it takes precedence over GlobalEnv.
+	AppEnvMap map[string]map[string]string
+
 	// Applications structured APP instruction and register it to this map
 	// APP myapp local://app.yaml
 	Applications map[string]version.VersionedApplication
@@ -93,6 +104,8 @@ func (kp *KubefileParser) generateResult(mainNode *Node) (*KubefileResult, error
 		result = &KubefileResult{
 			Applications:       map[string]version.VersionedApplication{},
 			ApplicationConfigs: map[string]*v12.ApplicationConfig{},
+			GlobalEnv:          map[string]string{},
+			AppEnvMap:          map[string]map[string]string{},
 			legacyContext: LegacyContext{
 				files:       []string{},
 				directories: []string{},
@@ -179,6 +192,18 @@ func (kp *KubefileParser) generateResult(mainNode *Node) (*KubefileResult, error
 		}
 	}
 
+	// register app with all env list.
+	for appName, appEnv := range result.AppEnvMap {
+		app := result.Applications[appName]
+		result.Applications[appName] = &v1.Application{
+			NameVar:    app.Name(),
+			TypeVar:    app.Type(),
+			FilesVar:   app.Files(),
+			VersionVar: app.Version(),
+			AppEnv:     appEnv,
+		}
+	}
+
 	return result, nil
 }
 
@@ -188,6 +213,12 @@ func (kp *KubefileParser) processOnCmd(result *KubefileResult, node *Node) error
 	case command.Label, command.Maintainer, command.Add, command.Arg, command.From, command.Run:
 		result.Dockerfile = mergeLines(result.Dockerfile, node.Original)
 		return nil
+	case command.Env:
+		// update global env to dockerfile at the same,	for using it at build stage.
+		result.Dockerfile = mergeLines(result.Dockerfile, node.Original)
+		return kp.processGlobalEnv(node, result)
+	case command.AppEnv:
+		return kp.processAppEnv(node, result)
 	case command.App:
 		_, err := kp.processApp(node, result)
 		return err
@@ -304,6 +335,75 @@ func (kp *KubefileParser) processAppCmds(node *Node, result *KubefileResult) err
 	return nil
 }
 
+func (kp *KubefileParser) processAppEnv(node *Node, result *KubefileResult) error {
+	var (
+		appName = ""
+		envList []string
+	)
+
+	// first node value is the command
+	for ptr := node.Next; ptr != nil; ptr = ptr.Next {
+		val := ptr.Value
+		// record the first word to be the app name
+		if appName == "" {
+			appName = val
+			continue
+		}
+		envList = append(envList, val)
+	}
+
+	if appName == "" {
+		return errors.New("app name should be specified in the APPENV instruction")
+	}
+
+	if _, ok := result.Applications[appName]; !ok {
+		return fmt.Errorf("the specified app name(%s) for `APPENV` should be exist", appName)
+	}
+
+	tmpEnv := make(map[string]string)
+	for _, elem := range envList {
+		var kv []string
+		if kv = strings.SplitN(elem, "=", 2); len(kv) != 2 {
+			continue
+		}
+		tmpEnv[kv[0]] = kv[1]
+	}
+
+	appEnv := result.AppEnvMap[appName]
+	if appEnv == nil {
+		appEnv = make(map[string]string)
+	}
+
+	for k, v := range tmpEnv {
+		appEnv[k] = v
+	}
+
+	result.AppEnvMap[appName] = appEnv
+	return nil
+}
+
+func (kp *KubefileParser) processGlobalEnv(node *Node, result *KubefileResult) error {
+	valueList := strings.SplitN(node.Original, "ENV ", 2)
+	if len(valueList) != 2 {
+		return fmt.Errorf("line %d: invalid ENV instruction: %s", node.StartLine, node.Original)
+	}
+	envs := valueList[1]
+
+	for _, elem := range strings.Split(envs, " ") {
+		if elem == "" {
+			continue
+		}
+
+		var kv []string
+		if kv = strings.SplitN(elem, "=", 2); len(kv) != 2 {
+			continue
+		}
+		result.GlobalEnv[kv[0]] = kv[1]
+	}
+
+	return nil
+}
+
 func (kp *KubefileParser) processCmd(node *Node, result *KubefileResult) error {
 	original := node.Original
 	cmd := strings.Split(original, "CMD ")

build/kubefile/parser/parse.go

@@ -214,6 +214,8 @@ func init() {
 		command.Run:         parseMaybeJSON,
 		command.App:         parseMaybeJSONToList,
 		command.AppCmds:     parseMaybeJSONToList,
+		command.Env:         parseNameOrNameVal,
+		command.AppEnv:      parseMaybeJSONToList,
 		command.KUBEVERSION: parseString,
 		command.CNI:         parseMaybeJSONToList,
 		command.CSI:         parseMaybeJSONToList,

build/kubefile/parser/parse_test.go

@@ -214,6 +214,54 @@ FROM scratch
 	assert.Equal(t, expectedResult.RawCmds, result.RawCmds)
 }
 
+func TestParserEnv(t *testing.T) {
+	appFilePath := "./test/kube-nginx-deployment/deployment.yaml"
+	imageEngine := testImageEngine{}
+	opts := options.BuildOptions{
+		PullPolicy: "missing",
+	}
+
+	buildCxt, err := setupTempContext()
+	assert.Equal(t, nil, err)
+	defer func() {
+		_ = os.RemoveAll(buildCxt)
+	}()
+
+	opts.ContextDir = buildCxt
+	testParser = NewParser(testAppRootPath, opts, imageEngine, platformParse.DefaultPlatform())
+
+	var (
+		text = fmt.Sprintf(`
+FROM scratch 
+APP app1 local://%s
+ENV globalKey=globalValue
+APPENV app1 key1=value1 key2=value2
+APPENV app1 key1=value3 key2=value3
+LAUNCH ["app1"]`, appFilePath)
+	)
+
+	reader := bytes.NewReader([]byte(text))
+	result, err := testParser.ParseKubefile(reader)
+	if err != nil {
+		t.Fatalf("failed to parse kubefile: %s", err)
+	}
+	defer func() {
+		_ = result.CleanLegacyContext()
+	}()
+
+	expectedResult := &KubefileResult{
+		GlobalEnv: map[string]string{
+			"globalKey": "globalValue",
+		},
+		AppEnvMap: map[string]map[string]string{
+			"app1": {"key1": "value3", "key2": "value3"},
+		},
+	}
+
+	assert.Equal(t, expectedResult.GlobalEnv, result.GlobalEnv)
+	assert.Equal(t, expectedResult.AppEnvMap, result.AppEnvMap)
+}
+
 func setupTempContext() (string, error) {
 	tmpDir, err := os.MkdirTemp("/tmp/", "sealer-test")
 	if err != nil {

cmd/sealer/cmd/image/build.go

@@ -430,6 +430,7 @@ func buildImageExtensionOnResult(result *parser.KubefileResult, imageType string
 		Applications:  []version2.VersionedApplication{},
 		Launch:        v12.Launch{},
 		SchemaVersion: v12.ImageSpecSchemaVersionV1Beta1,
+		Env:           result.GlobalEnv,
 		BuildClient: v12.BuildClient{
 			SealerVersion:  version.Get().GitVersion,
 			BuildahVersion: define.Version,

pkg/define/application/v1/application.go

@@ -28,6 +28,11 @@ type Application struct {
 	TypeVar    string   `json:"type,omitempty"`
 	FilesVar   []string `json:"files,omitempty"`
 	VersionVar string   `json:"version,omitempty"`
+
+	// AppEnv is a set of key value pair.
+	// it is app level, only this app will be aware of its existence,
+	// it is used to render app files, or as an environment variable for app startup and deletion commands
+	AppEnv map[string]string `json:"env,omitempty"`
 }
 
 func (app *Application) Version() string {
@@ -42,6 +47,10 @@ func (app *Application) Type() string {
 	return app.TypeVar
 }
 
+func (app *Application) Files() []string {
+	return app.FilesVar
+}
+
 func (app *Application) LaunchCmd(appRoot string, launchCmds []string) string {
 	if len(launchCmds) != 0 {
 		var cmds []string

pkg/define/application/version/version.go

@@ -22,5 +22,7 @@ type VersionedApplication interface {
 
 	Type() string
 
+	Files() []string
+
 	LaunchCmd(appRoot string, launchCmds []string) string
 }

pkg/define/image/v1/sealer_image.go

@@ -17,7 +17,7 @@ package v1
 import (
 	"encoding/json"
 
-	application_v1 "github.com/sealerio/sealer/pkg/define/application/v1"
+	applicationV1 "github.com/sealerio/sealer/pkg/define/application/v1"
 	"github.com/sealerio/sealer/pkg/define/application/version"
 	apiv1 "github.com/sealerio/sealer/types/api/v1"
 
@@ -99,6 +99,11 @@ type ImageExtension struct {
 	// Labels are metadata to the sealer image
 	Labels map[string]string `json:"labels,omitempty" yaml:"labels,omitempty"`
 
+	// Env is a set of key value pair.
+	// set to sealer image some default parameters which is in global level.
+	// user could overwrite it through v2.ClusterSpec at run stage.
+	Env map[string]string `json:"env,omitempty"`
+
 	// launch spec will declare
 	Launch Launch `json:"launch,omitempty"`
 }
@@ -139,9 +144,11 @@ type v1ImageExtension struct {
 	// Labels are metadata to the sealer image
 	Labels map[string]string `json:"labels,omitempty" yaml:"labels,omitempty"`
 	// applications in the sealer image
-	Applications []application_v1.Application `json:"applications,omitempty"`
+	Applications []applicationV1.Application `json:"applications,omitempty"`
 	// launch spec will declare
 	Launch Launch `json:"launch,omitempty"`
+	// Env global env
+	Env map[string]string `json:"env,omitempty"`
 }
 
 func (ie *ImageExtension) UnmarshalJSON(data []byte) error {
@@ -154,6 +161,7 @@ func (ie *ImageExtension) UnmarshalJSON(data []byte) error {
 	(*ie).BuildClient = v1Ex.BuildClient
 	(*ie).SchemaVersion = v1Ex.SchemaVersion
 	(*ie).Labels = v1Ex.Labels
+	(*ie).Env = v1Ex.Env
 	(*ie).Type = v1Ex.Type
 	(*ie).Applications = make([]version.VersionedApplication, len(v1Ex.Applications))
 	for i, app := range v1Ex.Applications {