http_client.go

package ranger

import (
	"errors"
	"fmt"
	"io"
	"net/http"
	"strconv"
	"strings"
)

type roundTripper struct {
	ranger Ranger
	client *http.Client
	rscGen RSCGen
}

func (s roundTripper) RoundTrip(request *http.Request) (*http.Response, error) {
	//if the request is not a GET request, we don't want to do anything special, just delegate to the default client
	if request.Method != http.MethodGet {
		return s.client.Do(request)
	}

	lengthReq, err := http.NewRequest("GET", request.URL.String(), nil)
	if err != nil {
		return nil, err
	}

	lengthReq.Header.Set("Range", ByteRange{From: 0, To: 0}.RangeHeader())
	lengthResp, err := s.client.Do(lengthReq)
	if err != nil {
		return nil, err
	}

	lengthRespRangeHeaderParts := strings.Split(lengthResp.Header.Get("Content-Range"), "/")
	if len(lengthRespRangeHeaderParts) < 2 {
		return nil, errors.New("could not figure out content length from Content-Range header")
	}

	totalContentLength, err := strconv.ParseInt(lengthRespRangeHeaderParts[1], 10, 64)
	if err != nil {
		return nil, fmt.Errorf("unable to get content length: %w", err)
	}

	parsedRange, err := ParseRange(request.Header.Get("Range"), totalContentLength)
	if err != nil || len(parsedRange) > 1 {
		return nil, fmt.Errorf("unable to parse requested Range header correctly: %w", err)
	}

	reader := s.rscGen(s.client, request.URL.String(), NewSizedRanger(totalContentLength, s.ranger))
	rangeToFetch := Range{
		Start:  0,
		Length: totalContentLength,
	}
	if parsedRange != nil {
		rangeToFetch = parsedRange[0]
	}
	_, err = reader.Seek(rangeToFetch.Start, io.SeekStart)
	if err != nil {
		return nil, fmt.Errorf("unable to seek correctly: %w", err)
	}

	headers := lengthResp.Header.Clone()
	headers.Set("Content-Range", rangeToFetch.ContentRange(totalContentLength))

	limitReader := io.LimitReader(reader, rangeToFetch.Length)
	body := readCloser{limitReader, reader}

	return &http.Response{
		Status:        lengthResp.Status,
		StatusCode:    lengthResp.StatusCode,
		Proto:         lengthResp.Proto,
		ProtoMajor:    lengthResp.ProtoMajor,
		ProtoMinor:    lengthResp.ProtoMinor,
		Header:        headers,
		Body:          body,
		ContentLength: rangeToFetch.Length,
		Close:         true,
		Request:       request,
		TLS:           lengthResp.TLS,
	}, nil
}

type RSCGen func(client *http.Client, url string, sr SizedRanger) io.ReadSeekCloser

type readCloser struct {
	r io.Reader
	c io.Closer
}

func (rc readCloser) Read(p []byte) (n int, err error) {
	return rc.r.Read(p)
}

func (rc readCloser) Close() error {
	return rc.c.Close()
}

func NewSeqRangingClient(ranger Ranger, client *http.Client) http.RoundTripper {
	return &roundTripper{
		ranger: ranger,
		client: client,
		rscGen: func(client *http.Client, url string, sr SizedRanger) io.ReadSeekCloser {
			return NewSeqReader(client, url, sr)
		},
	}
}