taple_core/message/
mod.rs1mod command;
2mod error;
3mod message_receiver;
4mod message_sender;
5mod message_task_manager;
6
7use crate::{
8 commons::{
9 errors::SubjectError,
10 identifier::KeyIdentifier,
11 models::HashId,
12 self_signature_manager::{SelfSignatureInterface, SelfSignatureManager},
13 },
14 signature::Signed,
15 DigestIdentifier, DigestDerivator,
16};
17use borsh::{BorshDeserialize, BorshSerialize};
18pub use command::*;
19pub use message_receiver::*;
20pub use message_sender::*;
21pub use message_task_manager::*;
22
23use serde::{de::DeserializeOwned, Deserialize, Serialize};
24
25use self::error::Error;
26
27#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, BorshSerialize, BorshDeserialize)]
34pub struct MessageContent<T: TaskCommandContent> {
35 pub sender_id: KeyIdentifier,
36 pub content: T,
37 pub receiver: KeyIdentifier,
38}
39
40impl<T: TaskCommandContent> HashId for MessageContent<T> {
41 fn hash_id(&self, derivator: DigestDerivator) -> Result<DigestIdentifier, SubjectError> {
42 DigestIdentifier::from_serializable_borsh(&self, derivator)
43 .map_err(|_| SubjectError::CryptoError("Hashing error in MessageContent".to_string()))
44 }
45}
46
47impl<T: TaskCommandContent> Signed<MessageContent<T>> {
48 pub fn new(
49 sender: KeyIdentifier,
50 receiver: KeyIdentifier,
51 content: T,
52 sender_sm: &SelfSignatureManager,
53 derivator: DigestDerivator,
54 ) -> Result<Self, Error> {
55 let message_content = MessageContent {
56 sender_id: sender.clone(),
57 content,
58 receiver,
59 };
60 let signature = sender_sm
61 .sign(&message_content, derivator)
62 .map_err(|_| Error::CreatingMessageError)?;
63 Ok(Self {
64 content: message_content,
65 signature,
66 })
67 }
68
69 pub fn verify(&self) -> Result<(), SubjectError> {
70 self.signature.verify(&self.content)
71 }
72}
73
74pub trait TaskCommandContent:
100 Serialize + std::fmt::Debug + Clone + Send + Sync + BorshDeserialize + BorshSerialize
101{
102}
103
104#[derive(Clone, Debug, PartialEq)]
105pub enum MessageTaskCommand<M>
106where
107 M: TaskCommandContent + Serialize + DeserializeOwned,
108{
109 Request(Option<String>, M, Vec<KeyIdentifier>, MessageConfig), Cancel(String), }
112
113#[derive(Clone, Debug, PartialEq)]
114pub struct MessageConfig {
115 pub timeout: u32,
116 pub replication_factor: f64,
117}
118
119impl MessageConfig {
120 pub fn timeout(&self) -> u32 {
121 self.timeout
122 }
123
124 pub fn replication_factor(&self) -> f64 {
125 self.replication_factor
126 }
127
128 pub fn direct_response() -> Self {
129 Self {
130 timeout: 0,
131 replication_factor: 1.0,
132 }
133 }
134}