Class: Protocol::HTTP::Body::Stream
- Inherits:
-
Object
- Object
- Protocol::HTTP::Body::Stream
- Defined in:
- lib/protocol/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
close must never be called on the input stream.
-
#closed? ⇒ Boolean
Whether the stream has been closed.
-
#empty? ⇒ Boolean
Whether there are any output chunks remaining?.
- #flush ⇒ Object
-
#initialize(input, output = Buffered.new) ⇒ Stream
constructor
A new instance of Stream.
-
#read(length = nil, buffer = nil) ⇒ Object
read behaves like IO#read.
- #read_nonblock(length, buffer = nil) ⇒ Object
-
#read_partial(length = nil) ⇒ Object
Read at most ‘length` bytes from the stream.
- #write(buffer) ⇒ Object (also: #write_nonblock)
Constructor Details
#initialize(input, output = Buffered.new) ⇒ Stream
Returns a new instance of Stream.
30 31 32 33 34 35 36 37 38 39 |
# File 'lib/protocol/http/body/stream.rb', line 30 def initialize(input, output = Buffered.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/protocol/http/body/stream.rb', line 41 def input @input end |
#output ⇒ Object (readonly)
Returns the value of attribute output.
42 43 44 |
# File 'lib/protocol/http/body/stream.rb', line 42 def output @output end |
Instance Method Details
#close(error = nil) ⇒ Object
Close the input and output bodies.
164 165 166 167 168 169 170 171 |
# File 'lib/protocol/http/body/stream.rb', line 164 def close(error = nil) self.close_read self.close_write return nil ensure @closed = true end |
#close_read ⇒ Object
152 153 154 155 |
# File 'lib/protocol/http/body/stream.rb', line 152 def close_read @input&.close @input = nil end |
#close_write ⇒ Object
close must never be called on the input stream. huh?
158 159 160 161 |
# File 'lib/protocol/http/body/stream.rb', line 158 def close_write @output&.close @output = nil end |
#closed? ⇒ Boolean
Whether the stream has been closed.
174 175 176 |
# File 'lib/protocol/http/body/stream.rb', line 174 def closed? @closed end |
#empty? ⇒ Boolean
Whether there are any output chunks remaining?
179 180 181 |
# File 'lib/protocol/http/body/stream.rb', line 179 def empty? @output.empty? end |
#flush ⇒ Object
149 150 |
# File 'lib/protocol/http/body/stream.rb', line 149 def flush end |
#read(length = 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 81 82 83 84 85 86 87 88 |
# File 'lib/protocol/http/body/stream.rb', line 51 def read(length = nil, buffer = nil) return '' if length == 0 buffer ||= Async::IO::Buffer.new # Take any previously buffered data and replace it into the given buffer. if @buffer buffer.replace(@buffer) @buffer = nil end if length while buffer.bytesize < length and chunk = read_next buffer << chunk end # This ensures the subsequent `slice!` works correctly. buffer.force_encoding(Encoding::BINARY) # This will be at least one copy: @buffer = buffer.byteslice(length, buffer.bytesize) # This should be zero-copy: buffer.slice!(length) 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
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 |
# File 'lib/protocol/http/body/stream.rb', line 112 def read_nonblock(length, buffer = nil) @buffer ||= read_next chunk = nil unless @buffer buffer&.clear return end 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(length = nil) ⇒ Object
Read at most ‘length` bytes from the stream. Will avoid reading from the underlying stream if possible.
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 |
# File 'lib/protocol/http/body/stream.rb', line 91 def read_partial(length = nil) if @buffer buffer = @buffer @buffer = nil else buffer = read_next end if buffer and length if buffer.bytesize > length # This ensures the subsequent `slice!` works correctly. buffer.force_encoding(Encoding::BINARY) @buffer = buffer.byteslice(length, buffer.bytesize) buffer.slice!(length) end end return buffer end |
#write(buffer) ⇒ Object Also known as: write_nonblock
138 139 140 141 142 143 144 145 |
# File 'lib/protocol/http/body/stream.rb', line 138 def write(buffer) if @output @output.write(buffer) return buffer.bytesize else raise IOError, "Stream is not writable, output has been closed!" end end |