This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8401

rust-chg: leverage impl trait at argument position
ClosedPublic

Authored by yuja on Apr 11 2020, 7:24 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG61fda2dbc522: rust-chg: leverage impl trait at argument position

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 11 2020, 7:24 AM
Alphare accepted this revision.Apr 14 2020, 5:07 AM
yuja added a commit: rHG61fda2dbc522: rust-chg: leverage impl trait at argument position.Apr 14 2020, 12:41 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG61fda2dbc522: rust-chg: leverage impl trait at argument position (authored by yuja). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/chg/src/clientext.rs (68 lines)
Mrust/chg/src/locator.rs (17 lines)
Mrust/chg/src/message.rs (18 lines)

Diff 21072

rust/chg/src/clientext.rs

/// Attaches the client file descriptors to the server. /// Attaches the client file descriptors to the server.
fn attach_io<I, O, E>(self, stdin: I, stdout: O, stderr: E) -> AttachIo<C, I, O, E> fn attach_io<I, O, E>(self, stdin: I, stdout: O, stderr: E) -> AttachIo<C, I, O, E>
where where
I: AsRawFd, I: AsRawFd,
O: AsRawFd, O: AsRawFd,
E: AsRawFd; E: AsRawFd;
/// Changes the working directory of the server. /// Changes the working directory of the server.
fn set_current_dir<P>(self, dir: P) -> OneShotRequest<C> fn set_current_dir(self, dir: impl AsRef<Path>) -> OneShotRequest<C>;
where
P: AsRef<Path>;
/// Updates the environment variables of the server. /// Updates the environment variables of the server.
fn set_env_vars_os<I, P>(self, vars: I) -> OneShotRequest<C> fn set_env_vars_os(
where self,
I: IntoIterator<Item = (P, P)>, vars: impl IntoIterator<Item = (impl AsRef<OsStr>, impl AsRef<OsStr>)>,
P: AsRef<OsStr>; ) -> OneShotRequest<C>;
/// Changes the process title of the server. /// Changes the process title of the server.
fn set_process_name<P>(self, name: P) -> OneShotRequest<C> fn set_process_name(self, name: impl AsRef<OsStr>) -> OneShotRequest<C>;
where
P: AsRef<OsStr>;
/// Changes the umask of the server process. /// Changes the umask of the server process.
fn set_umask(self, mask: u32) -> OneShotRequest<C>; fn set_umask(self, mask: u32) -> OneShotRequest<C>;
/// Runs the specified Mercurial command with cHg extension. /// Runs the specified Mercurial command with cHg extension.
fn run_command_chg<I, P, H>(self, handler: H, args: I) -> ChgRunCommand<C, H> fn run_command_chg<H>(
self,
handler: H,
args: impl IntoIterator<Item = impl AsRef<OsStr>>,
) -> ChgRunCommand<C, H>
where where
I: IntoIterator<Item = P>,
P: AsRef<OsStr>,
H: SystemHandler; H: SystemHandler;
/// Validates if the server can run Mercurial commands with the expected /// Validates if the server can run Mercurial commands with the expected
/// configuration. /// configuration.
/// ///
/// The `args` should contain early command arguments such as `--config` /// The `args` should contain early command arguments such as `--config`
/// and `-R`. /// and `-R`.
/// ///
/// Client-side environment must be sent prior to this request, by /// Client-side environment must be sent prior to this request, by
/// `set_current_dir()` and `set_env_vars_os()`. /// `set_current_dir()` and `set_env_vars_os()`.
fn validate<I, P>(self, args: I) -> OneShotQuery<C, fn(Bytes) -> io::Result<Vec<Instruction>>> fn validate(
where self,
I: IntoIterator<Item = P>, args: impl IntoIterator<Item = impl AsRef<OsStr>>,
P: AsRef<OsStr>; ) -> OneShotQuery<C, fn(Bytes) -> io::Result<Vec<Instruction>>>;
} }
impl<C> ChgClientExt<C> for Client<C> impl<C> ChgClientExt<C> for Client<C>
where where
C: Connection + AsRawFd, C: Connection + AsRawFd,
{ {
fn attach_io<I, O, E>(self, stdin: I, stdout: O, stderr: E) -> AttachIo<C, I, O, E> fn attach_io<I, O, E>(self, stdin: I, stdout: O, stderr: E) -> AttachIo<C, I, O, E>
where where
I: AsRawFd, I: AsRawFd,
O: AsRawFd, O: AsRawFd,
E: AsRawFd, E: AsRawFd,
{ {
AttachIo::with_client(self, stdin, stdout, Some(stderr)) AttachIo::with_client(self, stdin, stdout, Some(stderr))
} }
fn set_current_dir<P>(self, dir: P) -> OneShotRequest<C> fn set_current_dir(self, dir: impl AsRef<Path>) -> OneShotRequest<C> {
where
P: AsRef<Path>,
{
OneShotRequest::start_with_args(self, b"chdir", dir.as_ref().as_os_str().as_bytes()) OneShotRequest::start_with_args(self, b"chdir", dir.as_ref().as_os_str().as_bytes())
} }
fn set_env_vars_os<I, P>(self, vars: I) -> OneShotRequest<C> fn set_env_vars_os(
where self,
I: IntoIterator<Item = (P, P)>, vars: impl IntoIterator<Item = (impl AsRef<OsStr>, impl AsRef<OsStr>)>,
P: AsRef<OsStr>, ) -> OneShotRequest<C> {
{
OneShotRequest::start_with_args(self, b"setenv", message::pack_env_vars_os(vars)) OneShotRequest::start_with_args(self, b"setenv", message::pack_env_vars_os(vars))
} }
fn set_process_name<P>(self, name: P) -> OneShotRequest<C> fn set_process_name(self, name: impl AsRef<OsStr>) -> OneShotRequest<C> {
where
P: AsRef<OsStr>,
{
OneShotRequest::start_with_args(self, b"setprocname", name.as_ref().as_bytes()) OneShotRequest::start_with_args(self, b"setprocname", name.as_ref().as_bytes())
} }
fn set_umask(self, mask: u32) -> OneShotRequest<C> { fn set_umask(self, mask: u32) -> OneShotRequest<C> {
let mut args = BytesMut::with_capacity(mem::size_of_val(&mask)); let mut args = BytesMut::with_capacity(mem::size_of_val(&mask));
args.put_u32_be(mask); args.put_u32_be(mask);
OneShotRequest::start_with_args(self, b"setumask2", args) OneShotRequest::start_with_args(self, b"setumask2", args)
} }
fn run_command_chg<I, P, H>(self, handler: H, args: I) -> ChgRunCommand<C, H> fn run_command_chg<H>(
self,
handler: H,
args: impl IntoIterator<Item = impl AsRef<OsStr>>,
) -> ChgRunCommand<C, H>
where where
I: IntoIterator<Item = P>,
P: AsRef<OsStr>,
H: SystemHandler, H: SystemHandler,
{ {
ChgRunCommand::with_client(self, handler, message::pack_args_os(args)) ChgRunCommand::with_client(self, handler, message::pack_args_os(args))
} }
fn validate<I, P>(self, args: I) -> OneShotQuery<C, fn(Bytes) -> io::Result<Vec<Instruction>>> fn validate(
where self,
I: IntoIterator<Item = P>, args: impl IntoIterator<Item = impl AsRef<OsStr>>,
P: AsRef<OsStr>, ) -> OneShotQuery<C, fn(Bytes) -> io::Result<Vec<Instruction>>> {
{
OneShotQuery::start_with_args( OneShotQuery::start_with_args(
self, self,
b"validate", b"validate",
message::pack_args_os(args), message::pack_args_os(args),
message::parse_instructions, message::parse_instructions,
) )
} }
} }

