Fixed unexpected waiting during async service deployment

acceptance/api/v1/service_create_test.go

@@ -12,6 +12,7 @@
 package v1_test
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -88,7 +89,6 @@ var _ = Describe("ServiceCreate Endpoint", LService, func() {
 	})
 
 	When("service exists", func() {
-		var requestBody, serviceName string
 		var catalogService models.CatalogService
 
 		BeforeEach(func() {
@@ -107,34 +107,79 @@ var _ = Describe("ServiceCreate Endpoint", LService, func() {
 				Values: "{'service': {'type': 'ClusterIP'}}",
 			}
 			catalog.CreateCatalogService(catalogService)
+		})
 
-			serviceName = catalog.NewServiceName()
-			service := models.ServiceCreateRequest{
+		AfterEach(func() {
+			catalog.DeleteCatalogService(catalogService.Meta.Name)
+			env.DeleteNamespace(namespace)
+		})
+
+		It("returns success immediately if waiting", func() {
+			serviceCreateRequest := models.ServiceCreateRequest{
 				CatalogService: catalogService.Meta.Name,
-				Name:           serviceName,
+				Name:           catalog.NewServiceName(),
+				Wait:           true,
 			}
 
-			b, err := json.Marshal(service)
+			requestBody := &bytes.Buffer{}
+			err := json.NewEncoder(requestBody).Encode(serviceCreateRequest)
 			Expect(err).ToNot(HaveOccurred())
-			requestBody = string(b)
-		})
 
-		AfterEach(func() {
-			catalog.DeleteCatalogService(catalogService.Meta.Name)
-			env.DeleteNamespace(namespace)
+			endpoint := fmt.Sprintf("%s%s/namespaces/%s/services", serverURL, v1.Root, namespace)
+			response, err := env.Curl("POST", endpoint, requestBody)
+			Expect(err).ToNot(HaveOccurred())
+
+			b, err := io.ReadAll(response.Body)
+			Expect(err).ToNot(HaveOccurred())
+			response.Body.Close()
+			Expect(response.StatusCode).To(Equal(http.StatusOK), string(b))
+
+			endpoint = fmt.Sprintf("%s%s/namespaces/%s/services/%s", serverURL, v1.Root, namespace, serviceCreateRequest.Name)
+			response, err = env.Curl("GET", endpoint, nil)
+			Expect(err).ToNot(HaveOccurred())
+
+			var service models.Service
+			err = json.NewDecoder(response.Body).Decode(&service)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(service.Status.String()).To(BeEquivalentTo(models.ServiceStatusDeployed))
+
+			catalog.DeleteService(serviceCreateRequest.Name, namespace)
 		})
 
-		It("returns success", func() {
+		It("returns success after the deploy is ok if not waiting", func() {
+			serviceCreateRequest := models.ServiceCreateRequest{
+				CatalogService: catalogService.Meta.Name,
+				Name:           catalog.NewServiceName(),
+				Wait:           false,
+			}
+
+			requestBody := &bytes.Buffer{}
+			err := json.NewEncoder(requestBody).Encode(serviceCreateRequest)
+			Expect(err).ToNot(HaveOccurred())
+
 			endpoint := fmt.Sprintf("%s%s/namespaces/%s/services", serverURL, v1.Root, namespace)
-			response, err := env.Curl("POST", endpoint, strings.NewReader(requestBody))
+			response, err := env.Curl("POST", endpoint, requestBody)
 			Expect(err).ToNot(HaveOccurred())
-			defer catalog.DeleteService(serviceName, namespace)
 
 			b, err := io.ReadAll(response.Body)
 			Expect(err).ToNot(HaveOccurred())
 			response.Body.Close()
 
 			Expect(response.StatusCode).To(Equal(http.StatusOK), string(b))
+
+			Eventually(func() string {
+				endpoint := fmt.Sprintf("%s%s/namespaces/%s/services/%s", serverURL, v1.Root, namespace, serviceCreateRequest.Name)
+				response, err := env.Curl("GET", endpoint, nil)
+				Expect(err).ToNot(HaveOccurred())
+
+				var service models.Service
+				err = json.NewDecoder(response.Body).Decode(&service)
+				Expect(err).ToNot(HaveOccurred())
+
+				return service.Status.String()
+			}, "1m", "1s").Should(BeEquivalentTo(models.ServiceStatusDeployed))
+
+			catalog.DeleteService(serviceCreateRequest.Name, namespace)
 		})
 	})
 })

internal/helm/helm.go

@@ -25,6 +25,7 @@
 
 	"github.com/epinio/epinio/helpers/kubernetes"
 	"github.com/epinio/epinio/internal/appchart"
+	"github.com/epinio/epinio/internal/cli/server/requestctx"
 	"github.com/epinio/epinio/internal/domain"
 	"github.com/epinio/epinio/internal/duration"
 	"github.com/epinio/epinio/internal/names"
@@ -42,7 +43,6 @@
 
 type ServiceParameters struct {
 	models.AppRef                     // Service: name & namespace
-	Context       context.Context     // Operation context
 	Cluster       *kubernetes.Cluster // Cluster to talk to.
 	Chart         string              // Name of helm chart to deploy
 	Version       string              // Version of helm chart to deploy
@@ -121,7 +121,8 @@
 	return nil
 }
 
-func DeployService(logger logr.Logger, parameters ServiceParameters) error {
+func DeployService(ctx context.Context, parameters ServiceParameters) error {
+	logger := requestctx.Logger(ctx)
 	logger.Info("service helm setup", "parameters", parameters)
 
 	client, err := GetHelmClient(parameters.Cluster.RestConfig, logger, parameters.Namespace)
@@ -160,9 +161,17 @@
 		ReuseValues: true,
 	}
 
-	_, err = client.InstallOrUpgradeChart(parameters.Context, &chartSpec, nil)
+	if !parameters.Wait {
+		go func() {
+			if _, err = client.InstallOrUpgradeChart(context.Background(), &chartSpec, nil); err != nil {
+				logger.Error(err, "installing or upgrading service ASYNC")
+			}
+		}()
+		return nil
+	}
 
-	return err
+	_, err = client.InstallOrUpgradeChart(ctx, &chartSpec, nil)
+	return errors.Wrap(err, "installing or upgrading service SYNC")
 }
 
 func Deploy(logger logr.Logger, parameters ChartParameters) error {

internal/services/instances.go

@@ -157,10 +157,9 @@ func (s *ServiceClient) Create(ctx context.Context, namespace, name string, wait
 	}
 
 	err = helm.DeployService(
-		requestctx.Logger(ctx),
+		ctx,
 		helm.ServiceParameters{
 			AppRef:     models.NewAppRef(name, namespace),
-			Context:    ctx,
 			Cluster:    s.kubeClient,
 			Chart:      catalogService.HelmChart,
 			Version:    catalogService.ChartVersion,