120 lines
3.0 KiB
Go
120 lines
3.0 KiB
Go
package storage
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"regexp"
|
|
"strconv"
|
|
"time"
|
|
)
|
|
|
|
type Range struct {
|
|
Start uint64
|
|
Limit uint64
|
|
contentRange string
|
|
}
|
|
|
|
// Range Reconstructs Range header and returns it
|
|
func (r *Range) Range() string {
|
|
if r.Limit > 0 {
|
|
return fmt.Sprintf("bytes=%d-%d", r.Start, r.Start+r.Limit-1)
|
|
} else {
|
|
return fmt.Sprintf("bytes=%d-", r.Start)
|
|
}
|
|
}
|
|
|
|
// AcceptLength Tries to accept given range
|
|
// returns newContentLength if range was satisfied, otherwise returns given contentLength
|
|
func (r *Range) AcceptLength(contentLength uint64) (newContentLength uint64) {
|
|
newContentLength = contentLength
|
|
if r.Limit == 0 {
|
|
r.Limit = newContentLength - r.Start
|
|
}
|
|
if contentLength < r.Start {
|
|
return
|
|
}
|
|
if r.Limit > contentLength-r.Start {
|
|
return
|
|
}
|
|
r.contentRange = fmt.Sprintf("bytes %d-%d/%d", r.Start, r.Start+r.Limit-1, contentLength)
|
|
newContentLength = r.Limit
|
|
return
|
|
}
|
|
|
|
func (r *Range) SetContentRange(cr string) {
|
|
r.contentRange = cr
|
|
}
|
|
|
|
// Returns accepted Content-Range header. If range wasn't accepted empty string is returned
|
|
func (r *Range) ContentRange() string {
|
|
return r.contentRange
|
|
}
|
|
|
|
var rexp *regexp.Regexp = regexp.MustCompile(`^bytes=([0-9]+)-([0-9]*)$`)
|
|
|
|
// Parses HTTP Range header and returns struct on success
|
|
// only bytes=start-finish supported
|
|
func ParseRange(rng string) *Range {
|
|
if rng == "" {
|
|
return nil
|
|
}
|
|
|
|
matches := rexp.FindAllStringSubmatch(rng, -1)
|
|
if len(matches) != 1 || len(matches[0]) != 3 {
|
|
return nil
|
|
}
|
|
if len(matches[0][0]) != len(rng) || len(matches[0][1]) == 0 {
|
|
return nil
|
|
}
|
|
|
|
start, err := strconv.ParseUint(matches[0][1], 10, 64)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
if len(matches[0][2]) == 0 {
|
|
return &Range{Start: start, Limit: 0}
|
|
}
|
|
|
|
finish, err := strconv.ParseUint(matches[0][2], 10, 64)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
if finish < start || finish+1 < finish {
|
|
return nil
|
|
}
|
|
|
|
return &Range{Start: start, Limit: finish - start + 1}
|
|
}
|
|
|
|
// Storage is the interface for storage operation
|
|
type Storage interface {
|
|
// Get retrieves a file from storage
|
|
Get(ctx context.Context, token string, filename string, rng *Range) (reader io.ReadCloser, contentLength uint64, err error)
|
|
// Head retrieves content length of a file from storage
|
|
Head(ctx context.Context, token string, filename string) (contentLength uint64, err error)
|
|
// Put saves a file on storage
|
|
Put(ctx context.Context, token string, filename string, reader io.Reader, contentType string, contentLength uint64) error
|
|
// Delete removes a file from storage
|
|
Delete(ctx context.Context, token string, filename string) error
|
|
// IsNotExist indicates if a file doesn't exist on storage
|
|
IsNotExist(err error) bool
|
|
// Purge cleans up the storage
|
|
Purge(ctx context.Context, days time.Duration) error
|
|
// Whether storage supports Get with Range header
|
|
IsRangeSupported() bool
|
|
// Type returns the storage type
|
|
Type() string
|
|
}
|
|
|
|
func CloseCheck(c io.Closer) {
|
|
if c == nil {
|
|
return
|
|
}
|
|
|
|
if err := c.Close(); err != nil {
|
|
fmt.Println("Received close error:", err)
|
|
}
|
|
}
|