Merge pull request #997 from dushaniw/gw-undeploy

Handle API undeployment and redeployment events from CP in Gateway

Author: dushaniw

gateway/gateway-controller/api/openapi.yaml

@@ -2569,6 +2569,7 @@ components:
             - pending
             - deployed
             - failed
+            - undeployed
           example: deployed
         created_at:
           type: string
@@ -3636,6 +3637,7 @@ components:
             - pending
             - deployed
             - failed
+            - undeployed
           example: deployed
         created_at:
           type: string

gateway/gateway-controller/pkg/api/generated/generated.go

@@ -2105,10 +2105,10 @@ func (s *APIServer) waitForDeploymentAndNotify(configID string, correlationID st
 				// Extract API ID from stored config (use config ID as API ID)
 				apiID := configID
 
-				// Use empty revision ID for now (can be made configurable later)
-				revisionID := ""
+				// Use empty deployment ID for now (can be made configurable later)
+				deploymentID := ""
 
-				if err := s.controlPlaneClient.NotifyAPIDeployment(apiID, cfg, revisionID); err != nil {
+				if err := s.controlPlaneClient.NotifyAPIDeployment(apiID, cfg, deploymentID); err != nil {
 					log.Error("Failed to notify platform-api of successful deployment",
 						slog.String("api_id", apiID),
 						slog.Any("error", err))
@@ -2157,6 +2157,8 @@ func (s *APIServer) GetConfigDump(c *gin.Context) {
 			status = api.ConfigDumpAPIMetadataStatusFailed
 		case models.StatusPending:
 			status = api.ConfigDumpAPIMetadataStatusPending
+		case models.StatusUndeployed:
+			status = api.ConfigDumpAPIMetadataStatusUndeployed
 		default:
 			status = api.ConfigDumpAPIMetadataStatusPending
 		}

gateway/gateway-controller/pkg/api/handlers/handlers.go

@@ -394,7 +394,7 @@ func (m *MockControlPlaneClient) IsConnected() bool {
 	return m.connected
 }
 
-func (m *MockControlPlaneClient) NotifyAPIDeployment(apiID string, cfg *models.StoredConfig, revisionID string) error {
+func (m *MockControlPlaneClient) NotifyAPIDeployment(apiID string, cfg *models.StoredConfig, deploymentID string) error {
 	return nil
 }
 
@@ -442,7 +442,7 @@ func createTestAPIServer() *APIServer {
 			},
 		},
 	}
-	
+
 	// Initialize API key service (needed for API key operations)
 	apiKeyService := utils.NewAPIKeyService(store, mockDB, nil, &server.systemConfig.GatewayController.APIKey)
 	server.apiKeyService = apiKeyService
@@ -1372,11 +1372,11 @@ func TestWaitForDeploymentAndNotifyTimeout(t *testing.T) {
 func TestNewAPIServer(t *testing.T) {
 	store := storage.NewConfigStore()
 	mockDB := NewMockStorage()
-	
+
 	policyDefs := map[string]api.PolicyDefinition{
 		"test|v1": {Name: "test", Version: "v1"},
 	}
-	
+
 	// LLMProviderTemplate structure matches API spec
 	templateDefs := make(map[string]*api.LLMProviderTemplate)
 	templateName := "test-template"
@@ -1385,14 +1385,14 @@ func TestNewAPIServer(t *testing.T) {
 			Name: templateName,
 		},
 	}
-	
+
 	validator := config.NewAPIValidator()
-	
+
 	vhosts := &config.VHostsConfig{
 		Main:    config.VHostEntry{Default: "localhost"},
 		Sandbox: config.VHostEntry{Default: "sandbox-localhost"},
 	}
-	
+
 	systemConfig := &config.Config{
 		GatewayController: config.GatewayController{
 			Router: config.RouterConfig{
@@ -1404,7 +1404,7 @@ func TestNewAPIServer(t *testing.T) {
 			},
 		},
 	}
-	
+
 	// This test is simplified - full test would require proper xDS mocks
 	// Instead, we just verify the structure
 	t.Run("verify test server creation", func(t *testing.T) {
@@ -1416,7 +1416,7 @@ func TestNewAPIServer(t *testing.T) {
 		assert.NotNil(t, server.parser)
 		assert.NotNil(t, server.validator)
 	})
-	
+
 	// Verify configuration objects are created correctly
 	t.Run("verify config structures", func(t *testing.T) {
 		assert.NotNil(t, store)
@@ -2367,7 +2367,7 @@ func TestUpdateAPIKeyInvalidBody(t *testing.T) {
 	server.UpdateAPIKey(c, "test-handle", "test-key")
 
 	assert.Equal(t, http.StatusBadRequest, w.Code)
-	
+
 	var response api.ErrorResponse
 	err := json.Unmarshal(w.Body.Bytes(), &response)
 	require.NoError(t, err)
@@ -2390,7 +2390,7 @@ func TestUpdateAPIKeyMissingAPIKey(t *testing.T) {
 	server.UpdateAPIKey(c, "test-handle", "test-key")
 
 	assert.Equal(t, http.StatusBadRequest, w.Code)
-	
+
 	var response api.ErrorResponse
 	err := json.Unmarshal(w.Body.Bytes(), &response)
 	require.NoError(t, err)
@@ -2410,9 +2410,9 @@ func TestRevokeAPIKeyNotFound(t *testing.T) {
 	server.RevokeAPIKey(c, "test-handle", "nonexistent")
 
 	assert.Equal(t, http.StatusNotFound, w.Code)
-	
+
 	var response api.ErrorResponse
 	err := json.Unmarshal(w.Body.Bytes(), &response)
 	require.NoError(t, err)
 	assert.Equal(t, "error", response.Status)
-}
+}

gateway/gateway-controller/pkg/api/handlers/handlers_test.go

@@ -88,7 +88,7 @@ type ConnectionState struct {
 // ControlPlaneClient interface defines the methods needed from the control plane client
 type ControlPlaneClient interface {
 	IsConnected() bool
-	NotifyAPIDeployment(apiID string, apiConfig *models.StoredConfig, revisionID string) error
+	NotifyAPIDeployment(apiID string, apiConfig *models.StoredConfig, deploymentID string) error
 }
 
 // Client manages the WebSocket connection to the control plane
@@ -590,7 +590,7 @@ func (c *Client) handleAPIDeployedEvent(event map[string]interface{}) {
 	c.logger.Info("Processing API deployment",
 		slog.String("api_id", apiID),
 		slog.String("environment", deployedEvent.Payload.Environment),
-		slog.String("revision_id", deployedEvent.Payload.RevisionID),
+		slog.String("deployment_id", deployedEvent.Payload.DeploymentID),
 		slog.String("vhost", deployedEvent.Payload.VHost),
 		slog.String("correlation_id", deployedEvent.CorrelationID),
 	)
@@ -685,7 +685,114 @@ func (c *Client) handleAPIUndeployedEvent(event map[string]interface{}) {
 		slog.Any("timestamp", event["timestamp"]),
 		slog.Any("correlationId", event["correlationId"]),
 	)
-	// TODO: Implement actual API undeployment logic in Phase 6
+
+	// Parse the event into structured format
+	eventBytes, err := json.Marshal(event)
+	if err != nil {
+		c.logger.Error("Failed to marshal event for parsing",
+			slog.Any("error", err),
+		)
+		return
+	}
+
+	var undeployedEvent APIUndeployedEvent
+	if err := json.Unmarshal(eventBytes, &undeployedEvent); err != nil {
+		c.logger.Error("Failed to parse API undeployment event",
+			slog.Any("error", err),
+		)
+		return
+	}
+
+	// Extract API ID
+	apiID := undeployedEvent.Payload.APIID
+	if apiID == "" {
+		c.logger.Error("API ID is empty in undeployment event")
+		return
+	}
+
+	c.logger.Info("Processing API undeployment",
+		slog.String("api_id", apiID),
+		slog.String("environment", undeployedEvent.Payload.Environment),
+		slog.String("vhost", undeployedEvent.Payload.VHost),
+		slog.String("correlation_id", undeployedEvent.CorrelationID),
+	)
+
+	// Check if config exists in database first (source of truth when persistent storage is available)
+	var apiConfig *models.StoredConfig
+	if c.db != nil {
+		var err error
+		apiConfig, err = c.db.GetConfig(apiID)
+		if err != nil {
+			c.logger.Warn("API configuration not found in database for undeployment",
+				slog.String("api_id", apiID),
+				slog.Any("error", err),
+			)
+			// Not an error - the API might already be undeployed or deleted
+			return
+		}
+	} else {
+		// Fall back to in-memory store if database is not available
+		var err error
+		apiConfig, err = c.store.Get(apiID)
+		if err != nil {
+			c.logger.Warn("API configuration not found in storage for undeployment",
+				slog.String("api_id", apiID),
+				slog.Any("error", err),
+			)
+			// Not an error - the API might already be undeployed or deleted
+			return
+		}
+	}
+
+	// Set status to undeployed (preserve config, keys, and policies)
+	apiConfig.Status = models.StatusUndeployed
+	apiConfig.UpdatedAt = time.Now()
+	// Keep DeployedVersion as-is - it tracks when it was last deployed
+
+	// Update database (only if persistent mode)
+	if c.db != nil {
+		if err := c.db.UpdateConfig(apiConfig); err != nil {
+			c.logger.Error("Failed to update config status in database",
+				slog.String("api_id", apiID),
+				slog.Any("error", err),
+			)
+			return
+		}
+	}
+
+	// Update in-memory store
+	if err := c.store.Update(apiConfig); err != nil {
+		c.logger.Error("Failed to update config status in memory store",
+			slog.String("api_id", apiID),
+			slog.Any("error", err),
+		)
+		return
+	}
+
+	// Note: We keep API keys and policies for potential redeploy
+	// They will be reused if the API is redeployed
+
+	// Update xDS snapshot asynchronously (undeployed APIs will be filtered out)
+	go func() {
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+
+		if err := c.snapshotManager.UpdateSnapshot(ctx, undeployedEvent.CorrelationID); err != nil {
+			c.logger.Error("Failed to update xDS snapshot after API undeployment",
+				slog.String("api_id", apiID),
+				slog.Any("error", err),
+			)
+		} else {
+			c.logger.Info("Successfully updated xDS snapshot after API undeployment",
+				slog.String("api_id", apiID),
+			)
+		}
+	}()
+
+	c.logger.Info("Successfully processed API undeployment event",
+		slog.String("api_id", apiID),
+		slog.String("correlation_id", undeployedEvent.CorrelationID),
+	)
 }
 
 // handleAPIKeyCreatedEvent handles API key created events from platform-api
@@ -1119,7 +1226,7 @@ func (c *Client) IsConnected() bool {
 }
 
 // NotifyAPIDeployment sends a REST API call to platform-api when an API is deployed successfully
-func (c *Client) NotifyAPIDeployment(apiID string, apiConfig *models.StoredConfig, revisionID string) error {
+func (c *Client) NotifyAPIDeployment(apiID string, apiConfig *models.StoredConfig, deploymentID string) error {
 	// Check if connected to control plane
 	if !c.IsConnected() {
 		c.logger.Debug("Not connected to control plane, skipping API deployment notification",
@@ -1128,7 +1235,7 @@ func (c *Client) NotifyAPIDeployment(apiID string, apiConfig *models.StoredConfi
 	}
 
 	// Use the api utils service to send the deployment notification
-	return c.apiUtilsService.NotifyAPIDeployment(apiID, apiConfig, revisionID)
+	return c.apiUtilsService.NotifyAPIDeployment(apiID, apiConfig, deploymentID)
 }
 
 // getWebSocketURL constructs the base WebSocket URL from configuration

gateway/gateway-controller/pkg/controlplane/client.go

@@ -116,10 +116,10 @@ func TestClient_handleMessage_APIDeployedEvent(t *testing.T) {
 	event := map[string]interface{}{
 		"type": "api.deployed",
 		"payload": map[string]interface{}{
-			"apiId":       "test-api-123",
-			"environment": "production",
-			"revisionId":  "rev-1",
-			"vhost":       "api.example.com",
+			"apiId":        "test-api-123",
+			"environment":  "production",
+			"deploymentId": "rev-1",
+			"vhost":        "api.example.com",
 		},
 		"timestamp":     time.Now().Format(time.RFC3339),
 		"correlationId": "corr-12345",
@@ -440,7 +440,7 @@ func TestAPIDeployedEvent_JSONParsing(t *testing.T) {
 		"payload": {
 			"apiId": "api-123",
 			"environment": "production",
-			"revisionId": "rev-1",
+			"deploymentId": "rev-1",
 			"vhost": "api.example.com"
 		},
 		"timestamp": "2025-01-30T12:00:00Z",

gateway/gateway-controller/pkg/controlplane/client_integration_test.go

@@ -90,10 +90,10 @@ func TestAPIDeployedEvent(t *testing.T) {
 	event := APIDeployedEvent{
 		Type: "api.deployed",
 		Payload: APIDeployedEventPayload{
-			APIID:       "api-123",
-			Environment: "production",
-			RevisionID:  "rev-1",
-			VHost:       "api.example.com",
+			APIID:        "api-123",
+			Environment:  "production",
+			DeploymentID: "rev-1",
+			VHost:        "api.example.com",
 		},
 		Timestamp:     "2025-01-30T12:00:00Z",
 		CorrelationID: "corr-789",
@@ -108,8 +108,8 @@ func TestAPIDeployedEvent(t *testing.T) {
 	if event.Payload.Environment != "production" {
 		t.Errorf("Payload.Environment = %q, want %q", event.Payload.Environment, "production")
 	}
-	if event.Payload.RevisionID != "rev-1" {
-		t.Errorf("Payload.RevisionID = %q, want %q", event.Payload.RevisionID, "rev-1")
+	if event.Payload.DeploymentID != "rev-1" {
+		t.Errorf("Payload.DeploymentID = %q, want %q", event.Payload.DeploymentID, "rev-1")
 	}
 	if event.Payload.VHost != "api.example.com" {
 		t.Errorf("Payload.VHost = %q, want %q", event.Payload.VHost, "api.example.com")
@@ -121,10 +121,10 @@ func TestAPIDeployedEvent(t *testing.T) {
 
 func TestAPIDeployedEventPayload(t *testing.T) {
 	payload := APIDeployedEventPayload{
-		APIID:       "test-api",
-		Environment: "staging",
-		RevisionID:  "rev-2",
-		VHost:       "staging.example.com",
+		APIID:        "test-api",
+		Environment:  "staging",
+		DeploymentID: "rev-2",
+		VHost:        "staging.example.com",
 	}
 
 	if payload.APIID != "test-api" {
@@ -133,8 +133,8 @@ func TestAPIDeployedEventPayload(t *testing.T) {
 	if payload.Environment != "staging" {
 		t.Errorf("Environment = %q, want %q", payload.Environment, "staging")
 	}
-	if payload.RevisionID != "rev-2" {
-		t.Errorf("RevisionID = %q, want %q", payload.RevisionID, "rev-2")
+	if payload.DeploymentID != "rev-2" {
+		t.Errorf("DeploymentID = %q, want %q", payload.DeploymentID, "rev-2")
 	}
 	if payload.VHost != "staging.example.com" {
 		t.Errorf("VHost = %q, want %q", payload.VHost, "staging.example.com")
@@ -307,7 +307,7 @@ func TestClient_NotifyAPIDeployment_NotConnected(t *testing.T) {
 	client := createTestClient(t)
 
 	// When not connected, should return nil without error
-	err := client.NotifyAPIDeployment("api-123", nil, "rev-1")
+	err := client.NotifyAPIDeployment("api-123", nil, "deployment-1")
 	if err != nil {
 		t.Errorf("NotifyAPIDeployment() error = %v, want nil when not connected", err)
 	}