pkgctl/
args.rs

1// Copyright 2019 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use argh::FromArgs;
6use fidl_fuchsia_pkg_ext::BlobId;
7use fidl_fuchsia_pkg_rewrite_ext::RuleConfig;
8use std::path::PathBuf;
9
10#[derive(FromArgs, Debug, PartialEq)]
11/// Various operations on packages, package repositories, and the package cache.
12pub struct Args {
13    #[argh(subcommand)]
14    pub command: Command,
15}
16
17#[derive(FromArgs, Debug, PartialEq)]
18#[argh(subcommand)]
19pub enum Command {
20    Resolve(ResolveCommand),
21    Open(OpenCommand),
22    Repo(RepoCommand),
23    Rule(RuleCommand),
24    Gc(GcCommand),
25    GetHash(GetHashCommand),
26    PkgStatus(PkgStatusCommand),
27}
28
29#[derive(FromArgs, Debug, PartialEq)]
30#[argh(subcommand, name = "resolve")]
31/// Resolve a package.
32pub struct ResolveCommand {
33    #[argh(positional)]
34    pub pkg_url: String,
35
36    /// prints the contents of the resolved package, which can be slow for large packages.
37    #[argh(switch, short = 'v')]
38    pub verbose: bool,
39}
40
41#[derive(FromArgs, Debug, PartialEq)]
42#[argh(subcommand, name = "open")]
43/// Open a package by merkle root.
44pub struct OpenCommand {
45    #[argh(positional)]
46    pub meta_far_blob_id: BlobId,
47}
48
49#[derive(FromArgs, Debug, PartialEq)]
50#[argh(
51    subcommand,
52    name = "repo",
53    note = "A fuchsia package URL contains a repository hostname to identify the package's source.\n",
54    note = "Without any arguments the command outputs the list of configured repository URLs.\n",
55    note = "Note that repo commands expect the full repository URL, not just the hostname, e.g:",
56    note = "$ pkgctl repo rm fuchsia-pkg://example.com"
57)]
58/// Manage one or more known repositories.
59pub struct RepoCommand {
60    /// verbose output
61    #[argh(switch, short = 'v')]
62    pub verbose: bool,
63
64    #[argh(subcommand)]
65    pub subcommand: Option<RepoSubCommand>,
66}
67
68#[derive(FromArgs, Debug, PartialEq)]
69#[argh(subcommand)]
70pub enum RepoSubCommand {
71    Add(RepoAddCommand),
72    Remove(RepoRemoveCommand),
73    Show(RepoShowCommand),
74}
75
76#[derive(FromArgs, Debug, PartialEq)]
77#[argh(subcommand, name = "add")]
78/// Add a source repository.
79pub struct RepoAddCommand {
80    #[argh(subcommand)]
81    pub subcommand: RepoAddSubCommand,
82}
83
84#[derive(FromArgs, Debug, PartialEq)]
85#[argh(subcommand)]
86pub enum RepoAddSubCommand {
87    File(RepoAddFileCommand),
88    Url(RepoAddUrlCommand),
89}
90
91#[derive(FromArgs, Debug, PartialEq)]
92#[argh(subcommand, name = "file")]
93/// Add a repository config from a local file, in JSON format, which contains the different repository metadata and URLs.
94pub struct RepoAddFileCommand {
95    /// persist TUF metadata for repositories provided to the RepoManager.
96    #[argh(switch, short = 'p')]
97    pub persist: bool,
98    /// name of the source (a name from the URL will be derived if not provided).
99    #[argh(option, short = 'n')]
100    pub name: Option<String>,
101    /// repository config file, in JSON format, which contains the different repository metadata and URLs.
102    #[argh(positional)]
103    pub file: PathBuf,
104}
105
106#[derive(FromArgs, Debug, PartialEq)]
107#[argh(subcommand, name = "url")]
108/// Add a repository config via http, in JSON format, which contains the different repository metadata and URLs.
109pub struct RepoAddUrlCommand {
110    /// persist TUF metadata for repositories provided to the RepoManager.
111    #[argh(switch, short = 'p')]
112    pub persist: bool,
113    /// name of the source (a name from the URL will be derived if not provided).
114    #[argh(option, short = 'n')]
115    pub name: Option<String>,
116    /// http(s) URL pointing to a repository config file, in JSON format, which contains the different repository metadata and URLs.
117    #[argh(positional)]
118    pub repo_url: String,
119}
120
121#[derive(FromArgs, Debug, PartialEq)]
122#[argh(subcommand, name = "rm")]
123/// Remove a configured source repository.
124pub struct RepoRemoveCommand {
125    #[argh(positional)]
126    pub repo_url: String,
127}
128
129#[derive(FromArgs, Debug, PartialEq)]
130#[argh(subcommand, name = "show")]
131/// Show JSON-formatted details of a configured source repository.
132pub struct RepoShowCommand {
133    #[argh(positional)]
134    pub repo_url: String,
135}
136
137#[derive(FromArgs, Debug, PartialEq)]
138#[argh(subcommand, name = "rule")]
139/// Manage URL rewrite rules applied to package URLs during package resolution.
140pub struct RuleCommand {
141    #[argh(subcommand)]
142    pub subcommand: RuleSubCommand,
143}
144
145#[derive(FromArgs, Debug, PartialEq)]
146#[argh(subcommand)]
147pub enum RuleSubCommand {
148    Clear(RuleClearCommand),
149    DumpDynamic(RuleDumpDynamicCommand),
150    List(RuleListCommand),
151    Replace(RuleReplaceCommand),
152}
153
154#[derive(FromArgs, Debug, PartialEq)]
155#[argh(subcommand, name = "clear")]
156/// Clear all URL rewrite rules.
157pub struct RuleClearCommand {}
158
159#[derive(FromArgs, Debug, PartialEq)]
160#[argh(subcommand, name = "list")]
161/// List all URL rewrite rules.
162pub struct RuleListCommand {}
163
164#[derive(FromArgs, Debug, PartialEq)]
165#[argh(subcommand, name = "dump-dynamic")]
166/// Dumps all dynamic rewrite rules.
167pub struct RuleDumpDynamicCommand {}
168
169#[derive(FromArgs, Debug, PartialEq)]
170#[argh(subcommand, name = "replace")]
171/// Replace all dynamic rules with the provided rules.
172pub struct RuleReplaceCommand {
173    #[argh(subcommand)]
174    pub subcommand: RuleReplaceSubCommand,
175}
176
177#[derive(FromArgs, Debug, PartialEq)]
178#[argh(subcommand)]
179pub enum RuleReplaceSubCommand {
180    File(RuleReplaceFileCommand),
181    Json(RuleReplaceJsonCommand),
182}
183
184#[derive(FromArgs, Debug, PartialEq)]
185#[argh(subcommand, name = "file")]
186/// Replace all rewrite rules with ones specified in a file
187pub struct RuleReplaceFileCommand {
188    #[argh(positional)]
189    pub file: PathBuf,
190}
191
192#[derive(FromArgs, Debug, PartialEq)]
193#[argh(subcommand, name = "json")]
194/// Replace all rewrite rules with JSON from the command line
195pub struct RuleReplaceJsonCommand {
196    #[argh(positional, from_str_fn(parse_rule_config))]
197    pub config: RuleConfig,
198}
199
200#[derive(FromArgs, Debug, PartialEq)]
201#[argh(
202    subcommand,
203    name = "gc",
204    note = "This deletes any cached packages that are not present in the static and dynamic index.",
205    note = "Any blobs associated with these packages will be removed if they are not referenced by another component or package.",
206    note = "The static index currently is located at /system/data/static_packages, but this location is likely to change.",
207    note = "The dynamic index is dynamically calculated, and cannot easily be queried at this time."
208)]
209/// Trigger a manual garbage collection of the package cache.
210pub struct GcCommand {}
211
212#[derive(FromArgs, Debug, PartialEq)]
213#[argh(subcommand, name = "get-hash")]
214/// Get the hash of a package.
215pub struct GetHashCommand {
216    #[argh(positional)]
217    pub pkg_url: String,
218}
219
220#[derive(FromArgs, Debug, PartialEq)]
221#[argh(
222    subcommand,
223    name = "pkg-status",
224    note = "Exit codes:",
225    note = "    0 - pkg in tuf repo and on disk",
226    note = "    2 - pkg in tuf repo but not on disk",
227    note = "    3 - pkg not in tuf repo",
228    note = "    1 - any other misc application error"
229)]
230/// Determine if a pkg is in a registered tuf repo and/or on disk.
231pub struct PkgStatusCommand {
232    #[argh(positional)]
233    pub pkg_url: String,
234}
235
236fn parse_rule_config(config: &str) -> Result<RuleConfig, String> {
237    serde_json::from_str(config).map_err(|e| e.to_string())
238}
239
240#[cfg(test)]
241mod tests {
242    use super::*;
243    use assert_matches::assert_matches;
244
245    const REPO_URL: &str = "fuchsia-pkg://fuchsia.com";
246    const CONFIG_JSON: &str = r#"{"version": "1", "content": []}"#;
247    const CMD_NAME: &[&str] = &["pkgctl"];
248
249    #[test]
250    fn resolve() {
251        fn check(args: &[&str], expected_pkg_url: &str, expected_verbose: bool) {
252            assert_eq!(
253                Args::from_args(CMD_NAME, args),
254                Ok(Args {
255                    command: Command::Resolve(ResolveCommand {
256                        pkg_url: expected_pkg_url.to_string(),
257                        verbose: expected_verbose,
258                    })
259                })
260            );
261        }
262
263        let url = "fuchsia-pkg://fuchsia.com/foo/bar";
264
265        check(&["resolve", url], url, false);
266        check(&["resolve", "--verbose", url], url, true);
267        check(&["resolve", "-v", url], url, true);
268    }
269
270    #[test]
271    fn open() {
272        fn check(args: &[&str], expected_blob_id: &str) {
273            assert_eq!(
274                Args::from_args(CMD_NAME, args),
275                Ok(Args {
276                    command: Command::Open(OpenCommand {
277                        meta_far_blob_id: expected_blob_id.parse().unwrap(),
278                    })
279                })
280            )
281        }
282
283        let blob_id = "1111111111111111111111111111111111111111111111111111111111111111";
284        check(&["open", blob_id], blob_id);
285
286        check(&["open", blob_id], blob_id);
287    }
288
289    #[test]
290    fn open_reject_malformed_blobs() {
291        match Args::from_args(CMD_NAME, &["open", "bad_id"]) {
292            Err(argh::EarlyExit { output: _, status: _ }) => {}
293            result => panic!("unexpected result {result:?}"),
294        }
295    }
296
297    #[test]
298    fn repo() {
299        fn check(args: &[&str], expected: RepoCommand) {
300            assert_eq!(
301                Args::from_args(CMD_NAME, args),
302                Ok(Args { command: Command::Repo(expected) })
303            )
304        }
305
306        check(&["repo"], RepoCommand { verbose: false, subcommand: None });
307        check(&["repo", "-v"], RepoCommand { verbose: true, subcommand: None });
308        check(&["repo", "--verbose"], RepoCommand { verbose: true, subcommand: None });
309        check(
310            &["repo", "add", "file", "foo"],
311            RepoCommand {
312                verbose: false,
313                subcommand: Some(RepoSubCommand::Add(RepoAddCommand {
314                    subcommand: RepoAddSubCommand::File(RepoAddFileCommand {
315                        persist: false,
316                        name: None,
317                        file: "foo".into(),
318                    }),
319                })),
320            },
321        );
322        check(
323            &["repo", "add", "file", "-p", "foo"],
324            RepoCommand {
325                verbose: false,
326                subcommand: Some(RepoSubCommand::Add(RepoAddCommand {
327                    subcommand: RepoAddSubCommand::File(RepoAddFileCommand {
328                        persist: true,
329                        name: None,
330                        file: "foo".into(),
331                    }),
332                })),
333            },
334        );
335        check(
336            &["repo", "add", "file", "-n", "devhost", "foo"],
337            RepoCommand {
338                verbose: false,
339                subcommand: Some(RepoSubCommand::Add(RepoAddCommand {
340                    subcommand: RepoAddSubCommand::File(RepoAddFileCommand {
341                        persist: false,
342                        name: Some("devhost".to_string()),
343                        file: "foo".into(),
344                    }),
345                })),
346            },
347        );
348        check(
349            &["repo", "add", "url", "-n", "devhost", "http://foo.tld/fuchsia/config.json"],
350            RepoCommand {
351                verbose: false,
352                subcommand: Some(RepoSubCommand::Add(RepoAddCommand {
353                    subcommand: RepoAddSubCommand::Url(RepoAddUrlCommand {
354                        persist: false,
355                        name: Some("devhost".to_string()),
356                        repo_url: "http://foo.tld/fuchsia/config.json".into(),
357                    }),
358                })),
359            },
360        );
361        check(
362            &["repo", "add", "url", "-p", "-n", "devhost", "http://foo.tld/fuchsia/config.json"],
363            RepoCommand {
364                verbose: false,
365                subcommand: Some(RepoSubCommand::Add(RepoAddCommand {
366                    subcommand: RepoAddSubCommand::Url(RepoAddUrlCommand {
367                        persist: true,
368                        name: Some("devhost".to_string()),
369                        repo_url: "http://foo.tld/fuchsia/config.json".into(),
370                    }),
371                })),
372            },
373        );
374        check(
375            &["repo", "add", "url", "-p", "-n", "devhost", "http://foo.tld/fuchsia/config.json"],
376            RepoCommand {
377                verbose: false,
378                subcommand: Some(RepoSubCommand::Add(RepoAddCommand {
379                    subcommand: RepoAddSubCommand::Url(RepoAddUrlCommand {
380                        persist: true,
381                        name: Some("devhost".to_string()),
382                        repo_url: "http://foo.tld/fuchsia/config.json".into(),
383                    }),
384                })),
385            },
386        );
387        check(
388            &["repo", "rm", REPO_URL],
389            RepoCommand {
390                verbose: false,
391                subcommand: Some(RepoSubCommand::Remove(RepoRemoveCommand {
392                    repo_url: REPO_URL.to_string(),
393                })),
394            },
395        );
396        check(
397            &["repo", "show", REPO_URL],
398            RepoCommand {
399                verbose: false,
400                subcommand: Some(RepoSubCommand::Show(RepoShowCommand {
401                    repo_url: REPO_URL.to_string(),
402                })),
403            },
404        );
405    }
406
407    #[test]
408    fn rule() {
409        fn check(args: &[&str], expected: RuleCommand) {
410            match Args::from_args(CMD_NAME, args).unwrap() {
411                Args { command: Command::Rule(cmd) } => {
412                    assert_eq!(cmd, expected);
413                }
414                result => panic!("unexpected result {result:?}"),
415            }
416        }
417
418        check(
419            &["rule", "list"],
420            RuleCommand { subcommand: RuleSubCommand::List(RuleListCommand {}) },
421        );
422        check(
423            &["rule", "clear"],
424            RuleCommand { subcommand: RuleSubCommand::Clear(RuleClearCommand {}) },
425        );
426        check(
427            &["rule", "dump-dynamic"],
428            RuleCommand { subcommand: RuleSubCommand::DumpDynamic(RuleDumpDynamicCommand {}) },
429        );
430        check(
431            &["rule", "replace", "file", "foo"],
432            RuleCommand {
433                subcommand: RuleSubCommand::Replace(RuleReplaceCommand {
434                    subcommand: RuleReplaceSubCommand::File(RuleReplaceFileCommand {
435                        file: "foo".into(),
436                    }),
437                }),
438            },
439        );
440        check(
441            &["rule", "replace", "json", CONFIG_JSON],
442            RuleCommand {
443                subcommand: RuleSubCommand::Replace(RuleReplaceCommand {
444                    subcommand: RuleReplaceSubCommand::Json(RuleReplaceJsonCommand {
445                        config: RuleConfig::Version1(vec![]),
446                    }),
447                }),
448            },
449        );
450    }
451
452    #[test]
453    fn rule_replace_json_rejects_malformed_json() {
454        assert_matches!(
455            Args::from_args(CMD_NAME, &["rule", "replace", "json", "{"]),
456            Err(argh::EarlyExit { output: _, status: _ })
457        );
458    }
459
460    #[test]
461    fn gc() {
462        match Args::from_args(CMD_NAME, &["gc"]).unwrap() {
463            Args { command: Command::Gc(GcCommand {}) } => {}
464            result => panic!("unexpected result {result:?}"),
465        }
466    }
467
468    #[test]
469    fn get_hash() {
470        let url = "fuchsia-pkg://fuchsia.com/foo/bar";
471        match Args::from_args(CMD_NAME, &["get-hash", url]).unwrap() {
472            Args { command: Command::GetHash(GetHashCommand { pkg_url }) } if pkg_url == url => {}
473            result => panic!("unexpected result {result:?}"),
474        }
475    }
476
477    #[test]
478    fn pkg_status() {
479        let url = "fuchsia-pkg://fuchsia.com/foo/bar";
480        match Args::from_args(CMD_NAME, &["pkg-status", url]).unwrap() {
481            Args { command: Command::PkgStatus(PkgStatusCommand { pkg_url }) }
482                if pkg_url == url => {}
483            result => panic!("unexpected result {result:?}"),
484        }
485    }
486}
pkgctl/args.rs

pkgctl/
args.rs
