use std::sync::{atomic::Ordering, Arc};
use petgraph::graph::NodeIndex;
use zenoh_protocol::{
core::{WhatAmI, ZenohIdProto},
network::{
declare::{common::ext::WireExprType, TokenId},
ext,
interest::{InterestId, InterestMode},
Declare, DeclareBody, DeclareToken, UndeclareToken,
},
};
use zenoh_sync::get_mut_unchecked;
use super::{
face_hat, face_hat_mut, get_peer, hat, hat_mut, push_declaration_profile, res_hat, res_hat_mut,
HatCode, HatContext, HatFace, HatTables,
};
use crate::net::{
protocol::network::Network,
routing::{
dispatcher::{face::FaceState, tables::Tables},
hat::{CurrentFutureTrait, HatTokenTrait, SendDeclare},
router::{NodeId, Resource, SessionContext},
RoutingContext,
},
};
#[inline]
fn send_sourced_token_to_net_clildren(
tables: &Tables,
net: &Network,
clildren: &[NodeIndex],
res: &Arc<Resource>,
src_face: Option<&Arc<FaceState>>,
routing_context: NodeId,
) {
for child in clildren {
if net.graph.contains_node(*child) {
match tables.get_face(&net.graph[*child].zid).cloned() {
Some(mut someface) => {
if src_face
.map(|src_face| someface.id != src_face.id)
.unwrap_or(true)
{
let push_declaration = push_declaration_profile(&someface);
let key_expr = Resource::decl_key(res, &mut someface, push_declaration);
someface.primitives.send_declare(RoutingContext::with_expr(
&mut Declare {
interest_id: None,
ext_qos: ext::QoSType::DECLARE,
ext_tstamp: None,
ext_nodeid: ext::NodeIdType {
node_id: routing_context,
},
body: DeclareBody::DeclareToken(DeclareToken {
id: 0, wire_expr: key_expr,
}),
},
res.expr().to_string(),
));
}
}
None => tracing::trace!("Unable to find face for zid {}", net.graph[*child].zid),
}
}
}
}
#[inline]
fn propagate_simple_token_to(
tables: &mut Tables,
dst_face: &mut Arc<FaceState>,
res: &Arc<Resource>,
src_face: &mut Arc<FaceState>,
send_declare: &mut SendDeclare,
) {
if (src_face.id != dst_face.id || dst_face.zid == tables.zid)
&& !face_hat!(dst_face).local_tokens.contains_key(res)
&& dst_face.whatami == WhatAmI::Client
&& !face_hat!(dst_face).local_tokens.contains_key(res)
&& face_hat!(dst_face)
.remote_interests
.values()
.any(|i| i.options.tokens() && i.matches(res))
{
let id = face_hat!(dst_face).next_id.fetch_add(1, Ordering::SeqCst);
face_hat_mut!(dst_face).local_tokens.insert(res.clone(), id);
let key_expr = Resource::decl_key(res, dst_face, push_declaration_profile(dst_face));
send_declare(
&dst_face.primitives,
RoutingContext::with_expr(
Declare {
interest_id: None,
ext_qos: ext::QoSType::DECLARE,
ext_tstamp: None,
ext_nodeid: ext::NodeIdType::DEFAULT,
body: DeclareBody::DeclareToken(DeclareToken {
id,
wire_expr: key_expr,
}),
},
res.expr().to_string(),
),
);
}
}
fn propagate_simple_token(
tables: &mut Tables,
res: &Arc<Resource>,
src_face: &mut Arc<FaceState>,
send_declare: &mut SendDeclare,
) {
for mut dst_face in tables
.faces
.values()
.cloned()
.collect::<Vec<Arc<FaceState>>>()
{
propagate_simple_token_to(tables, &mut dst_face, res, src_face, send_declare);
}
}
fn propagate_sourced_token(
tables: &Tables,
res: &Arc<Resource>,
src_face: Option<&Arc<FaceState>>,
source: &ZenohIdProto,
) {
let net = hat!(tables).linkstatepeers_net.as_ref().unwrap();
match net.get_idx(source) {
Some(tree_sid) => {
if net.trees.len() > tree_sid.index() {
send_sourced_token_to_net_clildren(
tables,
net,
&net.trees[tree_sid.index()].children,
res,
src_face,
tree_sid.index() as NodeId,
);
} else {
tracing::trace!(
"Propagating token {}: tree for node {} sid:{} not yet ready",
res.expr(),
tree_sid.index(),
source
);
}
}
None => tracing::error!(
"Error propagating token {}: cannot get index of {}!",
res.expr(),
source
),
}
}
fn register_linkstatepeer_token(
tables: &mut Tables,
face: &mut Arc<FaceState>,
res: &mut Arc<Resource>,
peer: ZenohIdProto,
send_declare: &mut SendDeclare,
) {
if !res_hat!(res).linkstatepeer_tokens.contains(&peer) {
{
res_hat_mut!(res).linkstatepeer_tokens.insert(peer);
hat_mut!(tables).linkstatepeer_tokens.insert(res.clone());
}
propagate_sourced_token(tables, res, Some(face), &peer);
}
propagate_simple_token(tables, res, face, send_declare);
}
fn declare_linkstatepeer_token(
tables: &mut Tables,
face: &mut Arc<FaceState>,
res: &mut Arc<Resource>,
peer: ZenohIdProto,
send_declare: &mut SendDeclare,
) {
register_linkstatepeer_token(tables, face, res, peer, send_declare);
}
fn register_simple_token(
_tables: &mut Tables,
face: &mut Arc<FaceState>,
id: TokenId,
res: &mut Arc<Resource>,
) {
{
let res = get_mut_unchecked(res);
match res.session_ctxs.get_mut(&face.id) {
Some(ctx) => {
if !ctx.token {
get_mut_unchecked(ctx).token = true;
}
}
None => {
let ctx = res
.session_ctxs
.entry(face.id)
.or_insert_with(|| Arc::new(SessionContext::new(face.clone())));
get_mut_unchecked(ctx).token = true;
}
}
}
face_hat_mut!(face).remote_tokens.insert(id, res.clone());
}
fn declare_simple_token(
tables: &mut Tables,
face: &mut Arc<FaceState>,
id: TokenId,
res: &mut Arc<Resource>,
send_declare: &mut SendDeclare,
) {
register_simple_token(tables, face, id, res);
let zid = tables.zid;
register_linkstatepeer_token(tables, face, res, zid, send_declare);
}
#[inline]
fn remote_linkstatepeer_tokens(tables: &Tables, res: &Arc<Resource>) -> bool {
res.context.is_some()
&& res_hat!(res)
.linkstatepeer_tokens
.iter()
.any(|peer| peer != &tables.zid)
}
#[inline]
fn simple_tokens(res: &Arc<Resource>) -> Vec<Arc<FaceState>> {
res.session_ctxs
.values()
.filter_map(|ctx| {
if ctx.token {
Some(ctx.face.clone())
} else {
None
}
})
.collect()
}
#[inline]
fn remote_simple_tokens(tables: &Tables, res: &Arc<Resource>, face: &Arc<FaceState>) -> bool {
res.session_ctxs
.values()
.any(|ctx| (ctx.face.id != face.id || face.zid == tables.zid) && ctx.token)
}
#[inline]
fn send_forget_sourced_token_to_net_clildren(
tables: &Tables,
net: &Network,
clildren: &[NodeIndex],
res: &Arc<Resource>,
src_face: Option<&Arc<FaceState>>,
routing_context: Option<NodeId>,
) {
for child in clildren {
if net.graph.contains_node(*child) {
match tables.get_face(&net.graph[*child].zid).cloned() {
Some(mut someface) => {
if src_face
.map(|src_face| someface.id != src_face.id)
.unwrap_or(true)
{
let push_declaration = push_declaration_profile(&someface);
let wire_expr = Resource::decl_key(res, &mut someface, push_declaration);
someface.primitives.send_declare(RoutingContext::with_expr(
&mut Declare {
interest_id: None,
ext_qos: ext::QoSType::DECLARE,
ext_tstamp: None,
ext_nodeid: ext::NodeIdType {
node_id: routing_context.unwrap_or(0),
},
body: DeclareBody::UndeclareToken(UndeclareToken {
id: 0, ext_wire_expr: WireExprType { wire_expr },
}),
},
res.expr().to_string(),
));
}
}
None => tracing::trace!("Unable to find face for zid {}", net.graph[*child].zid),
}
}
}
}
fn propagate_forget_simple_token(
tables: &mut Tables,
res: &Arc<Resource>,
send_declare: &mut SendDeclare,
) {
for mut face in tables.faces.values().cloned() {
if let Some(id) = face_hat_mut!(&mut face).local_tokens.remove(res) {
send_declare(
&face.primitives,
RoutingContext::with_expr(
Declare {
interest_id: None,
ext_qos: ext::QoSType::DECLARE,
ext_tstamp: None,
ext_nodeid: ext::NodeIdType::DEFAULT,
body: DeclareBody::UndeclareToken(UndeclareToken {
id,
ext_wire_expr: WireExprType::null(),
}),
},
res.expr().to_string(),
),
);
}
for res in face_hat!(face)
.local_tokens
.keys()
.cloned()
.collect::<Vec<Arc<Resource>>>()
{
if !res.context().matches.iter().any(|m| {
m.upgrade().is_some_and(|m| {
m.context.is_some()
&& (remote_simple_tokens(tables, &m, &face)
|| remote_linkstatepeer_tokens(tables, &m))
})
}) {
if let Some(id) = face_hat_mut!(&mut face).local_tokens.remove(&res) {
send_declare(
&face.primitives,
RoutingContext::with_expr(
Declare {
interest_id: None,
ext_qos: ext::QoSType::DECLARE,
ext_tstamp: None,
ext_nodeid: ext::NodeIdType::DEFAULT,
body: DeclareBody::UndeclareToken(UndeclareToken {
id,
ext_wire_expr: WireExprType::null(),
}),
},
res.expr().to_string(),
),
);
}
}
}
}
}
fn propagate_forget_sourced_token(
tables: &Tables,
res: &Arc<Resource>,
src_face: Option<&Arc<FaceState>>,
source: &ZenohIdProto,
) {
let net = hat!(tables).linkstatepeers_net.as_ref().unwrap();
match net.get_idx(source) {
Some(tree_sid) => {
if net.trees.len() > tree_sid.index() {
send_forget_sourced_token_to_net_clildren(
tables,
net,
&net.trees[tree_sid.index()].children,
res,
src_face,
Some(tree_sid.index() as NodeId),
);
} else {
tracing::trace!(
"Propagating forget token {}: tree for node {} sid:{} not yet ready",
res.expr().to_string(),
tree_sid.index(),
source
);
}
}
None => tracing::error!(
"Error propagating forget token {}: cannot get index of {}!",
res.expr().to_string(),
source
),
}
}
fn unregister_linkstatepeer_token(
tables: &mut Tables,
res: &mut Arc<Resource>,
peer: &ZenohIdProto,
send_declare: &mut SendDeclare,
) {
res_hat_mut!(res)
.linkstatepeer_tokens
.retain(|token| token != peer);
if res_hat!(res).linkstatepeer_tokens.is_empty() {
hat_mut!(tables)
.linkstatepeer_tokens
.retain(|token| !Arc::ptr_eq(token, res));
propagate_forget_simple_token(tables, res, send_declare);
}
}
fn undeclare_linkstatepeer_token(
tables: &mut Tables,
face: Option<&Arc<FaceState>>,
res: &mut Arc<Resource>,
peer: &ZenohIdProto,
send_declare: &mut SendDeclare,
) {
if res_hat!(res).linkstatepeer_tokens.contains(peer) {
unregister_linkstatepeer_token(tables, res, peer, send_declare);
propagate_forget_sourced_token(tables, res, face, peer);
}
}
fn forget_linkstatepeer_token(
tables: &mut Tables,
face: &mut Arc<FaceState>,
res: &mut Arc<Resource>,
peer: &ZenohIdProto,
send_declare: &mut SendDeclare,
) {
undeclare_linkstatepeer_token(tables, Some(face), res, peer, send_declare);
}
pub(super) fn undeclare_simple_token(
tables: &mut Tables,
face: &mut Arc<FaceState>,
res: &mut Arc<Resource>,
send_declare: &mut SendDeclare,
) {
if !face_hat_mut!(face)
.remote_tokens
.values()
.any(|s| *s == *res)
{
if let Some(ctx) = get_mut_unchecked(res).session_ctxs.get_mut(&face.id) {
get_mut_unchecked(ctx).token = false;
}
let mut simple_tokens = simple_tokens(res);
let linkstatepeer_tokens = remote_linkstatepeer_tokens(tables, res);
if simple_tokens.is_empty() {
undeclare_linkstatepeer_token(tables, None, res, &tables.zid.clone(), send_declare);
}
if simple_tokens.len() == 1 && !linkstatepeer_tokens {
let mut face = &mut simple_tokens[0];
if face.whatami != WhatAmI::Client {
if let Some(id) = face_hat_mut!(face).local_tokens.remove(res) {
send_declare(
&face.primitives,
RoutingContext::with_expr(
Declare {
interest_id: None,
ext_qos: ext::QoSType::DECLARE,
ext_tstamp: None,
ext_nodeid: ext::NodeIdType::DEFAULT,
body: DeclareBody::UndeclareToken(UndeclareToken {
id,
ext_wire_expr: WireExprType::null(),
}),
},
res.expr().to_string(),
),
);
}
for res in face_hat!(face)
.local_tokens
.keys()
.cloned()
.collect::<Vec<Arc<Resource>>>()
{
if !res.context().matches.iter().any(|m| {
m.upgrade().is_some_and(|m| {
m.context.is_some()
&& (remote_simple_tokens(tables, &m, face)
|| remote_linkstatepeer_tokens(tables, &m))
})
}) {
if let Some(id) = face_hat_mut!(&mut face).local_tokens.remove(&res) {
send_declare(
&face.primitives,
RoutingContext::with_expr(
Declare {
interest_id: None,
ext_qos: ext::QoSType::DECLARE,
ext_tstamp: None,
ext_nodeid: ext::NodeIdType::DEFAULT,
body: DeclareBody::UndeclareToken(UndeclareToken {
id,
ext_wire_expr: WireExprType::null(),
}),
},
res.expr().to_string(),
),
);
}
}
}
}
}
}
}
fn forget_simple_token(
tables: &mut Tables,
face: &mut Arc<FaceState>,
id: TokenId,
send_declare: &mut SendDeclare,
) -> Option<Arc<Resource>> {
if let Some(mut res) = face_hat_mut!(face).remote_tokens.remove(&id) {
undeclare_simple_token(tables, face, &mut res, send_declare);
Some(res)
} else {
None
}
}
pub(super) fn token_remove_node(
tables: &mut Tables,
node: &ZenohIdProto,
send_declare: &mut SendDeclare,
) {
for mut res in hat!(tables)
.linkstatepeer_tokens
.iter()
.filter(|res| res_hat!(res).linkstatepeer_tokens.contains(node))
.cloned()
.collect::<Vec<Arc<Resource>>>()
{
unregister_linkstatepeer_token(tables, &mut res, node, send_declare);
Resource::clean(&mut res)
}
}
pub(super) fn token_tree_change(tables: &mut Tables, new_clildren: &[Vec<NodeIndex>]) {
let net = match hat!(tables).linkstatepeers_net.as_ref() {
Some(net) => net,
None => {
tracing::error!("Error accessing peers_net in token_tree_change!");
return;
}
};
for (tree_sid, tree_clildren) in new_clildren.iter().enumerate() {
if !tree_clildren.is_empty() {
let tree_idx = NodeIndex::new(tree_sid);
if net.graph.contains_node(tree_idx) {
let tree_id = net.graph[tree_idx].zid;
let tokens_res = &hat!(tables).linkstatepeer_tokens;
for res in tokens_res {
let tokens = &res_hat!(res).linkstatepeer_tokens;
for token in tokens {
if *token == tree_id {
send_sourced_token_to_net_clildren(
tables,
net,
tree_clildren,
res,
None,
tree_sid as NodeId,
);
}
}
}
}
}
}
}
#[inline]
fn make_token_id(res: &Arc<Resource>, face: &mut Arc<FaceState>, mode: InterestMode) -> u32 {
if mode.future() {
if let Some(id) = face_hat!(face).local_tokens.get(res) {
*id
} else {
let id = face_hat!(face).next_id.fetch_add(1, Ordering::SeqCst);
face_hat_mut!(face).local_tokens.insert(res.clone(), id);
id
}
} else {
0
}
}
pub(crate) fn declare_token_interest(
tables: &mut Tables,
face: &mut Arc<FaceState>,
id: InterestId,
res: Option<&mut Arc<Resource>>,
mode: InterestMode,
send_declare: &mut SendDeclare,
) {
if mode.current() && face.whatami == WhatAmI::Client {
let interest_id = Some(id);
if let Some(res) = res.as_ref() {
for token in &hat!(tables).linkstatepeer_tokens {
if token.context.is_some()
&& token.matches(res)
&& (remote_simple_tokens(tables, token, face)
|| remote_linkstatepeer_tokens(tables, token))
{
let id = make_token_id(token, face, mode);
let wire_expr = Resource::decl_key(token, face, push_declaration_profile(face));
send_declare(
&face.primitives,
RoutingContext::with_expr(
Declare {
interest_id,
ext_qos: ext::QoSType::DECLARE,
ext_tstamp: None,
ext_nodeid: ext::NodeIdType::DEFAULT,
body: DeclareBody::DeclareToken(DeclareToken { id, wire_expr }),
},
token.expr().to_string(),
),
);
}
}
} else {
for token in &hat!(tables).linkstatepeer_tokens {
if token.context.is_some()
&& (remote_simple_tokens(tables, token, face)
|| remote_linkstatepeer_tokens(tables, token))
{
let id = make_token_id(token, face, mode);
let wire_expr = Resource::decl_key(token, face, push_declaration_profile(face));
send_declare(
&face.primitives,
RoutingContext::with_expr(
Declare {
interest_id,
ext_qos: ext::QoSType::DECLARE,
ext_tstamp: None,
ext_nodeid: ext::NodeIdType::DEFAULT,
body: DeclareBody::DeclareToken(DeclareToken { id, wire_expr }),
},
token.expr().to_string(),
),
);
}
}
}
}
}
impl HatTokenTrait for HatCode {
fn declare_token(
&self,
tables: &mut Tables,
face: &mut Arc<FaceState>,
id: TokenId,
res: &mut Arc<Resource>,
node_id: NodeId,
_interest_id: Option<InterestId>,
send_declare: &mut SendDeclare,
) {
if face.whatami != WhatAmI::Client {
if let Some(peer) = get_peer(tables, face, node_id) {
declare_linkstatepeer_token(tables, face, res, peer, send_declare)
}
} else {
declare_simple_token(tables, face, id, res, send_declare)
}
}
fn undeclare_token(
&self,
tables: &mut Tables,
face: &mut Arc<FaceState>,
id: TokenId,
res: Option<Arc<Resource>>,
node_id: NodeId,
send_declare: &mut SendDeclare,
) -> Option<Arc<Resource>> {
if face.whatami != WhatAmI::Client {
if let Some(mut res) = res {
if let Some(peer) = get_peer(tables, face, node_id) {
forget_linkstatepeer_token(tables, face, &mut res, &peer, send_declare);
Some(res)
} else {
None
}
} else {
None
}
} else {
forget_simple_token(tables, face, id, send_declare)
}
}
}