Struct SessionClientRequest 

pub(crate) struct SessionClientRequest {
    pub destination: Address,
    pub forward_path: RoutingOptions,
    pub return_path: RoutingOptions,
    pub target: SessionTargetSpec,
    pub listen_host: Option<String>,
    pub capabilities: Option<Vec<SessionCapability>>,
    pub response_buffer: Option<ByteSize>,
    pub max_surb_upstream: Option<Bandwidth>,
    pub session_pool: Option<usize>,
    pub max_client_sessions: Option<usize>,
}

Request body for creating a new client session.

Fields

destination: Address

Address of the Exit node.

forward_path: RoutingOptions

The forward path for the Session.

return_path: RoutingOptions

The return path for the Session.

target: SessionTargetSpec

Target for the Session.

listen_host: Option<String>

Listen host (ip:port) for the Session socket at the Entry node.

Supports also partial specification (only ip or only :port) with the respective part replaced by the node’s configured default.

capabilities: Option<Vec<SessionCapability>>

Capabilities for the Session protocol.

Defaults to Segmentation and Retransmission for TCP and nothing for UDP.

response_buffer: Option<ByteSize>

The amount of response data the Session counterparty can deliver back to us, without us sending any SURBs to them.

In other words, this size is recalculated to a number of SURBs delivered to the counterparty upfront and then maintained. The maintenance is dynamic, based on the number of responses we receive.

All syntaxes like “2 MB”, “128 kiB”, “3MiB” are supported. The value must be at least the size of 2 Session packet payloads.

max_surb_upstream: Option<Bandwidth>

The maximum throughput at which artificial SURBs might be generated and sent to the recipient of the Session.

On Sessions that rarely send data but receive a lot (= Exit node has high SURB consumption), this should roughly match the maximum retrieval throughput.

All syntaxes like “2 MBps”, “1.2Mbps”, “300 kb/s”, “1.23 Mb/s” are supported.

session_pool: Option<usize>

How many Sessions to pool for clients.

If no sessions are pooled, they will be opened ad-hoc when a client connects. It has no effect on UDP sessions in the current implementation.

Currently, the maximum value is 5.

max_client_sessions: Option<usize>

The maximum number of client sessions that the listener can spawn.

This currently applies only to the TCP sessions, as UDP sessions cannot handle multiple clients (and spawn therefore always only a single session).

If this value is smaller than the value specified in session_pool, it will be set to that value.

The default value is 5.

Implementations

impl SessionClientRequest

pub(crate) async fn into_protocol_session_config( self, target_protocol: IpProtocol, ) -> Result<(Address, SessionTarget, HoprSessionClientConfig), ApiErrorStatus>

Converts the API client session request into protocol-level session configuration.

Trait Implementations

impl Clone for SessionClientRequest

fn clone(&self) -> SessionClientRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComposeSchema for SessionClientRequest

fn compose(generics: Vec<RefOr<Schema>>) -> RefOr<Schema>

impl Debug for SessionClientRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SessionClientRequest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SessionClientRequest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToSchema for SessionClientRequest

fn name() -> Cow<'static, str>

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference [utoipa::openapi::schema::Schema]s for this type.