This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9142

rust: move rustfmt.toml to repo root so it can be used by `hg fix`
ClosedPublic

Authored by martinvonz on Oct 1 2020, 12:20 PM.

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHG426294d06ddc: rust: move rustfmt.toml to repo root so it can be used by `hg fix`
Summary

hg fix runs the formatters from the repo root so it doesn't pick up
the rustfmt.toml configs we had in each the hg-core, hg-cpython,
and rhg packages, which resulted in warnings about async fn not
existing in Rust 2015. This patch moves the rustfmt.toml file to the
root so hg fix will use it.

By putting the rustfmt.toml file in a higher-level directory, it
also applies to the chg and hgcli packages. That makes
test-check-rust-format.t fail, so this patch also applies the new
formatting rules to those packages.

Diff Detail

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

Event Timeline

martinvonz created this revision.Oct 1 2020, 12:20 PM
martinvonz updated this revision to Diff 22976.Oct 1 2020, 12:21 PM
Alphare accepted this revision.Oct 2 2020, 3:17 AM
Alphare added a subscriber: Alphare.

Thanks

pulkit accepted this revision.Oct 2 2020, 3:31 AM
This revision is now accepted and ready to land.Oct 2 2020, 3:31 AM

Revision Contents
Changeset List

Diff 22975

contrib/examples/fix.hgrc

