class Execution

parameter　endpoint　Transport::Endpoint

The caller endpoint.

parameter　backend　Thread | Ractor

The isolated execution context.

parameter　request　Protocol::HTTP::Request

The original request.

parameter　parent　Async::Task

The parent task for body forwarding.

def initialize(endpoint, backend, request, parent)
	@endpoint = endpoint
	@backend = backend
	@request = request
	@parent = parent
	@input_task = nil
	@input_close_task = nil
	@finished = false
	@mutex = Mutex.new
end

attribute　Channel

The control channel.

def control
	@endpoint.control
end

attribute　Channel

The bidirectional body channel.

def body
	@endpoint.body
end

returns　Protocol::HTTP::Response

The reconstructed response.

def call
	description = request_description(@request)
	control.write(:request, description)
	
	if description[:body]
		@input_task = @parent.async do
			forward_request_body(@request.body)
		end
	end
	
	wait_for_response
rescue
	cancel($!)
	raise
end

parameter　stream　IO | Object

The caller's duplex stream.

returns　Async::Task

The forwarding task.

def stream_input(stream)
	@parent.async do
		@input_task&.wait
		
		while chunk = read_stream_chunk(stream)
			body.write(:stream_chunk, chunk)
		end
	rescue => error
		begin
			body.write(:stream_error, RemoteError.dump(error))
		rescue ClosedError
			# The worker has already finished:
		end
	ensure
		body.close_write
	end
end

def close_input
	@input_close_task ||= @parent.async do
		@input_task&.wait
		body.close_write
	end
end

def finish
	return unless transition_to_finished
	
	@input_task&.cancel
	@input_close_task&.cancel
	@endpoint.close
	@backend.join
	return nil
end

parameter　error　Exception | Nil

The cancellation reason.

def cancel(error = nil)
	return unless transition_to_finished
	
	begin
		control.write(:cancel, error && RemoteError.dump(error))
	rescue ClosedError
		# The worker has already finished:
	end
	
	@input_task&.cancel
	@input_close_task&.cancel
	@request.close(error)
	@endpoint.close
	return nil
end