Skip to main content

flowey_lib_hvlite/
resolve_vmm_tests_pipeline_artifacts.rs

1// Copyright (c) Microsoft Corporation.
2// Licensed under the MIT License.
3
4//! Resolve artifacts from the test content dir used as parts of the pipeline
5//! to run VMM tests.
6
7use crate::build_incubator::IncubatorOutput;
8use crate::build_nextest_vmm_tests::NextestVmmTestsArchive;
9use crate::build_prep_steps::PrepStepsOutput;
10use crate::build_test_igvm_agent_rpc_server::TestIgvmAgentRpcServerOutput;
11use flowey::node::prelude::*;
12
13#[derive(Serialize, Deserialize)]
14pub struct VmmTestsBuiltPipelineArtifacts {}
15
16flowey_request! {
17    pub struct Request {
18        /// Directory to symlink / copy test contents into. Does not need to be
19        /// empty.
20        pub test_content_dir: ReadVar<PathBuf>,
21        /// What triple VMM tests are built for.
22        ///
23        /// Used to detect cases of running Windows VMM tests via WSL2, and adjusting
24        /// reported paths appropriately.
25        pub vmm_tests_target: target_lexicon::Triple,
26
27        // Artifacts used by the test pipeline that are built in the openvmm repo
28        pub nextest_vmm_tests_archive: WriteVar<NextestVmmTestsArchive>,
29        pub incubator: Option<WriteVar<IncubatorOutput>>,
30        pub prep_steps: Option<WriteVar<PrepStepsOutput>>,
31        pub test_igvm_agent_rpc_server: Option<WriteVar<TestIgvmAgentRpcServerOutput>>,
32    }
33}
34
35new_simple_flow_node!(struct Node);
36
37impl SimpleFlowNode for Node {
38    type Request = Request;
39
40    fn imports(_ctx: &mut ImportCtx<'_>) {}
41
42    fn process_request(request: Self::Request, ctx: &mut NodeCtx<'_>) -> anyhow::Result<()> {
43        let Request {
44            test_content_dir,
45            vmm_tests_target,
46            nextest_vmm_tests_archive,
47            incubator,
48            prep_steps,
49            test_igvm_agent_rpc_server,
50        } = request;
51
52        let windows_target = matches!(
53            vmm_tests_target.operating_system,
54            target_lexicon::OperatingSystem::Windows
55        );
56
57        ctx.emit_rust_step("resolving vmm tests pipeline artifacts", |ctx| {
58            claim_vars!(
59                ctx,
60                (
61                    test_content_dir,
62                    nextest_vmm_tests_archive,
63                    incubator,
64                    prep_steps,
65                    test_igvm_agent_rpc_server,
66                )
67            );
68
69            move |rt| {
70                let test_content_dir = rt.read(test_content_dir);
71
72                let nextest_vmm_tests_archive_path = test_content_dir.join("vmm_tests.tar.zst");
73                if nextest_vmm_tests_archive_path.exists() {
74                    rt.write(
75                        nextest_vmm_tests_archive,
76                        &NextestVmmTestsArchive {
77                            archive_file: nextest_vmm_tests_archive_path,
78                        },
79                    );
80                } else {
81                    anyhow::bail!("{} not found", nextest_vmm_tests_archive_path.display());
82                }
83
84                if let Some(incubator) = incubator {
85                    if windows_target {
86                        anyhow::bail!("incubator is linux only");
87                    }
88                    let incubator_path = test_content_dir.join("incubator");
89                    if incubator_path.exists() {
90                        rt.write(
91                            incubator,
92                            &IncubatorOutput {
93                                bin: incubator_path,
94                                dbg: None,
95                            },
96                        );
97                    } else {
98                        anyhow::bail!("{} not found", incubator_path.display());
99                    }
100                }
101
102                if let Some(prep_steps) = prep_steps {
103                    let prep_steps_path = test_content_dir.join(if windows_target {
104                        "prep_steps.exe"
105                    } else {
106                        "prep_steps"
107                    });
108                    if prep_steps_path.exists() {
109                        let prep_steps_output = if windows_target {
110                            PrepStepsOutput::WindowsBin {
111                                exe: prep_steps_path,
112                                pdb: None,
113                            }
114                        } else {
115                            PrepStepsOutput::LinuxBin {
116                                bin: prep_steps_path,
117                                dbg: None,
118                            }
119                        };
120                        rt.write(prep_steps, &prep_steps_output);
121                    } else {
122                        anyhow::bail!("{} not found", prep_steps_path.display());
123                    };
124                }
125
126                if let Some(test_igvm_agent_rpc_server) = test_igvm_agent_rpc_server {
127                    if !windows_target {
128                        anyhow::bail!("test_igvm_agent_rpc_server is windows only");
129                    }
130                    let test_igvm_agent_rpc_server_path =
131                        test_content_dir.join("test_igvm_agent_rpc_server.exe");
132                    if test_igvm_agent_rpc_server_path.exists() {
133                        rt.write(
134                            test_igvm_agent_rpc_server,
135                            &TestIgvmAgentRpcServerOutput {
136                                exe: test_igvm_agent_rpc_server_path,
137                                pdb: None,
138                            },
139                        );
140                    } else {
141                        anyhow::bail!("{} not found", test_igvm_agent_rpc_server_path.display());
142                    }
143                }
144
145                Ok(())
146            }
147        });
148
149        Ok(())
150    }
151}