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
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

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 21018

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;