mirror of
https://github.com/microsoft/vscode.git
synced 2026-04-24 18:49:00 +01:00
move cli to top level
This commit is contained in:
Connor Peet
234
cli/src/bin/code/legacy_args.rs
Normal file
234
cli/src/bin/code/legacy_args.rs
Normal file
@@ -0,0 +1,234 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use cli::commands::args::{
|
||||
Cli, Commands, DesktopCodeOptions, ExtensionArgs, ExtensionSubcommand, InstallExtensionArgs,
|
||||
ListExtensionArgs, UninstallExtensionArgs,
|
||||
};
|
||||
|
||||
/// Tries to parse the argv using the legacy CLI interface, looking for its
|
||||
/// flags and generating a CLI with subcommands if those don't exist.
|
||||
pub fn try_parse_legacy(
|
||||
iter: impl IntoIterator<Item = impl Into<std::ffi::OsString>>,
|
||||
) -> Option<Cli> {
|
||||
let raw = clap_lex::RawArgs::new(iter);
|
||||
let mut cursor = raw.cursor();
|
||||
raw.next(&mut cursor); // Skip the bin
|
||||
|
||||
// First make a hashmap of all flags and capture positional arguments.
|
||||
let mut args: HashMap<String, Vec<String>> = HashMap::new();
|
||||
let mut last_arg = None;
|
||||
while let Some(arg) = raw.next(&mut cursor) {
|
||||
if let Some((long, value)) = arg.to_long() {
|
||||
if let Ok(long) = long {
|
||||
last_arg = Some(long.to_string());
|
||||
match args.get_mut(long) {
|
||||
Some(prev) => {
|
||||
if let Some(v) = value {
|
||||
prev.push(v.to_str_lossy().to_string());
|
||||
}
|
||||
}
|
||||
None => {
|
||||
if let Some(v) = value {
|
||||
args.insert(long.to_string(), vec![v.to_str_lossy().to_string()]);
|
||||
} else {
|
||||
args.insert(long.to_string(), vec![]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if let Ok(value) = arg.to_value() {
|
||||
if let Some(last_arg) = &last_arg {
|
||||
args.get_mut(last_arg)
|
||||
.expect("expected to have last arg")
|
||||
.push(value.to_string());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let get_first_arg_value =
|
||||
|key: &str| args.get(key).and_then(|v| v.first()).map(|s| s.to_string());
|
||||
let desktop_code_options = DesktopCodeOptions {
|
||||
extensions_dir: get_first_arg_value("extensions-dir"),
|
||||
user_data_dir: get_first_arg_value("user-data-dir"),
|
||||
use_version: None,
|
||||
};
|
||||
|
||||
// Now translate them to subcommands.
|
||||
// --list-extensions -> ext list
|
||||
// --install-extension=id -> ext install <id>
|
||||
// --uninstall-extension=id -> ext uninstall <id>
|
||||
// --status -> status
|
||||
|
||||
if args.contains_key("list-extensions") {
|
||||
Some(Cli {
|
||||
subcommand: Some(Commands::Extension(ExtensionArgs {
|
||||
subcommand: ExtensionSubcommand::List(ListExtensionArgs {
|
||||
category: get_first_arg_value("category"),
|
||||
show_versions: args.contains_key("show-versions"),
|
||||
}),
|
||||
desktop_code_options,
|
||||
})),
|
||||
..Default::default()
|
||||
})
|
||||
} else if let Some(exts) = args.remove("install-extension") {
|
||||
Some(Cli {
|
||||
subcommand: Some(Commands::Extension(ExtensionArgs {
|
||||
subcommand: ExtensionSubcommand::Install(InstallExtensionArgs {
|
||||
id_or_path: exts,
|
||||
pre_release: args.contains_key("pre-release"),
|
||||
force: args.contains_key("force"),
|
||||
}),
|
||||
desktop_code_options,
|
||||
})),
|
||||
..Default::default()
|
||||
})
|
||||
} else if let Some(exts) = args.remove("uninstall-extension") {
|
||||
Some(Cli {
|
||||
subcommand: Some(Commands::Extension(ExtensionArgs {
|
||||
subcommand: ExtensionSubcommand::Uninstall(UninstallExtensionArgs { id: exts }),
|
||||
desktop_code_options,
|
||||
})),
|
||||
..Default::default()
|
||||
})
|
||||
} else if args.contains_key("status") {
|
||||
Some(Cli {
|
||||
subcommand: Some(Commands::Status),
|
||||
..Default::default()
|
||||
})
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_parses_list_extensions() {
|
||||
let args = vec![
|
||||
"code",
|
||||
"--list-extensions",
|
||||
"--category",
|
||||
"themes",
|
||||
"--show-versions",
|
||||
];
|
||||
let cli = try_parse_legacy(args.into_iter()).unwrap();
|
||||
|
||||
if let Some(Commands::Extension(extension_args)) = cli.subcommand {
|
||||
if let ExtensionSubcommand::List(list_args) = extension_args.subcommand {
|
||||
assert_eq!(list_args.category, Some("themes".to_string()));
|
||||
assert!(list_args.show_versions);
|
||||
} else {
|
||||
panic!(
|
||||
"Expected list subcommand, got {:?}",
|
||||
extension_args.subcommand
|
||||
);
|
||||
}
|
||||
} else {
|
||||
panic!("Expected extension subcommand, got {:?}", cli.subcommand);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parses_install_extension() {
|
||||
let args = vec![
|
||||
"code",
|
||||
"--install-extension",
|
||||
"connor4312.codesong",
|
||||
"connor4312.hello-world",
|
||||
"--pre-release",
|
||||
"--force",
|
||||
];
|
||||
let cli = try_parse_legacy(args.into_iter()).unwrap();
|
||||
|
||||
if let Some(Commands::Extension(extension_args)) = cli.subcommand {
|
||||
if let ExtensionSubcommand::Install(install_args) = extension_args.subcommand {
|
||||
assert_eq!(
|
||||
install_args.id_or_path,
|
||||
vec!["connor4312.codesong", "connor4312.hello-world"]
|
||||
);
|
||||
assert!(install_args.pre_release);
|
||||
assert!(install_args.force);
|
||||
} else {
|
||||
panic!(
|
||||
"Expected install subcommand, got {:?}",
|
||||
extension_args.subcommand
|
||||
);
|
||||
}
|
||||
} else {
|
||||
panic!("Expected extension subcommand, got {:?}", cli.subcommand);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parses_uninstall_extension() {
|
||||
let args = vec!["code", "--uninstall-extension", "connor4312.codesong"];
|
||||
let cli = try_parse_legacy(args.into_iter()).unwrap();
|
||||
|
||||
if let Some(Commands::Extension(extension_args)) = cli.subcommand {
|
||||
if let ExtensionSubcommand::Uninstall(uninstall_args) = extension_args.subcommand {
|
||||
assert_eq!(uninstall_args.id, vec!["connor4312.codesong"]);
|
||||
} else {
|
||||
panic!(
|
||||
"Expected uninstall subcommand, got {:?}",
|
||||
extension_args.subcommand
|
||||
);
|
||||
}
|
||||
} else {
|
||||
panic!("Expected extension subcommand, got {:?}", cli.subcommand);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parses_user_data_dir_and_extensions_dir() {
|
||||
let args = vec![
|
||||
"code",
|
||||
"--uninstall-extension",
|
||||
"connor4312.codesong",
|
||||
"--user-data-dir",
|
||||
"foo",
|
||||
"--extensions-dir",
|
||||
"bar",
|
||||
];
|
||||
let cli = try_parse_legacy(args.into_iter()).unwrap();
|
||||
|
||||
if let Some(Commands::Extension(extension_args)) = cli.subcommand {
|
||||
assert_eq!(
|
||||
extension_args.desktop_code_options.user_data_dir,
|
||||
Some("foo".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
extension_args.desktop_code_options.extensions_dir,
|
||||
Some("bar".to_string())
|
||||
);
|
||||
if let ExtensionSubcommand::Uninstall(uninstall_args) = extension_args.subcommand {
|
||||
assert_eq!(uninstall_args.id, vec!["connor4312.codesong"]);
|
||||
} else {
|
||||
panic!(
|
||||
"Expected uninstall subcommand, got {:?}",
|
||||
extension_args.subcommand
|
||||
);
|
||||
}
|
||||
} else {
|
||||
panic!("Expected extension subcommand, got {:?}", cli.subcommand);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_status() {
|
||||
let args = vec!["code", "--status"];
|
||||
let cli = try_parse_legacy(args.into_iter()).unwrap();
|
||||
|
||||
if let Some(Commands::Status) = cli.subcommand {
|
||||
// no-op
|
||||
} else {
|
||||
panic!("Expected extension subcommand, got {:?}", cli.subcommand);
|
||||
}
|
||||
}
|
||||
}
|
||||
169
cli/src/bin/code/main.rs
Normal file
169
cli/src/bin/code/main.rs
Normal file
@@ -0,0 +1,169 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
mod legacy_args;
|
||||
|
||||
use std::process::Command;
|
||||
|
||||
use clap::Parser;
|
||||
use cli::{
|
||||
commands::{args, tunnels, version, CommandContext},
|
||||
desktop, log as own_log,
|
||||
state::LauncherPaths,
|
||||
update_service::UpdateService,
|
||||
util::{
|
||||
errors::{wrap, AnyError},
|
||||
prereqs::PreReqChecker,
|
||||
},
|
||||
};
|
||||
use legacy_args::try_parse_legacy;
|
||||
use opentelemetry::sdk::trace::TracerProvider as SdkTracerProvider;
|
||||
use opentelemetry::trace::TracerProvider;
|
||||
|
||||
use log::{Level, Metadata, Record};
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> Result<(), std::convert::Infallible> {
|
||||
let raw_args = std::env::args_os().collect::<Vec<_>>();
|
||||
let parsed = try_parse_legacy(&raw_args).unwrap_or_else(|| args::Cli::parse_from(&raw_args));
|
||||
let context = CommandContext {
|
||||
http: reqwest::Client::new(),
|
||||
paths: LauncherPaths::new(&parsed.global_options.cli_data_dir).unwrap(),
|
||||
log: own_log::Logger::new(
|
||||
SdkTracerProvider::builder().build().tracer("codecli"),
|
||||
if parsed.global_options.verbose {
|
||||
own_log::Level::Trace
|
||||
} else {
|
||||
parsed.global_options.log.unwrap_or(own_log::Level::Info)
|
||||
},
|
||||
),
|
||||
args: parsed,
|
||||
};
|
||||
|
||||
log::set_logger(Box::leak(Box::new(RustyLogger(context.log.clone()))))
|
||||
.map(|()| log::set_max_level(log::LevelFilter::Debug))
|
||||
.expect("expected to make logger");
|
||||
|
||||
let result = match context.args.subcommand.clone() {
|
||||
None => {
|
||||
let ca = context.args.get_base_code_args();
|
||||
start_code(context, ca).await
|
||||
}
|
||||
|
||||
Some(args::Commands::Extension(extension_args)) => {
|
||||
let mut ca = context.args.get_base_code_args();
|
||||
extension_args.add_code_args(&mut ca);
|
||||
start_code(context, ca).await
|
||||
}
|
||||
|
||||
Some(args::Commands::Status) => {
|
||||
let mut ca = context.args.get_base_code_args();
|
||||
ca.push("--status".to_string());
|
||||
start_code(context, ca).await
|
||||
}
|
||||
|
||||
Some(args::Commands::Version(version_args)) => match version_args.subcommand {
|
||||
args::VersionSubcommand::Use(use_version_args) => {
|
||||
version::switch_to(context, use_version_args).await
|
||||
}
|
||||
args::VersionSubcommand::Uninstall(uninstall_version_args) => {
|
||||
version::uninstall(context, uninstall_version_args).await
|
||||
}
|
||||
args::VersionSubcommand::List(list_version_args) => {
|
||||
version::list(context, list_version_args).await
|
||||
}
|
||||
},
|
||||
|
||||
Some(args::Commands::Tunnel(tunnel_args)) => match tunnel_args.subcommand {
|
||||
Some(args::TunnelSubcommand::Prune) => tunnels::prune(context).await,
|
||||
Some(args::TunnelSubcommand::Unregister) => tunnels::unregister(context).await,
|
||||
Some(args::TunnelSubcommand::Rename(rename_args)) => {
|
||||
tunnels::rename(context, rename_args).await
|
||||
}
|
||||
Some(args::TunnelSubcommand::User(user_command)) => {
|
||||
tunnels::user(context, user_command).await
|
||||
}
|
||||
Some(args::TunnelSubcommand::Service(service_args)) => {
|
||||
tunnels::service(context, service_args).await
|
||||
}
|
||||
None => tunnels::serve(context, tunnel_args.serve_args).await,
|
||||
},
|
||||
};
|
||||
|
||||
match result {
|
||||
Err(e) => print_and_exit(e),
|
||||
Ok(code) => std::process::exit(code),
|
||||
}
|
||||
}
|
||||
|
||||
fn print_and_exit<E>(err: E) -> !
|
||||
where
|
||||
E: std::fmt::Display,
|
||||
{
|
||||
own_log::emit(own_log::Level::Error, "", &format!("{}", err));
|
||||
std::process::exit(1);
|
||||
}
|
||||
|
||||
async fn start_code(context: CommandContext, args: Vec<String>) -> Result<i32, AnyError> {
|
||||
let platform = PreReqChecker::new().verify().await?;
|
||||
let version_manager = desktop::CodeVersionManager::new(&context.paths, platform);
|
||||
let update_service = UpdateService::new(context.log.clone(), context.http.clone());
|
||||
let version = match &context.args.editor_options.code_options.use_version {
|
||||
Some(v) => desktop::RequestedVersion::try_from(v.as_str())?,
|
||||
None => version_manager.get_preferred_version(),
|
||||
};
|
||||
|
||||
let binary = match version_manager.try_get_entrypoint(&version).await {
|
||||
Some(ep) => ep,
|
||||
None => {
|
||||
desktop::prompt_to_install(&version)?;
|
||||
version_manager.install(&update_service, &version).await?
|
||||
}
|
||||
};
|
||||
|
||||
let code = Command::new(binary)
|
||||
.args(args)
|
||||
.status()
|
||||
.map(|s| s.code().unwrap_or(1))
|
||||
.map_err(|e| wrap(e, "error running VS Code"))?;
|
||||
|
||||
Ok(code)
|
||||
}
|
||||
|
||||
/// Logger that uses the common rust "log" crate and directs back to one of
|
||||
/// our managed loggers.
|
||||
struct RustyLogger(own_log::Logger);
|
||||
|
||||
impl log::Log for RustyLogger {
|
||||
fn enabled(&self, metadata: &Metadata) -> bool {
|
||||
metadata.level() <= Level::Debug
|
||||
}
|
||||
|
||||
fn log(&self, record: &Record) {
|
||||
if !self.enabled(record.metadata()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// exclude noisy log modules:
|
||||
let src = match record.module_path() {
|
||||
Some("russh::cipher") => return,
|
||||
Some("russh::negotiation") => return,
|
||||
Some(s) => s,
|
||||
None => "<unknown>",
|
||||
};
|
||||
|
||||
self.0.emit(
|
||||
match record.level() {
|
||||
log::Level::Debug => own_log::Level::Debug,
|
||||
log::Level::Error => own_log::Level::Error,
|
||||
log::Level::Info => own_log::Level::Info,
|
||||
log::Level::Trace => own_log::Level::Trace,
|
||||
log::Level::Warn => own_log::Level::Warn,
|
||||
},
|
||||
&format!("[{}] {}", src, record.args()),
|
||||
);
|
||||
}
|
||||
|
||||
fn flush(&self) {}
|
||||
}
|
||||
Reference in New Issue
Block a user