Method readerForOffset

pkg/schema/filereader.go:317–397

readerForOffset returns a ReadCloser that reads some number of bytes and then EOF from the provided offset. Seeing EOF doesn't mean the end of the whole file; just the chunk at that offset. The caller must close the ReadCloser when done reading. The provided context is not used after the method re

(ctx context.Context, off int64)

// chunk at that offset.  The caller must close the ReadCloser when done reading.
// The provided context is not used after the method returns.
func (fr *FileReader) readerForOffset(ctx context.Context, off int64) (io.ReadCloser, error) {
	if debug {
		log.Printf("(%p) readerForOffset %d + %d = %d", fr, fr.rootOff, off, fr.rootOff+off)
	}
	if off < 0 {
		panic("negative offset")
	}
	if off >= fr.size {
		return types.EmptyBody, nil
	}
	offRemain := off
	var skipped int64
	parts := fr.ss.Parts
	for len(parts) > 0 && parts[0].Size <= uint64(offRemain) {
		offRemain -= int64(parts[0].Size)
		skipped += int64(parts[0].Size)
		parts = parts[1:]
	}
	if len(parts) == 0 {
		return types.EmptyBody, nil
	}
	p0 := parts[0]
	var rsc readerutil.ReadSeekCloser
	var err error
	switch {
	case p0.BlobRef.Valid() && p0.BytesRef.Valid():
		return nil, fmt.Errorf("part illegally contained both a blobRef and bytesRef")
	case !p0.BlobRef.Valid() && !p0.BytesRef.Valid():
		return io.NopCloser(
			io.LimitReader(zeroReader{},
				int64(p0.Size-uint64(offRemain)))), nil
	case p0.BlobRef.Valid():
		blob, err := fr.getBlob(ctx, p0.BlobRef)
		if err != nil {
			return nil, err
		}
		byteReader, err := blob.ReadAll(ctx)
		if err != nil {
			return nil, err
		}
		rsc = struct {
			io.ReadSeeker
			io.Closer
		}{
			byteReader,
			io.NopCloser(nil),
		}
	case p0.BytesRef.Valid():
		var ss *superset
		ss, err = fr.getSuperset(ctx, p0.BytesRef)
		if err != nil {
			return nil, err
		}
		rsc, err = ss.NewFileReader(fr.fetcher)
		if err == nil {
			subFR := rsc.(*FileReader)
			subFR.parent = fr.rootReader()
			subFR.rootOff = fr.rootOff + skipped