client.go

package tus

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

const (
	ProtocolVersion = "1.0.0"
)

// Client represents the tus client.
// You can use it in goroutines to create parallels uploads.
type Client struct {
	Config  *Config
	Url     string
	Version string
	Header  http.Header

	client *http.Client
}

// NewClient creates a new tus client.
func NewClient(url string, config *Config) (*Client, error) {
	if config == nil {
		config = DefaultConfig()
	} else {
		if err := config.Validate(); err != nil {
			return nil, err
		}
	}

	if config.Header == nil {
		config.Header = make(http.Header)
	}

	if config.HttpClient == nil {
		config.HttpClient = &http.Client{}
	}

	return &Client{
		Config:  config,
		Url:     url,
		Version: ProtocolVersion,
		Header:  config.Header,

		client: config.HttpClient,
	}, nil
}

func (c *Client) Do(req *http.Request) (*http.Response, error) {
	for k, v := range c.Header {
		req.Header[k] = v
	}

	req.Header.Set("Tus-Resumable", ProtocolVersion)

	return c.client.Do(req)
}

// CreateUpload creates a new upload in the server.
func (c *Client) CreateUpload(u *Upload) (*Uploader, error) {
	if u == nil {
		return nil, ErrNilUpload
	}

	if c.Config.Resume && len(u.Fingerprint) == 0 {
		return nil, ErrFingerprintNotSet
	}

	req, err := http.NewRequest("POST", c.Url, nil)

	if err != nil {
		return nil, err
	}

	req.Header.Set("Content-Length", "0")
	req.Header.Set("Upload-Length", strconv.FormatInt(u.size, 10))
	req.Header.Set("Upload-Metadata", u.EncodedMetadata())

	res, err := c.Do(req)

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

	switch res.StatusCode {
	case 201:
		location := res.Header.Get("Location")

		newURL, err := c.resolveLocationURL(location)
		if err != nil {
			return nil, err
		}

		if c.Config.Resume {
			c.Config.Store.Set(u.Fingerprint, newURL.String())
		}

		return NewUploader(c, newURL.String(), u, 0), nil
	case 412:
		return nil, ErrVersionMismatch
	case 413:
		return nil, ErrLargeUpload
	default:
		return nil, newClientError(res)
	}
}

func (c *Client) resolveLocationURL(location string) (*netUrl.URL, error) {
	baseURL, err := netUrl.Parse(c.Url)
	if err != nil {
		return nil, fmt.Errorf("invalid URL '%s'", c.Url)
	}

	locationURL, err := netUrl.Parse(location)
	if err != nil {
		return nil, fmt.Errorf("invalid Location header value for a Creation '%s': %s", location, err.Error())
	}
	newURL := baseURL.ResolveReference(locationURL)
	return newURL, nil
}

// ResumeUpload resumes the upload if already created, otherwise it will return an error.
func (c *Client) ResumeUpload(u *Upload) (*Uploader, error) {
	if u == nil {
		return nil, ErrNilUpload
	}

	if !c.Config.Resume {
		return nil, ErrResumeNotEnabled
	} else if len(u.Fingerprint) == 0 {
		return nil, ErrFingerprintNotSet
	}

	url, found := c.Config.Store.Get(u.Fingerprint)

	if !found {
		return nil, ErrUploadNotFound
	}

	offset, err := c.getUploadOffset(url)

	if err != nil {
		return nil, err
	}

	return NewUploader(c, url, u, offset), nil
}

// CreateOrResumeUpload resumes the upload if already created or creates a new upload in the server.
func (c *Client) CreateOrResumeUpload(u *Upload) (*Uploader, error) {
	if u == nil {
		return nil, ErrNilUpload
	}

	uploader, err := c.ResumeUpload(u)

	if err == nil {
		return uploader, err
	} else if (errors.Is(err, ErrResumeNotEnabled)) || (errors.Is(err, ErrUploadNotFound)) {
		return c.CreateUpload(u)
	}

	return nil, err
}

func (c *Client) uploadChunk(url string, body io.Reader, size, offset, fileSize int64) (int64, *http.Response, error) {
	var method string

	if !c.Config.OverridePatchMethod {
		method = "PATCH"
	} else {
		method = "POST"
	}

	req, err := http.NewRequest(method, url, body)

	if err != nil {
		return -1, nil, err
	}

	req.Header.Set("Content-Type", "application/offset+octet-stream")
	req.Header.Set("Content-Length", strconv.FormatInt(size, 10))
	req.Header.Set("Upload-Offset", strconv.FormatInt(offset, 10))

	if c.Config.OverridePatchMethod {
		req.Header.Set("X-HTTP-Method-Override", "PATCH")
	}

	res, err := c.Do(req)

	if err != nil {
		return -1, nil, err
	}
	defer res.Body.Close()

	switch res.StatusCode {
	case 200, 201:
		if newOffset, _ := strconv.ParseInt(res.Header.Get("Upload-Offset"), 10, 64); newOffset == fileSize {
			return newOffset, res, nil
		} else {
			return -1, nil, err
		}
	case 204:
		if newOffset, err := strconv.ParseInt(res.Header.Get("Upload-Offset"), 10, 64); err == nil {
			return newOffset, nil, nil
		} else {
			return -1, nil, err
		}
	case 409:
		return -1, nil, ErrOffsetMismatch
	case 412:
		return -1, nil, ErrVersionMismatch
	case 413:
		return -1, nil, ErrLargeUpload
	default:
		return -1, nil, newClientError(res)
	}
}

func (c *Client) getUploadOffset(url string) (int64, error) {
	req, err := http.NewRequest("HEAD", url, nil)

	if err != nil {
		return -1, err
	}

	res, err := c.Do(req)

	if err != nil {
		return -1, err
	}
	defer res.Body.Close()

	switch res.StatusCode {
	case 200:
		i, err := strconv.ParseInt(res.Header.Get("Upload-Offset"), 10, 64)

		if err == nil {
			return i, nil
		} else {
			return -1, err
		}
	case 403, 404, 410:
		// file doesn't exists.
		return -1, ErrUploadNotFound
	case 412:
		return -1, ErrVersionMismatch
	default:
		return -1, newClientError(res)
	}
}

func newClientError(res *http.Response) ClientError {
	body, _ := io.ReadAll(res.Body)
	return ClientError{
		Code: res.StatusCode,
		Body: body,
	}
}