Struct wasmtime_wasi_http::struct::WasiHttp

pub struct WasiHttp {
    pub request_id_base: u32,
    pub response_id_base: u32,
    pub fields_id_base: u32,
    pub streams_id_base: u32,
    pub future_id_base: u32,
    pub requests: HashMap<u32, ActiveRequest>,
    pub responses: HashMap<u32, ActiveResponse>,
    pub fields: HashMap<u32, HashMap<String, Vec<Vec<u8>>>>,
    pub streams: HashMap<u32, Stream>,
    pub futures: HashMap<u32, ActiveFuture>,
}

Fields

request_id_base: u32

response_id_base: u32

fields_id_base: u32

streams_id_base: u32

future_id_base: u32

requests: HashMap<u32, ActiveRequest>

responses: HashMap<u32, ActiveResponse>

fields: HashMap<u32, HashMap<String, Vec<Vec<u8>>>>

streams: HashMap<u32, Stream>

futures: HashMap<u32, ActiveFuture>

Implementations

impl WasiHttp

pub fn new() -> Self

Trait Implementations

impl Clone for WasiHttp

fn clone(&self) -> WasiHttp

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Host for WasiHttp

fn read( &mut self, stream: InputStream, len: u64 ) -> Result<Result<(Vec<u8>, bool), StreamError>>

Read bytes from a stream.

fn skip( &mut self, stream: InputStream, len: u64 ) -> Result<Result<(u64, bool), StreamError>>

Skip bytes from a stream.

fn subscribe_to_input_stream(&mut self, _this: InputStream) -> Result<Pollable>

Create a pollable which will resolve once either the specified stream has bytes available to read or the other end of the stream has been closed.

fn drop_input_stream(&mut self, stream: InputStream) -> Result<()>

Dispose of the specified input-stream, after which it may no longer be used.

fn write( &mut self, this: OutputStream, buf: Vec<u8> ) -> Result<Result<u64, StreamError>>

Write bytes to a stream.

fn write_zeroes( &mut self, this: OutputStream, len: u64 ) -> Result<Result<u64, StreamError>>

Write multiple zero bytes to a stream.

fn splice( &mut self, _this: OutputStream, _src: InputStream, _len: u64 ) -> Result<Result<(u64, bool), StreamError>>

Read from one stream and write to another.

fn forward( &mut self, _this: OutputStream, _src: InputStream ) -> Result<Result<u64, StreamError>>

Forward the entire contents of an input stream to an output stream.

fn subscribe_to_output_stream( &mut self, _this: OutputStream ) -> Result<Pollable>

Create a pollable which will resolve once either the specified stream is ready to accept bytes or the other end of the stream has been closed.

fn drop_output_stream(&mut self, stream: OutputStream) -> Result<()>

Dispose of the specified output-stream, after which it may no longer be used.

fn blocking_read( &mut self, _: InputStream, _: u64 ) -> Result<Result<(Vec<u8>, bool), StreamError>>

Read bytes from a stream, with blocking.

fn blocking_skip( &mut self, _: InputStream, _: u64 ) -> Result<Result<(u64, bool), StreamError>>

Skip bytes from a stream, with blocking.

fn blocking_write( &mut self, _: OutputStream, _: Vec<u8> ) -> Result<Result<u64, StreamError>>

Write bytes to a stream, with blocking.

fn blocking_write_zeroes( &mut self, _: OutputStream, _: u64 ) -> Result<Result<u64, StreamError>>

Write multiple zero bytes to a stream, with blocking.

fn blocking_splice( &mut self, _: OutputStream, _: InputStream, _: u64 ) -> Result<Result<(u64, bool), StreamError>>

Read from one stream and write to another, with blocking.

impl Host for WasiHttp

fn drop_fields(&mut self, fields: Fields) -> Result<()>

fn new_fields(&mut self, entries: Vec<(String, String)>) -> Result<Fields>

fn fields_get(&mut self, fields: Fields, name: String) -> Result<Vec<Vec<u8>>>

fn fields_set( &mut self, fields: Fields, name: String, value: Vec<Vec<u8>> ) -> Result<()>

fn fields_delete(&mut self, fields: Fields, name: String) -> Result<()>

fn fields_append( &mut self, fields: Fields, name: String, value: Vec<u8> ) -> Result<()>

fn fields_entries(&mut self, fields: Fields) -> Result<Vec<(String, Vec<u8>)>>

fn fields_clone(&mut self, fields: Fields) -> Result<Fields>

fn finish_incoming_stream( &mut self, s: IncomingStream ) -> Result<Option<Trailers>>

fn finish_outgoing_stream( &mut self, _s: OutgoingStream, _trailers: Option<Trailers> ) -> Result<()>

fn drop_incoming_request(&mut self, _request: IncomingRequest) -> Result<()>

fn drop_outgoing_request(&mut self, request: OutgoingRequest) -> Result<()>

fn incoming_request_method( &mut self, _request: IncomingRequest ) -> Result<Method>

fn incoming_request_path_with_query( &mut self, _request: IncomingRequest ) -> Result<Option<String>>

fn incoming_request_scheme( &mut self, _request: IncomingRequest ) -> Result<Option<Scheme>>

fn incoming_request_authority( &mut self, _request: IncomingRequest ) -> Result<Option<String>>

fn incoming_request_headers( &mut self, _request: IncomingRequest ) -> Result<Headers>

fn incoming_request_consume( &mut self, _request: IncomingRequest ) -> Result<Result<IncomingStream, ()>>

fn new_outgoing_request( &mut self, method: Method, path_with_query: Option<String>, scheme: Option<Scheme>, authority: Option<String>, headers: Headers ) -> Result<OutgoingRequest>

fn outgoing_request_write( &mut self, request: OutgoingRequest ) -> Result<Result<OutgoingStream, ()>>

fn drop_response_outparam(&mut self, _response: ResponseOutparam) -> Result<()>

fn set_response_outparam( &mut self, _outparam: ResponseOutparam, _response: Result<OutgoingResponse, Error> ) -> Result<Result<(), ()>>

fn drop_incoming_response(&mut self, response: IncomingResponse) -> Result<()>

fn drop_outgoing_response(&mut self, _response: OutgoingResponse) -> Result<()>

fn incoming_response_status( &mut self, response: IncomingResponse ) -> Result<StatusCode>

fn incoming_response_headers( &mut self, response: IncomingResponse ) -> Result<Headers>

fn incoming_response_consume( &mut self, response: IncomingResponse ) -> Result<Result<IncomingStream, ()>>

fn new_outgoing_response( &mut self, _status_code: StatusCode, _headers: Headers ) -> Result<OutgoingResponse>

fn outgoing_response_write( &mut self, _response: OutgoingResponse ) -> Result<Result<OutgoingStream, ()>>

fn drop_future_incoming_response( &mut self, future: FutureIncomingResponse ) -> Result<()>

fn future_incoming_response_get( &mut self, future: FutureIncomingResponse ) -> Result<Option<Result<IncomingResponse, Error>>>

fn listen_to_future_incoming_response( &mut self, _f: FutureIncomingResponse ) -> Result<Pollable>

impl Host for WasiHttp

fn handle( &mut self, request_id: OutgoingRequest, options: Option<RequestOptions> ) -> Result<FutureIncomingResponse>