Method RoundTrip

modules/frontend/pipeline/sync_handler_cache.go:33–103

RoundTrip implements http.RoundTripper

(req Request)

// RoundTrip implements http.RoundTripper
func (c cachingWare) RoundTrip(req Request) (*http.Response, error) {
	// short circuit everything if there cache is no cache
	if c.cache == nil {
		return c.next.RoundTrip(req)
	}

	// extract cache key
	key := req.CacheKey()
	if len(key) > 0 {
		body := c.cache.fetchBytes(req.Context(), key)
		if len(body) > 0 {
			contentType := determineContentType(body)

			resp := &http.Response{
				Header:        http.Header{api.HeaderContentType: []string{contentType}, combiner.TempoCacheHeader: []string{combiner.TempoCacheHit}},
				StatusCode:    http.StatusOK,
				Status:        http.StatusText(http.StatusOK),
				Body:          io.NopCloser(bytes.NewBuffer(body)),
				ContentLength: int64(len(body)),
			}

			return resp, nil
		}
	}

	resp, err := c.next.RoundTrip(req)

	// Add cache miss header for all responses that weren't from cache
	if resp != nil {
		if resp.Header == nil {
			resp.Header = http.Header{}
		}
		resp.Header[combiner.TempoCacheHeader] = []string{combiner.TempoCacheMiss}
	}

	// do not cache if there was an error
	if err != nil {
		return resp, err
	}

	// do not cache if response is not HTTP 2xx
	if !shouldCache(resp.StatusCode) {
		return resp, nil
	}

	if len(key) > 0 {
		// don't bother caching if the response is too large
		maxItemSize := c.cache.c.MaxItemSize()
		if maxItemSize > 0 && resp.ContentLength > int64(maxItemSize) {
			return resp, nil
		}

		buffer, err := api.ReadBodyToBuffer(resp)
		if err != nil {
			return resp, fmt.Errorf("failed to cache: %w", err)
		}

		// reset the body so the caller can read it