( )⚙ D8380 rust-chg: collect server flags from command arguments

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8380

rust-chg: collect server flags from command arguments
ClosedPublic

Authored by yuja on Apr 6 2020, 10:19 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG00ac60658654: rust-chg: collect server flags from command arguments
Summary

This is the reimplementation of testsensitiveflag() and setcmdserverargs()
of chg.c.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

yuja created this revision.Apr 6 2020, 10:19 AM
Alphare accepted this revision.Apr 8 2020, 4:23 AM
yuja added a commit: rHG00ac60658654: rust-chg: collect server flags from command arguments.Apr 9 2020, 3:26 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG00ac60658654: rust-chg: collect server flags from command arguments (authored by yuja). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/chg/src/locator.rs (109 lines)
Mrust/chg/src/main.rs (5 lines)

Diff 20996

rust/chg/src/locator.rs

use super::procutil; use super::procutil;
const REQUIRED_SERVER_CAPABILITIES: &[&str] = &["attachio", "chdir", "runcommand", "setenv"]; const REQUIRED_SERVER_CAPABILITIES: &[&str] = &["attachio", "chdir", "runcommand", "setenv"];
/// Helper to connect to and spawn a server process. /// Helper to connect to and spawn a server process.
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct Locator { pub struct Locator {
hg_command: OsString, hg_command: OsString,
hg_early_args: Vec<OsString>,
current_dir: PathBuf, current_dir: PathBuf,
env_vars: Vec<(OsString, OsString)>, env_vars: Vec<(OsString, OsString)>,
process_id: u32, process_id: u32,
base_sock_path: PathBuf, base_sock_path: PathBuf,
timeout: Duration, timeout: Duration,
} }
impl Locator { impl Locator {
/// Creates locator capturing the current process environment. /// Creates locator capturing the current process environment.
/// ///
/// If no `$CHGSOCKNAME` is specified, the socket directory will be /// If no `$CHGSOCKNAME` is specified, the socket directory will be
/// created as necessary. /// created as necessary.
pub fn prepare_from_env() -> io::Result<Locator> { pub fn prepare_from_env() -> io::Result<Locator> {
Ok(Locator { Ok(Locator {
hg_command: default_hg_command(), hg_command: default_hg_command(),
hg_early_args: Vec::new(),
current_dir: env::current_dir()?, current_dir: env::current_dir()?,
env_vars: env::vars_os().collect(), env_vars: env::vars_os().collect(),
process_id: process::id(), process_id: process::id(),
base_sock_path: prepare_server_socket_path()?, base_sock_path: prepare_server_socket_path()?,
timeout: default_timeout(), timeout: default_timeout(),
}) })
} }
/// Temporary socket path for this client process. /// Temporary socket path for this client process.
fn temp_sock_path(&self) -> PathBuf { fn temp_sock_path(&self) -> PathBuf {
let src = self.base_sock_path.as_os_str().as_bytes(); let src = self.base_sock_path.as_os_str().as_bytes();
let mut buf = Vec::with_capacity(src.len() + 6); // "{src}.{pid}".len() let mut buf = Vec::with_capacity(src.len() + 6); // "{src}.{pid}".len()
buf.extend_from_slice(src); buf.extend_from_slice(src);
buf.extend_from_slice(format!(".{}", self.process_id).as_bytes()); buf.extend_from_slice(format!(".{}", self.process_id).as_bytes());
OsString::from_vec(buf).into() OsString::from_vec(buf).into()
} }
/// Specifies the arguments to be passed to the server at start.
pub fn set_early_args<I, P>(&mut self, args: I)
where
I: IntoIterator<Item = P>,
P: AsRef<OsStr>,
{
self.hg_early_args = args.into_iter().map(|a| a.as_ref().to_owned()).collect();
}
/// Connects to the server. /// Connects to the server.
/// ///
/// The server process will be spawned if not running. /// The server process will be spawned if not running.
pub fn connect(self) -> impl Future<Item = (Self, UnixClient), Error = io::Error> { pub fn connect(self) -> impl Future<Item = (Self, UnixClient), Error = io::Error> {
self.try_connect() self.try_connect()
} }
/// Tries to connect to the existing server, or spawns new if not running. /// Tries to connect to the existing server, or spawns new if not running.
Command::new(&self.hg_command) Command::new(&self.hg_command)
.arg("serve") .arg("serve")
.arg("--cmdserver") .arg("--cmdserver")
.arg("chgunix") .arg("chgunix")
.arg("--address") .arg("--address")
.arg(&sock_path) .arg(&sock_path)
.arg("--daemon-postexec") .arg("--daemon-postexec")
.arg("chdir:/") .arg("chdir:/")
.args(&self.hg_early_args)
.current_dir(&self.current_dir) .current_dir(&self.current_dir)
.env_clear() .env_clear()
.envs(self.env_vars.iter().cloned()) .envs(self.env_vars.iter().cloned())
.env("CHGINTERNALMARK", "") .env("CHGINTERNALMARK", "")
.spawn_async() .spawn_async()
.into_future() .into_future()
.and_then(|server| self.connect_spawned(server, sock_path)) .and_then(|server| self.connect_spawned(server, sock_path))
.and_then(|(loc, client, sock_path)| { .and_then(|(loc, client, sock_path)| {
} else { } else {
let msg = format!( let msg = format!(
"insufficient server capabilities: {}", "insufficient server capabilities: {}",
unsupported.join(", ") unsupported.join(", ")
); );
Err(io::Error::new(io::ErrorKind::Other, msg)) Err(io::Error::new(io::ErrorKind::Other, msg))
} }
} }
/// Collects arguments which need to be passed to the server at start.
pub fn collect_early_args<I, P>(args: I) -> Vec<OsString>
where
I: IntoIterator<Item = P>,
P: AsRef<OsStr>,
{
let mut args_iter = args.into_iter();
let mut early_args = Vec::new();
while let Some(arg) = args_iter.next() {
let argb = arg.as_ref().as_bytes();
if argb == b"--" {
break;
} else if argb.starts_with(b"--") {
let mut split = argb[2..].splitn(2, |&c| c == b'=');
match split.next().unwrap() {
b"traceback" => {
if split.next().is_none() {
early_args.push(arg.as_ref().to_owned());
}
}
b"config" | b"cwd" | b"repo" | b"repository" => {
if split.next().is_some() {
// --<flag>=<val>
early_args.push(arg.as_ref().to_owned());
} else {
// --<flag> <val>
args_iter.next().map(|val| {
early_args.push(arg.as_ref().to_owned());
early_args.push(val.as_ref().to_owned());
});
}
}
_ => {}
}
} else if argb.starts_with(b"-R") {
if argb.len() > 2 {
// -R<val>
early_args.push(arg.as_ref().to_owned());
} else {
// -R <val>
args_iter.next().map(|val| {
early_args.push(arg.as_ref().to_owned());
early_args.push(val.as_ref().to_owned());
});
}
}
}
early_args
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn collect_early_args_some() {
assert!(collect_early_args(&[] as &[&OsStr]).is_empty());
assert!(collect_early_args(&["log"]).is_empty());
assert_eq!(
collect_early_args(&["log", "-Ra", "foo"]),
os_string_vec_from(&[b"-Ra"])
);
assert_eq!(
collect_early_args(&["log", "-R", "repo", "", "--traceback", "a"]),
os_string_vec_from(&[b"-R", b"repo", b"--traceback"])
);
assert_eq!(
collect_early_args(&["log", "--config", "diff.git=1", "-q"]),
os_string_vec_from(&[b"--config", b"diff.git=1"])
);
assert_eq!(
collect_early_args(&["--cwd=..", "--repository", "r", "log"]),
os_string_vec_from(&[b"--cwd=..", b"--repository", b"r"])
);
assert_eq!(
collect_early_args(&["log", "--repo=r", "--repos", "a"]),
os_string_vec_from(&[b"--repo=r"])
);
}
#[test]
fn collect_early_args_orphaned() {
assert!(collect_early_args(&["log", "-R"]).is_empty());
assert!(collect_early_args(&["log", "--config"]).is_empty());
}
#[test]
fn collect_early_args_unwanted_value() {
assert!(collect_early_args(&["log", "--traceback="]).is_empty());
}
fn os_string_vec_from(v: &[&[u8]]) -> Vec<OsString> {
v.iter().map(|s| OsStr::from_bytes(s).to_owned()).collect()
}
}

rust/chg/src/main.rs

// Copyright 2018 Yuya Nishihara <yuya@tcha.org> // Copyright 2018 Yuya Nishihara <yuya@tcha.org>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
extern crate chg; extern crate chg;
extern crate futures; extern crate futures;
extern crate log; extern crate log;
extern crate tokio; extern crate tokio;
extern crate tokio_hglib; extern crate tokio_hglib;
use chg::locator::Locator; use chg::locator::{self, Locator};
use chg::procutil; use chg::procutil;
use chg::{ChgClientExt, ChgUiHandler}; use chg::{ChgClientExt, ChgUiHandler};
use futures::sync::oneshot; use futures::sync::oneshot;
use std::env; use std::env;
use std::io; use std::io;
use std::process; use std::process;
use std::time::Instant; use std::time::Instant;
use tokio::prelude::*; use tokio::prelude::*;
let code = run().unwrap_or_else(|err| { let code = run().unwrap_or_else(|err| {
writeln!(io::stderr(), "chg: abort: {}", err).unwrap_or(()); writeln!(io::stderr(), "chg: abort: {}", err).unwrap_or(());
255 255
}); });
process::exit(code); process::exit(code);
} }
fn run() -> io::Result<i32> { fn run() -> io::Result<i32> {
let loc = Locator::prepare_from_env()?; let mut loc = Locator::prepare_from_env()?;
loc.set_early_args(locator::collect_early_args(env::args_os().skip(1)));
let handler = ChgUiHandler::new(); let handler = ChgUiHandler::new();
let (result_tx, result_rx) = oneshot::channel(); let (result_tx, result_rx) = oneshot::channel();
let fut = loc let fut = loc
.connect() .connect()
.and_then(|(_, client)| client.attach_io(io::stdin(), io::stdout(), io::stderr())) .and_then(|(_, client)| client.attach_io(io::stdin(), io::stdout(), io::stderr()))
.and_then(|client| { .and_then(|client| {
let pid = client.server_spec().process_id.unwrap(); let pid = client.server_spec().process_id.unwrap();
let pgid = client.server_spec().process_group_id; let pgid = client.server_spec().process_group_id;