aleph_types/message/
program.rs

1use crate::item_hash::ItemHash;
2use crate::message::execution::base::{Encoding, ExecutableContent, Interface};
3use crate::message::execution::environment::{FunctionEnvironment, FunctionTriggers};
4use crate::toolkit::serde::{default_some_false, default_true};
5use serde::{Deserialize, Serialize};
6use std::path::PathBuf;
7
8#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9pub struct FunctionRuntime {
10    #[serde(rename = "ref")]
11    reference: ItemHash,
12    #[serde(default = "default_true")]
13    use_latest: bool,
14    comment: String,
15}
16
17#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
18pub struct CodeContent {
19    encoding: Encoding,
20    entrypoint: String,
21    /// Reference to the STORE message containing the code.
22    #[serde(rename = "ref")]
23    reference: ItemHash,
24    #[serde(default)]
25    interface: Option<Interface>,
26    #[serde(default)]
27    args: Option<Vec<String>>,
28    #[serde(default)]
29    use_latest: bool,
30}
31
32#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
33pub struct DataContent {
34    encoding: Encoding,
35    mount: PathBuf,
36    #[serde(default, rename = "ref")]
37    reference: Option<ItemHash>,
38    #[serde(default = "default_some_false")]
39    use_latest: Option<bool>,
40}
41
42#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
43pub struct Export {
44    encoding: Encoding,
45    mount: PathBuf,
46}
47
48#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
49pub struct ProgramContent {
50    #[serde(flatten)]
51    pub base: ExecutableContent,
52    /// Code to execute.
53    pub code: CodeContent,
54    /// Execution runtime (rootfs with Python interpreter).
55    pub runtime: FunctionRuntime,
56    /// Data to use during computation.
57    #[serde(default)]
58    pub data: Option<DataContent>,
59    /// Properties of the execution environment.
60    pub environment: FunctionEnvironment,
61    /// Data to export after computation.
62    #[serde(default)]
63    pub export: Option<Export>,
64    /// Signals that trigger an execution.
65    pub on: FunctionTriggers,
66}
67
68impl ProgramContent {
69    pub fn executable_content(&self) -> &ExecutableContent {
70        &self.base
71    }
72}
73
74#[cfg(test)]
75mod tests {
76    use super::*;
77    use crate::chain::{Address, Chain, Signature};
78    use crate::message::base_message::MessageContentEnum;
79    use crate::message::execution::environment::MachineResources;
80    use crate::message::execution::volume::{BaseVolume, ImmutableVolume, MachineVolume};
81    use crate::message::{ContentSource, Message, MessageType};
82    use crate::storage_size::{MemorySize, MiB};
83    use crate::timestamp::Timestamp;
84    use crate::{channel, item_hash};
85    use assert_matches::assert_matches;
86    use std::collections::HashMap;
87
88    const PROGRAM_FIXTURE: &str = include_str!(concat!(
89        env!("CARGO_MANIFEST_DIR"),
90        "/../../fixtures/messages/program/program.json"
91    ));
92
93    const PROGRAM_WITH_EMPTY_ARRAY_AS_METADATA: &str = include_str!(concat!(
94        env!("CARGO_MANIFEST_DIR"),
95        "/../../fixtures/messages/program/program-with-array-as-metadata.json"
96    ));
97
98    #[test]
99    fn test_deserialize_program_message() {
100        let message: Message = serde_json::from_str(PROGRAM_FIXTURE).unwrap();
101
102        assert_eq!(
103            message.sender,
104            Address::from("0x9C2FD74F9CA2B7C4941690316B0Ebc35ce55c885".to_string())
105        );
106        assert_eq!(message.chain, Chain::Ethereum);
107        assert_eq!(
108            message.signature,
109            Signature::from(
110                "0x421c656709851fba752f323a117bc7a07f175a4dd7faf1d8fc1cd9a99028081a6419f9e8b0a7cd454bfef1c52d1f0675a7a59a7d07eb4ebdb22e18bbaf415f881c".to_string()
111            )
112        );
113        assert_matches!(message.message_type, MessageType::Program);
114        assert_matches!(
115            message.content_source,
116            ContentSource::Inline { item_content: _ }
117        );
118        assert_eq!(
119            &message.item_hash.to_string(),
120            "acab01087137c68a5e84734e75145482651accf3bea80fb9b723b761639ecc1c"
121        );
122        assert_eq!(message.time, Timestamp::from(1757026128.773));
123        assert_eq!(message.channel, Some(channel!("ALEPH-CLOUDSOLUTIONS")));
124
125        // Check content fields
126        assert_eq!(
127            &message.content.address,
128            &Address::from("0x9C2FD74F9CA2B7C4941690316B0Ebc35ce55c885".to_string())
129        );
130        assert_eq!(&message.content.time, &Timestamp::from(1757026128.773));
131
132        // Check program content fields
133        let program_content = match message.content() {
134            MessageContentEnum::Program(content) => content,
135            other => {
136                panic!("Expected MessageContentEnum::Program, got {:?}", other);
137            }
138        };
139
140        assert!(!program_content.base.allow_amend);
141        assert_eq!(
142            program_content.base.metadata,
143            Some(HashMap::from([(
144                "name".to_string(),
145                serde_json::Value::String("Hoymiles".to_string())
146            )]))
147        );
148        assert_eq!(program_content.base.variables, Some(HashMap::new()));
149        assert_eq!(
150            program_content.base.resources,
151            MachineResources {
152                vcpus: 2,
153                memory: MiB::from_units(4096),
154                seconds: 30,
155                published_ports: None,
156            }
157        );
158        assert_matches!(program_content.base.authorized_keys, None);
159        assert_eq!(
160            program_content.environment,
161            FunctionEnvironment {
162                reproducible: false,
163                internet: true,
164                aleph_api: true,
165                shared_cache: false,
166            }
167        );
168        assert_eq!(
169            program_content.base.volumes,
170            vec![MachineVolume::Immutable(ImmutableVolume {
171                base: BaseVolume {
172                    comment: None,
173                    mount: Some(PathBuf::from("/opt/packages"))
174                },
175                reference: Some(item_hash!(
176                    "8df728d560ed6e9103b040a6b5fc5417e0a52e890c12977464ebadf9becf1bf6"
177                )),
178                use_latest: true,
179            })]
180        );
181        assert_eq!(program_content.base.replaces, None);
182        assert_eq!(
183            program_content.code,
184            CodeContent {
185                encoding: Encoding::Zip,
186                entrypoint: "main:app".to_string(),
187                reference: item_hash!(
188                    "9a4735bca0d3f7032ddd6659c35387b57b470550c931841e6862ece4e9e6523e"
189                ),
190                interface: None,
191                args: None,
192                use_latest: true,
193            }
194        );
195        assert_eq!(
196            program_content.runtime,
197            FunctionRuntime {
198                reference: item_hash!(
199                    "63f07193e6ee9d207b7d1fcf8286f9aee34e6f12f101d2ec77c1229f92964696"
200                ),
201                use_latest: true,
202                comment: "Aleph Alpine Linux with Python 3.12".to_string(),
203            }
204        );
205        assert_eq!(program_content.data, None);
206        assert_eq!(program_content.export, None);
207        assert_eq!(
208            program_content.on,
209            FunctionTriggers {
210                http: true,
211                persistent: Some(false)
212            }
213        );
214
215        // No confirmation on this fixture
216        assert!(!message.confirmed());
217        assert!(message.confirmations.is_empty());
218    }
219
220    #[test]
221    /// Some nodes return old PROGRAM messages where the metadata field is an empty list instead of
222    /// an object. While this should never happen, fixing this server-side is tricky so we support
223    /// it in the SDK by treating it like an empty map.
224    fn load_program_with_empty_array_as_metadata() {
225        let message: Message = serde_json::from_str(PROGRAM_WITH_EMPTY_ARRAY_AS_METADATA).unwrap();
226
227        // Check that the metadata field is empty
228        let program_content = match message.content() {
229            MessageContentEnum::Program(content) => content,
230            other => {
231                panic!("Expected MessageContentEnum::Program, got {:?}", other);
232            }
233        };
234
235        assert_matches!(program_content.base.metadata, Some(ref map) if map.is_empty());
236    }
237}
aleph_types/message/program.rs

aleph_types/message/
program.rs
