use super::{
commands::{info_usage, list_usage, refresh_usage, subnet_command, subnet_usage},
options::{CatalogInfoOptions, CatalogListOptions, CatalogRefreshOptions},
};
use crate::cli::clap::parse_required_subcommand;
use crate::{
cli::{common::write_text_or_json, help::print_help_or_version},
nns::{NnsCommandError, now_unix_secs},
project::icp_root,
subnet_catalog::{
DEFAULT_STALE_AFTER_SECONDS, SubnetCatalogCacheRequest, SubnetCatalogInfoRequest,
SubnetCatalogListRequest, SubnetCatalogRefreshRequest, build_subnet_catalog_info_report,
build_subnet_catalog_list_report, refresh_subnet_catalog, subnet_catalog_info_report_text,
subnet_catalog_list_report_text, subnet_catalog_list_report_verbose_text,
subnet_catalog_refresh_report_text,
},
version_text,
};
use std::{
ffi::OsString,
path::{Path, PathBuf},
};
pub(in crate::nns) fn run<I>(args: I) -> Result<(), NnsCommandError>
where
I: IntoIterator<Item = OsString>,
{
let args = args.into_iter().collect::<Vec<_>>();
if print_help_or_version(&args, subnet_usage, version_text()) {
return Ok(());
}
let (command, args) = parse_required_subcommand(subnet_command(), args)
.map_err(|_| NnsCommandError::Usage(subnet_usage()))?;
match command.as_str() {
"list" => run_catalog_list(args),
"info" => run_catalog_info(args),
"refresh" => run_catalog_refresh(args),
_ => unreachable!("nns subnet dispatch command only defines known commands"),
}
}
fn run_catalog_list<I>(args: I) -> Result<(), NnsCommandError>
where
I: IntoIterator<Item = OsString>,
{
let args = args.into_iter().collect::<Vec<_>>();
if print_help_or_version(&args, list_usage, version_text()) {
return Ok(());
}
let options = CatalogListOptions::parse(args)?;
let format = options.format;
let verbose = options.verbose;
let icp_root = icp_root().map_err(|err| NnsCommandError::Usage(err.to_string()))?;
let request = SubnetCatalogListRequest {
cache: cache_request(&icp_root, &options.network),
source_endpoint: options.source_endpoint,
now_unix_secs: now_unix_secs()?,
stale_after_seconds: DEFAULT_STALE_AFTER_SECONDS,
filters: options.filters,
show_ranges: options.show_ranges,
range_limit: options.range_limit,
range_offset: options.range_offset,
};
let report = build_subnet_catalog_list_report(&request)?;
write_text_or_json(format, &report, |report| {
if verbose {
subnet_catalog_list_report_verbose_text(report)
} else {
subnet_catalog_list_report_text(report)
}
})
}
fn run_catalog_info<I>(args: I) -> Result<(), NnsCommandError>
where
I: IntoIterator<Item = OsString>,
{
let args = args.into_iter().collect::<Vec<_>>();
if print_help_or_version(&args, info_usage, version_text()) {
return Ok(());
}
let options = CatalogInfoOptions::parse(args)?;
let format = options.format;
let icp_root = icp_root().map_err(|err| NnsCommandError::Usage(err.to_string()))?;
let request = SubnetCatalogInfoRequest {
cache: cache_request(&icp_root, &options.network),
source_endpoint: options.source_endpoint,
input: options.input.clone(),
forced: options.forced,
now_unix_secs: now_unix_secs()?,
stale_after_seconds: DEFAULT_STALE_AFTER_SECONDS,
};
let report = build_subnet_catalog_info_report(&request)?;
write_text_or_json(format, &report, subnet_catalog_info_report_text)
}
fn run_catalog_refresh<I>(args: I) -> Result<(), NnsCommandError>
where
I: IntoIterator<Item = OsString>,
{
let args = args.into_iter().collect::<Vec<_>>();
if print_help_or_version(&args, refresh_usage, version_text()) {
return Ok(());
}
let options = CatalogRefreshOptions::parse(args)?;
let format = options.format;
let icp_root = icp_root().map_err(|err| NnsCommandError::Usage(err.to_string()))?;
let request = SubnetCatalogRefreshRequest {
cache: cache_request(&icp_root, &options.network),
source_endpoint: options.source_endpoint,
now_unix_secs: now_unix_secs()?,
lock_stale_after_seconds: options.lock_stale_after_seconds,
dry_run: options.dry_run,
output_path: options.output_path,
};
let report = refresh_subnet_catalog(&request)?;
write_text_or_json(format, &report, subnet_catalog_refresh_report_text)
}
fn cache_request(icp_root: &Path, network: &str) -> SubnetCatalogCacheRequest {
SubnetCatalogCacheRequest {
icp_root: PathBuf::from(icp_root),
network: network.to_string(),
}
}