fixed cmd_delay | updated default timout temprorary

Author: RawthiL

pkg/relayer/cmd/cmd_relay.go

@@ -14,6 +14,7 @@ import (
 	"net/url"
 	"os"
 	"strings"
+	"time"
 
 	"github.com/cosmos/cosmos-sdk/client"
 	cosmosflags "github.com/cosmos/cosmos-sdk/client/flags"
@@ -347,43 +348,49 @@ func runRelay(cmd *cobra.Command, args []string) error {
 	}
 	logger.Info().Msgf("✅ Endpoint URL parsed: %v", reqUrl)
 
+	// Create http client
+	backendClient := &http.Client{
+		Timeout: 600 * time.Second,
+	}
+
+	ctxWithTimeout, cancelFn := context.WithTimeout(context.Background(), 600*time.Second)
+	defer cancelFn()
+
 	// Send multiple requests sequentially as specified by the count flag
 	for i := 1; i <= flagRelayRequestCount; i++ {
+
 		// Create the HTTP request with the relay request body
-		httpReq := &http.Request{
-			Method: http.MethodPost,
-			URL:    reqUrl,
-			Body:   io.NopCloser(bytes.NewReader(relayReqBz)),
+		httpReq, err := http.NewRequestWithContext(
+			ctxWithTimeout,
+			http.MethodPost, // This is the method to the Relay Miner node
+			reqUrl.String(),
+			io.NopCloser(bytes.NewReader(relayReqBz)),
+		)
+		if err != nil {
+			logger.Error().Err(err).Msg("❌ Error creating relay request")
+			continue
 		}
 
 		// Send the request HTTP request containing the signed relay request
-		httpResp, err := http.DefaultClient.Do(httpReq)
+		httpResp, err := backendClient.Do(httpReq)
 		if err != nil {
 			logger.Error().Err(err).Msg("❌ Error sending relay request")
-			proxy.CloseRequestBody(logger, httpResp.Body)
-			continue
-		}
-
-		bodyCloseErr := httpResp.Body.Close()
-		if bodyCloseErr != nil {
-			logger.Error().Err(bodyCloseErr).Msg("❌ Error closing response body")
-			proxy.CloseRequestBody(logger, httpResp.Body)
 			continue
 		}
 
 		// Ensure the supplier operator signature is present
 		supplierSignerAddress := signedRelayReq.Meta.SupplierOperatorAddress
 		if supplierSignerAddress == "" {
 			logger.Error().Msg("❌ Supplier operator signature is missing")
-			proxy.CloseRequestBody(logger, httpResp.Body)
+			proxy.CloseBody(logger, httpResp.Body)
 			continue
 		}
 		// Ensure the supplier operator address matches the expected address
 		if flagRelaySupplier == "" {
 			logger.Warn().Msg("⚠️ Supplier operator address not specified, skipping signature check")
 		} else if supplierSignerAddress != flagRelaySupplier {
 			logger.Error().Msgf("❌ Supplier operator address %s does not match the expected address %s", supplierSignerAddress, flagRelaySupplier)
-			proxy.CloseRequestBody(logger, httpResp.Body)
+			proxy.CloseBody(logger, httpResp.Body)
 			continue
 		}
 
@@ -392,18 +399,22 @@ func runRelay(cmd *cobra.Command, args []string) error {
 		// Handle response according to type
 		if proxy.IsStreamingResponse(httpResp) {
 			streamErr := processStreamRequest(ctx, httpResp, supplierSignerAddress, accountClient, logger)
-			proxy.CloseRequestBody(logger, httpResp.Body)
+			proxy.CloseBody(logger, httpResp.Body)
 			if streamErr != nil {
 				logger.Error().Err(streamErr).Msg("❌ Stream errored")
 			}
 		} else {
 			// Normal, non-streaming request
 			reqErr := processNormalRequest(ctx, httpResp, supplierSignerAddress, accountClient, logger)
-			proxy.CloseRequestBody(logger, httpResp.Body)
+			proxy.CloseBody(logger, httpResp.Body)
 			if reqErr != nil {
 				logger.Error().Err(reqErr).Msg("❌ Request errored")
 			}
 		}
+
+		// This is intentionally not a defer because the loop could introduce memory leaks,
+		// performance issues and bad connection management for high flagRelayRequestCount values
+		proxy.CloseBody(logger, httpResp.Body)
 	}
 
 	return nil

pkg/relayer/config/relayminer_configs_reader.go

@@ -9,7 +9,7 @@ import (
 
 // DefaultRequestTimeoutSeconds is the default timeout for requests in seconds.
 // If not specified in the config, it will be used as a fallback.
-const DefaultRequestTimeoutSeconds = 10
+const DefaultRequestTimeoutSeconds = 600
 
 // DefaultMaxBodySize defines the default maximum HTTP body size as a string, used as a fallback if unspecified.
 const DefaultMaxBodySize = "20MB"

pkg/relayer/proxy/sync.go

@@ -300,26 +300,13 @@ func (server *relayMinerHTTPServer) serveSyncRequest(
 			Msg("backend service returned a non-2XX status code. Passing it through to the client.")
 	}
 
-	// Check if the response is a stream
-	isStream := IsStreamingResponse(httpResponse)
-	// Create empty relay response
-	var relayResponse *types.RelayResponse
-	var responseSize float64
-	if isStream {
-		logger.Debug().Msg("Handling streaming request.")
-
-		// Process and assign the relay response
-		relayResponse, responseSize, err = server.HandleHttpStream(httpResponse, writer, meta, logger)
-		if err != nil {
-			return relayRequest, err
-		}
-	} else {
-		logger.Debug().Msg("Handling normal request.")
-
 	// Check if the response is a stream
 	streamThis := IsStreamingResponse(httpResponse)
 	// Create empty relay response
-	var relayResponse *types.RelayResponse
+	relayResponse := &types.RelayResponse{
+		Meta:    types.RelayResponseMetadata{SessionHeader: meta.SessionHeader},
+		Payload: nil,
+	}
 	var responseSize float64
 	if streamThis {
 		logger.Debug().Msg("Handling streaming request.")