flowey_lib_common/
download_gh_cli.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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! Download a copy of the GitHub CLI.
//!
//! NOTE: this node will _not_ set up any form of authentication for the
//! downloaded CLI binary!

use crate::cache::CacheHit;
use crate::cache::CacheResult;
use flowey::node::prelude::*;

flowey_request! {
    pub enum Request {
        /// Version of `gh` to download (e.g: 2.52.0)
        Version(String),
        /// Get a path to downloaded `gh`
        Get(WriteVar<PathBuf>),
    }
}

new_flow_node!(struct Node);

impl FlowNode for Node {
    type Request = Request;

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

    fn emit(requests: Vec<Self::Request>, ctx: &mut NodeCtx<'_>) -> anyhow::Result<()> {
        let mut version = None;
        let mut install_reqs = Vec::new();

        for req in requests {
            match req {
                Request::Version(v) => same_across_all_reqs("Version", &mut version, v)?,
                Request::Get(v) => install_reqs.push(v),
            }
        }

        let version = version.ok_or(anyhow::anyhow!("Missing essential request: Version"))?;
        let install_reqs = install_reqs;

        // -- end of req processing -- //

        if install_reqs.is_empty() {
            return Ok(());
        }

        let gh_bin = ctx.platform().binary("gh");

        let gh_arch = match ctx.arch() {
            FlowArch::X86_64 => "amd64",
            FlowArch::Aarch64 => "arm64",
            arch => anyhow::bail!("unsupported architecture {arch}"),
        };

        let cache_dir = ctx.emit_rust_stepv("create gh cache dir", |_| {
            |_| Ok(std::env::current_dir()?.absolute()?)
        });

        let cache_key = ReadVar::from_static(format!("gh-cli-{version}"));
        let hitvar = ctx.reqv(|hitvar| crate::cache::Request {
            label: "gh-cli".into(),
            dir: cache_dir.clone(),
            key: cache_key,
            restore_keys: None,
            hitvar: CacheResult::HitVar(hitvar),
        });

        ctx.emit_rust_step("installing gh", |ctx| {
            let cache_dir = cache_dir.claim(ctx);
            let hitvar = hitvar.claim(ctx);
            let install_reqs = install_reqs.claim(ctx);
            move |rt| {
                let cache_dir = rt.read(cache_dir);

                let cached = if matches!(rt.read(hitvar), CacheHit::Hit) {
                    let cached_bin = cache_dir.join(&gh_bin);
                    assert!(cached_bin.exists());
                    Some(cached_bin)
                } else {
                    None
                };

                let path_to_gh = if let Some(cached) = cached {
                    cached
                } else {
                    let sh = xshell::Shell::new()?;
                    match rt.platform() {
                        FlowPlatform::Windows => {
                            xshell::cmd!(sh, "curl --fail -L https://github.com/cli/cli/releases/download/v{version}/gh_{version}_windows_{gh_arch}.zip -o gh.zip").run()?;
                            xshell::cmd!(sh, "tar -xf gh.zip").run()?;
                        },
                        FlowPlatform::Linux(_) => {
                            xshell::cmd!(sh, "curl --fail -L https://github.com/cli/cli/releases/download/v{version}/gh_{version}_linux_{gh_arch}.tar.gz -o gh.tar.gz").run()?;
                            xshell::cmd!(sh, "tar -xf gh.tar.gz --strip-components=1").run()?;
                        },
                        FlowPlatform::MacOs => {
                            xshell::cmd!(sh, "curl --fail -L https://github.com/cli/cli/releases/download/v{version}/gh_{version}_macOS_{gh_arch}.zip -o gh.zip").run()?;
                            xshell::cmd!(sh, "tar -xf gh.zip --strip-components=1").run()?;
                        }
                        platform => anyhow::bail!("unsupported platform {platform}"),
                    };

                    // move the unzipped bin into the cache dir
                    let final_bin = cache_dir.join(&gh_bin);
                    fs_err::rename(format!("bin/{gh_bin}"), &final_bin)?;

                    final_bin.absolute()?
                };

                for var in install_reqs {
                    rt.write(var, &path_to_gh)
                }

                Ok(())
            }
        });

        Ok(())
    }
}