Add request action protocols selection

Author: bukka

TODO.md

@@ -48,9 +48,6 @@ in the future.
 
 #### Structure - Instances, Actions, Servers, Services
 
-- http/2 requests
-  - add http_version field to the request action
-  - update the client to allow using http/2
 - extend request action to support file upload
   - it should chunked update and set option to set delay between chunks to be able to create server timeouts
   - it should also allow doing partial unfinished uploads
@@ -76,6 +73,9 @@ in the future.
 - support TLS config in bench action
   - this will likely require using custom transport
 - extend TLS config for request and bench to support client cert
+- support `protocols` field in bench action
+  - extract the common logic
+- extend protocols to support http3 in bench and request action
 - integrate better instance action identification
   - it should introduce name for each action and also pass parent name to nested actions in `parallel` or `not`
 - add execute action custom environment variables support

conf/parser/parser.go

@@ -16,18 +16,19 @@ package parser
 
 import (
 	"fmt"
+	"math"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+
 	"github.com/pkg/errors"
 	"github.com/spf13/afero"
 	"github.com/wstool/wst/app"
 	"github.com/wstool/wst/conf/loader"
 	"github.com/wstool/wst/conf/parser/factory"
 	"github.com/wstool/wst/conf/parser/location"
 	"github.com/wstool/wst/conf/types"
-	"math"
-	"path/filepath"
-	"reflect"
-	"strconv"
-	"strings"
 )
 
 type ConfigParam string
