Retry patterns과 aws sdk waiters

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

func (w Waiter) WaitWithContext(ctx aws.Context) error {

	for attempt := 1; ; attempt++ {
		req, err := w.NewRequest(w.RequestOptions)
		if err != nil {
			waiterLogf(w.Logger, "unable to create request %v", err)
			return err
		}
		req.Handlers.Build.PushBack(MakeAddToUserAgentFreeFormHandler("Waiter"))
		err = req.Send()

		// See if any of the acceptors match the request's response, or error
		for _, a := range w.Acceptors {
			if matched, matchErr := a.match(w.Name, w.Logger, req, err); matched {
				return matchErr
			}
		}

		// The Waiter should only check the resource state MaxAttempts times
		// This is here instead of in the for loop above to prevent delaying
		// unnecessary when the waiter will not retry.
		if attempt == w.MaxAttempts {
			break
		}

		// Delay to wait before inspecting the resource again
		delay := w.Delay(attempt)
		if sleepFn := req.Config.SleepDelay; sleepFn != nil {
			// Support SleepDelay for backwards compatibility and testing
			sleepFn(delay)
		} else {
			sleepCtxFn := w.SleepWithContext
			if sleepCtxFn == nil {
				sleepCtxFn = aws.SleepWithContext
			}

			if err := sleepCtxFn(ctx, delay); err != nil {
				return awserr.New(CanceledErrorCode, "waiter context canceled", err)
			}
		}
	}

	return awserr.New(WaiterResourceNotReadyErrorCode, "exceeded wait attempts", nil)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

func (w Waiter) WaitWithContext(ctx context.Context) error {
	for attempt := 1; ; attempt++ {
		res, err := w.NewRequest()

		if err != nil {
			return err
		}

		for _, a := range w.Acceptors {
			if matched, matchErr := a.match(w.Name, res, err); matched {
				return matchErr
			}
		}

		if attempt == w.MaxAttempts {
			break
		}

		delay := w.Delay(attempt)

		if err := sleepWithContext(ctx, delay); err != nil {
			return awserr.New(CanceledErrorCode, "waiter context canceled", err)
		}
	}

	return awserr.New(WaiterResourceNotReadyErrorCode,
		"exceeded wait attempts", nil)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

func (j *Jenkins) WaitUntilJenkinsJobSuccessfulWithContext(ctx context.Context, jobName string, buildID int) error {
	w := request.Waiter{
		Name:                   "WaitUntilJenkinsJobSuccessful",
		MaxAttempts:            120,
		Delay:                  request.ConstantWaiterDelay(15 * time.Second),
		ExecuteAfterFirstDelay: true,
		Acceptors: []request.WaiterAcceptor{
			{
				State:   request.SuccessWaiterState,
				Matcher: request.PathWaiterMatch, Argument: "result",
				Expected: "SUCCESS",
			},
			{
				State:   request.FailureWaiterState,
				Matcher: request.PathWaiterMatch, Argument: "result",
				Expected: "FAILURE",
			},
			{
				State:   request.FailureWaiterState,
				Matcher: request.PathWaiterMatch, Argument: "result",
				Expected: "ABORTED",
			},
		},
		NewRequest: func() (interface{}, error) {
			build, err := j.GetBuild(jobName, buildID)

			return build, err
		},
	}

	return w.WaitWithContext(ctx)
}