lium 0.1.2

Abstraction Layer of ChromiumOS development
Documentation 
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
126
127
128
129
130
131
132
133
134
135
136
137

// Copyright 2023 The ChromiumOS Authors
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd

use std::cmp::Ordering;

use anyhow::bail;
use anyhow::Result;
use argh::FromArgs;
use lium::chroot::Chroot;
use lium::cros::ensure_testing_rsa_is_there;
use lium::dut::SshInfo;
use lium::repo::get_repo_dir;
use once_cell::sync::Lazy;
use regex::Regex;

static RE_CROS_KERNEL: Lazy<Regex> = Lazy::new(|| Regex::new("chromeos-kernel-").unwrap());

#[derive(FromArgs, PartialEq, Debug)]
/// deploy package(s)
#[argh(subcommand, name = "deploy")]
pub struct Args {
    /// target cros repo dir
    #[argh(option)]
    repo: Option<String>,

    /// a DUT identifier (e.g. 127.0.0.1, localhost:2222)
    #[argh(option)]
    dut: String,

    /// packages to deploy
    #[argh(positional)]
    packages: Vec<String>,

    /// if specified, it will skip automatic reboot
    #[argh(switch)]
    skip_reboot: bool,

    /// use ab_update for kernel package
    #[argh(switch)]
    ab_update: bool,
}

#[tracing::instrument(level = "trace")]
pub fn run(args: &Args) -> Result<()> {
    ensure_testing_rsa_is_there()?;

    let target = {
        let t = SshInfo::new(&args.dut)?;
        if t.needs_port_forwarding_in_chroot() {
            let port = t.start_ssh_forwarding_range_background(4100..4200)?;
            SshInfo::new_host_and_port("localhost", port)?
        } else {
            t
        }
    };
    println!("Target DUT is {:?}", target);

    let board = target.get_board()?;
    let packages_str = args.packages.join(" ");
    let chroot = Chroot::new(&get_repo_dir(&args.repo)?)?;

    let kernel_pkg = extract_kernel_pkg(&args.packages)?;

    cros_workon_user_packages(&chroot, &board, &args.packages, &packages_str, &target)?;

    if kernel_pkg.is_some() {
        chroot.run_bash_script_in_chroot(
            "update_kernel",
            &format!(
                r###"
cros-workon-{board} start {packages_str}
~/trunk/src/scripts/update_kernel.sh {} --remote={} --ssh_port {} --remote_bootargs
"###,
                if args.ab_update { "--ab_update" } else { "" },
                target.host(),
                target.port()
            ),
            None,
        )?;

        return Ok(());
    }

    if !args.skip_reboot {
        println!("Rebooting DUT...");
        target.run_cmd_piped(&["reboot; exit"])?;
    }

    Ok(())
}

fn extract_kernel_pkg(packages: &[String]) -> Result<Option<String>> {
    let kernel_packages: Vec<_> = packages
        .iter()
        .filter(|&s| RE_CROS_KERNEL.is_match(s))
        .collect();

    match kernel_packages.len().cmp(&1) {
        Ordering::Greater => {
            bail!("There are more than 2 kernel packages. Please specify one of them.");
        }
        Ordering::Equal => Ok(Some(kernel_packages[0].to_string())),
        _ => Ok(None),
    }
}

fn cros_workon_user_packages(
    chroot: &Chroot,
    board: &str,
    packages: &[String],
    packages_str: &str,
    target: &SshInfo,
) -> Result<()> {
    // Filter out all kernel packages and join them into a space seperated list.
    let user_pkgs: String = packages
        .iter()
        .filter(|&s| !RE_CROS_KERNEL.is_match(s))
        .map(|s| s.to_string())
        .collect::<Vec<_>>()
        .join(" ");

    if !user_pkgs.is_empty() {
        chroot.run_bash_script_in_chroot(
            "deploy",
            &format!(
                r"cros-workon-{board} start {packages_str} && cros deploy {} {user_pkgs}",
                target.host_and_port()
            ),
            None,
        )?;
    }

    Ok(())
}