MeteorLight/http.go

package main

import (
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"net/url"
	"strconv"
)

const rangeReaderBufferSize = 1024 * 64

type RangeReadSeekCloser struct {
	uri  *url.URL
	size int64
	i    int64
	buf  []byte
	ib   int64
}

func NewRangeReadSeekCloser(uri string) (*RangeReadSeekCloser, error) {
	parsedUrl, err := url.Parse(uri)
	if err != nil {
		return nil, err
	}
	r := &RangeReadSeekCloser{
		uri: parsedUrl,
		buf: make([]byte, 0, rangeReaderBufferSize),
	}

	if err = r.getInformation(); err != nil {
		return nil, err
	}

	return r, nil
}

func (r *RangeReadSeekCloser) GetURI() string {
	return r.uri.String()
}

func (r *RangeReadSeekCloser) Read(p []byte) (n int, err error) {
	if r.i >= r.size {
		return 0, io.EOF
	}

	if r.i >= r.ib {
		bufStart := int(r.i - r.ib)
		bufEnd := bufStart + len(p)
		if bufEnd <= len(r.buf) {
			copy(p, r.buf[bufStart:bufEnd])
			r.i += int64(len(p))
			return len(p), nil
		}
	}

	//TODO: EOF error / limit
	headers := make(http.Header)

	startOffset := r.i
	endOffset := r.i + int64(len(p)) - 1
	if endOffset-startOffset+1 < rangeReaderBufferSize {
		endOffset = startOffset + rangeReaderBufferSize - 1
	}
	if endOffset >= (r.size - 1) {
		endOffset = r.size - 1
	}

	expectedLength := endOffset - startOffset + 1

	returnLength := int(endOffset - startOffset + 1)
	if returnLength > len(p) {
		returnLength = len(p)
	}

	headers.Set("Range", fmt.Sprintf("bytes=%d-%d", startOffset, endOffset))
	response, err := http.DefaultClient.Do(&http.Request{
		Method: "GET",
		URL:    r.uri,
		Header: headers,
	})

	if err != nil {
		return 0, err
	}
	defer response.Body.Close()

	if response.StatusCode != http.StatusPartialContent {
		return 0, fmt.Errorf("response status code %d != %d", response.StatusCode, http.StatusPartialContent)
	}

	contentLength, err := strconv.ParseInt(response.Header.Get("content-length"), 10, 0)
	if err != nil {
		return 0, errors.New("server response does not have a valid Content-Length")
	}

	if contentLength != expectedLength {
		return 0, fmt.Errorf("server returned %d bytes, expected %d", contentLength, expectedLength)
	}

	data, err := ioutil.ReadAll(response.Body)
	if err != nil {
		return 0, err
	}

	if len(data) != int(expectedLength) {
		return 0, fmt.Errorf("read %d bytes, expected %d", len(data), expectedLength)
	}
	copy(p[:returnLength], data[:returnLength])

	r.buf = data
	r.ib = r.i

	r.i += int64(returnLength)
	return returnLength, nil
}

func (r *RangeReadSeekCloser) Seek(offset int64, whence int) (int64, error) {
	switch whence {
	case io.SeekStart:
		r.i = offset

	case io.SeekCurrent:
		r.i += offset

	case io.SeekEnd:
		//todo: maybe without -1?
		r.i = (r.size - 1) - offset
	default:
		return 0, fmt.Errorf("unknown whence %d", whence)
	}

	if r.i >= r.size {
		return r.i, io.EOF
	} else if r.i < 0 {
		return r.i, io.ErrUnexpectedEOF
	}

	return r.i, nil
}

func (r *RangeReadSeekCloser) Close() error {
	//todo close?
	return nil
}

func (r *RangeReadSeekCloser) getInformation() error {
	response, err := http.DefaultClient.Head(r.GetURI())
	if err != nil {
		return err
	}
	defer response.Body.Close()
	if response.StatusCode != http.StatusOK {
		return fmt.Errorf("response status code %d != %d", response.StatusCode, http.StatusOK)
	}
	if response.Header.Get("accept-ranges") != "bytes" {
		return errors.New("server does not accept Range")
	}
	if r.size, err = strconv.ParseInt(response.Header.Get("content-length"), 10, 0); err != nil {
		return errors.New("server response does not have a valid Content-Length")
	}

	return nil
}