Added a generic function for retry mechanism (#1071)

* Added generic function to implement retry mechanism on top of a function

* Used InvokeFunctionWithRetryAttempts() for retry mechanism

* Moved GetStakerSRZRBalance() from stake.go to stakedToken.go

* Fixed tests

* Added alternate RPC support

* Added alternateProvider as a config paramter

* Added GetAlternateProvider() in GetConfig()

* Fixed GetStringAlternateProvider() usage in setConfig()

* Fixed tests

* Used alternateProvider from config

* Requested changes

Author: Yashk767

client/alternateClient.go

@@ -0,0 +1,63 @@
+package client
+
+import (
+	"github.com/ethereum/go-ethereum/ethclient"
+	"razor/logger"
+	"reflect"
+	"time"
+)
+
+var (
+	log                   = logger.NewLogger()
+	alternateClientStruct AlternateClientStruct
+)
+
+type AlternateClientStruct struct {
+	switchToAlternateClient bool
+	alternateProvider       string
+}
+
+func StartTimerForAlternateClient(switchClientAfterTime uint64) {
+	log.Infof("StartTimerForAlternateClient: Alternate client will be switched back to primary client in %v seconds!", switchClientAfterTime)
+	time.Sleep(time.Duration(switchClientAfterTime) * time.Second)
+	log.Info("Switching back to primary RPC..")
+	SetSwitchToAlternateClientStatus(false)
+}
+
+//ReplaceClientWithAlternateClient will replace the primary client(client from primary RPC) with secondary client which would be created using alternate RPC
+func ReplaceClientWithAlternateClient(arguments []reflect.Value) []reflect.Value {
+	clientDataType := reflect.TypeOf((*ethclient.Client)(nil)).Elem()
+	for i := range arguments {
+		argument := arguments[i]
+		argumentDataType := reflect.TypeOf(argument.Interface()).Elem()
+		if argumentDataType != nil {
+			if argumentDataType == clientDataType {
+				alternateProvider := GetAlternateProvider()
+				alternateClient, dialErr := ethclient.Dial(alternateProvider)
+				if dialErr != nil {
+					log.Errorf("Error in connecting using alternate RPC %v: %v", alternateProvider, dialErr)
+					return arguments
+				}
+				arguments[i] = reflect.ValueOf(alternateClient)
+				return arguments
+			}
+		}
+	}
+	return arguments
+}
+
+func GetSwitchToAlternateClientStatus() bool {
+	return alternateClientStruct.switchToAlternateClient
+}
+
+func SetSwitchToAlternateClientStatus(status bool) {
+	alternateClientStruct.switchToAlternateClient = status
+}
+
+func GetAlternateProvider() string {
+	return alternateClientStruct.alternateProvider
+}
+
+func SetAlternateProvider(alternateProvider string) {
+	alternateClientStruct.alternateProvider = alternateProvider
+}

cmd/config-utils.go

@@ -2,6 +2,7 @@
 package cmd
 
 import (
+	"razor/client"
 	"razor/core"
 	"razor/core/types"
 	"razor/utils"
@@ -14,6 +15,7 @@ import (
 func (*UtilsStruct) GetConfigData() (types.Configurations, error) {
 	config := types.Configurations{
 		Provider:           "",
+		AlternateProvider:  "",
 		GasMultiplier:      0,
 		BufferPercent:      0,
 		WaitTime:           0,
@@ -30,6 +32,10 @@ func (*UtilsStruct) GetConfigData() (types.Configurations, error) {
 	if err != nil {
 		return config, err
 	}
+	alternateProvider, err := cmdUtils.GetAlternateProvider()
+	if err != nil {
+		return config, err
+	}
 	gasMultiplier, err := cmdUtils.GetMultiplier()
 	if err != nil {
 		return config, err
@@ -79,6 +85,8 @@ func (*UtilsStruct) GetConfigData() (types.Configurations, error) {
 		return config, err
 	}
 	config.Provider = provider
+	config.AlternateProvider = alternateProvider
+	client.SetAlternateProvider(alternateProvider)
 	config.GasMultiplier = gasMultiplier
 	config.BufferPercent = bufferPercent
 	config.WaitTime = waitTime
@@ -117,6 +125,26 @@ func (*UtilsStruct) GetProvider() (string, error) {
 	return provider, nil
 }
 
+//This function returns the alternate provider
+func (*UtilsStruct) GetAlternateProvider() (string, error) {
+	alternateProvider, err := flagSetUtils.GetRootStringAlternateProvider()
+	if err != nil {
+		return core.DefaultAlternateProvider, err
+	}
+	if alternateProvider == "" {
+		if viper.IsSet("alternateProvider") {
+			alternateProvider = viper.GetString("alternateProvider")
+		} else {
+			alternateProvider = core.DefaultAlternateProvider
+			log.Debug("alternate provider is not set, taking its default value ", alternateProvider)
+		}
+	}
+	if !strings.HasPrefix(alternateProvider, "https") {
+		log.Warn("You are not using a secure RPC URL. Switch to an https URL instead to be safe.")
+	}
+	return alternateProvider, nil
+}
+
 //This function returns the multiplier
 func (*UtilsStruct) GetMultiplier() (float32, error) {
 	gasMultiplier, err := flagSetUtils.GetRootFloat32GasMultiplier()

cmd/config-utils_test.go

@@ -11,6 +11,7 @@ import (
 func TestGetConfigData(t *testing.T) {
 	nilConfig := types.Configurations{
 		Provider:           "",
+		AlternateProvider:  "",
 		GasMultiplier:      0,
 		BufferPercent:      0,
 		WaitTime:           0,
@@ -25,6 +26,7 @@ func TestGetConfigData(t *testing.T) {
 
 	configData := types.Configurations{
 		Provider:           "",
+		AlternateProvider:  "",
 		GasMultiplier:      1,
 		BufferPercent:      20,
 		WaitTime:           1,
@@ -41,6 +43,8 @@ func TestGetConfigData(t *testing.T) {
 	type args struct {
 		provider             string
 		providerErr          error
+		alternateProvider    string
+		alternateProviderErr error
 		gasMultiplier        float32
 		gasMultiplierErr     error
 		bufferPercent        int32
@@ -76,6 +80,7 @@ func TestGetConfigData(t *testing.T) {
 			name: "Test 1: When GetConfigData function executes successfully",
 			args: args{
 				provider:          "",
+				alternateProvider: "",
 				gasMultiplier:     1,
 				bufferPercent:     20,
 				waitTime:          1,
@@ -163,12 +168,21 @@ func TestGetConfigData(t *testing.T) {
 			want:    nilConfig,
 			wantErr: errors.New("httpTimeout error"),
 		},
+		{
+			name: "Test 11: When there is an error in getting alternate provider",
+			args: args{
+				alternateProviderErr: errors.New("alternate provider error"),
+			},
+			want:    nilConfig,
+			wantErr: errors.New("alternate provider error"),
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			SetUpMockInterfaces()
 
 			cmdUtilsMock.On("GetProvider").Return(tt.args.provider, tt.args.providerErr)
+			cmdUtilsMock.On("GetAlternateProvider").Return(tt.args.alternateProvider, tt.args.alternateProviderErr)
 			cmdUtilsMock.On("GetMultiplier").Return(tt.args.gasMultiplier, tt.args.gasMultiplierErr)
 			cmdUtilsMock.On("GetWaitTime").Return(tt.args.waitTime, tt.args.waitTimeErr)
 			cmdUtilsMock.On("GetGasPrice").Return(tt.args.gasPrice, tt.args.gasPriceErr)
@@ -630,6 +644,74 @@ func TestGetProvider(t *testing.T) {
 	}
 }
 
+func TestGetAlternateProvider(t *testing.T) {
+	type args struct {
+		alternateProvider    string
+		alternateProviderErr error
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr error
+	}{
+		{
+			name: "Test 1: When getAlternateProvider function execute successfully",
+			args: args{
+				alternateProvider: "https://polygon-mumbai.g.alchemy.com/v2/-Re1lE3oDIVTWchuKMfRIECn0I",
+			},
+			want:    "https://polygon-mumbai.g.alchemy.com/v2/-Re1lE3oDIVTWchuKMfRIECn0I",
+			wantErr: nil,
+		},
+		{
+			name: "Test 2: When alternate provider has prefix https",
+			args: args{
+				alternateProvider: "127.0.0.1:8545",
+			},
+			want:    "127.0.0.1:8545",
+			wantErr: nil,
+		},
+		{
+			name: "Test 3: When there is an error in getting alternate provider",
+			args: args{
+				alternateProviderErr: errors.New("alternateProvider error"),
+			},
+			want:    "http://127.0.0.1:8545",
+			wantErr: errors.New("alternateProvider error"),
+		},
+		{
+			name: "Test 4: When alternate provider is nil",
+			args: args{
+				alternateProvider: "",
+			},
+			want:    "http://127.0.0.1:8545",
+			wantErr: nil,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			SetUpMockInterfaces()
+
+			flagSetMock.On("GetRootStringAlternateProvider").Return(tt.args.alternateProvider, tt.args.alternateProviderErr)
+			utils := &UtilsStruct{}
+
+			got, err := utils.GetAlternateProvider()
+			if got != tt.want {
+				t.Errorf("getAlternateProvider() got = %v, want %v", got, tt.want)
+			}
+			if err == nil || tt.wantErr == nil {
+				if err != tt.wantErr {
+					t.Errorf("Error for getAlternateProvider function, got = %v, want = %v", err, tt.wantErr)
+				}
+			} else {
+				if err.Error() != tt.wantErr.Error() {
+					t.Errorf("Error for getAlternateProvider function, got = %v, want = %v", err, tt.wantErr)
+				}
+			}
+		})
+	}
+}
+
 func TestGetWaitTime(t *testing.T) {
 	type args struct {
 		waitTime    int32

cmd/interface.go

@@ -111,6 +111,7 @@ type AssetManagerInterface interface {
 
 type FlagSetInterface interface {
 	GetStringProvider(flagSet *pflag.FlagSet) (string, error)
+	GetStringAlternateProvider(flagSet *pflag.FlagSet) (string, error)
 	GetFloat32GasMultiplier(flagSet *pflag.FlagSet) (float32, error)
 	GetInt32Buffer(flagSet *pflag.FlagSet) (int32, error)
 	GetInt32Wait(flagSet *pflag.FlagSet) (int32, error)
@@ -122,6 +123,7 @@ type FlagSetInterface interface {
 	GetInt64HTTPTimeout(flagSet *pflag.FlagSet) (int64, error)
 	GetUint32BountyId(flagSet *pflag.FlagSet) (uint32, error)
 	GetRootStringProvider() (string, error)
+	GetRootStringAlternateProvider() (string, error)
 	GetRootFloat32GasMultiplier() (float32, error)
 	GetRootInt32Buffer() (int32, error)
 	GetRootInt32Wait() (int32, error)
@@ -167,6 +169,7 @@ type FlagSetInterface interface {
 type UtilsCmdInterface interface {
 	SetConfig(flagSet *pflag.FlagSet) error
 	GetProvider() (string, error)
+	GetAlternateProvider() (string, error)
 	GetMultiplier() (float32, error)
 	GetWaitTime() (int32, error)
 	GetGasPrice() (int32, error)

cmd/mocks/flag_set_interface.go

@@ -15,6 +15,7 @@ import (
 
 var (
 	Provider           string
+	AlternateProvider  string
 	GasMultiplier      float32
 	BufferPercent      int32
 	WaitTime           int32
@@ -61,6 +62,7 @@ func init() {
 	cobra.OnInitialize(initConfig)
 
 	rootCmd.PersistentFlags().StringVarP(&Provider, "provider", "p", "", "provider name")
+	rootCmd.PersistentFlags().StringVarP(&AlternateProvider, "alternateProvider", "", "", "alternate provider name")
 	rootCmd.PersistentFlags().Float32VarP(&GasMultiplier, "gasmultiplier", "g", -1, "gas multiplier value")
 	rootCmd.PersistentFlags().Int32VarP(&BufferPercent, "buffer", "b", 0, "buffer percent")
 	rootCmd.PersistentFlags().Int32VarP(&WaitTime, "wait", "w", -1, "wait time")
@@ -115,6 +117,7 @@ func setLogLevel() {
 
 	log.Debug("Config details: ")
 	log.Debugf("Provider: %s", config.Provider)
+	log.Debugf("Alternate Provider: %s", config.AlternateProvider)
 	log.Debugf("Gas Multiplier: %.2f", config.GasMultiplier)
 	log.Debugf("Buffer Percent: %d", config.BufferPercent)
 	log.Debugf("Wait Time: %d", config.WaitTime)