1use crate::common::CommonArch;
5use crate::common::CommonTriple;
6use crate::init_vmm_tests_content_dir::VmmTestsBuiltArtifactsWrite;
7use flowey::node::prelude::*;
8use flowey_lib_common::gh_workflow_id;
9
10flowey_request! {
11 pub struct Request {
12 pub built_artifacts_write: VmmTestsBuiltArtifactsWrite,
13 pub target: CommonTriple,
14 }
15}
16
17new_simple_flow_node!(struct Node);
18
19impl SimpleFlowNode for Node {
20 type Request = Request;
21
22 fn imports(ctx: &mut ImportCtx<'_>) {
23 ctx.import::<flowey_lib_common::download_gh_artifact::Node>();
24 ctx.import::<gh_workflow_id::Node>();
25 ctx.import::<resolve_artifact::Node>();
26 }
27
28 fn process_request(request: Self::Request, ctx: &mut NodeCtx<'_>) -> anyhow::Result<()> {
29 let Request {
30 built_artifacts_write:
31 VmmTestsBuiltArtifactsWrite {
32 flowey_hvlite,
33 nextest_vmm_tests_archive,
34 incubator,
35 prep_steps,
36 test_igvm_agent_rpc_server,
37 openvmm,
38 openvmm_vhost,
39 pipette_windows,
40 pipette_linux_musl,
41 guest_test_uefi,
42 openhcl_standard,
43 openhcl_standard_dev,
44 openhcl_cvm,
45 openhcl_linux_direct,
46 tmks,
47 tmk_vmm,
48 tmk_vmm_linux_musl,
49 vmgstool,
50 vmgstool_dev,
51 tpm_guest_tests_windows,
52 tpm_guest_tests_linux,
53 },
54 target,
55 } = request;
56
57 let run = ctx.reqv(|v| gh_workflow_id::Request {
59 repo_owner: "microsoft".into(),
60 repo_name: "openvmm".into(),
61 commit_or_branch: gh_workflow_id::GitCommitOrBranch::Branch(ReadVar::from_static(
62 "main".into(),
63 )),
64 pipeline_name: "openvmm-ci.yaml".into(),
65 require_run_status: Some(gh_workflow_id::GhRunStatus::Success),
66 require_successful_job_with_name: None,
67 gh_workflow: v,
68 });
69 let run_id = run.map(ctx, |r| r.id);
70
71 let arch_tag = match target.common_arch()? {
72 CommonArch::X86_64 => "x64",
73 CommonArch::Aarch64 => "aarch64",
74 };
75
76 let os = target.as_triple().operating_system;
77 let os_tag = match os {
78 target_lexicon::OperatingSystem::Windows => "windows",
79 target_lexicon::OperatingSystem::Linux => "linux",
80 _ => anyhow::bail!("unsupported operating system: {:?}", os),
81 };
82
83 if flowey_hvlite.is_some() {
84 anyhow::bail!("downloading flowey_hvlite is not supported");
85 }
86
87 if let Some(nextest_vmm_tests_archive) = nextest_vmm_tests_archive {
88 download_artifact(
89 ctx,
90 format!("{arch_tag}-{os_tag}-vmm-tests-archive"),
91 run_id.clone(),
92 nextest_vmm_tests_archive,
93 );
94 }
95
96 if let Some(incubator) = incubator {
97 download_artifact(
98 ctx,
99 format!("{arch_tag}-{os_tag}-incubator"),
100 run_id.clone(),
101 incubator,
102 );
103 }
104
105 if let Some(prep_steps) = prep_steps {
106 download_artifact(
107 ctx,
108 format!("{arch_tag}-{os_tag}-prep_steps"),
109 run_id.clone(),
110 prep_steps,
111 );
112 }
113
114 if let Some(test_igvm_agent_rpc_server) = test_igvm_agent_rpc_server {
115 download_artifact(
116 ctx,
117 format!("{arch_tag}-{os_tag}-test_igvm_agent_rpc_server"),
118 run_id.clone(),
119 test_igvm_agent_rpc_server,
120 );
121 }
122
123 if let Some(openvmm) = openvmm {
124 download_artifact(
125 ctx,
126 format!("{arch_tag}-{os_tag}-openvmm"),
127 run_id.clone(),
128 openvmm,
129 );
130 }
131
132 if let Some(openvmm_vhost) = openvmm_vhost {
133 download_artifact(
134 ctx,
135 format!("{arch_tag}-{os_tag}-openvmm_vhost"),
136 run_id.clone(),
137 openvmm_vhost,
138 );
139 }
140
141 if let Some(pipette_windows) = pipette_windows {
142 download_artifact(
143 ctx,
144 format!("{arch_tag}-windows-pipette"),
145 run_id.clone(),
146 pipette_windows,
147 );
148 }
149
150 if let Some(pipette_linux_musl) = pipette_linux_musl {
151 download_artifact(
152 ctx,
153 format!("{arch_tag}-linux-musl-pipette"),
154 run_id.clone(),
155 pipette_linux_musl,
156 );
157 }
158
159 if let Some(guest_test_uefi) = guest_test_uefi {
160 download_artifact(
161 ctx,
162 format!("{arch_tag}-guest_test_uefi"),
163 run_id.clone(),
164 guest_test_uefi,
165 );
166 }
167
168 if let Some(openhcl_standard) = openhcl_standard {
169 download_artifact(
170 ctx,
171 format!("{arch_tag}-openhcl-igvm"),
172 run_id.clone(),
173 openhcl_standard,
174 );
175 }
176
177 if let Some(openhcl_standard_dev) = openhcl_standard_dev {
178 download_artifact(
179 ctx,
180 format!("{arch_tag}-openhcl-igvm-devkern"),
181 run_id.clone(),
182 openhcl_standard_dev,
183 );
184 }
185
186 if let Some(openhcl_cvm) = openhcl_cvm {
187 download_artifact(
188 ctx,
189 format!("{arch_tag}-openhcl-igvm-cvm"),
190 run_id.clone(),
191 openhcl_cvm,
192 );
193 }
194
195 if let Some(openhcl_linux_direct) = openhcl_linux_direct {
196 download_artifact(
197 ctx,
198 format!("{arch_tag}-openhcl-igvm-test-linux-direct"),
199 run_id.clone(),
200 openhcl_linux_direct,
201 );
202 }
203
204 if let Some(tmks) = tmks {
205 download_artifact(ctx, format!("{arch_tag}-tmks"), run_id.clone(), tmks);
206 }
207
208 if let Some(tmk_vmm) = tmk_vmm {
209 download_artifact(
210 ctx,
211 format!("{arch_tag}-{os_tag}-tmk_vmm"),
212 run_id.clone(),
213 tmk_vmm,
214 );
215 }
216
217 if let Some(tmk_vmm_linux_musl) = tmk_vmm_linux_musl {
218 download_artifact(
219 ctx,
220 format!("{arch_tag}-linux-musl-tmk_vmm"),
221 run_id.clone(),
222 tmk_vmm_linux_musl,
223 );
224 }
225
226 if let Some(vmgstool) = vmgstool {
227 download_artifact(
228 ctx,
229 format!("{arch_tag}-{os_tag}-vmgstool"),
230 run_id.clone(),
231 vmgstool,
232 );
233 }
234
235 if let Some(vmgstool_dev) = vmgstool_dev {
236 download_artifact(
237 ctx,
238 format!("{arch_tag}-{os_tag}-vmgstool-dev"),
239 run_id.clone(),
240 vmgstool_dev,
241 );
242 }
243
244 if let Some(tpm_guest_tests_windows) = tpm_guest_tests_windows {
245 download_artifact(
246 ctx,
247 format!("{arch_tag}-windows-tpm_guest_tests"),
248 run_id.clone(),
249 tpm_guest_tests_windows,
250 );
251 }
252
253 if let Some(tpm_guest_tests_linux) = tpm_guest_tests_linux {
254 download_artifact(
255 ctx,
256 format!("{arch_tag}-linux-tpm_guest_tests"),
257 run_id.clone(),
258 tpm_guest_tests_linux,
259 );
260 }
261
262 Ok(())
263 }
264}
265
266fn download_artifact<T: Artifact>(
267 ctx: &mut NodeCtx<'_>,
268 file_name: String,
269 run_id: ReadVar<String>,
270 output: WriteVar<T>,
271) {
272 let downloaded_artifact = ctx.reqv(|v| flowey_lib_common::download_gh_artifact::Request {
273 repo_owner: "microsoft".into(),
274 repo_name: "openvmm".into(),
275 file_name,
276 path: v,
277 run_id,
278 });
279 ctx.req(resolve_artifact::Request::new(downloaded_artifact, output));
280}