rust/chg/src/locator.rs

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. /// Specifies the arguments to be passed to the server at start.
pub fn set_early_args<I, P>(&mut self, args: I) pub fn set_early_args(&mut self, args: impl IntoIterator<Item = impl AsRef<OsStr>>) {
where
I: IntoIterator<Item = P>,
P: AsRef<OsStr>,
{
self.hg_early_args = args.into_iter().map(|a| a.as_ref().to_owned()).collect(); 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> {
future::loop_fn((self, 0), |(loc, cnt)| { future::loop_fn((self, 0), |(loc, cnt)| {
.and_then(|s| s.parse().ok()) .and_then(|s| s.parse().ok())
.unwrap_or(60); .unwrap_or(60);
Duration::from_secs(secs) Duration::from_secs(secs)
} }
/// Creates a directory which the other users cannot access to. /// Creates a directory which the other users cannot access to.
/// ///
/// If the directory already exists, tests its permission. /// If the directory already exists, tests its permission.
fn create_secure_dir<P>(path: P) -> io::Result<()> fn create_secure_dir(path: impl AsRef<Path>) -> io::Result<()> {
where
P: AsRef<Path>,
{
DirBuilder::new() DirBuilder::new()
.mode(0o700) .mode(0o700)
.create(path.as_ref()) .create(path.as_ref())
.or_else(|err| { .or_else(|err| {
if err.kind() == io::ErrorKind::AlreadyExists { if err.kind() == io::ErrorKind::AlreadyExists {
check_secure_dir(path).map(|_| ()) check_secure_dir(path).map(|_| ())
} else { } else {
Err(err) Err(err)
"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. /// Collects arguments which need to be passed to the server at start.
pub fn collect_early_args<I, P>(args: I) -> Vec<OsString> pub fn collect_early_args(args: impl IntoIterator<Item = impl AsRef<OsStr>>) -> Vec<OsString> {
where
I: IntoIterator<Item = P>,
P: AsRef<OsStr>,
{
let mut args_iter = args.into_iter(); let mut args_iter = args.into_iter();
let mut early_args = Vec::new(); let mut early_args = Vec::new();
while let Some(arg) = args_iter.next() { while let Some(arg) = args_iter.next() {
let argb = arg.as_ref().as_bytes(); let argb = arg.as_ref().as_bytes();
if argb == b"--" { if argb == b"--" {
break; break;
} else if argb.starts_with(b"--") { } else if argb.starts_with(b"--") {
let mut split = argb[2..].splitn(2, |&c| c == b'='); let mut split = argb[2..].splitn(2, |&c| c == b'=');

rust/chg/src/message.rs

const INITIAL_PACKED_ENV_VARS_CAPACITY: usize = 4096; const INITIAL_PACKED_ENV_VARS_CAPACITY: usize = 4096;
/// Packs environment variables of platform encoding into bytes. /// Packs environment variables of platform encoding into bytes.
/// ///
/// # Panics /// # Panics
/// ///
/// Panics if key or value contains `\0` character, or key contains '=' /// Panics if key or value contains `\0` character, or key contains '='
/// character. /// character.
pub fn pack_env_vars_os<I, P>(vars: I) -> Bytes pub fn pack_env_vars_os(
where vars: impl IntoIterator<Item = (impl AsRef<OsStr>, impl AsRef<OsStr>)>,
I: IntoIterator<Item = (P, P)>, ) -> Bytes {
P: AsRef<OsStr>,
{
let mut vars_iter = vars.into_iter(); let mut vars_iter = vars.into_iter();
if let Some((k, v)) = vars_iter.next() { if let Some((k, v)) = vars_iter.next() {
let mut dst = BytesMut::with_capacity(INITIAL_PACKED_ENV_VARS_CAPACITY); let mut dst = BytesMut::with_capacity(INITIAL_PACKED_ENV_VARS_CAPACITY);
pack_env_into(&mut dst, k.as_ref(), v.as_ref()); pack_env_into(&mut dst, k.as_ref(), v.as_ref());
for (k, v) in vars_iter { for (k, v) in vars_iter {
dst.reserve(1); dst.reserve(1);
dst.put_u8(b'\0'); dst.put_u8(b'\0');
pack_env_into(&mut dst, k.as_ref(), v.as_ref()); pack_env_into(&mut dst, k.as_ref(), v.as_ref());
assert!(!k.as_bytes().contains(&b'='), "key shouldn't contain '='"); assert!(!k.as_bytes().contains(&b'='), "key shouldn't contain '='");
assert!(!v.as_bytes().contains(&0), "value shouldn't contain NUL"); assert!(!v.as_bytes().contains(&0), "value shouldn't contain NUL");
dst.reserve(k.as_bytes().len() + 1 + v.as_bytes().len()); dst.reserve(k.as_bytes().len() + 1 + v.as_bytes().len());
dst.put_slice(k.as_bytes()); dst.put_slice(k.as_bytes());
dst.put_u8(b'='); dst.put_u8(b'=');
dst.put_slice(v.as_bytes()); dst.put_slice(v.as_bytes());
} }
fn decode_latin1<S>(s: S) -> String fn decode_latin1(s: impl AsRef<[u8]>) -> String {
where
S: AsRef<[u8]>,
{
s.as_ref().iter().map(|&c| c as char).collect() s.as_ref().iter().map(|&c| c as char).collect()
} }
fn new_parse_error<E>(error: E) -> io::Error fn new_parse_error(error: impl Into<Box<dyn error::Error + Send + Sync>>) -> io::Error {
where
E: Into<Box<dyn error::Error + Send + Sync>>,
{
io::Error::new(io::ErrorKind::InvalidData, error) io::Error::new(io::ErrorKind::InvalidData, error)
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use std::os::unix::ffi::OsStringExt; use std::os::unix::ffi::OsStringExt;
use std::panic; use std::panic;