( )⚙ D8383 rust-chg: update name of the server process

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8383

rust-chg: update name of the server process
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG80d6e3415636: rust-chg: update name of the server process
Summary

This is a copy of updateprocname() of hgclient.c.

At this point, rust-chg is basically functional. I did dogfooding for
a couple of weeks in 2018. There are a few remaining tasks:

a. loop detection by CHGINTERNALMARK
b. forward unsupported commands (notably serve -d) to real hg
c. better handling of early server exception
d. modernize codebase (2018 edition, impl trait, async/await)

For (d), we'll probably want to switch to async-std, but I'm thinking of
upgrading to Tokio 0.2 as an intermediate step since process API isn't
ported to async-std yet. I'm pretty sure future migration to async-std
will be painless compared to the mass rewrite from futures-0.1 to 0.3.

https://github.com/async-rs/async-std/issues/22

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:47 AM
Alphare added a subscriber: Alphare.

For (d) [modernizing the codebase], we'll probably want to switch to async-std, but I'm thinking of
upgrading to Tokio 0.2 as an intermediate step since process API isn't
ported to async-std yet. I'm pretty sure future migration to async-std
will be painless compared to the mass rewrite from futures-0.1 to 0.3.

That seems reasonable indeed.

There is also a potentially interesting project we need to keep an eye out for, since it's made by the same person that started async-std in the first place: https://stjepang.github.io/2020/04/03/why-im-building-a-new-async-runtime.html. I have to admit that the constant rewrites of async runtimes (or lack thereof) does not help when making a decision and are not really reassuring, but I guess it's a new-ish problem in the Rust ecosystem.

yuja added a commit: rHG80d6e3415636: rust-chg: update name of the server process.Apr 9 2020, 3:26 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG80d6e3415636: rust-chg: update name of the server process (authored by yuja). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 21021

rust/chg/src/clientext.rs

P: AsRef<Path>; 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<I, P>(self, vars: I) -> OneShotRequest<C>
where where
I: IntoIterator<Item = (P, P)>, I: IntoIterator<Item = (P, P)>,
P: AsRef<OsStr>; P: AsRef<OsStr>;
/// Changes the process title of the server.
fn set_process_name<P>(self, name: P) -> 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<I, P, H>(self, handler: H, args: I) -> ChgRunCommand<C, H>
where where
I: IntoIterator<Item = P>, I: IntoIterator<Item = P>,
P: AsRef<OsStr>, P: AsRef<OsStr>,
fn set_env_vars_os<I, P>(self, vars: I) -> OneShotRequest<C> fn set_env_vars_os<I, P>(self, vars: I) -> OneShotRequest<C>
where where
I: IntoIterator<Item = (P, P)>, I: IntoIterator<Item = (P, P)>,
P: AsRef<OsStr>, P: AsRef<OsStr>,
{ {
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>
where
P: AsRef<OsStr>,
{
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<I, P, H>(self, handler: H, args: I) -> ChgRunCommand<C, H>
where where

rust/chg/src/locator.rs

} }
} }
}) })
.and_then(|(loc, client)| { .and_then(|(loc, client)| {
check_server_capabilities(client.server_spec())?; check_server_capabilities(client.server_spec())?;
Ok((loc, client)) Ok((loc, client))
}) })
.and_then(|(loc, client)| { .and_then(|(loc, client)| {
// It's purely optional, and the server might not support this command.
if client.server_spec().capabilities.contains("setprocname") {
let fut = client
.set_process_name(format!("chg[worker/{}]", loc.process_id))
.map(|client| (loc, client));
Either::A(fut)
} else {
Either::B(future::ok((loc, client)))
}
})
.and_then(|(loc, client)| {
client client
.set_current_dir(&loc.current_dir) .set_current_dir(&loc.current_dir)
.map(|client| (loc, client)) .map(|client| (loc, client))
}) })
.and_then(|(loc, client)| { .and_then(|(loc, client)| {
client client
.set_env_vars_os(loc.env_vars.iter().cloned()) .set_env_vars_os(loc.env_vars.iter().cloned())
.map(|client| (loc, client)) .map(|client| (loc, client))