]>
Commit | Line | Data |
---|---|---|
bae9f6d2 JC |
1 | package aws |
2 | ||
3 | import ( | |
4 | "io" | |
5 | "sync" | |
6 | ) | |
7 | ||
8 | // ReadSeekCloser wraps a io.Reader returning a ReaderSeekerCloser. Should | |
9 | // only be used with an io.Reader that is also an io.Seeker. Doing so may | |
10 | // cause request signature errors, or request body's not sent for GET, HEAD | |
11 | // and DELETE HTTP methods. | |
12 | // | |
13 | // Deprecated: Should only be used with io.ReadSeeker. If using for | |
14 | // S3 PutObject to stream content use s3manager.Uploader instead. | |
15 | func ReadSeekCloser(r io.Reader) ReaderSeekerCloser { | |
16 | return ReaderSeekerCloser{r} | |
17 | } | |
18 | ||
19 | // ReaderSeekerCloser represents a reader that can also delegate io.Seeker and | |
20 | // io.Closer interfaces to the underlying object if they are available. | |
21 | type ReaderSeekerCloser struct { | |
22 | r io.Reader | |
23 | } | |
24 | ||
25 | // Read reads from the reader up to size of p. The number of bytes read, and | |
26 | // error if it occurred will be returned. | |
27 | // | |
28 | // If the reader is not an io.Reader zero bytes read, and nil error will be returned. | |
29 | // | |
30 | // Performs the same functionality as io.Reader Read | |
31 | func (r ReaderSeekerCloser) Read(p []byte) (int, error) { | |
32 | switch t := r.r.(type) { | |
33 | case io.Reader: | |
34 | return t.Read(p) | |
35 | } | |
36 | return 0, nil | |
37 | } | |
38 | ||
39 | // Seek sets the offset for the next Read to offset, interpreted according to | |
40 | // whence: 0 means relative to the origin of the file, 1 means relative to the | |
41 | // current offset, and 2 means relative to the end. Seek returns the new offset | |
42 | // and an error, if any. | |
43 | // | |
44 | // If the ReaderSeekerCloser is not an io.Seeker nothing will be done. | |
45 | func (r ReaderSeekerCloser) Seek(offset int64, whence int) (int64, error) { | |
46 | switch t := r.r.(type) { | |
47 | case io.Seeker: | |
48 | return t.Seek(offset, whence) | |
49 | } | |
50 | return int64(0), nil | |
51 | } | |
52 | ||
53 | // IsSeeker returns if the underlying reader is also a seeker. | |
54 | func (r ReaderSeekerCloser) IsSeeker() bool { | |
55 | _, ok := r.r.(io.Seeker) | |
56 | return ok | |
57 | } | |
58 | ||
59 | // Close closes the ReaderSeekerCloser. | |
60 | // | |
61 | // If the ReaderSeekerCloser is not an io.Closer nothing will be done. | |
62 | func (r ReaderSeekerCloser) Close() error { | |
63 | switch t := r.r.(type) { | |
64 | case io.Closer: | |
65 | return t.Close() | |
66 | } | |
67 | return nil | |
68 | } | |
69 | ||
70 | // A WriteAtBuffer provides a in memory buffer supporting the io.WriterAt interface | |
71 | // Can be used with the s3manager.Downloader to download content to a buffer | |
72 | // in memory. Safe to use concurrently. | |
73 | type WriteAtBuffer struct { | |
74 | buf []byte | |
75 | m sync.Mutex | |
76 | ||
77 | // GrowthCoeff defines the growth rate of the internal buffer. By | |
78 | // default, the growth rate is 1, where expanding the internal | |
79 | // buffer will allocate only enough capacity to fit the new expected | |
80 | // length. | |
81 | GrowthCoeff float64 | |
82 | } | |
83 | ||
84 | // NewWriteAtBuffer creates a WriteAtBuffer with an internal buffer | |
85 | // provided by buf. | |
86 | func NewWriteAtBuffer(buf []byte) *WriteAtBuffer { | |
87 | return &WriteAtBuffer{buf: buf} | |
88 | } | |
89 | ||
90 | // WriteAt writes a slice of bytes to a buffer starting at the position provided | |
91 | // The number of bytes written will be returned, or error. Can overwrite previous | |
92 | // written slices if the write ats overlap. | |
93 | func (b *WriteAtBuffer) WriteAt(p []byte, pos int64) (n int, err error) { | |
94 | pLen := len(p) | |
95 | expLen := pos + int64(pLen) | |
96 | b.m.Lock() | |
97 | defer b.m.Unlock() | |
98 | if int64(len(b.buf)) < expLen { | |
99 | if int64(cap(b.buf)) < expLen { | |
100 | if b.GrowthCoeff < 1 { | |
101 | b.GrowthCoeff = 1 | |
102 | } | |
103 | newBuf := make([]byte, expLen, int64(b.GrowthCoeff*float64(expLen))) | |
104 | copy(newBuf, b.buf) | |
105 | b.buf = newBuf | |
106 | } | |
107 | b.buf = b.buf[:expLen] | |
108 | } | |
109 | copy(b.buf[pos:], p) | |
110 | return pLen, nil | |
111 | } | |
112 | ||
113 | // Bytes returns a slice of bytes written to the buffer. | |
114 | func (b *WriteAtBuffer) Bytes() []byte { | |
115 | b.m.Lock() | |
116 | defer b.m.Unlock() | |
117 | return b.buf | |
118 | } |