Method fetchRemainingBlocksFromURL

target_fetch.go:82–128

(client HTTPRequester, rawURL, referer string)

}

func (zs *Syncer) fetchRemainingBlocksFromURL(client HTTPRequester, rawURL, referer string) (int64, error) {
	u, err := url.Parse(rawURL)
	if err != nil {
		return 0, fmt.Errorf("invalid URL %s: %w", rawURL, err)
	}
	var absURL *url.URL
	if !u.IsAbs() {
		if referer == "" {
			return 0, fmt.Errorf("URL '%s' from the .zsync file is relative, but no referer URL is known", rawURL)
		}
		base, err := url.Parse(referer)
		if err != nil {
			return 0, err
		}
		absURL = base.ResolveReference(u)
	} else {
		absURL = u
	}

	ranges := zs.NeededByteRanges()
	if len(ranges) == 0 {
		return 0, nil
	}

	g, ctx := errgroup.WithContext(context.Background())
	g.SetLimit(3)

	var (
		httpBytesDownloaded int64
		mu                  sync.Mutex
	)

	for _, r := range ranges {
		g.Go(func() error {
			bytesReceived, err := zs.fetchRange(ctx, client, absURL, r)
			// Lock protecting httpBytesDownloaded.
			mu.Lock()
			defer mu.Unlock()
			httpBytesDownloaded += bytesReceived
			if err != nil {
				return err
			}
			return nil
		})
	}
	return httpBytesDownloaded, g.Wait()
}

func (zs *Syncer) fetchRange(ctx context.Context, client HTTPRequester, url *url.URL, r ByteRange) (int64, error) {
	req, err := http.NewRequestWithContext(ctx, "GET", url.String(), nil)