[fix] [fix]
clang-format:command = clang-format --style file clang-format:command = clang-format --style file
clang-format:pattern = set:(**.c or **.cc or **.h) and not "include:contrib/clang-format-ignorelist" clang-format:pattern = set:(**.c or **.cc or **.h) and not "include:contrib/clang-format-ignorelist"
rustfmt:command = rustfmt +nightly rustfmt:command = rustfmt +nightly
rustfmt:pattern = set:**.rs rustfmt:pattern = set:"**.rs" - "mercurial/thirdparty/**"
black:command = black --config=black.toml - black:command = black --config=black.toml -
black:pattern = set:**.py - mercurial/thirdparty/** black:pattern = set:**.py - mercurial/thirdparty/**
# Mercurial doesn't have any Go code, but if we did this is how we # Mercurial doesn't have any Go code, but if we did this is how we
# would configure `hg fix` for Go: # would configure `hg fix` for Go:
go:command = gofmt go:command = gofmt
go:pattern = set:**.go go:pattern = set:**.go

rust/chg/src/clientext.rs

/// Attaches the client file descriptors to the server. /// Attaches the client file descriptors to the server.
pub async fn attach_io( pub async fn attach_io(
&mut self, &mut self,
stdin: &impl AsRawFd, stdin: &impl AsRawFd,
stdout: &impl AsRawFd, stdout: &impl AsRawFd,
stderr: &impl AsRawFd, stderr: &impl AsRawFd,
) -> io::Result<()> { ) -> io::Result<()> {
attachio::attach_io(self.client.borrow_protocol_mut(), stdin, stdout, stderr).await attachio::attach_io(
self.client.borrow_protocol_mut(),
stdin,
stdout,
stderr,
)
.await
} }
/// Changes the working directory of the server. /// Changes the working directory of the server.
pub async fn set_current_dir(&mut self, dir: impl AsRef<Path>) -> io::Result<()> { pub async fn set_current_dir(
&mut self,
dir: impl AsRef<Path>,
) -> io::Result<()> {
let dir_bytes = dir.as_ref().as_os_str().as_bytes().to_owned(); let dir_bytes = dir.as_ref().as_os_str().as_bytes().to_owned();
self.client self.client
.borrow_protocol_mut() .borrow_protocol_mut()
.send_command_with_args("chdir", dir_bytes) .send_command_with_args("chdir", dir_bytes)
.await .await
} }
/// Updates the environment variables of the server. /// Updates the environment variables of the server.
pub async fn set_env_vars_os( pub async fn set_env_vars_os(
&mut self, &mut self,
vars: impl IntoIterator<Item = (impl AsRef<OsStr>, impl AsRef<OsStr>)>, vars: impl IntoIterator<Item = (impl AsRef<OsStr>, impl AsRef<OsStr>)>,
) -> io::Result<()> { ) -> io::Result<()> {
self.client self.client
.borrow_protocol_mut() .borrow_protocol_mut()
.send_command_with_args("setenv", message::pack_env_vars_os(vars)) .send_command_with_args("setenv", message::pack_env_vars_os(vars))
.await .await
} }
/// Changes the process title of the server. /// Changes the process title of the server.
pub async fn set_process_name(&mut self, name: impl AsRef<OsStr>) -> io::Result<()> { pub async fn set_process_name(
&mut self,
name: impl AsRef<OsStr>,
) -> io::Result<()> {
let name_bytes = name.as_ref().as_bytes().to_owned(); let name_bytes = name.as_ref().as_bytes().to_owned();
self.client self.client
.borrow_protocol_mut() .borrow_protocol_mut()
.send_command_with_args("setprocname", name_bytes) .send_command_with_args("setprocname", name_bytes)
.await .await
} }
/// Changes the umask of the server process. /// Changes the umask of the server process.

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(&mut self, args: impl IntoIterator<Item = impl AsRef<OsStr>>) { pub fn set_early_args(
self.hg_early_args = args.into_iter().map(|a| a.as_ref().to_owned()).collect(); &mut self,
args: impl IntoIterator<Item = impl 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 async fn connect(&mut self) -> io::Result<ChgClient> { pub async fn connect(&mut self) -> io::Result<ChgClient> {
for _cnt in 0..10 { for _cnt in 0..10 {
let mut client = self.try_connect().await?; let mut client = self.try_connect().await?;
self.hg_command self.hg_command
); );
Err(io::Error::new(io::ErrorKind::Other, msg)) Err(io::Error::new(io::ErrorKind::Other, msg))
} }
/// Runs instructions received from the server. /// Runs instructions received from the server.
/// ///
/// Returns true if the client should try connecting to the other server. /// Returns true if the client should try connecting to the other server.
fn run_instructions(&mut self, instructions: &[Instruction]) -> io::Result<bool> { fn run_instructions(
&mut self,
instructions: &[Instruction],
) -> io::Result<bool> {
let mut reconnect = false; let mut reconnect = false;
for inst in instructions { for inst in instructions {
debug!("instruction: {:?}", inst); debug!("instruction: {:?}", inst);
match inst { match inst {
Instruction::Exit(_) => { Instruction::Exit(_) => {
// Just returns the current connection to run the // Just returns the current connection to run the
// unparsable command and report the error // unparsable command and report the error
return Ok(false); return Ok(false);
} }
Instruction::Reconnect => { Instruction::Reconnect => {
reconnect = true; reconnect = true;
} }
Instruction::Redirect(path) => { Instruction::Redirect(path) => {
if path.parent() != self.base_sock_path.parent() { if path.parent() != self.base_sock_path.parent() {
let msg = format!( let msg = format!(
"insecure redirect instruction from server: {}", "insecure redirect instruction from server: {}",
path.display() path.display()
); );
return Err(io::Error::new(io::ErrorKind::InvalidData, msg)); return Err(io::Error::new(
io::ErrorKind::InvalidData,
msg,
));
} }
self.redirect_sock_path = Some(path.to_owned()); self.redirect_sock_path = Some(path.to_owned());
reconnect = true; reconnect = true;
} }
Instruction::Unlink(path) => { Instruction::Unlink(path) => {
if path.parent() != self.base_sock_path.parent() { if path.parent() != self.base_sock_path.parent() {
let msg = format!( let msg = format!(
"insecure unlink instruction from server: {}", "insecure unlink instruction from server: {}",
path.display() path.display()
); );
return Err(io::Error::new(io::ErrorKind::InvalidData, msg)); return Err(io::Error::new(
io::ErrorKind::InvalidData,
msg,
));
} }
fs::remove_file(path).unwrap_or(()); // may race fs::remove_file(path).unwrap_or(()); // may race
} }
} }
} }
Ok(reconnect) Ok(reconnect)
} }
}) })
} }
fn check_secure_dir<P>(path: P) -> io::Result<P> fn check_secure_dir<P>(path: P) -> io::Result<P>
where where
P: AsRef<Path>, P: AsRef<Path>,
{ {
let a = fs::symlink_metadata(path.as_ref())?; let a = fs::symlink_metadata(path.as_ref())?;
if a.is_dir() && a.uid() == procutil::get_effective_uid() && (a.mode() & 0o777) == 0o700 { if a.is_dir()
&& a.uid() == procutil::get_effective_uid()
&& (a.mode() & 0o777) == 0o700
{
Ok(path) Ok(path)
} else { } else {
Err(io::Error::new(io::ErrorKind::Other, "insecure directory")) Err(io::Error::new(io::ErrorKind::Other, "insecure directory"))
} }
} }
fn check_server_capabilities(spec: &ServerSpec) -> io::Result<()> { fn check_server_capabilities(spec: &ServerSpec) -> io::Result<()> {
let unsupported: Vec<_> = REQUIRED_SERVER_CAPABILITIES let unsupported: Vec<_> = REQUIRED_SERVER_CAPABILITIES
.iter() .iter()
.cloned() .cloned()
.filter(|&s| !spec.capabilities.contains(s)) .filter(|&s| !spec.capabilities.contains(s))
.collect(); .collect();
if unsupported.is_empty() { if unsupported.is_empty() {
Ok(()) Ok(())
} 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. /// Collects arguments which need to be passed to the server at start.
pub fn collect_early_args(args: impl IntoIterator<Item = impl AsRef<OsStr>>) -> Vec<OsString> { pub fn collect_early_args(
args: impl IntoIterator<Item = impl AsRef<OsStr>>,
) -> Vec<OsString> {
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

#[derive(Clone, Debug, Eq, PartialEq)] #[derive(Clone, Debug, Eq, PartialEq)]
pub struct CommandSpec { pub struct CommandSpec {
pub command: OsString, pub command: OsString,
pub current_dir: OsString, pub current_dir: OsString,
pub envs: Vec<(OsString, OsString)>, pub envs: Vec<(OsString, OsString)>,
} }
/// Parses "S" channel request into command type and spec. /// Parses "S" channel request into command type and spec.
pub fn parse_command_spec(data: Bytes) -> io::Result<(CommandType, CommandSpec)> { pub fn parse_command_spec(
data: Bytes,
) -> io::Result<(CommandType, CommandSpec)> {
let mut split = data.split(|&c| c == b'\0'); let mut split = data.split(|&c| c == b'\0');
let ctype = parse_command_type(split.next().ok_or(new_parse_error("missing type"))?)?; let ctype = parse_command_type(
split.next().ok_or(new_parse_error("missing type"))?,
)?;
let command = split.next().ok_or(new_parse_error("missing command"))?; let command = split.next().ok_or(new_parse_error("missing command"))?;
let current_dir = split.next().ok_or(new_parse_error("missing current dir"))?; let current_dir =
split.next().ok_or(new_parse_error("missing current dir"))?;
let mut envs = Vec::new(); let mut envs = Vec::new();
for l in split { for l in split {
let mut s = l.splitn(2, |&c| c == b'='); let mut s = l.splitn(2, |&c| c == b'=');
let k = s.next().unwrap(); let k = s.next().unwrap();
let v = s.next().ok_or(new_parse_error("malformed env"))?; let v = s.next().ok_or(new_parse_error("malformed env"))?;
envs.push(( envs.push((
OsStr::from_bytes(k).to_owned(), OsStr::from_bytes(k).to_owned(),
if l.is_empty() { if l.is_empty() {
continue; continue;
} }
let mut s = l.splitn(2, |&c| c == b' '); let mut s = l.splitn(2, |&c| c == b' ');
let inst = match (s.next().unwrap(), s.next()) { let inst = match (s.next().unwrap(), s.next()) {
(b"exit", Some(arg)) => decode_latin1(arg) (b"exit", Some(arg)) => decode_latin1(arg)
.parse() .parse()
.map(Instruction::Exit) .map(Instruction::Exit)
.map_err(|_| new_parse_error(format!("invalid exit code: {:?}", arg)))?, .map_err(|_| {
new_parse_error(format!("invalid exit code: {:?}", arg))
})?,
(b"reconnect", None) => Instruction::Reconnect, (b"reconnect", None) => Instruction::Reconnect,
(b"redirect", Some(arg)) => { (b"redirect", Some(arg)) => {
Instruction::Redirect(OsStr::from_bytes(arg).to_owned().into()) Instruction::Redirect(OsStr::from_bytes(arg).to_owned().into())
} }
(b"unlink", Some(arg)) => Instruction::Unlink(OsStr::from_bytes(arg).to_owned().into()), (b"unlink", Some(arg)) => {
Instruction::Unlink(OsStr::from_bytes(arg).to_owned().into())
}
_ => { _ => {
return Err(new_parse_error(format!("unknown command: {:?}", l))); return Err(new_parse_error(format!(
"unknown command: {:?}",
l
)));
} }
}; };
instructions.push(inst); instructions.push(inst);
} }
Ok(instructions) Ok(instructions)
} }
// allocate large buffer as environment variables can be quite long // allocate large buffer as environment variables can be quite long
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( pub fn pack_env_vars_os(
vars: impl IntoIterator<Item = (impl AsRef<OsStr>, impl AsRef<OsStr>)>, vars: impl IntoIterator<Item = (impl AsRef<OsStr>, impl AsRef<OsStr>)>,
) -> Bytes { ) -> Bytes {
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());
} }
dst.freeze() dst.freeze()
} else { } else {
dst.put_u8(b'='); dst.put_u8(b'=');
dst.put_slice(v.as_bytes()); dst.put_slice(v.as_bytes());
} }
fn decode_latin1(s: impl AsRef<[u8]>) -> String { fn decode_latin1(s: impl AsRef<[u8]>) -> String {
s.as_ref().iter().map(|&c| c as char).collect() s.as_ref().iter().map(|&c| c as char).collect()
} }
fn new_parse_error(error: impl Into<Box<dyn error::Error + Send + Sync>>) -> io::Error { fn new_parse_error(
error: impl Into<Box<dyn error::Error + Send + Sync>>,
) -> io::Error {
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;
(CommandType::Pager, spec) (CommandType::Pager, spec)
); );
} }
#[test] #[test]
fn parse_command_spec_too_short() { fn parse_command_spec_too_short() {
assert!(parse_command_spec(Bytes::from_static(b"")).is_err()); assert!(parse_command_spec(Bytes::from_static(b"")).is_err());
assert!(parse_command_spec(Bytes::from_static(b"pager")).is_err()); assert!(parse_command_spec(Bytes::from_static(b"pager")).is_err());
assert!(parse_command_spec(Bytes::from_static(b"pager\0less")).is_err()); assert!(
parse_command_spec(Bytes::from_static(b"pager\0less")).is_err()
);
} }
#[test] #[test]
fn parse_command_spec_malformed_env() { fn parse_command_spec_malformed_env() {
assert!(parse_command_spec(Bytes::from_static(b"pager\0less\0/tmp\0HOME")).is_err()); assert!(parse_command_spec(Bytes::from_static(
b"pager\0less\0/tmp\0HOME"
))
.is_err());
} }
#[test] #[test]
fn parse_command_spec_unknown_type() { fn parse_command_spec_unknown_type() {
assert!(parse_command_spec(Bytes::from_static(b"paper\0less")).is_err()); assert!(
parse_command_spec(Bytes::from_static(b"paper\0less")).is_err()
);
} }
#[test] #[test]
fn parse_instructions_good() { fn parse_instructions_good() {
let src = [ let src = [
b"exit 123".as_ref(), b"exit 123".as_ref(),
b"reconnect".as_ref(), b"reconnect".as_ref(),
b"redirect /whatever".as_ref(), b"redirect /whatever".as_ref(),

rust/chg/src/procutil.rs

} }
/// Changes the given fd to blocking mode. /// Changes the given fd to blocking mode.
pub fn set_blocking_fd(fd: RawFd) -> io::Result<()> { pub fn set_blocking_fd(fd: RawFd) -> io::Result<()> {
let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) }; let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) };
if flags < 0 { if flags < 0 {
return Err(io::Error::last_os_error()); return Err(io::Error::last_os_error());
} }
let r = unsafe { libc::fcntl(fd, libc::F_SETFL, flags & !libc::O_NONBLOCK) }; let r =
unsafe { libc::fcntl(fd, libc::F_SETFL, flags & !libc::O_NONBLOCK) };
if r < 0 { if r < 0 {
return Err(io::Error::last_os_error()); return Err(io::Error::last_os_error());
} }
Ok(()) Ok(())
} }
/// Sends file descriptors via the given socket. /// Sends file descriptors via the given socket.
pub fn send_raw_fds(sock_fd: RawFd, fds: &[RawFd]) -> io::Result<()> { pub fn send_raw_fds(sock_fd: RawFd, fds: &[RawFd]) -> io::Result<()> {
let r = unsafe { sendfds(sock_fd, fds.as_ptr(), fds.len() as size_t) }; let r = unsafe { sendfds(sock_fd, fds.as_ptr(), fds.len() as size_t) };
if r < 0 { if r < 0 {
return Err(io::Error::last_os_error()); return Err(io::Error::last_os_error());
} }
Ok(()) Ok(())
} }
static SETUP_SIGNAL_HANDLER: sync::Once = sync::Once::new(); static SETUP_SIGNAL_HANDLER: sync::Once = sync::Once::new();
static RESTORE_SIGNAL_HANDLER: sync::Once = sync::Once::new(); static RESTORE_SIGNAL_HANDLER: sync::Once = sync::Once::new();
/// Installs signal handlers to forward signals to the server. /// Installs signal handlers to forward signals to the server.
/// ///
/// # Safety /// # Safety
/// ///
/// This touches global states, and thus synchronized as a one-time /// This touches global states, and thus synchronized as a one-time
/// initialization function. /// initialization function.
pub fn setup_signal_handler_once(pid: u32, pgid: Option<u32>) -> io::Result<()> { pub fn setup_signal_handler_once(
pid: u32,
pgid: Option<u32>,
) -> io::Result<()> {
let pid_signed = pid as i32; let pid_signed = pid as i32;
let pgid_signed = pgid.map(|n| n as i32).unwrap_or(0); let pgid_signed = pgid.map(|n| n as i32).unwrap_or(0);
let mut r = 0; let mut r = 0;
SETUP_SIGNAL_HANDLER.call_once(|| { SETUP_SIGNAL_HANDLER.call_once(|| {
r = unsafe { setupsignalhandler(pid_signed, pgid_signed) }; r = unsafe { setupsignalhandler(pid_signed, pgid_signed) };
}); });
if r < 0 { if r < 0 {
return Err(io::Error::last_os_error()); return Err(io::Error::last_os_error());

rust/chg/src/runcommand.rs

loop { loop {
match proto.fetch_response().await? { match proto.fetch_response().await? {
ChannelMessage::Data(b'r', data) => { ChannelMessage::Data(b'r', data) => {
return message::parse_result_code(data); return message::parse_result_code(data);
} }
ChannelMessage::Data(..) => { ChannelMessage::Data(..) => {
// just ignores data sent to optional channel // just ignores data sent to optional channel
} }
ChannelMessage::InputRequest(..) | ChannelMessage::LineRequest(..) => { ChannelMessage::InputRequest(..)
| ChannelMessage::LineRequest(..) => {
return Err(io::Error::new( return Err(io::Error::new(
io::ErrorKind::InvalidData, io::ErrorKind::InvalidData,
"unsupported request", "unsupported request",
)); ));
} }
ChannelMessage::SystemRequest(data) => { ChannelMessage::SystemRequest(data) => {
let (cmd_type, cmd_spec) = message::parse_command_spec(data)?; let (cmd_type, cmd_spec) = message::parse_command_spec(data)?;
match cmd_type { match cmd_type {
CommandType::Pager => { CommandType::Pager => {
// server spins new command loop while pager request is // server spins new command loop while pager request is
// in progress, which can be terminated by "" command. // in progress, which can be terminated by "" command.
let pin = handler.spawn_pager(&cmd_spec).await?; let pin = handler.spawn_pager(&cmd_spec).await?;
attachio::attach_io(proto, &io::stdin(), &pin, &pin).await?; attachio::attach_io(proto, &io::stdin(), &pin, &pin)
.await?;
proto.send_command("").await?; // terminator proto.send_command("").await?; // terminator
} }
CommandType::System => { CommandType::System => {
let code = handler.run_system(&cmd_spec).await?; let code = handler.run_system(&cmd_spec).await?;
let data = message::pack_result_code(code); let data = message::pack_result_code(code);
proto.send_data(data).await?; proto.send_data(data).await?;
} }
} }
} }
} }
} }
} }

rust/chg/src/uihandler.rs

/// Callback to process shell command requests received from server. /// Callback to process shell command requests received from server.
#[async_trait] #[async_trait]
pub trait SystemHandler { pub trait SystemHandler {
type PagerStdin: AsRawFd; type PagerStdin: AsRawFd;
/// Handles pager command request. /// Handles pager command request.
/// ///
/// Returns the pipe to be attached to the server if the pager is spawned. /// Returns the pipe to be attached to the server if the pager is spawned.
async fn spawn_pager(&mut self, spec: &CommandSpec) -> io::Result<Self::PagerStdin>; async fn spawn_pager(
&mut self,
spec: &CommandSpec,
) -> io::Result<Self::PagerStdin>;
/// Handles system command request. /// Handles system command request.
/// ///
/// Returns command exit code (positive) or signal number (negative). /// Returns command exit code (positive) or signal number (negative).
async fn run_system(&mut self, spec: &CommandSpec) -> io::Result<i32>; async fn run_system(&mut self, spec: &CommandSpec) -> io::Result<i32>;
} }
/// Default cHg implementation to process requests received from server. /// Default cHg implementation to process requests received from server.
Ok(()) Ok(())
} }
} }
#[async_trait] #[async_trait]
impl SystemHandler for ChgUiHandler { impl SystemHandler for ChgUiHandler {
type PagerStdin = ChildStdin; type PagerStdin = ChildStdin;
async fn spawn_pager(&mut self, spec: &CommandSpec) -> io::Result<Self::PagerStdin> { async fn spawn_pager(
let mut pager = new_shell_command(&spec).stdin(Stdio::piped()).spawn()?; &mut self,
spec: &CommandSpec,
) -> io::Result<Self::PagerStdin> {
let mut pager =
new_shell_command(&spec).stdin(Stdio::piped()).spawn()?;
let pin = pager.stdin.take().unwrap(); let pin = pager.stdin.take().unwrap();
procutil::set_blocking_fd(pin.as_raw_fd())?; procutil::set_blocking_fd(pin.as_raw_fd())?;
// TODO: if pager exits, notify the server with SIGPIPE immediately. // TODO: if pager exits, notify the server with SIGPIPE immediately.
// otherwise the server won't get SIGPIPE if it does not write // otherwise the server won't get SIGPIPE if it does not write
// anything. (issue5278) // anything. (issue5278)
// kill(peerpid, SIGPIPE); // kill(peerpid, SIGPIPE);
self.pager = Some(pager); self.pager = Some(pager);
Ok(pin) Ok(pin)

rust/hg-core/rustfmt.toml

  • This file was moved to rustfmt.toml.

rust/hg-cpython/rustfmt.toml

  • This file was deleted.
max_width = 79
wrap_comments = true
error_on_line_overflow = true

rust/hgcli/build.rs

// This Source Code Form is subject to the terms of the Mozilla Public // This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this // License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/. // file, You can obtain one at https://mozilla.org/MPL/2.0/.
/*! Build script to integrate PyOxidizer. */ /*! Build script to integrate PyOxidizer. */
fn main() { fn main() {
if let Ok(config_rs) = std::env::var("DEP_PYTHONXY_DEFAULT_PYTHON_CONFIG_RS") { if let Ok(config_rs) =
std::env::var("DEP_PYTHONXY_DEFAULT_PYTHON_CONFIG_RS")
{
println!( println!(
"cargo:rustc-env=PYOXIDIZER_DEFAULT_PYTHON_CONFIG_RS={}", "cargo:rustc-env=PYOXIDIZER_DEFAULT_PYTHON_CONFIG_RS={}",
config_rs config_rs
); );
} else { } else {
panic!("unable to find build artifacts generated by pyembed crate"); panic!("unable to find build artifacts generated by pyembed crate");
} }
} }

