Struct CallBinding 

pub struct CallBinding {
    pub audience: String,
    pub method: String,
    pub route: String,
    pub path_params: Vec<String>,
    pub query: Option<String>,
    pub contract_sha: [u8; 32],
    pub idempotency_key: Option<String>,
    pub if_match: Option<String>,
    pub payload_type: Option<String>,
    pub payload_accept: Option<Vec<String>>,
}

Everything one call binds, owned.

query is the raw query string as the client will send it; it is canonicalised here, and an empty result binds as None, as it does in the Rust client. idempotency_key and if_match are bound exactly as the request header will carry them, so the caller must send those headers byte for byte.

Fields

audience: String

The configured name of the service addressed (never the Host).

method: String

HTTP method, e.g. "POST".

route: String

The RPC op_id, or the REST route template.

path_params: Vec<String>

REST path parameter values in template order; empty for RPC.

query: Option<String>

The request’s query string, in any spelling.

contract_sha: [u8; 32]

The op contract digest (OP_CONTRACTS of the generated client).

idempotency_key: Option<String>

The request’s Idempotency-Key header value, if it carries one.

if_match: Option<String>

The request’s If-Match header value, if it carries one.

payload_type: Option<String>

The type the request payload is sealed under; None is application/cbor. Bound in the AAD. For compact wire keys (compact wire keys design §5.1) it is application/vnd.cratestack.compact+cbor. When it is not CBOR the request must also carry Cratestack-Payload-Type (selector_headers).

payload_accept: Option<Vec<String>>

The types the call reads its answer in, in order of preference; None is just application/cbor. A response sealed under another type is refused (response_for). When it is not just CBOR the request must also carry Cratestack-Payload-Accept.

Implementations

impl CallBinding

pub fn request(&self) -> Binding<'_>

The request binding: what a request is sealed and opened under.

pub fn response(&self, sealed_request: &[u8], status: u16) -> Binding<'_>

The binding of the response to sealed_request (the exact bytes that travelled) with the HTTP status it came back with. This is the CBOR-answer binding; for a call that accepts other types use response_for.

impl CallBinding

pub fn request_payload_type(&self) -> &str

The type the request payload is sealed under: the CBOR codec’s unless payload_type says otherwise.

pub fn accepted_payload_types(&self) -> Vec<&str>

The types the call reads its answer in, in order of preference.

pub fn validate(&self) -> Result<(), CratestackError>

Check the payload type and the accept list: each must be sealable (cratestack_core::is_sealable_payload_type, so never an envelope, a +cbor-seq stream or a multipart body) and the list well formed. Fails with Validation, before anything is sealed.

pub fn selector_headers(&self) -> Vec<(&'static str, String)>

The payload-type selector headers this call must send, as (name, value): Cratestack-Payload-Type when the request type is not CBOR, Cratestack-Payload-Accept when the accept list is not just CBOR. Empty for a default call, which sends neither. They are not themselves signed; the binding makes a wrong one fail verification.

pub fn response_for( &self, sealed_request: &[u8], status: u16, response_type: Option<&str>, ) -> Result<Binding<'_>, CratestackError>

The binding of the response to sealed_request with the HTTP status, sealed under the type the response’s Cratestack-Payload-Type header named (response_type; None means CBOR). The type is the binding’s payload_media_type.

A type the call did not ask for (not in the accept list) is Unauthorized, the coarse refusal, before any body is opened. The header is not authenticated by itself: it names the string the binding is rebuilt with, and a wrong one fails verification.

Trait Implementations

impl Clone for CallBinding

fn clone(&self) -> CallBinding

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CallBinding

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for CallBinding

impl PartialEq for CallBinding

fn eq(&self, other: &CallBinding) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for CallBinding