Struct zenoh::net::Session

pub struct Session { /* fields omitted */ }

A zenoh-net session.

Implementations

impl Session

pub fn id(&self) -> impl ZFuture<Output = String>

Returns the identifier for this session.

pub fn hlc(&self) -> Option<&HLC>

pub fn close(self) -> impl ZFuture<Output = ZResult<()>>

Close the zenoh-net Session.

Sessions are automatically closed when dropped, but you may want to use this function to handle errors or close the Session asynchronously.

Examples

use zenoh::net::*;

let session = open(config::peer()).await.unwrap();
session.close().await.unwrap();

pub fn info(&self) -> impl ZFuture<Output = InfoProperties>

Get informations about the zenoh-net Session.

Examples

use zenoh::net::*;

let session = open(config::peer()).await.unwrap();
let info = session.info();

pub fn declare_resource(
    &self,
    resource: &ResKey
) -> impl ZFuture<Output = ZResult<ResourceId>>

Associate a numerical Id with the given resource key.

This numerical Id will be used on the network to save bandwidth and ease the retrieval of the concerned resource in the routing tables.

Arguments

• resource - The resource key to map to a numerical Id

Examples

use zenoh::net::*;

let session = open(config::peer()).await.unwrap();
let rid = session.declare_resource(&"/resource/name".into()).await.unwrap();

pub fn undeclare_resource(
    &self,
    rid: ResourceId
) -> impl ZFuture<Output = ZResult<()>>

Undeclare the numerical Id/resource key association previously declared with declare_resource.

Arguments

• rid - The numerical Id to unmap

Examples

use zenoh::net::*;

let session = open(config::peer()).await.unwrap();
let rid = session.declare_resource(&"/resource/name".into()).await.unwrap();
session.undeclare_resource(rid).await;

pub fn declare_publisher(
    &self,
    resource: &ResKey
) -> impl ZFuture<Output = ZResult<Publisher<'_>>>

Declare a Publisher for the given resource key.

Written resources that match the given key will only be sent on the network if matching subscribers exist in the system.

Arguments

• resource - The resource key to publish

Examples

use zenoh::net::*;

let session = open(config::peer()).await.unwrap();
let publisher = session.declare_publisher(&"/resource/name".into()).await.unwrap();
session.write(&"/resource/name".into(), "value".as_bytes().into()).await.unwrap();

pub fn declare_subscriber(
    &self,
    reskey: &ResKey,
    info: &SubInfo
) -> impl ZFuture<Output = ZResult<Subscriber<'_>>>

Declare a Subscriber for the given resource key.

Arguments

• resource - The resource key to subscribe
• info - The SubInfo to configure the subscription

Examples

use zenoh::net::*;
use futures::prelude::*;

let session = open(config::peer()).await.unwrap();
let sub_info = SubInfo {
    reliability: Reliability::Reliable,
    mode: SubMode::Push,
    period: None
};
let mut subscriber = session.declare_subscriber(&"/resource/name".into(), &sub_info).await.unwrap();
while let Some(sample) = subscriber.receiver().next().await {
    println!("Received : {:?}", sample);
}

pub fn declare_callback_subscriber<DataHandler>(
    &self,
    reskey: &ResKey,
    info: &SubInfo,
    data_handler: DataHandler
) -> impl ZFuture<Output = ZResult<CallbackSubscriber<'_>>> where
    DataHandler: FnMut(Sample) + Send + Sync + 'static, 

Declare a CallbackSubscriber for the given resource key.

Arguments

• resource - The resource key to subscribe
• info - The SubInfo to configure the subscription
• data_handler - The callback that will be called on each data reception

Examples

use zenoh::net::*;

let session = open(config::peer()).await.unwrap();
let sub_info = SubInfo {
    reliability: Reliability::Reliable,
    mode: SubMode::Push,
    period: None
};
let subscriber = session.declare_callback_subscriber(&"/resource/name".into(), &sub_info,
    |sample| { println!("Received : {} {}", sample.res_name, sample.payload); }
).await.unwrap();

pub fn declare_local_subscriber(
    &self,
    reskey: &ResKey
) -> impl ZFuture<Output = ZResult<Subscriber<'_>>>

This is an experimental API.

pub fn declare_queryable(
    &self,
    resource: &ResKey,
    kind: ZInt
) -> impl ZFuture<Output = ZResult<Queryable<'_>>>

Declare a Queryable for the given resource key.

Arguments

• resource - The resource key the Queryable will reply to
• kind - The kind of Queryable

Examples

use zenoh::net::*;
use zenoh::net::queryable::EVAL;
use futures::prelude::*;