rust/hgcli/src/main.rs

use pyembed::MainPythonInterpreter; use pyembed::MainPythonInterpreter;
// Include an auto-generated file containing the default // Include an auto-generated file containing the default
// `pyembed::PythonConfig` derived by the PyOxidizer configuration file. // `pyembed::PythonConfig` derived by the PyOxidizer configuration file.
// //
// If you do not want to use PyOxidizer to generate this file, simply // If you do not want to use PyOxidizer to generate this file, simply
// remove this line and instantiate your own instance of // remove this line and instantiate your own instance of
// `pyembed::PythonConfig`. // `pyembed::PythonConfig`.
include!(env!("PYOXIDIZER_DEFAULT_PYTHON_CONFIG_RS")); include!(env!("PYOXIDIZER_DEFAULT_PYTHON_CONFIG_RS"));
fn main() { fn main() {
// The following code is in a block so the MainPythonInterpreter is destroyed in an // The following code is in a block so the MainPythonInterpreter is
// orderly manner, before process exit. // destroyed in an orderly manner, before process exit.
let code = { let code = {
// Load the default Python configuration as derived by the PyOxidizer config // Load the default Python configuration as derived by the PyOxidizer
// file used at build time. // config file used at build time.
let config = default_python_config(); let config = default_python_config();
// Construct a new Python interpreter using that config, handling any errors // Construct a new Python interpreter using that config, handling any
// from construction. // errors from construction.
match MainPythonInterpreter::new(config) { match MainPythonInterpreter::new(config) {
Ok(mut interp) => { Ok(mut interp) => {
// And run it using the default run configuration as specified by the // And run it using the default run configuration as specified
// configuration. If an uncaught Python exception is raised, handle it. // by the configuration. If an uncaught Python
// This includes the special SystemExit, which is a request to terminate the // exception is raised, handle it.
// process. // This includes the special SystemExit, which is a request to
// terminate the process.
interp.run_as_main() interp.run_as_main()
} }
Err(msg) => { Err(msg) => {
eprintln!("{}", msg); eprintln!("{}", msg);
1 1
} }
} }
}; };
// And exit the process according to code execution results. // And exit the process according to code execution results.
std::process::exit(code); std::process::exit(code);
} }

rust/rhg/rustfmt.toml

  • This file was deleted.
max_width = 79
wrap_comments = true
error_on_line_overflow = true

rustfmt.toml

  • This file was moved from rust/hg-core/rustfmt.toml.
edition = "2018"
max_width = 79 max_width = 79
wrap_comments = true wrap_comments = true
error_on_line_overflow = true error_on_line_overflow = true
rust/hgcli/src/main.rs