Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use Retry method of utils Package

Best Rod code snippet using utils.Retry

option.go

Source:option.go

...271		di.Push("WithConnReporterEnabled()")272		o.RemoteOpt.EnableConnPoolReporter = true273	}}274}275// WithFailureRetry sets the failure retry policy for client, it will take effect for all methods.276func WithFailureRetry(p *retry.FailurePolicy) Option {277	return Option{F: func(o *client.Options, di *utils.Slice) {278		if p == nil {279			return280		}281		di.Push(fmt.Sprintf("WithFailureRetry(%+v)", *p))282		if o.RetryMethodPolicies == nil {283			o.RetryMethodPolicies = make(map[string]retry.Policy)284		}285		if o.RetryMethodPolicies[retry.Wildcard].BackupPolicy != nil {286			panic("BackupPolicy has been setup, cannot support Failure Retry at same time")287		}288		o.RetryMethodPolicies[retry.Wildcard] = retry.BuildFailurePolicy(p)289	}}290}291// WithBackupRequest sets the backup request policy for client, it will take effect for all methods.292func WithBackupRequest(p *retry.BackupPolicy) Option {293	return Option{F: func(o *client.Options, di *utils.Slice) {294		if p == nil {295			return296		}297		di.Push(fmt.Sprintf("WithBackupRequest(%+v)", *p))298		if o.RetryMethodPolicies == nil {299			o.RetryMethodPolicies = make(map[string]retry.Policy)300		}301		if o.RetryMethodPolicies[retry.Wildcard].FailurePolicy != nil {302			panic("BackupPolicy has been setup, cannot support Failure Retry at same time")303		}304		o.RetryMethodPolicies[retry.Wildcard] = retry.BuildBackupRequest(p)305	}}306}307// WithRetryMethodPolicies sets the retry policy for method.308// The priority is higher than WithFailureRetry and WithBackupRequest. Only the methods which are not included by309// this config will use the policy that is configured by WithFailureRetry or WithBackupRequest .310// FailureRetry and BackupRequest can be set for different method at same time.311// Notice: method name is case-sensitive, it should be same with the definition in IDL.312func WithRetryMethodPolicies(mp map[string]retry.Policy) Option {313	return Option{F: func(o *client.Options, di *utils.Slice) {314		if mp == nil {315			return316		}317		di.Push(fmt.Sprintf("WithRetryMethodPolicies(%+v)", mp))318		if o.RetryMethodPolicies == nil {319			o.RetryMethodPolicies = make(map[string]retry.Policy)320		}321		wildcardCfg := o.RetryMethodPolicies[retry.Wildcard]322		o.RetryMethodPolicies = mp323		if wildcardCfg.Enable && !mp[retry.Wildcard].Enable {324			// if there is enabled wildcard config before, keep it325			o.RetryMethodPolicies[retry.Wildcard] = wildcardCfg326		}327	}}328}329// WithSpecifiedResultRetry is used with FailureRetry.330// When you enable FailureRetry and want to retry with the specified error or response, you can configure this Option.331// ShouldResultRetry is defined inside retry.FailurePolicy, so WithFailureRetry also can set ShouldResultRetry.332// But if your retry policy is enabled by remote config, WithSpecifiedResultRetry is useful.333func WithSpecifiedResultRetry(rr *retry.ShouldResultRetry) Option {334	return Option{F: func(o *client.Options, di *utils.Slice) {335		if rr == nil {336			return337		}338		di.Push(fmt.Sprintf("WithSpecifiedResultRetry(%+v)", rr))339		o.RetryWithResult = rr340	}}341}342// WithCircuitBreaker adds a circuitbreaker suite for the client.343func WithCircuitBreaker(s *circuitbreak.CBSuite) Option {344	return Option{F: func(o *client.Options, di *utils.Slice) {345		di.Push("WithCircuitBreaker()")346		o.CBSuite = s347	}}348}349// WithGRPCConnPoolSize sets the value for the client connection pool size.350// In general, you should not adjust the size of the connection pool, otherwise it may cause performance degradation.351// You should adjust the size according to the actual situation.352func WithGRPCConnPoolSize(s uint32) Option {353	return Option{F: func(o *client.Options, di *utils.Slice) {...

