refactor: handle grpc connection for local and static mode

Signed-off-by: Youngjin Jo <[email protected]>

Author: Youngjin Jo

cmd/common/fetchService.go

@@ -236,6 +236,12 @@ func FetchService(serviceName string, verb string, resourceName string, options
 	defer refClient.Reset()
 
 	// Call the service
+	fmt.Println("serviceName:", serviceName)
+	fmt.Println("verb:", verb)
+	fmt.Println("resourceName:", resourceName)
+	fmt.Println("apiEndpoint:", apiEndpoint)
+	fmt.Println("identityEndpoint:", identityEndpoint)
+	fmt.Println("hasIdentityService:", hasIdentityService)
 	jsonBytes, err := fetchJSONResponse(config, serviceName, verb, resourceName, options, apiEndpoint, identityEndpoint, hasIdentityService)
 	if err != nil {
 		// Check if the error is about missing required parameters
@@ -427,19 +433,39 @@ func fetchJSONResponse(config *Config, serviceName string, verb string, resource
 		}
 	} else {
 		if !hasIdentityService {
-			urlParts := strings.Split(apiEndpoint, "//")
-			if len(urlParts) != 2 {
-				return nil, fmt.Errorf("invalid API endpoint format: %s", apiEndpoint)
-			}
+			// Handle gRPC+SSL protocol directly
+			if strings.HasPrefix(config.Environments[config.Environment].Endpoint, "grpc+ssl://") {
+				endpoint := config.Environments[config.Environment].Endpoint
+				parts := strings.Split(endpoint, "/")
+				endpoint = strings.Join(parts[:len(parts)-1], "/")
+				parts = strings.Split(endpoint, "://")
+				if len(parts) != 2 {
+					return nil, fmt.Errorf("invalid endpoint format: %s", endpoint)
+				}
 
-			domainParts := strings.Split(urlParts[1], ".")
-			if len(domainParts) < 4 {
-				return nil, fmt.Errorf("invalid domain format in API endpoint: %s", apiEndpoint)
-			}
+				hostParts := strings.Split(parts[1], ".")
+				if len(hostParts) < 4 {
+					return nil, fmt.Errorf("invalid endpoint format: %s", endpoint)
+				}
 
-			domainParts[0] = convertServiceNameToEndpoint(serviceName)
+				// Replace service name
+				hostParts[0] = convertServiceNameToEndpoint(serviceName)
+				hostPort = strings.Join(hostParts, ".")
+			} else {
+				// Original HTTP/HTTPS handling
+				urlParts := strings.Split(apiEndpoint, "//")
+				if len(urlParts) != 2 {
+					return nil, fmt.Errorf("invalid API endpoint format: %s", apiEndpoint)
+				}
 
-			hostPort = strings.Join(domainParts, ".") + ":443"
+				domainParts := strings.Split(urlParts[1], ".")
+				if len(domainParts) < 4 {
+					return nil, fmt.Errorf("invalid domain format in API endpoint: %s", apiEndpoint)
+				}
+
+				domainParts[0] = convertServiceNameToEndpoint(serviceName)
+				hostPort = strings.Join(domainParts, ".") + ":443"
+			}
 		} else {
 			trimmedEndpoint := strings.TrimPrefix(identityEndpoint, "grpc+ssl://")
 			parts := strings.Split(trimmedEndpoint, ".")

cmd/other/apiResources.go

@@ -201,6 +201,39 @@ func FetchEndpointsMap(endpoint string) (map[string]string, error) {
 	}
 
 	if !hasIdentityService {
+		// Handle gRPC+SSL protocol directly
+		if strings.HasPrefix(endpoint, "grpc+ssl://") {
+			// Parse the endpoint
+			parts := strings.Split(endpoint, "/")
+			endpoint = strings.Join(parts[:len(parts)-1], "/")
+			parts = strings.Split(endpoint, "://")
+			if len(parts) != 2 {
+				return nil, fmt.Errorf("invalid endpoint format: %s", endpoint)
+			}
+
+			hostParts := strings.Split(parts[1], ".")
+			svc := hostParts[0]
+			baseDomain := strings.Join(hostParts[1:], ".")
+
+			// Configure TLS
+			tlsConfig := &tls.Config{
+				InsecureSkipVerify: false,
+			}
+			opts := []grpc.DialOption{
+				grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)),
+			}
+
+			//If current service is not identity, modify hostPort to use identity service
+			if svc != "identity" {
+				hostPort := fmt.Sprintf("identity.%s", baseDomain)
+				endpoints, err := invokeGRPCEndpointList(hostPort, opts)
+				if err != nil {
+					return nil, fmt.Errorf("failed to get endpoints from gRPC: %v", err)
+				}
+				return endpoints, nil
+			}
+		}
+
 		payload := map[string]string{}
 		jsonPayload, err := json.Marshal(payload)
 		if err != nil {

cmd/other/login.go

@@ -697,6 +697,13 @@ func executeUserLogin(currentEnv string) {
 			scope = "WORKSPACE"
 		}
 
+		// Grant new token using the refresh token
+		newAccessToken, err := grantToken("", identityEndpoint, hasIdentityService, refreshToken, scope, domainID, workspaceID)
+		if err != nil {
+			pterm.Error.Println("Failed to retrieve new access token:", err)
+			exitWithError()
+		}
+
 		// Create cache directory
 		envCacheDir := filepath.Join(homeDir, ".cfctl", "cache", currentEnv)
 		if err := os.MkdirAll(envCacheDir, 0700); err != nil {
@@ -710,7 +717,7 @@ func executeUserLogin(currentEnv string) {
 			exitWithError()
 		}
 
-		if err := os.WriteFile(filepath.Join(envCacheDir, "access_token"), []byte(accessToken), 0600); err != nil {
+		if err := os.WriteFile(filepath.Join(envCacheDir, "access_token"), []byte(newAccessToken), 0600); err != nil {
 			pterm.Error.Printf("Failed to save access token: %v\n", err)
 			exitWithError()
 		}
@@ -721,6 +728,12 @@ func executeUserLogin(currentEnv string) {
 
 // GetAPIEndpoint fetches the actual API endpoint from the config endpoint
 func GetAPIEndpoint(endpoint string) (string, error) {
+	// Handle gRPC+SSL protocol
+	if strings.HasPrefix(endpoint, "grpc+ssl://") {
+		// For gRPC+SSL endpoints, return as is since it's already in the correct format
+		return endpoint, nil
+	}
+
 	// Remove protocol prefix if exists
 	endpoint = strings.TrimPrefix(endpoint, "https://")
 	endpoint = strings.TrimPrefix(endpoint, "http://")
@@ -759,6 +772,20 @@ func GetAPIEndpoint(endpoint string) (string, error) {
 
 // GetIdentityEndpoint fetches the identity service endpoint from the API endpoint
 func GetIdentityEndpoint(apiEndpoint string) (string, bool, error) {
+	// If the endpoint is already gRPC+SSL
+	if strings.HasPrefix(apiEndpoint, "grpc+ssl://") {
+		// Check if it contains 'identity'
+		containsIdentity := strings.Contains(apiEndpoint, "identity")
+
+		// Remove /v1 suffix if present
+		if idx := strings.Index(apiEndpoint, "/v"); idx != -1 {
+			apiEndpoint = apiEndpoint[:idx]
+		}
+
+		return apiEndpoint, containsIdentity, nil
+	}
+
+	// Original HTTP/HTTPS handling logic
 	endpointListURL := fmt.Sprintf("%s/identity/endpoint/list", apiEndpoint)
 
 	payload := map[string]string{}
@@ -1062,7 +1089,7 @@ func loadEnvironmentConfig() {
 				"Please enable proxy mode and set identity endpoint first.")
 
 		pterm.DefaultBox.WithBoxStyle(pterm.NewStyle(pterm.FgCyan)).
-			Println("$ cfctl config endpoint -s identity\n" +
+			Println("$ cfctl setting endpoint -s identity\n" +
 				"$ cfctl login")
 
 		exitWithError()

cmd/other/setting.go

@@ -493,6 +493,17 @@ You can either specify a new endpoint URL directly or use the service-based endp
 		if listFlag {
 			token, err := getToken(appV)
 			if err != nil {
+				if strings.HasSuffix(currentEnv, "-user") {
+					pterm.DefaultBox.WithTitle("Authentication Required").
+						WithTitleTopCenter().
+						WithBoxStyle(pterm.NewStyle(pterm.FgLightCyan)).
+						WithRightPadding(4).
+						WithLeftPadding(4).
+						Println("Please login to SpaceONE Console first.\n" +
+							"Run the following command to authenticate:\n\n" +
+							"$ cfctl login")
+					return
+				}
 				pterm.Error.Println("Error retrieving token:", err)
 				return
 			}
@@ -1290,6 +1301,19 @@ func updateSetting(envName, endpoint string, envSuffix string) {
 	envKey := fmt.Sprintf("environments.%s.endpoint", fullEnvName)
 	v.Set(envKey, endpoint)
 
+	// Set proxy based on endpoint type
+	proxyKey := fmt.Sprintf("environments.%s.proxy", fullEnvName)
+	if strings.HasPrefix(endpoint, "grpc://") || strings.HasPrefix(endpoint, "grpc+ssl://") {
+		// Check if endpoint contains 'identity'
+		if strings.Contains(strings.ToLower(endpoint), "identity") {
+			v.Set(proxyKey, true)
+		} else {
+			v.Set(proxyKey, false)
+		}
+	} else {
+		v.Set(proxyKey, true)
+	}
+
 	// Set additional configurations based on environment type
 	if envName == "local" {
 		// Local environment settings (only for pure 'local', not 'local-user' or 'local-app')

cmd/root.go

@@ -233,6 +233,20 @@ func showInitializationGuide() {
 			pterm.Info.Println("After updating the token, please try your command again.")
 		}
 	} else if strings.HasSuffix(currentEnv, "-user") {
+		// Get endpoint from environment config
+		envConfig := mainV.Sub(fmt.Sprintf("environments.%s", currentEnv))
+		if envConfig == nil {
+			pterm.Warning.Printf("No environment configuration found.\n")
+			return
+		}
+
+		endpoint := envConfig.GetString("endpoint")
+
+		// Skip authentication warning for gRPC+SSL endpoints
+		if strings.HasPrefix(endpoint, "grpc+ssl://") {
+			return
+		}
+
 		pterm.Warning.Printf("Authentication required.\n")
 		pterm.Info.Println("To see Available Commands, please authenticate first:")
 		pterm.Info.Println("$ cfctl login")
@@ -318,70 +332,104 @@ func addDynamicServiceCommands() error {
 		return nil
 	}
 
-	// For non-local environments, continue with existing logic...
+	// For non-local environments
+	endpoint := config.Endpoint
+	var apiEndpoint string
+
+	if strings.HasPrefix(endpoint, "grpc+ssl://") {
+		apiEndpoint = endpoint
+	} else if strings.HasPrefix(endpoint, "http://") || strings.HasPrefix(endpoint, "https://") {
+		apiEndpoint, err = other.GetAPIEndpoint(endpoint)
+		if err != nil {
+			return fmt.Errorf("failed to get API endpoint: %v", err)
+		}
+	}
+
+	// Try to use cached endpoints first
 	if cachedEndpointsMap != nil {
+		currentService := ""
+		if strings.HasPrefix(endpoint, "grpc+ssl://") {
+			parts := strings.Split(endpoint, "://")
+			if len(parts) == 2 {
+				hostParts := strings.Split(parts[1], ".")
+				if len(hostParts) > 0 {
+					currentService = hostParts[0]
+				}
+			}
+		}
+
+		if currentService != "identity" && currentService != "" {
+			if cmd := createServiceCommand(currentService); cmd != nil {
+				cmd.GroupID = "available"
+				rootCmd.AddCommand(cmd)
+			}
+			return nil
+		}
+
+		// If identity service or no specific service, add all available commands
 		for serviceName := range cachedEndpointsMap {
 			cmd := createServiceCommand(serviceName)
+			cmd.GroupID = "available"
 			rootCmd.AddCommand(cmd)
 		}
 		return nil
 	}
 
-	// Only show progress bar when actually fetching services
-	if len(os.Args) == 1 || (len(os.Args) > 1 &&
-		os.Args[1] != "setting" &&
-		os.Args[1] != "login" &&
-		os.Args[1] != "api_resources" &&
-		os.Args[1] != "short_name") {
-		// Create progress bar
-		progressbar, _ := pterm.DefaultProgressbar.
-			WithTotal(4).
-			WithTitle("Initializing services").
-			Start()
-
-		progressbar.UpdateTitle("Preparing endpoint configuration")
-		endpoint := config.Endpoint
-
-		var apiEndpoint string
-		if strings.HasPrefix(endpoint, "http://") || strings.HasPrefix(endpoint, "https://") {
-			apiEndpoint, err = other.GetAPIEndpoint(endpoint)
-			if err != nil {
-				pterm.Error.Printf("Failed to get API endpoint: %v\n", err)
-				os.Exit(1)
-			}
-		}
+	// If no cached endpoints, fetch them
+	progressbar, _ := pterm.DefaultProgressbar.
+		WithTotal(4).
+		WithTitle("Initializing services").
+		Start()
 
-		progressbar.Increment()
-		time.Sleep(time.Millisecond * 300)
+	progressbar.UpdateTitle("Fetching available services")
+	endpointsMap, err := other.FetchEndpointsMap(apiEndpoint)
+	if err != nil {
+		return fmt.Errorf("failed to fetch services: %v", err)
+	}
 
-		progressbar.UpdateTitle("Fetching available services")
-		endpointsMap, err := other.FetchEndpointsMap(apiEndpoint)
-		if err != nil {
-			return fmt.Errorf("failed to fetch services: %v", err)
-		}
-		progressbar.Increment()
-		time.Sleep(time.Millisecond * 300)
-
-		progressbar.UpdateTitle("Creating cache for faster subsequent runs")
-		cachedEndpointsMap = endpointsMap
-		if err := saveEndpointsCache(endpointsMap); err != nil {
-			_, err2 := fmt.Fprintf(os.Stderr, "Warning: Failed to cache endpoints: %v\n", err)
-			if err2 != nil {
-				return err2
+	progressbar.Increment()
+	time.Sleep(time.Millisecond * 300)
+
+	progressbar.UpdateTitle("Creating cache for faster subsequent runs")
+	cachedEndpointsMap = endpointsMap
+	if err := saveEndpointsCache(endpointsMap); err != nil {
+		fmt.Fprintf(os.Stderr, "Warning: Failed to cache endpoints: %v\n", err)
+	}
+
+	progressbar.Increment()
+	time.Sleep(time.Millisecond * 300)
+
+	//progressbar.UpdateTitle("Finalizing")
+	progressbar.Increment()
+	time.Sleep(time.Millisecond * 300)
+
+	fmt.Println()
+	// Add commands based on the current service
+	currentService := ""
+	if strings.HasPrefix(endpoint, "grpc+ssl://") {
+		parts := strings.Split(endpoint, "://")
+		if len(parts) == 2 {
+			hostParts := strings.Split(parts[1], ".")
+			if len(hostParts) > 0 {
+				currentService = hostParts[0]
 			}
 		}
-		progressbar.Increment()
-		time.Sleep(time.Millisecond * 300)
+	}
 
-		progressbar.UpdateTitle("Registering verbs and resources commands to the cache")
+	if currentService != "identity" && currentService != "" {
+		if cmd := createServiceCommand(currentService); cmd != nil {
+			cmd.GroupID = "available"
+			rootCmd.AddCommand(cmd)
+		}
+	} else {
 		for serviceName := range endpointsMap {
 			cmd := createServiceCommand(serviceName)
+			cmd.GroupID = "available"
 			rootCmd.AddCommand(cmd)
 		}
-		progressbar.Increment()
-		time.Sleep(time.Millisecond * 300)
 	}
 
+	progressbar.Increment()
 	return nil
 }