flowey_lib_common/
download_gh_artifact.rs

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
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! Download a github release artifact

use flowey::node::prelude::*;

flowey_request! {
    pub struct Request {
        /// First component of a github repo path
        ///
        /// e.g: the "foo" in "github.com/foo/bar"
        pub repo_owner: String,
        /// Second component of a github repo path
        ///
        /// e.g: the "bar" in "github.com/foo/bar"
        pub repo_name: String,
        /// Specific artifact to download.
        pub file_name: String,
        /// Path to downloaded artifact.
        pub path: WriteVar<PathBuf>,
        /// The Github actions run id to download artifacts from
        pub run_id: ReadVar<String>,
        /// Github token to authenticate with
        pub gh_token: ReadVar<String>,
    }
}

new_simple_flow_node!(struct Node);

impl SimpleFlowNode for Node {
    type Request = Request;

    fn imports(ctx: &mut ImportCtx<'_>) {
        ctx.import::<crate::cache::Node>();
        ctx.import::<crate::use_gh_cli::Node>();
    }

    fn process_request(request: Self::Request, ctx: &mut NodeCtx<'_>) -> anyhow::Result<()> {
        let Request {
            repo_owner,
            repo_name,
            file_name,
            path,
            run_id,
            gh_token,
        } = request;

        ctx.req(crate::use_gh_cli::Request::WithAuth(
            crate::use_gh_cli::GhCliAuth::AuthToken(gh_token),
        ));
        let gh_cli = ctx.reqv(crate::use_gh_cli::Request::Get);

        ctx.emit_rust_step("download artifacts from github actions run", |ctx| {
            let gh_cli = gh_cli.claim(ctx);
            let run_id = run_id.claim(ctx);
            let path = path.claim(ctx);
            move |rt| {
                let sh = xshell::Shell::new()?;
                let gh_cli = rt.read(gh_cli);
                let run_id = rt.read(run_id);

                let path_end = format!("{repo_owner}/{repo_name}/{run_id}");
                let out_dir = std::env::current_dir()?.absolute()?.join(path_end);
                fs_err::create_dir_all(&out_dir)?;
                sh.change_dir(&out_dir);

                xshell::cmd!(sh, "{gh_cli} run download {run_id} -R {repo_owner}/{repo_name} --pattern {file_name}").run()?;

                if !out_dir.join(file_name).exists() {
                    anyhow::bail!("Failed to download artifact");
                }

                rt.write(path, &out_dir);
                Ok(())
            }
        });

        Ok(())
    }
}