client_methods_test.go

Source:client_methods_test.go

...12	"razor/utils/mocks"13	"reflect"14	"testing"15)16func TestOptionUtilsStruct_SuggestGasPriceWithRetry(t *testing.T) {17	var client *ethclient.Client18	type args struct {19		gasPrice    *big.Int20		gasPriceErr error21	}22	tests := []struct {23		name    string24		args    args25		want    *big.Int26		wantErr bool27	}{28		{29			name: "Test 1: When SuggestGasPriceWithRetry() executes successfully",30			args: args{31				gasPrice: big.NewInt(1),32			},33			want:    big.NewInt(1),34			wantErr: false,35		},36		{37			name: "Test 2: When there is an error in getting gasPrice",38			args: args{39				gasPriceErr: errors.New("gasPrice Error"),40			},41			want:    nil,42			wantErr: true,43		},44	}45	for _, tt := range tests {46		t.Run(tt.name, func(t *testing.T) {47			retryMock := new(mocks.RetryUtils)48			clientMock := new(mocks.ClientUtils)49			optionsPackageStruct := OptionsPackageStruct{50				RetryInterface:  retryMock,51				ClientInterface: clientMock,52			}53			utils := StartRazor(optionsPackageStruct)54			clientMock.On("SuggestGasPrice", mock.AnythingOfType("*ethclient.Client"), context.Background()).Return(tt.args.gasPrice, tt.args.gasPriceErr)55			retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1))56			got, err := utils.SuggestGasPriceWithRetry(client)57			if (err != nil) != tt.wantErr {58				t.Errorf("SuggestGasPriceWithRetry() error = %v, wantErr %v", err, tt.wantErr)59				return60			}61			if !reflect.DeepEqual(got, tt.want) {62				t.Errorf("SuggestGasPriceWithRetry() got = %v, want %v", got, tt.want)63			}64		})65	}66}67func TestUtilsStruct_BalanceAtWithRetry(t *testing.T) {68	var client *ethclient.Client69	var account common.Address70	type args struct {71		balance    *big.Int72		balanceErr error73	}74	tests := []struct {75		name    string76		args    args77		want    *big.Int78		wantErr bool79	}{80		{81			name: "Test 1: When BalanceAtWithRetry() executes successfully",82			args: args{83				balance: big.NewInt(1000),84			},85			want:    big.NewInt(1000),86			wantErr: false,87		},88		{89			name: "Test 2: When there is an error in getting balance",90			args: args{91				balanceErr: errors.New("balance error"),92			},93			want:    nil,94			wantErr: true,95		},96	}97	for _, tt := range tests {98		t.Run(tt.name, func(t *testing.T) {99			retryMock := new(mocks.RetryUtils)100			clientMock := new(mocks.ClientUtils)101			optionsPackageStruct := OptionsPackageStruct{102				RetryInterface:  retryMock,103				ClientInterface: clientMock,104			}105			utils := StartRazor(optionsPackageStruct)106			clientMock.On("BalanceAt", mock.AnythingOfType("*ethclient.Client"), context.Background(), mock.AnythingOfType("common.Address"), mock.AnythingOfType("*big.Int")).Return(tt.args.balance, tt.args.balanceErr)107			retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1))108			got, err := utils.BalanceAtWithRetry(client, account)109			if (err != nil) != tt.wantErr {110				t.Errorf("BalanceAtWithRetry() error = %v, wantErr %v", err, tt.wantErr)111				return112			}113			if !reflect.DeepEqual(got, tt.want) {114				t.Errorf("BalanceAtWithRetry() got = %v, want %v", got, tt.want)115			}116		})117	}118}119func TestUtilsStruct_EstimateGasWithRetry(t *testing.T) {120	var client *ethclient.Client121	var message ethereum.CallMsg122	type args struct {123		gasLimit    uint64124		gasLimitErr error125	}126	tests := []struct {127		name    string128		args    args129		want    uint64130		wantErr bool131	}{132		{133			name: "Test 1: When EstimateGasWithRetry executes successfully",134			args: args{135				gasLimit: 2,136			},137			want:    2,138			wantErr: false,139		},140		{141			name: "Test 2: When there is an error in getting gasLimit",142			args: args{143				gasLimitErr: errors.New("gasLimit error"),144			},145			want:    0,146			wantErr: true,147		},148	}149	for _, tt := range tests {150		t.Run(tt.name, func(t *testing.T) {151			retryMock := new(mocks.RetryUtils)152			clientMock := new(mocks.ClientUtils)153			optionsPackageStruct := OptionsPackageStruct{154				RetryInterface:  retryMock,155				ClientInterface: clientMock,156			}157			utils := StartRazor(optionsPackageStruct)158			clientMock.On("EstimateGas", mock.AnythingOfType("*ethclient.Client"), context.Background(), mock.AnythingOfType("ethereum.CallMsg")).Return(tt.args.gasLimit, tt.args.gasLimitErr)159			retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1))160			got, err := utils.EstimateGasWithRetry(client, message)161			if (err != nil) != tt.wantErr {162				t.Errorf("EstimateGasWithRetry() error = %v, wantErr %v", err, tt.wantErr)163				return164			}165			if got != tt.want {166				t.Errorf("EstimateGasWithRetry() got = %v, want %v", got, tt.want)167			}168		})169	}170}171func TestUtilsStruct_FilterLogsWithRetry(t *testing.T) {172	var client *ethclient.Client173	var query ethereum.FilterQuery174	type args struct {175		logs    []types.Log176		logsErr error177	}178	tests := []struct {179		name    string180		args    args181		want    []types.Log182		wantErr bool183	}{184		{185			name: "Test 1: When FilterLogsWithRetry executes successfully",186			args: args{187				logs: []types.Log{},188			},189			want:    []types.Log{},190			wantErr: false,191		},192		{193			name: "Test 2: When there is an error in getting filterLogs",194			args: args{195				logsErr: errors.New("logs error"),196			},197			want:    nil,198			wantErr: true,199		},200	}201	for _, tt := range tests {202		t.Run(tt.name, func(t *testing.T) {203			retryMock := new(mocks.RetryUtils)204			clientMock := new(mocks.ClientUtils)205			optionsPackageStruct := OptionsPackageStruct{206				RetryInterface:  retryMock,207				ClientInterface: clientMock,208			}209			utils := StartRazor(optionsPackageStruct)210			clientMock.On("FilterLogs", mock.AnythingOfType("*ethclient.Client"), context.Background(), mock.AnythingOfType("ethereum.FilterQuery")).Return(tt.args.logs, tt.args.logsErr)211			retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1))212			got, err := utils.FilterLogsWithRetry(client, query)213			if (err != nil) != tt.wantErr {214				t.Errorf("FilterLogsWithRetry() error = %v, wantErr %v", err, tt.wantErr)215				return216			}217			if !reflect.DeepEqual(got, tt.want) {218				t.Errorf("FilterLogsWithRetry() got = %v, want %v", got, tt.want)219			}220		})221	}222}223func TestUtilsStruct_GetLatestBlockWithRetry(t *testing.T) {224	var client *ethclient.Client225	type args struct {226		latestHeader    *types.Header227		latestHeaderErr error228	}229	tests := []struct {230		name    string231		args    args232		want    *types.Header233		wantErr bool234	}{235		{236			name: "Test 1: When GetLatestBlockWithRetry executes successfully",237			args: args{238				latestHeader: &types.Header{},239			},240			want:    &types.Header{},241			wantErr: false,242		},243		{244			name: "Test 2: When there is an error in getting latestHeader",245			args: args{246				latestHeaderErr: errors.New("header error"),247			},248			want:    nil,249			wantErr: true,250		},251	}252	for _, tt := range tests {253		t.Run(tt.name, func(t *testing.T) {254			retryMock := new(mocks.RetryUtils)255			clientMock := new(mocks.ClientUtils)256			optionsPackageStruct := OptionsPackageStruct{257				RetryInterface:  retryMock,258				ClientInterface: clientMock,259			}260			utils := StartRazor(optionsPackageStruct)261			clientMock.On("HeaderByNumber", mock.AnythingOfType("*ethclient.Client"), context.Background(), mock.AnythingOfType("*big.Int")).Return(tt.args.latestHeader, tt.args.latestHeaderErr)262			retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1))263			got, err := utils.GetLatestBlockWithRetry(client)264			if (err != nil) != tt.wantErr {265				t.Errorf("GetLatestBlockWithRetry() error = %v, wantErr %v", err, tt.wantErr)266				return267			}268			if !reflect.DeepEqual(got, tt.want) {269				t.Errorf("GetLatestBlockWithRetry() got = %v, want %v", got, tt.want)270			}271		})272	}273}274func TestUtilsStruct_GetPendingNonceAtWithRetry(t *testing.T) {275	var client *ethclient.Client276	var accountAddress common.Address277	type args struct {278		nonce    uint64279		nonceErr error280	}281	tests := []struct {282		name    string283		args    args284		want    uint64285		wantErr bool286	}{287		{288			name: "Test 1: When BalanceAtWithRetry() executes successfully",289			args: args{290				nonce: 2,291			},292			want:    2,293			wantErr: false,294		},295		{296			name: "Test 2: When there is an error in getting nonce",297			args: args{298				nonceErr: errors.New("nonce error"),299			},300			want:    0,301			wantErr: true,302		},303	}304	for _, tt := range tests {305		t.Run(tt.name, func(t *testing.T) {306			retryMock := new(mocks.RetryUtils)307			clientMock := new(mocks.ClientUtils)308			optionsPackageStruct := OptionsPackageStruct{309				RetryInterface:  retryMock,310				ClientInterface: clientMock,311			}312			utils := StartRazor(optionsPackageStruct)313			clientMock.On("PendingNonceAt", mock.AnythingOfType("*ethclient.Client"), context.Background(), mock.AnythingOfType("common.Address")).Return(tt.args.nonce, tt.args.nonceErr)314			retryMock.On("RetryAttempts", mock.AnythingOfType("uint")).Return(retry.Attempts(1))315			got, err := utils.GetPendingNonceAtWithRetry(client, accountAddress)316			if (err != nil) != tt.wantErr {317				t.Errorf("GetPendingNonceAtWithRetry() error = %v, wantErr %v", err, tt.wantErr)318				return319			}320			if got != tt.want {321				t.Errorf("GetPendingNonceAtWithRetry() got = %v, want %v", got, tt.want)322			}323		})324	}325}...

