| package aws |
| |
| import ( |
| "io" |
| "sync" |
| ) |
| |
| // ReadSeekCloser wraps a io.Reader returning a ReaderSeekerCloser. Should |
| // only be used with an io.Reader that is also an io.Seeker. Doing so may |
| // cause request signature errors, or request body's not sent for GET, HEAD |
| // and DELETE HTTP methods. |
| // |
| // Deprecated: Should only be used with io.ReadSeeker. If using for |
| // S3 PutObject to stream content use s3manager.Uploader instead. |
| func ReadSeekCloser(r io.Reader) ReaderSeekerCloser { |
| return ReaderSeekerCloser{r} |
| } |
| |
| // ReaderSeekerCloser represents a reader that can also delegate io.Seeker and |
| // io.Closer interfaces to the underlying object if they are available. |
| type ReaderSeekerCloser struct { |
| r io.Reader |
| } |
| |
| // Read reads from the reader up to size of p. The number of bytes read, and |
| // error if it occurred will be returned. |
| // |
| // If the reader is not an io.Reader zero bytes read, and nil error will be returned. |
| // |
| // Performs the same functionality as io.Reader Read |
| func (r ReaderSeekerCloser) Read(p []byte) (int, error) { |
| switch t := r.r.(type) { |
| case io.Reader: |
| return t.Read(p) |
| } |
| return 0, nil |
| } |
| |
| // Seek sets the offset for the next Read to offset, interpreted according to |
| // whence: 0 means relative to the origin of the file, 1 means relative to the |
| // current offset, and 2 means relative to the end. Seek returns the new offset |
| // and an error, if any. |
| // |
| // If the ReaderSeekerCloser is not an io.Seeker nothing will be done. |
| func (r ReaderSeekerCloser) Seek(offset int64, whence int) (int64, error) { |
| switch t := r.r.(type) { |
| case io.Seeker: |
| return t.Seek(offset, whence) |
| } |
| return int64(0), nil |
| } |
| |
| // IsSeeker returns if the underlying reader is also a seeker. |
| func (r ReaderSeekerCloser) IsSeeker() bool { |
| _, ok := r.r.(io.Seeker) |
| return ok |
| } |
| |
| // Close closes the ReaderSeekerCloser. |
| // |
| // If the ReaderSeekerCloser is not an io.Closer nothing will be done. |
| func (r ReaderSeekerCloser) Close() error { |
| switch t := r.r.(type) { |
| case io.Closer: |
| return t.Close() |
| } |
| return nil |
| } |
| |
| // A WriteAtBuffer provides a in memory buffer supporting the io.WriterAt interface |
| // Can be used with the s3manager.Downloader to download content to a buffer |
| // in memory. Safe to use concurrently. |
| type WriteAtBuffer struct { |
| buf []byte |
| m sync.Mutex |
| |
| // GrowthCoeff defines the growth rate of the internal buffer. By |
| // default, the growth rate is 1, where expanding the internal |
| // buffer will allocate only enough capacity to fit the new expected |
| // length. |
| GrowthCoeff float64 |
| } |
| |
| // NewWriteAtBuffer creates a WriteAtBuffer with an internal buffer |
| // provided by buf. |
| func NewWriteAtBuffer(buf []byte) *WriteAtBuffer { |
| return &WriteAtBuffer{buf: buf} |
| } |
| |
| // WriteAt writes a slice of bytes to a buffer starting at the position provided |
| // The number of bytes written will be returned, or error. Can overwrite previous |
| // written slices if the write ats overlap. |
| func (b *WriteAtBuffer) WriteAt(p []byte, pos int64) (n int, err error) { |
| pLen := len(p) |
| expLen := pos + int64(pLen) |
| b.m.Lock() |
| defer b.m.Unlock() |
| if int64(len(b.buf)) < expLen { |
| if int64(cap(b.buf)) < expLen { |
| if b.GrowthCoeff < 1 { |
| b.GrowthCoeff = 1 |
| } |
| newBuf := make([]byte, expLen, int64(b.GrowthCoeff*float64(expLen))) |
| copy(newBuf, b.buf) |
| b.buf = newBuf |
| } |
| b.buf = b.buf[:expLen] |
| } |
| copy(b.buf[pos:], p) |
| return pLen, nil |
| } |
| |
| // Bytes returns a slice of bytes written to the buffer. |
| func (b *WriteAtBuffer) Bytes() []byte { |
| b.m.Lock() |
| defer b.m.Unlock() |
| return b.buf |
| } |