refactor: used a common http client for all the requests

client/httpClient.go

@@ -0,0 +1,23 @@
+package client
+
+import (
+	"net/http"
+	"razor/core"
+	"time"
+)
+
+var httpClient *http.Client
+
+func InitHttpClient(httpTimeout int64) {
+	httpClient = &http.Client{
+		Timeout: time.Duration(httpTimeout) * time.Second,
+		Transport: &http.Transport{
+			MaxIdleConns:        core.HTTPClientMaxIdleConns,
+			MaxIdleConnsPerHost: core.HTTPClientMaxIdleConnsPerHost,
+		},
+	}
+}
+
+func GetHttpClient() *http.Client {
+	return httpClient
+}

cmd/config-utils.go

@@ -99,7 +99,6 @@ func (*UtilsStruct) GetConfigData() (types.Configurations, error) {
 	config.RPCTimeout = rpcTimeout
 	utils.RPCTimeout = rpcTimeout
 	config.HTTPTimeout = httpTimeout
-	utils.HTTPTimeout = httpTimeout
 	config.LogFileMaxSize = logFileMaxSize
 	config.LogFileMaxBackups = logFileMaxBackups
 	config.LogFileMaxAge = logFileMaxAge

cmd/vote.go

@@ -10,6 +10,7 @@ import (
 	"os/signal"
 	"path/filepath"
 	"razor/accounts"
+	clientPkg "razor/client"
 	"razor/core"
 	"razor/core/types"
 	"razor/logger"
@@ -88,6 +89,8 @@ func (*UtilsStruct) ExecuteVote(flagSet *pflag.FlagSet) {
 
 	account := types.Account{Address: address, Password: password}
 
+	clientPkg.InitHttpClient(config.HTTPTimeout)
+
 	cmdUtils.HandleExit()
 
 	err = cmdUtils.InitAssetCache(client)

core/constants.go

@@ -86,3 +86,8 @@ var MaxIterations = 10000000
 
 var AssetUpdateListenerInterval = 10
 var AssetCacheExpiry = 5 * EpochLength
+
+// Following are the constants used in custom http.Transport configuration for the common HTTP client that we use for all the requests
+
+var HTTPClientMaxIdleConns = 15
+var HTTPClientMaxIdleConnsPerHost = 5

utils/api.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"net/http"
 	"razor/cache"
+	clientPkg "razor/client"
 	"razor/core"
 	"regexp"
 	"time"
@@ -20,10 +21,6 @@ import (
 )
 
 func GetDataFromAPI(dataSourceURLStruct types.DataSourceURL, localCache *cache.LocalCache) ([]byte, error) {
-	client := http.Client{
-		Timeout: time.Duration(HTTPTimeout) * time.Second,
-	}
-
 	cacheKey, err := generateCacheKey(dataSourceURLStruct.URL, dataSourceURLStruct.Body)
 	if err != nil {
 		log.Errorf("Error in generating cache key for API %s: %v", dataSourceURLStruct.URL, err)
@@ -36,7 +33,7 @@ func GetDataFromAPI(dataSourceURLStruct types.DataSourceURL, localCache *cache.L
 		return cachedData, nil
 	}
 
-	response, err := makeAPIRequest(client, dataSourceURLStruct)
+	response, err := makeAPIRequest(dataSourceURLStruct)
 	if err != nil {
 		return nil, err
 	}
@@ -46,7 +43,7 @@ func GetDataFromAPI(dataSourceURLStruct types.DataSourceURL, localCache *cache.L
 	return response, nil
 }
 
-func makeAPIRequest(client http.Client, dataSourceURLStruct types.DataSourceURL) ([]byte, error) {
+func makeAPIRequest(dataSourceURLStruct types.DataSourceURL) ([]byte, error) {
 	var requestBody io.Reader // Using the broader io.Reader interface here
 
 	switch dataSourceURLStruct.Type {
@@ -68,7 +65,7 @@ func makeAPIRequest(client http.Client, dataSourceURLStruct types.DataSourceURL)
 	var response []byte
 	err := retry.Do(
 		func() error {
-			responseBody, err := ProcessRequest(client, dataSourceURLStruct, requestBody)
+			responseBody, err := ProcessRequest(dataSourceURLStruct, requestBody)
 			if err != nil {
 				log.Errorf("Error in processing %s request: %v", dataSourceURLStruct.Type, err)
 				return err
@@ -124,13 +121,14 @@ func addHeaderToRequest(request *http.Request, headerMap map[string]string) *htt
 	return request
 }
 
-func ProcessRequest(client http.Client, dataSourceURLStruct types.DataSourceURL, requestBody io.Reader) ([]byte, error) {
+func ProcessRequest(dataSourceURLStruct types.DataSourceURL, requestBody io.Reader) ([]byte, error) {
+	httpClient := clientPkg.GetHttpClient()
 	request, err := http.NewRequest(dataSourceURLStruct.Type, dataSourceURLStruct.URL, requestBody)
 	if err != nil {
 		return nil, err
 	}
 	requestWithHeader := addHeaderToRequest(request, dataSourceURLStruct.Header)
-	response, err := client.Do(requestWithHeader)
+	response, err := httpClient.Do(requestWithHeader)
 	if err != nil {
 		log.Errorf("Error sending %s request URL %s: %v", dataSourceURLStruct.Type, dataSourceURLStruct.URL, err)
 		return nil, err

utils/api_test.go

@@ -3,6 +3,7 @@ package utils
 import (
 	"encoding/hex"
 	"razor/cache"
+	clientPkg "razor/client"
 	"razor/core/types"
 	"reflect"
 	"testing"
@@ -164,6 +165,7 @@ func TestGetDataFromAPI(t *testing.T) {
 			wantErr: true,
 		},
 	}
+	clientPkg.InitHttpClient(10)
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			localCache := cache.NewLocalCache(time.Second * 10)

utils/struct-utils.go

@@ -5,6 +5,7 @@ import (
 	"crypto/ecdsa"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io"
 	"io/fs"
 	"math/big"
@@ -29,7 +30,6 @@ import (
 )
 
 var RPCTimeout int64
-var HTTPTimeout int64
 
 func StartRazor(optionsPackageStruct OptionsPackageStruct) Utils {
 	UtilsInterface = optionsPackageStruct.UtilsInterface
@@ -59,30 +59,58 @@ func StartRazor(optionsPackageStruct OptionsPackageStruct) Utils {
 }
 
 func InvokeFunctionWithTimeout(interfaceName interface{}, methodName string, args ...interface{}) []reflect.Value {
-	var functionCall []reflect.Value
-	var gotFunction = make(chan bool)
 	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(RPCTimeout)*time.Second)
 	defer cancel()
 
+	resultChan := make(chan []reflect.Value)
+	errChan := make(chan error)
+
 	go func() {
+		defer close(resultChan)
+		defer close(errChan)
+
 		inputs := make([]reflect.Value, len(args))
-		for i := range args {
-			inputs[i] = reflect.ValueOf(args[i])
+		for i, arg := range args {
+			inputs[i] = reflect.ValueOf(arg)
 		}
-		log.Debug("Blockchain function: ", methodName)
-		functionCall = reflect.ValueOf(interfaceName).MethodByName(methodName).Call(inputs)
-		gotFunction <- true
-	}()
-	for {
+
+		log.Debug("Invoking blockchain function: ", methodName)
+
+		// Attempt to call the function
+		var result []reflect.Value
+		func() {
+			defer func() {
+				if r := recover(); r != nil {
+					errChan <- fmt.Errorf("panic during function call: %v", r)
+				}
+			}()
+			result = reflect.ValueOf(interfaceName).MethodByName(methodName).Call(inputs)
+		}()
+
+		// Send the result back or indicate the function has completed
 		select {
 		case <-ctx.Done():
-			log.Errorf("%s function timeout!", methodName)
-			log.Debug("Kindly check your connection")
-			return nil
-
-		case <-gotFunction:
-			return functionCall
+			// If the context is done, return the context-related error
+			errChan <- ctx.Err()
+		default:
+			resultChan <- result
 		}
+	}()
+
+	select {
+	case <-ctx.Done():
+		log.Errorf("%s function timeout!", methodName)
+		log.Debug("Please check your connection")
+		return nil
+
+	case err := <-errChan:
+		// Handle any errors that occurred during the function call
+		log.Errorf("Error:%v occurred in %s function!", err, methodName)
+		return nil
+
+	case result := <-resultChan:
+		// Function completed successfully
+		return result
 	}
 }