bifrostlink 0.2.0

Topology-aware RPC library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

extern crate self as bifrostlink;

mod port;
use std::{fmt, hash::Hash};

use bytes::Bytes;
pub use port::Port;
mod util;
use serde::{de::DeserializeOwned, Serialize};
mod connection;
mod qos;
mod route;
pub use route::Rtt;

mod event;
pub mod packet;

mod notification;
pub use notification::{IncomingNotification, Notification, OutgoingNotification};
mod request;
pub use request::{IncomingRequest, OutgoingRequest, Request};

mod internal_handlers;

pub(crate) mod callback;

// pub(crate) mod polling;
// pub use polling::request::PollingRequest;

mod rpc;
pub use rpc::{Remote, Rpc, WeakRpc};

pub mod error;

pub mod declarative;

// pub use polling::notification::PollingNotification;

use self::error::ErrorT;
use self::packet::{OpaquePacketWrapper, OutgoingMessage, RequestId, ResponseTo};

pub trait AddressT:
	Clone + Serialize + DeserializeOwned + Hash + Eq + fmt::Debug + Send + Sync + 'static
{
}

pub trait Config: 'static {
	type Address: AddressT;
	type Error: ErrorT;

	// It is transferred by channels, but never stored in shared stucts.
	type EncodedData: Send;

	fn decode_headers(
		data_with_headers: Bytes,
	) -> Result<(OpaquePacketWrapper<Self::Address>, Self::EncodedData), Self::Error>;

	fn decode_data<T: DeserializeOwned>(data: Self::EncodedData) -> Result<T, Self::Error>;

	fn encode_data<T: Serialize>(headers: OpaquePacketWrapper<Self::Address>, data: T) -> Bytes;
}

pub trait ConfigExt: Config {
	fn encode_outgoing<T: Serialize>(
		headers: OpaquePacketWrapper<Self::Address>,
		value: T,
	) -> OutgoingMessage<Self::Address> {
		let to = match &headers {
			OpaquePacketWrapper::Response { request_origin, .. } => request_origin,
			OpaquePacketWrapper::Request { receiver, .. } => receiver,
		};
		OutgoingMessage {
			to: to.clone(),
			message: Self::encode_data(headers, value),
		}
	}
	fn encode_notification<T: OutgoingNotification>(
		sender: Self::Address,
		receiver: Self::Address,
		notification: T,
	) -> OutgoingMessage<Self::Address> {
		Self::encode_outgoing(
			OpaquePacketWrapper::Request {
				sender,
				receiver,
				request: T::name(),
				response: None,
			},
			notification,
		)
	}
	fn encode_error_response<E: fmt::Display>(
		rid: RequestId,
		me: Self::Address,
		request_origin: Self::Address,
		error: E,
	) -> OutgoingMessage<Self::Address> {
		Self::encode_outgoing(
			OpaquePacketWrapper::Response {
				rid,
				response_from: me,
				request_origin,
				error: Some(error.to_string()),
			},
			(),
		)
	}
	fn encode_response<T: Serialize>(
		rid: RequestId,
		me: Self::Address,
		request_origin: Self::Address,
		data: T,
	) -> OutgoingMessage<Self::Address> {
		Self::encode_outgoing(
			OpaquePacketWrapper::Response {
				rid,
				response_from: me,
				request_origin,
				error: None,
			},
			data,
		)
	}
	fn encode_request<T: OutgoingRequest + Serialize>(
		sender: Self::Address,
		receiver: Self::Address,
		rid: RequestId,
		data: T,
	) -> OutgoingMessage<Self::Address> {
		Self::encode_outgoing(
			OpaquePacketWrapper::Request {
				sender,
				receiver,
				request: T::name().to_owned(),
				response: Some(ResponseTo { rid }),
			},
			data,
		)
	}
}
impl<C> ConfigExt for C where C: Config {}