@@ -174,13 +175,36 @@ func (p *ConfigParser) processFactoryParam(
 
 func (p *ConfigParser) processEnumParam(enums string, data interface{}, fieldName string) error {
 	enumList := strings.Split(enums, "|")
-	for _, enum := range enumList {
-		if enum == data {
-			return nil
+
+	// Check if data is a slice/array
+	dataValue := reflect.ValueOf(data)
+	if dataValue.Kind() == reflect.Slice || dataValue.Kind() == reflect.Array {
+		// Validate each element in the array
+		for i := 0; i < dataValue.Len(); i++ {
+			elem := dataValue.Index(i).Interface()
+			if !isValidEnum(elem, enumList) {
+				return errors.Errorf("value %v at index %d is not valid for field %s (valid values: %s)",
+					elem, i, fieldName, enums)
+			}
 		}
+		return nil
 	}
 
-	return errors.Errorf("values %v are not valid for field %s", enums, p.Pos())
+	// Single value validation
+	if !isValidEnum(data, enumList) {
+		return errors.Errorf("value %v is not valid for field %s (valid values: %s)",
+			data, fieldName, enums)
+	}
+	return nil
+}
+
+func isValidEnum(value interface{}, enumList []string) bool {
+	for _, enum := range enumList {
+		if enum == fmt.Sprintf("%v", value) {
+			return true
+		}
+	}
+	return false
 }
 
 func (p *ConfigParser) processKeysParam(keys string, data interface{}, fieldName string) error {

conf/parser/parser_test.go

@@ -16,6 +16,11 @@ package parser
 
 import (
 	"fmt"
+	"math"
+	"os"
+	"reflect"
+	"testing"
+
 	"github.com/pkg/errors"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
@@ -28,10 +33,6 @@ import (
 	appMocks "github.com/wstool/wst/mocks/generated/app"
 	loaderMocks "github.com/wstool/wst/mocks/generated/conf/loader"
 	factoryMocks "github.com/wstool/wst/mocks/generated/conf/parser/factory"
-	"math"
-	"os"
-	"reflect"
-	"testing"
 )
 
 func Test_isValidParam(t *testing.T) {
@@ -293,19 +294,33 @@ func Test_ConfigParser_processEnumParam(t *testing.T) {
 		wantErr   bool
 	}{
 		{
-			name:      "Value found in enum list",
+			name:      "Value found in enum list for single value",
 			enums:     "enum1|enum2|enum3",
 			data:      "enum2",
 			fieldName: "field",
 			wantErr:   false, // No error because data is in enum list
 		},
 		{
-			name:      "Value not found - should trigger error",
+			name:      "Value found in enum list for multiple values",
+			enums:     "enum1|enum2|enum3",
+			data:      []string{"enum2", "enum3"},
+			fieldName: "field",
+			wantErr:   false, // No error because all data items are in enum list
+		},
+		{
+			name:      "Value not found in a single value",
 			enums:     "enum1|enum2|enum3",
 			data:      "enum4",
 			fieldName: "field",
 			wantErr:   true, // Error because data is not in enum list
 		},
+		{
+			name:      "Value not found in multiple values",
+			enums:     "enum1|enum2|enum3",
+			data:      []string{"enum2", "enum4"},
+			fieldName: "field",
+			wantErr:   true, // Error because one item in data is not in enum list
+		},
 	}
 
 	for _, tt := range tests {

conf/types/action.go

@@ -120,6 +120,7 @@ type RequestAction struct {
 	OnFailure  string          `wst:"on_failure,enum=fail|ignore|skip,default=fail"`
 	Id         string          `wst:"id,default=last"`
 	Scheme     string          `wst:"scheme,enum=http|https,default=http"`
+	Protocols  []string        `wst:"protocols,enum=http1.1|http2"`
 	Path       string          `wst:"path"`
 	EncodePath bool            `wst:"encode_path,default=true"`
 	Method     string          `wst:"method,enum=GET|HEAD|DELETE|POST|PUT|PATCH|PURGE,default=GET"`

run/actions/action/request/request.go

@@ -31,6 +31,13 @@ import (
 	"github.com/wstool/wst/run/services"
 )
 
+type Protocol string
+
+const (
+	ProtocolHTTP11 Protocol = "http1.1"
+	ProtocolHTTP2  Protocol = "http2"
+)
+
 type Maker interface {
 	Make(
 		config *types.RequestAction,
@@ -67,6 +74,28 @@ func (m *ActionMaker) Make(
 		return nil, errors.New("TLS configuration is only valid for HTTPS requests")
 	}
 
+	// Set default protocols if not specified
+	protocols := config.Protocols
+	if len(protocols) == 0 {
+		if config.Scheme == "https" {
+			// Default for HTTPS: allow both HTTP/1.1 and HTTP/2
+			protocols = []string{string(ProtocolHTTP11), string(ProtocolHTTP2)}
+		} else {
+			// Default for HTTP: only HTTP/1.1 (h2c is not commonly supported)
+			protocols = []string{string(ProtocolHTTP11)}
+		}
+	}
+
+	// Convert strings to Protocol type and validate
+	validatedProtocols := make([]Protocol, 0, len(protocols))
+	for _, protoStr := range protocols {
+		proto := Protocol(protoStr)
+		if proto == ProtocolHTTP2 && config.Scheme != "https" {
+			m.fnd.Logger().Infof("Using unencrypted HTTP/2 (h2c) over plain HTTP")
+		}
+		validatedProtocols = append(validatedProtocols, proto)
+	}
+
 	return &Action{
 		fnd:        m.fnd,
 		service:    svc,
@@ -80,6 +109,7 @@ func (m *ActionMaker) Make(
 		method:     config.Method,
 		headers:    config.Headers,
 		tls:        &config.TLS,
+		protocols:  validatedProtocols,
 	}, nil
 }
 
@@ -121,6 +151,7 @@ type Action struct {
 	method     string
 	headers    types.Headers
 	tls        *types.TLSClientConfig
+	protocols  []Protocol
 }
 
 func (a *Action) When() action.When {
@@ -136,34 +167,32 @@ func (a *Action) Timeout() time.Duration {
 }
 
 func (a *Action) Execute(ctx context.Context, runData runtime.Data) (bool, error) {
-	a.fnd.Logger().Infof("Executing request action")
+	a.fnd.Logger().Infof("Executing request action with HTTP protocols: %v", a.protocols)
 
-	// Create transport.
+	// Create transport
 	tr := &http.Transport{}
+
+	// Configure protocols using the Protocols API
+	protocolConfig := a.buildProtocolConfig()
+	tr.Protocols = protocolConfig
+
 	if a.scheme == "https" {
-		tlsConfig := &tls.Config{
-			InsecureSkipVerify: a.tls.SkipVerify,
-		}
-		if a.tls.CACert != "" {
-			caCert, err := a.service.FindCertificate(a.tls.CACert)
-			if err != nil {
-				return false, errors.Errorf("CA certificate %s not found", a.tls.CACert)
-			}
-			caCertPool := a.fnd.X509CertPool()
-			if !caCertPool.AppendCertFromPEM(caCert.Certificate.CertificateData()) {
-				return false, errors.New("failed to parse CA certificate")
-			}
-			tlsConfig.RootCAs = caCertPool.CertPool()
+		tlsConfig, err := a.buildTLSConfig()
+		if err != nil {
+			return false, err
 		}
 		tr.TLSClientConfig = tlsConfig
 	}
 
+	a.fnd.Logger().Debugf("Protocol configuration: HTTP/1=%t, HTTP/2=%t, UnencryptedHTTP/2=%t",
+		protocolConfig.HTTP1(), protocolConfig.HTTP2(), protocolConfig.UnencryptedHTTP2())
+
 	publicUrl, err := a.service.PublicUrl(a.scheme, a.path)
 	if err != nil {
 		return false, err
 	}
 
-	// Create the HTTP request.
+	// Create the HTTP request
 	req, err := http.NewRequestWithContext(ctx, a.method, publicUrl, nil)
 	if err != nil {
 		return false, err
@@ -178,27 +207,27 @@ func (a *Action) Execute(ctx context.Context, runData runtime.Data) (bool, error
 		}
 	}
 
-	// Add headers to the request.
+	// Add headers to the request
 	for key, value := range a.headers {
 		req.Header.Add(key, value)
 	}
 	a.fnd.Logger().Debugf("Sending request: %s", requestToString(req))
 
-	// Send the request.
+	// Send the request
 	client := a.fnd.HttpClient(tr)
 	resp, err := client.Do(req)
 	if err != nil {
 		return false, err
 	}
 	defer resp.Body.Close()
 
-	// Read the response body.
+	// Read the response body
 	body, err := readResponse(ctx, resp.Body)
 	if err != nil {
 		return false, err
 	}
 
-	// Create a ResponseData instance to hold both body and headers.
+	// Create a ResponseData instance to hold both body and headers
 	responseData := ResponseData{
 		Status:     resp.Status,
 		StatusCode: resp.StatusCode,
@@ -207,16 +236,57 @@ func (a *Action) Execute(ctx context.Context, runData runtime.Data) (bool, error
 		Headers:    resp.Header,
 	}
 
-	// Store the ResponseData in runData.
+	// Store the ResponseData in runData
 	key := fmt.Sprintf("response/%s", a.id)
-	a.fnd.Logger().Debugf("Storing response %s: %s", key, responseData)
+	a.fnd.Logger().Debugf("Storing response %s: %s (protocol: %s)", key, responseData, resp.Proto)
 	if err := runData.Store(key, responseData); err != nil {
 		return false, err
 	}
 
 	return true, nil
 }
 
+func (a *Action) buildProtocolConfig() *http.Protocols {
+	config := new(http.Protocols)
+
+	for _, proto := range a.protocols {
+		switch proto {
+		case ProtocolHTTP11:
+			config.SetHTTP1(true)
+		case ProtocolHTTP2:
+			if a.scheme == "https" {
+				// HTTP/2 over TLS
+				config.SetHTTP2(true)
+			} else {
+				// HTTP/2 cleartext (h2c) over plain HTTP
+				config.SetUnencryptedHTTP2(true)
+			}
+		}
+	}
+
+	return config
+}
+
+func (a *Action) buildTLSConfig() (*tls.Config, error) {
+	tlsConfig := &tls.Config{
+		InsecureSkipVerify: a.tls.SkipVerify,
+	}
+
+	if a.tls.CACert != "" {
+		caCert, err := a.service.FindCertificate(a.tls.CACert)
+		if err != nil {
+			return nil, errors.Errorf("CA certificate %s not found", a.tls.CACert)
+		}
+		caCertPool := a.fnd.X509CertPool()
+		if !caCertPool.AppendCertFromPEM(caCert.Certificate.CertificateData()) {
+			return nil, errors.New("failed to parse CA certificate")
+		}
+		tlsConfig.RootCAs = caCertPool.CertPool()
+	}
+
+	return tlsConfig, nil
+}
+
 func requestToString(req *http.Request) string {
 	var headers string
 	for name, values := range req.Header {