Module handle 

Low-level interfaces to the Compute APIs.

For most applications, you should instead use the types in the top level of the crate, such as Request and Response. Future SDKs will not include these interfaces.

Reasons not to use handles

• The high-level interface has many more conveniences for application development. For example, there are methods for transparently reading and writing HTTP bodies as JSON, and common function argument types such as header values can accept and convert a variety of types automatically.

• BodyHandle and StreamingBodyHandle are unbuffered. Performance can suffer dramatically if repeated small reads and writes are made to these types. The higher-level equivalents, Body and StreamingBody are buffered automatically, though you can explicitly control some aspects of the buffering using std::io::BufRead and std::io::Write::flush().

• Explicit buffer sizes are required to get data such as header values from the Compute host. If the size you choose isn’t large enough, the operation will fail with an error and make you try again. The high-level interfaces automatically retry any such operations with the necessary buffer sizes.

• The high-level interface keeps data about a request or response in WebAssembly memory until it is sent to the client or a backend, whereas the handle interface is backed by memory in the Compute host.

  Suppose your application needs to manipulate headers in multiple functions. The handle interface would require you to either manually keep track of the headers separately from the handle they came from, or perform redundant copies to and from WebAssembly memory. The high-level interface would keep all of your header information in WebAssembly until it’s ready to use, improving performance.

Modules

config_store

Low-level Compute Config Store interfaces.

dictionaryDeprecated

Low-level Compute Dictionary interfaces.

Structs

BodyHandle

A low-level interface to HTTP bodies.

PendingRequestHandle

A handle to a pending asynchronous request returned by RequestHandle::send_async() or RequestHandle::send_async_streaming().

RequestHandle

The low-level interface to HTTP requests.

ResponseHandle

A low-level interface to HTTP responses.

StreamingBodyHandle

A low-level interface to a streaming HTTP body.

Enums

CacheOverride

Optional override for response caching behavior.

PollHandleResult

The result of a call to PendingRequestHandle::poll().

Functions

client_ddos_detectedDeprecated

Returns whether the request was tagged as contributing to a DDoS attack

client_ip_addrDeprecated

Returns the IP address of the client making the HTTP request.

client_original_header_count

Returns the number of headers in the client request as originally received.

client_original_header_names

Returns the client request’s header names exactly as they were originally received.

client_request_and_body

Get handles to the client request headers and body at the same time.

client_tls_cipher_openssl_name

Get the cipher suite used to secure the downstream client TLS connection, as a string, panicking if it is not UTF-8.

client_tls_client_helloDeprecated

Get the raw bytes sent by the client in the TLS ClientHello message.

client_tls_ja4Deprecated

Get the JA4 hash of the TLS ClientHello message.

client_tls_ja3_md5Deprecated

Get the JA3 hash of the TLS ClientHello message.

client_tls_protocolDeprecated

Get the TLS protocol version used to secure the downstream client TLS connection, as a string, panicking if it is not UTF-8.

select_handles

Given a collection of PendingRequestHandles, block until the result of one of the handles is ready.

server_ip_addrDeprecated

Returns the IP address on which this server received the HTTP request.