Add a new validation to use or not upload API to install packages (#2511)

This PR checks whether or not the Elastic stack allows to upload
packages via API. If it cannot be used the upload API, packages
will be installed from the Package Registry.
Until Elastic stack 8.8.2 the license required was Enterprise to use
that API endpoint. In Elastic stack 8.8.2 onwards, the license required
for this feature was changed to basic.

Author: mrodm

internal/elasticsearch/client.go

@@ -196,7 +196,7 @@ type Info struct {
 	Version     struct {
 		Number      string `json:"number"`
 		BuildFlavor string `json:"build_flavor"`
-	} `json:"version`
+	} `json:"version"`
 }
 
 // Info gets cluster information and metadata.

internal/kibana/packages.go

@@ -7,13 +7,16 @@ package kibana
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"os"
 
 	"github.com/elastic/elastic-package/internal/packages"
 )
 
+var ErrNotSupported error = errors.New("not supported")
+
 // InstallPackage installs the given package in Fleet.
 func (c *Client) InstallPackage(ctx context.Context, name, version string) ([]packages.Asset, error) {
 	path := c.epmPackageUrl(name, version)
@@ -27,6 +30,47 @@ func (c *Client) InstallPackage(ctx context.Context, name, version string) ([]pa
 	return processResults("install", statusCode, respBody)
 }
 
+// EnsureZipPackageCanBeInstalled checks whether or not it can be installed a package using the upload API.
+// This is intened to be used between 8.7.0 and 8.8.2 stack versions, and it is only safe to be run in those
+// stack versions.
+func (c *Client) EnsureZipPackageCanBeInstalled(ctx context.Context) error {
+	path := fmt.Sprintf("%s/epm/packages", FleetAPI)
+
+	req, err := c.newRequest(ctx, http.MethodPost, path, nil)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/zip")
+	req.Header.Add("elastic-api-version", "2023-10-31")
+
+	statusCode, respBody, err := c.doRequest(req)
+	if err != nil {
+		return fmt.Errorf("could not install zip package: %w", err)
+	}
+	switch statusCode {
+	case http.StatusBadRequest:
+		// If the stack allows to use the upload API, the response is like this one:
+		// {
+		//   "statusCode":400,
+		//   "error":"Bad Request",
+		//   "message":"Error during extraction of package: Error: end of central directory record signature not found. Assumed content type was application/zip, check if this matches the archive type."
+		// }
+		return nil
+	case http.StatusForbidden:
+		var resp struct {
+			Message string `json:"message"`
+		}
+		if err := json.Unmarshal(respBody, &resp); err != nil {
+			return fmt.Errorf("could not unmarhsall response to JSON: %w", err)
+		}
+		if resp.Message == "Requires Enterprise license" {
+			return ErrNotSupported
+		}
+	}
+
+	return fmt.Errorf("unexpected response (status code %d): %s", statusCode, string(respBody))
+}
+
 // InstallZipPackage installs the local zip package in Fleet.
 func (c *Client) InstallZipPackage(ctx context.Context, zipFile string) ([]packages.Asset, error) {
 	path := fmt.Sprintf("%s/epm/packages", FleetAPI)

internal/packages/installer/factory.go

@@ -18,7 +18,10 @@ import (
 	"github.com/elastic/elastic-package/internal/validation"
 )
 
-var semver8_7_0 = semver.MustParse("8.7.0")
+var (
+	semver8_7_0 = semver.MustParse("8.7.0")
+	semver8_8_2 = semver.MustParse("8.8.2")
+)
 
 // Installer is responsible for installation/uninstallation of the package.
 type Installer interface {
@@ -54,11 +57,15 @@ func NewForPackage(options Options) (Installer, error) {
 		return nil, fmt.Errorf("failed to get kibana version: %w", err)
 	}
 
-	supportsZip := !version.LessThan(semver8_7_0)
+	supportsUploadZip, reason, err := isAllowedInstallationViaApi(context.TODO(), options.Kibana, version)
+	if err != nil {
+		return nil, fmt.Errorf("failed to validate whether or not it can be used upload API: %w", err)
+	}
 	if options.ZipPath != "" {
-		if !supportsZip {
-			return nil, fmt.Errorf("not supported uploading zip packages in Kibana %s (%s required)", version, semver8_7_0)
+		if !supportsUploadZip {
+			return nil, errors.New(reason)
 		}
+
 		if !options.SkipValidation {
 			logger.Debugf("Validating built .zip package (path: %s)", options.ZipPath)
 			errs, skipped := validation.ValidateAndFilterFromZip(options.ZipPath)
@@ -75,20 +82,41 @@ func NewForPackage(options Options) (Installer, error) {
 
 	target, err := builder.BuildPackage(builder.BuildOptions{
 		PackageRoot:    options.RootPath,
-		CreateZip:      supportsZip,
+		CreateZip:      supportsUploadZip,
 		SignPackage:    false,
 		SkipValidation: options.SkipValidation,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("failed to build package: %v", err)
 	}
 
-	if supportsZip {
+	if supportsUploadZip {
 		return CreateForZip(options.Kibana, target)
 	}
 	return CreateForManifest(options.Kibana, target)
 }
 
+func isAllowedInstallationViaApi(ctx context.Context, kbnClient *kibana.Client, kibanaVersion *semver.Version) (bool, string, error) {
+	reason := ""
+	if kibanaVersion.LessThan(semver8_7_0) {
+		reason = fmt.Sprintf("not supported uploading zip packages in Kibana %s (%s required)", kibanaVersion, semver8_7_0)
+		return false, reason, nil
+	}
+
+	if kibanaVersion.LessThan(semver8_8_2) {
+		err := kbnClient.EnsureZipPackageCanBeInstalled(ctx)
+		if errors.Is(err, kibana.ErrNotSupported) {
+			reason = fmt.Sprintf("not supported uploading zip packages in Kibana %s (%s required or Enteprise license)", kibanaVersion, semver8_8_2)
+			return false, reason, nil
+		}
+		if err != nil {
+			return false, "", err
+		}
+	}
+
+	return true, "", nil
+}
+
 func kibanaVersion(kibana *kibana.Client) (*semver.Version, error) {
 	version, err := kibana.Version()
 	if err != nil {