Method sendHTTPRequestLoop

pkg/controller/rtctrl/runtime.go:152–225

()

}

func (info *RuntimeInfo) sendHTTPRequestLoop() {
	needStop := false
	defer func() {
		if needStop {
			info.stopRuntime()
		}
	}()
loop:
	for {
		select {
		case request := <-info.httpRequestChan:

			httpreq := request.Request
			reqLogger := request.Logger
			requestInfo := info.loadRequest(request.RequestID)
			if requestInfo != nil {
				requestInfo.StepDone(StageSendRequest)
			}
			cancel := request.CtxCancel
			retryDuration := httpRetryDuration
			timer := time.NewTimer(info.retryDeadline)
		RequestLoop:
			for {
				select {
				case <-timer.C:
					errMsg := fmt.Sprintf("%s Task timed out after %d seconds", requestInfo.RequestID, info.WaitRuntimeAliveTimeout)
					m := innerErr.AwsErrorMessage{
						ErrorMessage: errMsg,
					}
					requestInfo.InvokeResult(StatusTimeout, m.String())
					requestInfo.Notify()
					break RequestLoop
				case <-requestInfo.TimeoutChannel:
					// when request timeout, cancel the request
					cancel()
					break RequestLoop
				default:
					invokeStart := time.Now().UnixNano()
					httprsp, err := info.httpClient.Do(httpreq)
					invokeEnd := time.Now().UnixNano()
					if err != nil {
						reqLogger.Infof("request failed: %s retry after %s", err.Error(), retryDuration.String())
						<-time.After(retryDuration)
						if retryDuration < time.Second {
							retryDuration += time.Duration(100) * time.Millisecond
						}
						continue
					}
					requestInfo.InvokeDone()
					requestInfo.StepDone(StageInvokeDone)
					reqLogger.Infof("invoke time %d", time.Duration(invokeEnd-invokeStart)/time.Microsecond)
					resp := &InvokeHTTPResponse{
						RequestID: request.RequestID,
						Response:  httprsp,
					}
					info.httpResponseChan <- resp
					break RequestLoop
				}