fix #3162: decouple gp env from theia

Author: akosyakov

components/gitpod-cli/BUILD.yaml

@@ -8,5 +8,9 @@ packages:
     env:
       - CGO_ENABLED=0
       - GOOS=linux
+    deps:
+      - components/common-go:lib
+      - components/supervisor-api/go:lib
+      - components/gitpod-protocol/go:lib
     config:
       packaging: app

components/gitpod-cli/cmd/env.go

@@ -5,13 +5,21 @@
 package cmd
 
 import (
+	"context"
+	"errors"
 	"fmt"
 	"os"
 	"strings"
+	"sync"
+	"time"
 
 	"github.com/spf13/cobra"
+	"golang.org/x/xerrors"
+	"google.golang.org/grpc"
 
 	"github.com/gitpod-io/gitpod/gitpod-cli/pkg/theialib"
+	serverapi "github.com/gitpod-io/gitpod/gitpod-protocol"
+	supervisor "github.com/gitpod-io/gitpod/supervisor/api"
 )
 
 var exportEnvs = false
@@ -42,82 +50,243 @@ delete environment variables with a repository pattern of */foo, foo/* or */*.
 `,
 	Args: cobra.ArbitraryArgs,
 	Run: func(cmd *cobra.Command, args []string) {
-		fail := func(msg string) {
-			fmt.Fprintln(os.Stderr, msg)
-			os.Exit(-1)
+		if len(args) > 0 {
+			if unsetEnvs {
+				deleteEnvs(args)
+				return
+			}
+
+			setEnvs(args)
+		} else {
+			getEnvs()
 		}
+	},
+}
 
-		service, err := theialib.NewServiceFromEnv()
+type connectToServerResult struct {
+	repositoryPattern string
+	client            *serverapi.APIoverJSONRPC
+}
+
+func connectToServer(ctx context.Context) (*connectToServerResult, error) {
+	supervisorAddr := os.Getenv("SUPERVISOR_ADDR")
+	if supervisorAddr == "" {
+		supervisorAddr = "localhost:22999"
+	}
+	supervisorConn, err := grpc.Dial(supervisorAddr, grpc.WithInsecure())
+	if err != nil {
+		return nil, xerrors.Errorf("failed connecting to supervisor: %w", err)
+	}
+	wsinfo, err := supervisor.NewInfoServiceClient(supervisorConn).WorkspaceInfo(ctx, &supervisor.WorkspaceInfoRequest{})
+	if err != nil {
+		return nil, xerrors.Errorf("failed getting workspace info from supervisor: %w", err)
+	}
+	if wsinfo.Repository == nil {
+		return nil, xerrors.New("workspace info is missing repository")
+	}
+	if wsinfo.Repository.Owner == "" {
+		return nil, xerrors.New("repository info is missing owner")
+	}
+	if wsinfo.Repository.Name == "" {
+		return nil, xerrors.New("repository info is missing name")
+	}
+	repositoryPattern := wsinfo.Repository.Owner + "/" + wsinfo.Repository.Name
+	clientToken, err := supervisor.NewTokenServiceClient(supervisorConn).GetToken(ctx, &supervisor.GetTokenRequest{
+		Host: wsinfo.GitpodApi.Host,
+		Kind: "gitpod",
+		Scope: []string{
+			"function:getEnvVars",
+			"function:setEnvVar",
+			"function:deleteEnvVar",
+			"resource:envVar::" + repositoryPattern + "::create/get/update/delete",
+		},
+	})
+	if err != nil {
+		return nil, xerrors.Errorf("failed getting token from supervisor: %w", err)
+	}
+	client, err := serverapi.ConnectToServer(wsinfo.GitpodApi.Endpoint, serverapi.ConnectToServerOpts{Token: clientToken.Token, Context: ctx})
+	if err != nil {
+		return nil, xerrors.Errorf("failed connecting to server: %w", err)
+	}
+	return &connectToServerResult{repositoryPattern, client}, nil
+}
+
+func getEnvs() {
+	if !isTheiaIDE() {
+		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
+		defer cancel()
+		result, err := connectToServer(ctx)
 		if err != nil {
 			fail(err.Error())
 		}
 
-		setEnvs := func() {
-			vars := make([]theialib.EnvironmentVariable, len(args))
-			for i, arg := range args {
-				kv := strings.Split(arg, "=")
-				if len(kv) != 2 {
-					fail(fmt.Sprintf("%s has no value (correct format is %s=some_value)", arg, arg))
-				}
+		vars, err := result.client.GetEnvVars(ctx)
+		if err != nil {
+			fail("failed to fetch env vars from server: " + err.Error())
+		}
 
-				key := strings.TrimSpace(kv[0])
-				if key == "" {
-					fail(fmt.Sprintf("variable must have a name"))
-				}
-				// Do not trim value - the user might want whitespace here
-				// Also do not check if the value is empty, as an empty value means we want to delete the variable
-				val := kv[1]
-				if val == "" {
-					fail(fmt.Sprintf("variable must have a value; use -u to unset a variable"))
-				}
+		for _, v := range vars {
+			printVar(v, exportEnvs)
+		}
+		return
+	}
 
-				vars[i] = theialib.EnvironmentVariable{Name: key, Value: val}
-			}
+	service, err := theialib.NewServiceFromEnv()
+	if err != nil {
+		fail(err.Error())
+	}
 
-			_, err = service.SetEnvVar(theialib.SetEnvvarRequest{Variables: vars})
-			if err != nil {
-				fail(fmt.Sprintf("cannot set environment variables: %v", err))
-			}
+	vars, err := service.GetEnvVars(theialib.GetEnvvarsRequest{})
+	if err != nil {
+		fail(fmt.Sprintf("cannot get environment variables: %v", err))
+	}
 
-			for _, v := range vars {
-				printVar(v, exportEnvs)
-			}
+	for _, v := range vars.Variables {
+		printVarFromTheia(v, exportEnvs)
+	}
+}
+
+func setEnvs(args []string) {
+	if !isTheiaIDE() {
+		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
+		defer cancel()
+		result, err := connectToServer(ctx)
+		if err != nil {
+			fail(err.Error())
 		}
-		getEnvs := func() {
-			vars, err := service.GetEnvVars(theialib.GetEnvvarsRequest{})
-			if err != nil {
-				fail(fmt.Sprintf("cannot get environment variables: %v", err))
+
+		vars := make([]*serverapi.UserEnvVarValue, len(args))
+		for i, arg := range args {
+			kv := strings.Split(arg, "=")
+			if len(kv) != 2 {
+				fail(fmt.Sprintf("%s has no value (correct format is %s=some_value)", arg, arg))
 			}
 
-			for _, v := range vars.Variables {
-				printVar(v, exportEnvs)
+			key := strings.TrimSpace(kv[0])
+			if key == "" {
+				fail(fmt.Sprintf("variable must have a name"))
 			}
-		}
-		doUnsetEnvs := func() {
-			resp, err := service.DeleteEnvVar(theialib.DeleteEnvvarRequest{Variables: args})
-			if err != nil {
-				fail(fmt.Sprintf("cannot unset environment variables: %v", err))
+			// Do not trim value - the user might want whitespace here
+			// Also do not check if the value is empty, as an empty value means we want to delete the variable
+			val := kv[1]
+			if val == "" {
+				fail(fmt.Sprintf("variable must have a value; use -u to unset a variable"))
 			}
 
-			if len(resp.NotDeleted) != 0 {
-				fail(fmt.Sprintf("cannot unset environment variables: %s", strings.Join(resp.NotDeleted, ", ")))
-			}
+			vars[i] = &serverapi.UserEnvVarValue{Name: key, Value: val, RepositoryPattern: result.repositoryPattern}
 		}
 
-		if len(args) > 0 {
-			if unsetEnvs {
-				doUnsetEnvs()
-				return
-			}
+		var exitCode int
+		var wg sync.WaitGroup
+		wg.Add(len(vars))
+		for _, v := range vars {
+			go func(v *serverapi.UserEnvVarValue) {
+				err = result.client.SetEnvVar(ctx, v)
+				if err != nil {
+					fmt.Fprintln(os.Stderr, fmt.Sprintf("cannot set %s: %v", v.Name, err))
+					exitCode = -1
+				} else {
+					printVar(v, exportEnvs)
+				}
+				wg.Done()
+			}(v)
+		}
+		wg.Wait()
+		os.Exit(exitCode)
+	}
 
-			setEnvs()
-		} else {
-			getEnvs()
+	service, err := theialib.NewServiceFromEnv()
+	if err != nil {
+		fail(err.Error())
+	}
+
+	vars := make([]theialib.EnvironmentVariable, len(args))
+	for i, arg := range args {
+		kv := strings.Split(arg, "=")
+		if len(kv) != 2 {
+			fail(fmt.Sprintf("%s has no value (correct format is %s=some_value)", arg, arg))
 		}
-	},
+
+		key := strings.TrimSpace(kv[0])
+		if key == "" {
+			fail(fmt.Sprintf("variable must have a name"))
+		}
+		// Do not trim value - the user might want whitespace here
+		// Also do not check if the value is empty, as an empty value means we want to delete the variable
+		val := kv[1]
+		if val == "" {
+			fail(fmt.Sprintf("variable must have a value; use -u to unset a variable"))
+		}
+
+		vars[i] = theialib.EnvironmentVariable{Name: key, Value: val}
+	}
+
+	_, err = service.SetEnvVar(theialib.SetEnvvarRequest{Variables: vars})
+	if err != nil {
+		fail(fmt.Sprintf("cannot set environment variables: %v", err))
+	}
+
+	for _, v := range vars {
+		printVarFromTheia(v, exportEnvs)
+	}
+}
+
+func deleteEnvs(args []string) {
+	if !isTheiaIDE() {
+		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
+		defer cancel()
+		result, err := connectToServer(ctx)
+		if err != nil {
+			fail(err.Error())
+		}
+
+		var exitCode int
+		var wg sync.WaitGroup
+		wg.Add(len(args))
+		for _, name := range args {
+			go func(name string) {
+				err = result.client.DeleteEnvVar(ctx, &serverapi.UserEnvVarValue{Name: name, RepositoryPattern: result.repositoryPattern})
+				if err != nil {
+					fmt.Fprintln(os.Stderr, fmt.Sprintf("cannot unset %s: %v", name, err))
+					exitCode = -1
+				}
+				wg.Done()
+			}(name)
+		}
+		wg.Wait()
+		os.Exit(exitCode)
+	}
+
+	service, err := theialib.NewServiceFromEnv()
+	if err != nil {
+		fail(err.Error())
+	}
+
+	resp, err := service.DeleteEnvVar(theialib.DeleteEnvvarRequest{Variables: args})
+	if err != nil {
+		fail(fmt.Sprintf("cannot unset environment variables: %v", err))
+	}
+
+	if len(resp.NotDeleted) != 0 {
+		fail(fmt.Sprintf("cannot unset environment variables: %s", strings.Join(resp.NotDeleted, ", ")))
+	}
+}
+
+func fail(msg string) {
+	fmt.Fprintln(os.Stderr, msg)
+	os.Exit(-1)
 }
 
-func printVar(v theialib.EnvironmentVariable, export bool) {
+func printVar(v *serverapi.UserEnvVarValue, export bool) {
+	val := strings.Replace(v.Value, "\"", "\\\"", -1)
+	if export {
+		fmt.Printf("export %s=\"%s\"\n", v.Name, val)
+	} else {
+		fmt.Printf("%s=%s\n", v.Name, val)
+	}
+}
+
+func printVarFromTheia(v theialib.EnvironmentVariable, export bool) {
 	val := strings.Replace(v.Value, "\"", "\\\"", -1)
 	if export {
 		fmt.Printf("export %s=\"%s\"\n", v.Name, val)
@@ -132,3 +301,8 @@ func init() {
 	envCmd.Flags().BoolVarP(&exportEnvs, "export", "e", false, "produce a script that can be eval'ed in Bash")
 	envCmd.Flags().BoolVarP(&unsetEnvs, "unset", "u", false, "deletes/unsets persisted environment variables")
 }
+
+func isTheiaIDE() bool {
+	stat, err := os.Stat("/theia")
+	return !errors.Is(os.ErrNotExist, err) && stat != nil && stat.IsDir()
+}