retry.go

Source:retry.go

...8	"looklapi/common/mongoutils"9	"looklapi/common/utils"10	"time"11)12const _RetryCollectionName = "mq_msg_retry" // éè¯è®°å½è¡¨13/**14éè¯æ¶æ¯15*/16func retry(metaMsg *mqMessage, consumer *consumer) bool {17	switch consumer.Type {18	case _WorkQueue:19		return retryWorker(metaMsg, consumer.RouteKey, consumer.MaxRetry)20	case _Broadcast:21		return retryBroadcast(metaMsg, consumer.Exchange, consumer.MaxRetry)22	default:23		loggers.GetLogger().Warn("unvalid consumer type")24		return false25	}26}27/**28éè¯å·¥ä½éåæ¶æ¯29*/30func retryWorker(metaMsg *mqMessage, routeKey string, maxRetry uint32) bool {31	mqRetry := &mqMsgRetry{32		Id:          primitive.NewObjectID().Hex(),33		PublishType: int32(_WorkQueue),34		Key:         routeKey,35		Guid:        metaMsg.Guid,36		Timestamp:   metaMsg.Timespan,37		MaxRetry:    int32(maxRetry),38		Body:        metaMsg.JsonContent,39		Status:      0,40	}41	if metaMsg.CurrentRetry >= mqRetry.MaxRetry {42		// è¾¾å°æå¤§éè¯æ¬¡æ°43		addOrUpdate(mqRetry)44		return true45	} else {46		retryCount := getRetryCount(mqRetry.Guid, mqRetry.Timestamp, false)47		if retryCount != utils.MaxInt32 && retryCount >= mqRetry.MaxRetry {48			// è¾¾å°æå¤§éè¯æ¬¡æ°49			return true50		}51	}52	if mqRetry.Timestamp.UnixNano()/1000000+30*60*1000 <= time.Now().UnixNano()/1000000 {53		// 30åéæªæåæ¶è´¹çæ¾å¼æ54		errmsg := fmt.Sprintf("routekey:%s, guid:%s, timespan:%s è¶è¿30åéæªæ¶è´¹",55			routeKey, mqRetry.Guid, mqRetry.Timestamp.Format("2006-01-02 15:04:05"))56		loggers.GetLogger().Warn(errmsg)57		return true58	}59	addOrUpdate(mqRetry)60	time.Sleep(1000 * time.Millisecond) // çå¾1ç§61	// éæ°åå¸å°éå°¾62	metaMsg.CurrentRetry += 163	return PubWorkQueueMsg(routeKey, metaMsg)64}65/**66éè¯å¹¿æéåæ¶æ¯67*/68func retryBroadcast(metaMsg *mqMessage, exchange string, maxRetry uint32) bool {69	retrycount := getRetryCount(metaMsg.Guid, metaMsg.Timespan, true)70	if retrycount != utils.MaxInt32 && retrycount >= int32(maxRetry) {71		// è¾¾å°æå¤§éè¯æ¬¡æ°72		return true73	}74	if metaMsg.Timespan.UnixNano()/1000000+5*60*1000 <= time.Now().UnixNano()/1000000 {75		// 5åéæªæåæ¶è´¹çå¹¿ææ¶æ¯æ¾å¼æ76		errmsg := fmt.Sprintf("exchange:%s, guid:%s, timespan:%s è¶è¿5åéæªæ¶è´¹",77			exchange, metaMsg.Guid, metaMsg.Timespan.Format("2006-01-02 15:04:05"))78		loggers.GetLogger().Warn(errmsg)79		return true80	}81	// åå¥mongodb82	mqretry := &mqMsgRetry{83		Id:          primitive.NewObjectID().Hex(),84		PublishType: int32(_Broadcast),85		Key:         exchange,86		Guid:        metaMsg.Guid,87		Timestamp:   metaMsg.Timespan,88		MaxRetry:    int32(maxRetry),89		Body:        metaMsg.JsonContent,90		Status:      0,91	}92	result := false93	if !addOrUpdate(mqretry) {94		// åçéè¯¯æ¶è¿åtrue, é²æ¢æ»å¾ªç¯95		result = true96		errmsg := fmt.Sprintf("æ¶æ¯éè¯å¤±è´¥, exchange:%s, guid:%s, timespan:%s.",97			exchange, metaMsg.Guid, metaMsg.Timespan.Format("2006-01-02 15:04:05"))98		loggers.GetLogger().Warn(errmsg)99	} else {100		// çå¾ä¸¤ç§å¥ééè¯101		time.Sleep(2000 * time.Millisecond)102	}103	return result104}105/**106éè¯æå107*/108func retrySuccess(metaMsg *mqMessage, csType consumerType) {109	if metaMsg == nil || utils.IsEmpty(metaMsg.Guid) {110		return111	}112	defer func() {113		if err := recover(); err != nil {114			if tr, ok := err.(error); ok {115				fmt.Println(tr.Error())116			} else if msg, ok := err.(string); ok {117				fmt.Println(msg)118			}119		}120	}()121	filter := bson.D{122		{"guid", metaMsg.Guid},123		{"timespan", metaMsg.Timespan},124	}125	if csType == _Broadcast {126		filter = append(filter, bson.E{Key: "hostIp", Value: utils.HostIp()})127	}128	updates := bson.D{129		{"$inc", bson.D{{"current_retry", 1}}},130		{"$set", bson.D{{"status", 1}, {"update_time", time.Now()}}},131	}132	if _, err := mongoutils.GetCollection(_RetryCollectionName).UpdateOne(nil, filter, updates); err != nil {133		fmt.Println(err.Error())134	}135}136/**137è·åéè¯æ¬¡æ°138*/139func getRetryCount(guid string, timespan time.Time, isBroadcast bool) int32 {140	if utils.IsEmpty(guid) {141		return utils.MaxInt32142	}143	result := int32(0)144	filter := bson.D{145		{"guid", guid},146		{"timespan", timespan},147	}148	if isBroadcast {149		filter = append(filter, bson.E{Key: "hostIp", Value: utils.HostIp()})150	}151	singleOne := mongoutils.GetCollection(_RetryCollectionName).FindOne(nil, filter)152	msgRetry := &mqMsgRetry{}153	if err := singleOne.Decode(msgRetry); err == nil || err == mongo.ErrNoDocuments {154		result = msgRetry.CurrentRetry155	} else {156		result = utils.MaxInt32157		loggers.GetLogger().Error(err)158	}159	return result160}161/**162æ°å¢ææ´æ°163*/164func addOrUpdate(model *mqMsgRetry) bool {165	if model == nil || utils.IsEmpty(model.Guid) || utils.IsEmpty(model.Key) {166		return false167	}168	filter := bson.D{169		{"guid", model.Guid},170		{"timespan", model.Timestamp},171	}172	if model.PublishType == int32(_Broadcast) {173		filter = append(filter, bson.E{Key: "hostIp", Value: utils.HostIp()})174	}175	collection := mongoutils.GetCollection(model.TbCollName())176	exist := false177	if count, err := collection.CountDocuments(nil, filter); err == nil && count > 0 {178		exist = true179	}180	result := false181	if !exist {182		// add183		if model.PublishType == int32(_Broadcast) {184			model.HostIp = utils.HostIp()185		} else {186			model.HostIp = ""187		}188		model.CurrentRetry = 0189		model.UpdateTime = time.Now()190		if _, err := collection.InsertOne(nil, model); err == nil {191			result = true192		}193	} else {194		// update195		updates := bson.D{196			{"$inc", bson.D{{"current_retry", 1}}},197			{"$set", bson.D{{"update_time", time.Now()}}},198		}199		if _, err := collection.UpdateOne(nil, filter, updates); err == nil {200			result = true201		}202	}...

