Class: Async::HTTP::Body::Stream
- Inherits:
-
Object
- Object
- Async::HTTP::Body::Stream
- Defined in:
- lib/async/http/body/stream.rb
Overview
The input stream is an IO-like object which contains the raw HTTP POST data. When applicable, its external encoding must be “ASCII-8BIT” and it must be opened in binary mode, for Ruby 1.9 compatibility. The input stream must respond to gets, each, read and rewind.
Instance Attribute Summary collapse
-
#input ⇒ Object
readonly
Returns the value of attribute input.
-
#output ⇒ Object
readonly
Returns the value of attribute output.
Instance Method Summary collapse
-
#close(error = nil) ⇒ Object
Close the input and output bodies.
- #close_read ⇒ Object
- #close_write ⇒ Object
-
#closed? ⇒ Boolean
Whether the stream has been closed.
-
#empty? ⇒ Boolean
Whether there are any output chunks remaining?.
- #flush ⇒ Object
-
#initialize(input, output = Writable.new) ⇒ Stream
constructor
A new instance of Stream.
-
#read(size = nil, buffer = nil) ⇒ Object
read behaves like IO#read.
- #read_nonblock(length, buffer = nil) ⇒ Object
-
#read_partial(size = nil) ⇒ Object
Read at most ‘size` bytes from the stream.
- #write(buffer) ⇒ Object (also: #write_nonblock)
Constructor Details
#initialize(input, output = Writable.new) ⇒ Stream
Returns a new instance of Stream.
30 31 32 33 34 35 36 37 38 39 |
# File 'lib/async/http/body/stream.rb', line 30 def initialize(input, output = Writable.new) @input = input @output = output raise ArgumentError, "Non-writable output!" unless output.respond_to?(:write) # Will hold remaining data in `#read`. @buffer = nil @closed = false end |
Instance Attribute Details
#input ⇒ Object (readonly)
Returns the value of attribute input.
41 42 43 |
# File 'lib/async/http/body/stream.rb', line 41 def input @input end |
#output ⇒ Object (readonly)
Returns the value of attribute output.
42 43 44 |
# File 'lib/async/http/body/stream.rb', line 42 def output @output end |
Instance Method Details
#close(error = nil) ⇒ Object
Close the input and output bodies.
142 143 144 145 146 147 |
# File 'lib/async/http/body/stream.rb', line 142 def close(error = nil) self.close_read self.close_write ensure @closed = true end |
#close_read ⇒ Object
133 134 135 |
# File 'lib/async/http/body/stream.rb', line 133 def close_read @input&.close end |
#close_write ⇒ Object
137 138 139 |
# File 'lib/async/http/body/stream.rb', line 137 def close_write @output&.close end |
#closed? ⇒ Boolean
Whether the stream has been closed.
150 151 152 |
# File 'lib/async/http/body/stream.rb', line 150 def closed? @closed end |
#empty? ⇒ Boolean
Whether there are any output chunks remaining?
155 156 157 |
# File 'lib/async/http/body/stream.rb', line 155 def empty? @output.empty? end |
#flush ⇒ Object
130 131 |
# File 'lib/async/http/body/stream.rb', line 130 def flush end |
#read(size = nil, buffer = nil) ⇒ Object
read behaves like IO#read. Its signature is read([length, [buffer]]). If given, length must be a non-negative Integer (>= 0) or nil, and buffer must be a String and may not be nil. If length is given and not nil, then this method reads at most length bytes from the input stream. If length is not given or nil, then this method reads all data until EOF. When EOF is reached, this method returns nil if length is given and not nil, or “” if length is not given or is nil. If buffer is given, then the read data will be placed into buffer instead of a newly created String object.
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 |
# File 'lib/async/http/body/stream.rb', line 51 def read(size = nil, buffer = nil) return '' if size == 0 buffer ||= Async::IO::Buffer.new if @buffer buffer.replace(@buffer) @buffer = nil end if size while buffer.bytesize < size and chunk = read_next buffer << chunk end @buffer = buffer.byteslice(size, buffer.bytesize) buffer = buffer.byteslice(0, size) if buffer.empty? return nil else return buffer end else while chunk = read_next buffer << chunk end return buffer end end |
#read_nonblock(length, buffer = nil) ⇒ Object
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 |
# File 'lib/async/http/body/stream.rb', line 101 def read_nonblock(length, buffer = nil) @buffer ||= read_next chunk = nil return nil if @buffer.nil? if @buffer.bytesize > length chunk = @buffer.byteslice(0, length) @buffer = @buffer.byteslice(length, @buffer.bytesize) else chunk = @buffer @buffer = nil end if buffer buffer.replace(chunk) else buffer = chunk end return buffer end |
#read_partial(size = nil) ⇒ Object
Read at most ‘size` bytes from the stream. Will avoid reading from the underlying stream if possible.
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 |
# File 'lib/async/http/body/stream.rb', line 83 def read_partial(size = nil) if @buffer buffer = @buffer @buffer = nil else buffer = read_next end if buffer and size if buffer.bytesize > size @buffer = buffer.byteslice(size, buffer.bytesize) buffer = buffer.byteslice(0, size) end end return buffer end |
#write(buffer) ⇒ Object Also known as: write_nonblock
124 125 126 |
# File 'lib/async/http/body/stream.rb', line 124 def write(buffer) @output.write(buffer) end |