let session = open(config::peer()).await.unwrap();
let mut queryable = session.declare_queryable(&"/resource/name".into(), EVAL).await.unwrap();
while let Some(query) = queryable.receiver().next().await {
    query.reply_async(Sample{
        res_name: "/resource/name".to_string(),
        payload: "value".as_bytes().into(),
        data_info: None,
    }).await;
}

pub fn write(
    &self,
    resource: &ResKey,
    payload: ZBuf
) -> impl ZFuture<Output = ZResult<()>>

Write data.

Arguments

• resource - The resource key to write
• payload - The value to write

Examples

use zenoh::net::*;

let session = open(config::peer()).await.unwrap();
session.write(&"/resource/name".into(), "value".as_bytes().into()).await.unwrap();

pub fn write_ext(
    &self,
    resource: &ResKey,
    payload: ZBuf,
    encoding: ZInt,
    kind: ZInt,
    congestion_control: CongestionControl
) -> impl ZFuture<Output = ZResult<()>>

Write data with options.

Arguments

• resource - The resource key to write
• payload - The value to write
• encoding - The encoding of the value
• kind - The kind of value
• congestion_control - The value for the congestion control

Examples

use zenoh::net::*;

let session = open(config::peer()).await.unwrap();
session.write_ext(&"/resource/name".into(), "value".as_bytes().into(), encoding::TEXT_PLAIN, data_kind::PUT, CongestionControl::Drop).await.unwrap();

pub fn query(
    &self,
    resource: &ResKey,
    predicate: &str,
    target: QueryTarget,
    consolidation: QueryConsolidation
) -> impl ZFuture<Output = ZResult<ReplyReceiver>>

Query data from the matching queryables in the system.

Arguments

• resource - The resource key to query
• predicate - An indication to matching queryables about the queried data
• target - The kind of queryables that should be target of this query
• consolidation - The kind of consolidation that should be applied on replies

Examples

use zenoh::net::*;
use futures::prelude::*;

let session = open(config::peer()).await.unwrap();
let mut replies = session.query(
    &"/resource/name".into(),
    "predicate",
    QueryTarget::default(),
    QueryConsolidation::default()
).await.unwrap();
while let Some(reply) = replies.next().await {
    println!(">> Received {:?}", reply.data);
}

pub fn reskey_to_resname(&self, reskey: &ResKey) -> ZResult<String>

Trait Implementations

impl Debug for Session

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

Formats the value using the given formatter.

impl Drop for Session

fn drop(&mut self)

Executes the destructor for this type.

impl From<&'_ Session> for Zenoh

fn from(s: &Session) -> Self

Performs the conversion.

impl From<Session> for Zenoh

fn from(session: Session) -> Self

Performs the conversion.

impl Primitives for Session

fn decl_resource(&self, rid: ZInt, reskey: &ResKey)

fn forget_resource(&self, _rid: ZInt)

fn decl_publisher(
    &self,
    _reskey: &ResKey,
    _routing_context: Option<RoutingContext>
)

fn forget_publisher(
    &self,
    _reskey: &ResKey,
    _routing_context: Option<RoutingContext>
)

fn decl_subscriber(
    &self,
    _reskey: &ResKey,
    _sub_info: &SubInfo,
    _routing_context: Option<RoutingContext>
)

fn forget_subscriber(
    &self,
    _reskey: &ResKey,
    _routing_context: Option<RoutingContext>
)

fn decl_queryable(
    &self,
    _reskey: &ResKey,
    _kind: ZInt,
    _routing_context: Option<RoutingContext>
)

fn forget_queryable(
    &self,
    _reskey: &ResKey,
    _routing_context: Option<RoutingContext>
)

fn send_data(
    &self,
    reskey: &ResKey,
    payload: ZBuf,
    channel: Channel,
    congestion_control: CongestionControl,
    info: Option<DataInfo>,
    _routing_context: Option<RoutingContext>
)

fn send_query(
    &self,
    reskey: &ResKey,
    predicate: &str,
    qid: ZInt,
    target: QueryTarget,
    consolidation: QueryConsolidation,
    _routing_context: Option<RoutingContext>
)

fn send_reply_data(
    &self,
    qid: ZInt,
    replier_kind: ZInt,
    replier_id: PeerId,
    reskey: ResKey,
    data_info: Option<DataInfo>,
    payload: ZBuf
)

fn send_reply_final(&self, qid: ZInt)

fn send_pull(
    &self,
    _is_final: bool,
    _reskey: &ResKey,
    _pull_id: ZInt,
    _max_samples: &Option<ZInt>
)

fn send_close(&self)