Drop retry logic from autoscaler

This commit removes the Knative components such as rewinder and the
replayRoundTripper. This was done to move the retry logic into the rio
controller and the gateway controller. This allows for using envoy to
program the retry logic via the Glood virtualService.

This was done to increase the observability of the system and open the
option of cutomizable timeouts at a later point in time.

pkg/gatewayserver/roundtripper.go

@@ -17,15 +17,8 @@ import (
 	"crypto/tls"
 	"net"
 	"net/http"
-	"strconv"
 
-	"github.com/sirupsen/logrus"
 	"golang.org/x/net/http2"
-	"k8s.io/apimachinery/pkg/util/wait"
-)
-
-const (
-	requestCountHTTPHeader = "Request-Retry-Count"
 )
 
 type roundTripperFunc func(*http.Request) (*http.Response, error)
@@ -55,71 +48,3 @@ var http2Transport http.RoundTripper = &http2.Transport{
 
 // AutoTransport uses h2c for HTTP2 requests and falls back to `http.DefaultTransport` for all others
 var autoTransport = newHTTPTransport(http.DefaultTransport, http2Transport)
-
-type retryCond func(*http.Response) bool
-
-// RetryStatus will filter responses matching `status`
-func retryStatus(status int) retryCond {
-	return func(resp *http.Response) bool {
-		return resp.StatusCode == status
-	}
-}
-
-type retryRoundTripper struct {
-	transport       http.RoundTripper
-	backoffSettings wait.Backoff
-	retryConditions []retryCond
-}
-
-// RetryRoundTripper retries a request on error or retry condition, using the given `retry` strategy
-func newRetryRoundTripper(rt http.RoundTripper, b wait.Backoff, conditions ...retryCond) http.RoundTripper {
-	return &retryRoundTripper{
-		transport:       rt,
-		backoffSettings: b,
-		retryConditions: conditions,
-	}
-}
-
-func (rrt *retryRoundTripper) RoundTrip(r *http.Request) (resp *http.Response, err error) {
-	// The request body cannot be read multiple times for retries.
-	// The workaround is to clone the request body into a byte reader
-	// so the body can be read multiple times.
-	if r.Body != nil {
-		logrus.Debugf("Wrapping body in a rewinder.")
-		r.Body = newRewinder(r.Body)
-	}
-
-	attempts := 0
-	wait.ExponentialBackoff(rrt.backoffSettings, func() (bool, error) {
-		attempts++
-		r.Header.Add(requestCountHTTPHeader, strconv.Itoa(attempts))
-		resp, err = rrt.transport.RoundTrip(r)
-
-		if err != nil {
-			logrus.Errorf("Error making a request: %s", err)
-			return false, nil
-		}
-
-		for _, retryCond := range rrt.retryConditions {
-			if retryCond(resp) {
-				resp.Body.Close()
-				return false, nil
-			}
-		}
-		return true, nil
-	})
-
-	if err == nil {
-		logrus.Infof("Finished after %d attempt(s). Response code: %d", attempts, resp.StatusCode)
-
-		if resp.Header == nil {
-			resp.Header = make(http.Header)
-		}
-
-		resp.Header.Add(requestCountHTTPHeader, strconv.Itoa(attempts))
-	} else {
-		logrus.Errorf("Failed after %d attempts. Last error: %v", attempts, err)
-	}
-
-	return
-}

pkg/gatewayserver/serve.go

@@ -18,15 +18,11 @@ import (
 	"github.com/sirupsen/logrus"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/proxy"
-	"k8s.io/apimachinery/pkg/util/wait"
 )
 
 const (
-	maxRetries             = 18 // the sum of all retries would add up to 1 minute
-	minRetryInterval       = 100 * time.Millisecond
-	exponentialBackoffBase = 1.3
-	RioNameHeader          = "X-Rio-ServiceName"
-	RioNamespaceHeader     = "X-Rio-Namespace"
+	RioNameHeader      = "X-Rio-ServiceName"
+	RioNamespaceHeader = "X-Rio-Namespace"
 )
 
 func NewHandler(rContext *types.Context, lock *sync.RWMutex, autoscalers map[string]*servicescale.SimpleScale) Handler {
@@ -81,8 +77,7 @@ func (h Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	app, version := services.AppAndVersion(svc)
 	serveFQDN(name2.SafeConcatName(app, version), namespace, checkPort, w, r)
 
-	logrus.Infof("activating service %s/%s takes %v seconds", svc.Name, svc.Namespace, time.Now().Sub(start).Seconds())
-	return
+	logrus.Infof("activating service %s/%s takes %v seconds", svc.Name, svc.Namespace, time.Since(start).Seconds())
 }
 
 func serveFQDN(name, namespace, port string, w http.ResponseWriter, r *http.Request) {
@@ -95,15 +90,7 @@ func serveFQDN(name, namespace, port string, w http.ResponseWriter, r *http.Requ
 	r.URL.Host = targetURL.Host
 	r.Host = targetURL.Host
 
-	shouldRetry := []retryCond{retryStatus(http.StatusServiceUnavailable), retryStatus(http.StatusBadGateway)}
-	backoffSettings := wait.Backoff{
-		Duration: minRetryInterval,
-		Factor:   exponentialBackoffBase,
-		Steps:    maxRetries,
-	}
-
-	rt := newRetryRoundTripper(autoTransport, backoffSettings, shouldRetry...)
-	httpProxy := proxy.NewUpgradeAwareHandler(targetURL, rt, true, false, er)
+	httpProxy := proxy.NewUpgradeAwareHandler(targetURL, autoTransport, true, false, er)
 	httpProxy.ServeHTTP(w, r)
 }