Class: Async::HTTP::Body::Writable

Inherits:
Readable
  • Object
show all
Defined in:
lib/async/http/body/writable.rb

Overview

A dynamic body which you can write to and read from.

Direct Known Subclasses

Slowloris

Defined Under Namespace

Classes: Closed

Instance Method Summary collapse

Methods inherited from Readable

#each, #finish, #join

Constructor Details

#initialize(length = nil, queue: Async::Queue.new) ⇒ Writable

Returns a new instance of Writable.

Parameters:

  • length (Integer) (defaults to: nil) —

    The length of the response body if known.

  • queue (Async::Queue) (defaults to: Async::Queue.new) —

    Specify a different queue implementation, e.g. ‘Async::LimitedQueue.new(8)` to enable back-pressure streaming.



35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/async/http/body/writable.rb', line 35

def initialize(length = nil, queue: Async::Queue.new)
	@queue = queue
	
	@length = length
	
	@count = 0
	
	@finished = false
	
	@closed = false
	@error = nil
end

Instance Method Details

#close(error = nil) ⇒ Object

Stop generating output; cause the next call to write to fail with the given error.



53
54
55
56
57
58
59
60
61
62
 
# File 'lib/async/http/body/writable.rb', line 53

def close(error = nil)
	unless @closed
		@queue.enqueue(nil)
		
		@closed = true
		@error = error
	end
	
	super
end

#closed? ⇒ Boolean

Returns:

  • (Boolean) 


64
65
66
 
# File 'lib/async/http/body/writable.rb', line 64

def closed?
	@closed
end

#empty? ⇒ Boolean

Has the producer called #finish and has the reader consumed the nil token?

Returns:

  • (Boolean) 


69
70
71
 
# File 'lib/async/http/body/writable.rb', line 69

def empty?
	@finished
end

#inspect ⇒ Object 



98
99
100
 
# File 'lib/async/http/body/writable.rb', line 98

def inspect
	"\#<#{self.class} #{@count} chunks written#{@finished ? ', finished' : ', waiting'}>"
end

#length ⇒ Object 



48
49
50
 
# File 'lib/async/http/body/writable.rb', line 48

def length
	@length
end

#read ⇒ Object

Read the next available chunk.



74
75
76
77
78
79
80
81
82
 
# File 'lib/async/http/body/writable.rb', line 74

def read
	return if @finished
	
	unless chunk = @queue.dequeue
		@finished = true
	end
	
	return chunk
end

#write(chunk) ⇒ Object Also known as: <<

Write a single chunk to the body. Signal completion by calling ‘#finish`.



85
86
87
88
89
90
91
92
93
94
 
# File 'lib/async/http/body/writable.rb', line 85

def write(chunk)
	# If the reader breaks, the writer will break.
	# The inverse of this is less obvious (*)
	if @closed
		raise(@error || Closed)
	end
	
	@count += 1
	@queue.enqueue(chunk)
end