Retry

Using AI Code Generation

1func main() {2    err := utils.Retry(3, time.Second, func() error {3        return errors.New("Error")4    })5    if err != nil {6        fmt.Println(err)7    }8}

Retry

Using AI Code Generation

1import (2func main() {3	fmt.Println("Hello, playground")4	utils.Retry(5, 1, func() (err error) {5		if i == 3 {6		}7		err = fmt.Errorf("Error %d", i)8	})9}10import (11func Retry(retryCount int, retryInterval int, f func() error) {12	for i := 0; i < retryCount; i++ {13		err := f()14		if err == nil {15		}16		fmt.Println("Error:", err)17		time.Sleep(time.Duration(retryInterval) * time.Second)18	}19}20import (21func TestRetrySuccess(t *testing.T) {22	Retry(5, 1, func() (err error) {23		if i == 3 {24		}25		err = fmt.Errorf("Error %d", i)26	})27	if i != 3 {28		t.Errorf("Expected i to be 3 but got %d", i)29	}30}31func TestRetryFailure(t *testing.T) {32	Retry(5, 1, func() (err error) {33		if i == 3 {34		}35		err = fmt.Errorf("Error %d", i)36	})37	if i == 3 {38		t.Errorf("Expected i to be 3 but got %d", i)39	}40}41func TestRetryFailureWithPanic(t *testing.T) {42	Retry(5, 1, func() (err error) {43		if i == 3 {44		}45		err = errors.New("Error")46		panic(err)47	})48	if i == 3 {49		t.Errorf("Expected i to be 3 but got

Retry

Using AI Code Generation

1import (2func main() {3	retry = utils.Retry{MaxRetryCount: 5, RetryInterval: 10}4	fmt.Println(retry.Retry())5}6import "fmt"7type Retry struct {8}9func (r Retry) Retry() string {10	return fmt.Sprintf("MaxRetryCount: %d, RetryInterval: %d", r.MaxRetryCount, r.RetryInterval)11}12    /usr/local/go/src/pkg/utils (from $GOROOT)13    /home/username/go/src/pkg/utils (from $GOPATH)14type MyStruct struct {15}16func (m *MyStruct) HasKey(key string) bool {17}18func main() {19    http.HandleFunc("/", handler)20    http.ListenAndServe(":8080", nil)21}22func handler(w http.ResponseWriter, r *http.Request) {23    fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))24}

Retry

Using AI Code Generation

1func main() {2    retry := utils.Retry{}3    retry.Retry(10, 5, func() error {4        fmt.Println("Hello")5    })6}7func main() {8    retry := utils.Retry{}9    retry.Retry(10, 5, func() error {10        fmt.Println("Hello")11    })12}13type Retry struct {14}15func (r Retry) Retry(attempts int, sleep time.Duration, f func() error) (err error) {16    for i := 0; ; i++ {17        err = f()18        if err == nil {19        }20        if i >= (attempts - 1) {21        }22        time.Sleep(sleep)23    }24    return fmt.Errorf("after %d attempts, last error: %s", attempts, err)25}26func main() {27    retry := utils.Retry{}28    retry.Retry(10, 5, func() error {29        fmt.Println("Hello")30    })31}32func main() {33    retry := utils.Retry{}34    retry.Retry(10, 5, func() error {35        fmt.Println("Hello")36    })37}38func main() {39    retry := utils.Retry{}40    retry.Retry(10, 5, func() error {41        fmt.Println("Hello")42    })43}

Retry

Using AI Code Generation

1import (2func main() {3    fmt.Println("Enter a number")4    fmt.Scan(&a)5    fmt.Println("Square of number is", utils.Retry(a))6}

Retry

Using AI Code Generation

1func main() {2    response, err := utils.Retry(func() (*http.Response, error) {3    })4    if err != nil {5        panic(err)6    }7}8func main() {9    response, err := utils.Retry(func() (*http.Response, error) {10    })11    if err != nil {12        panic(err)13    }14}15func main() {16    response, err := utils.Retry(func() (*http.Response, error) {17    })18    if err != nil {19        panic(err)20    }21}22func main() {23    response, err := utils.Retry(func() (*http.Response, error) {24    })25    if err != nil {26        panic(err)27    }28}29func main() {30    response, err := utils.Retry(func() (*http.Response, error) {31    })32    if err != nil {33        panic(err)34    }35}36func main() {

Retry

Using AI Code Generation

1import (2func main() {3    function := func() error {4    }5    onRetry := func(err error) {6        fmt.Println("Retrying...")7    }8    err := utils.Retry(5, 1, function, onRetry)9    if err != nil {10        fmt.Println("Failed to retry")11    }12}13function := func() error {14}15err := utils.Retry(5, 1, function, nil)16if err != nil {17    fmt.Println("Failed to retry")18}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.