( )⚙ D7578 rust: run rustfmt

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7578

rust: run rustfmt
ClosedPublic

Authored by indygreg on Dec 7 2019, 4:11 PM.

Details

Reviewers
kevincox
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHGce088b38f92b: rust: run rustfmt
Summary
  1. skip-blame automated reformatting

Diff Detail

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

Event Timeline

indygreg created this revision.Dec 7 2019, 4:11 PM
kevincox accepted this revision.Dec 9 2019, 7:17 AM
Alphare accepted this revision.Dec 9 2019, 8:09 AM
pulkit accepted this revision.Dec 10 2019, 9:56 AM
This revision is now accepted and ready to land.Dec 10 2019, 9:56 AM
indygreg added a commit: rHGce088b38f92b: rust: run rustfmt.Dec 10 2019, 10:44 AM
Closed by commit rHGce088b38f92b: rust: run rustfmt (authored by indygreg). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 18538

rust/chg/src/attachio.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.
//! Functions to send client-side fds over the command server channel. //! Functions to send client-side fds over the command server channel.
use futures::{Async, Future, Poll}; use futures::{Async, Future, Poll};
use std::io; use std::io;
use std::os::unix::io::AsRawFd; use std::os::unix::io::AsRawFd;
use tokio_hglib::{Client, Connection};
use tokio_hglib::codec::ChannelMessage; use tokio_hglib::codec::ChannelMessage;
use tokio_hglib::protocol::MessageLoop; use tokio_hglib::protocol::MessageLoop;
use tokio_hglib::{Client, Connection};
use super::message; use super::message;
use super::procutil; use super::procutil;
/// Future to send client-side fds over the command server channel. /// Future to send client-side fds over the command server channel.
/// ///
/// This works as follows: /// This works as follows:
/// 1. Client sends "attachio" request. /// 1. Client sends "attachio" request.
/// 2. Server sends back 1-byte input request. /// 2. Server sends back 1-byte input request.
/// 3. Client sends fds with 1-byte dummy payload in response. /// 3. Client sends fds with 1-byte dummy payload in response.
/// 4. Server returns the number of the fds received. /// 4. Server returns the number of the fds received.
/// ///
/// If the stderr is omitted, it will be redirected to the stdout. This /// If the stderr is omitted, it will be redirected to the stdout. This
/// allows us to attach the pager stdin to both stdout and stderr, and /// allows us to attach the pager stdin to both stdout and stderr, and
/// dispose of the client-side handle once attached. /// dispose of the client-side handle once attached.
#[must_use = "futures do nothing unless polled"] #[must_use = "futures do nothing unless polled"]
pub struct AttachIo<C, I, O, E> pub struct AttachIo<C, I, O, E>
where C: Connection, where
C: Connection,
{ {
msg_loop: MessageLoop<C>, msg_loop: MessageLoop<C>,
stdin: I, stdin: I,
stdout: O, stdout: O,
stderr: Option<E>, stderr: Option<E>,
} }
impl<C, I, O, E> AttachIo<C, I, O, E> impl<C, I, O, E> AttachIo<C, I, O, E>
where C: Connection + AsRawFd, where
C: Connection + AsRawFd,
I: AsRawFd, I: AsRawFd,
O: AsRawFd, O: AsRawFd,
E: AsRawFd, E: AsRawFd,
{ {
pub fn with_client(client: Client<C>, stdin: I, stdout: O, stderr: Option<E>) pub fn with_client(
-> AttachIo<C, I, O, E> { client: Client<C>,
stdin: I,
stdout: O,
stderr: Option<E>,
) -> AttachIo<C, I, O, E> {
let msg_loop = MessageLoop::start(client, b"attachio"); let msg_loop = MessageLoop::start(client, b"attachio");
AttachIo { msg_loop, stdin, stdout, stderr } AttachIo {
msg_loop,
stdin,
stdout,
stderr,
}
} }
} }
impl<C, I, O, E> Future for AttachIo<C, I, O, E> impl<C, I, O, E> Future for AttachIo<C, I, O, E>
where C: Connection + AsRawFd, where
C: Connection + AsRawFd,
I: AsRawFd, I: AsRawFd,
O: AsRawFd, O: AsRawFd,
E: AsRawFd, E: AsRawFd,
{ {
type Item = Client<C>; type Item = Client<C>;
type Error = io::Error; type Error = io::Error;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> { fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
loop { loop {
let (client, msg) = try_ready!(self.msg_loop.poll()); let (client, msg) = try_ready!(self.msg_loop.poll());
match msg { match msg {
ChannelMessage::Data(b'r', data) => { ChannelMessage::Data(b'r', data) => {
let fd_cnt = message::parse_result_code(data)?; let fd_cnt = message::parse_result_code(data)?;
if fd_cnt == 3 { if fd_cnt == 3 {
return Ok(Async::Ready(client)); return Ok(Async::Ready(client));
} else { } else {
return Err(io::Error::new(io::ErrorKind::InvalidData, return Err(io::Error::new(
"unexpected attachio result")); io::ErrorKind::InvalidData,
"unexpected attachio result",
));
} }
} }
ChannelMessage::Data(..) => { ChannelMessage::Data(..) => {
// just ignore data sent to uninteresting (optional) channel // just ignore data sent to uninteresting (optional) channel
self.msg_loop = MessageLoop::resume(client); self.msg_loop = MessageLoop::resume(client);
} }
ChannelMessage::InputRequest(1) => { ChannelMessage::InputRequest(1) => {
// this may fail with EWOULDBLOCK in theory, but the // this may fail with EWOULDBLOCK in theory, but the
// payload is quite small, and the send buffer should // payload is quite small, and the send buffer should
// be empty so the operation will complete immediately // be empty so the operation will complete immediately
let sock_fd = client.as_raw_fd(); let sock_fd = client.as_raw_fd();
let ifd = self.stdin.as_raw_fd(); let ifd = self.stdin.as_raw_fd();
let ofd = self.stdout.as_raw_fd(); let ofd = self.stdout.as_raw_fd();
let efd = self.stderr.as_ref().map_or(ofd, |f| f.as_raw_fd()); let efd = self.stderr.as_ref().map_or(ofd, |f| f.as_raw_fd());
procutil::send_raw_fds(sock_fd, &[ifd, ofd, efd])?; procutil::send_raw_fds(sock_fd, &[ifd, ofd, efd])?;
self.msg_loop = MessageLoop::resume(client); self.msg_loop = MessageLoop::resume(client);
} }
ChannelMessage::InputRequest(..) | ChannelMessage::LineRequest(..) | ChannelMessage::InputRequest(..)
ChannelMessage::SystemRequest(..) => { | ChannelMessage::LineRequest(..)
return Err(io::Error::new(io::ErrorKind::InvalidData, | ChannelMessage::SystemRequest(..) => {
"unsupported request while attaching io")); return Err(io::Error::new(
io::ErrorKind::InvalidData,
"unsupported request while attaching io",
));
} }
} }
} }
} }
} }

rust/chg/src/clientext.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.
//! cHg extensions to command server client. //! cHg extensions to command server client.
use std::ffi::OsStr; use std::ffi::OsStr;
use std::os::unix::ffi::OsStrExt; use std::os::unix::ffi::OsStrExt;
use std::os::unix::io::AsRawFd; use std::os::unix::io::AsRawFd;
use std::path::Path; use std::path::Path;
use tokio_hglib::{Client, Connection};
use tokio_hglib::protocol::OneShotRequest; use tokio_hglib::protocol::OneShotRequest;
use tokio_hglib::{Client, Connection};
use super::attachio::AttachIo; use super::attachio::AttachIo;
use super::message; use super::message;
use super::runcommand::ChgRunCommand; use super::runcommand::ChgRunCommand;
use super::uihandler::SystemHandler; use super::uihandler::SystemHandler;
pub trait ChgClientExt<C> pub trait ChgClientExt<C>
where C: Connection + AsRawFd, where
C: Connection + AsRawFd,
{ {
/// 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 I: AsRawFd, where
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<P>(self, dir: P) -> OneShotRequest<C>
where P: AsRef<Path>; where
P: AsRef<Path>;
/// 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 I: IntoIterator<Item = P>, where
I: IntoIterator<Item = P>,
P: AsRef<OsStr>, P: AsRef<OsStr>,
H: SystemHandler; H: SystemHandler;
} }
impl<C> ChgClientExt<C> for Client<C> impl<C> ChgClientExt<C> for Client<C>
where C: Connection + AsRawFd, where
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 I: AsRawFd, where
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<P>(self, dir: P) -> OneShotRequest<C>
where P: AsRef<Path>, 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 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 I: IntoIterator<Item = P>, where
I: IntoIterator<Item = P>,
P: AsRef<OsStr>, 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))
} }
} }

rust/chg/src/locator.rs

path.push(format!("chg{}", procutil::get_effective_uid())); path.push(format!("chg{}", procutil::get_effective_uid()));
path path
} }
} }
/// Determines the default hg command. /// Determines the default hg command.
pub fn default_hg_command() -> OsString { pub fn default_hg_command() -> OsString {
// TODO: maybe allow embedding the path at compile time (or load from hgrc) // TODO: maybe allow embedding the path at compile time (or load from hgrc)
env::var_os("CHGHG").or(env::var_os("HG")).unwrap_or(OsStr::new("hg").to_owned()) env::var_os("CHGHG")
.or(env::var_os("HG"))
.unwrap_or(OsStr::new("hg").to_owned())
} }
fn default_timeout() -> Duration { fn default_timeout() -> Duration {
let secs = env::var("CHGTIMEOUT").ok().and_then(|s| s.parse().ok()).unwrap_or(60); let secs = env::var("CHGTIMEOUT")
.ok()
.and_then(|s| s.parse().ok())
.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<P>(path: P) -> io::Result<()>
where P: AsRef<Path>, where
P: AsRef<Path>,
{ {
DirBuilder::new().mode(0o700).create(path.as_ref()).or_else(|err| { DirBuilder::new()
.mode(0o700)
.create(path.as_ref())
.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)
} }
}) })
} }
fn check_secure_dir<P>(path: P) -> io::Result<P> fn check_secure_dir<P>(path: P) -> io::Result<P>
where P: AsRef<Path>, where
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"))
} }
} }

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::{ChgClientExt, ChgUiHandler};
use chg::locator; use chg::locator;
use chg::procutil; use chg::procutil;
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::*;
use tokio_hglib::UnixClient; use tokio_hglib::UnixClient;
metadata.target().starts_with("chg::") metadata.target().starts_with("chg::")
} }
fn log(&self, record: &log::Record) { fn log(&self, record: &log::Record) {
if self.enabled(record.metadata()) { if self.enabled(record.metadata()) {
// just make the output looks similar to chg of C // just make the output looks similar to chg of C
let l = format!("{}", record.level()).to_lowercase(); let l = format!("{}", record.level()).to_lowercase();
let t = self.start.elapsed(); let t = self.start.elapsed();
writeln!(io::stderr(), "chg: {}: {}.{:06} {}", writeln!(
l, t.as_secs(), t.subsec_micros(), record.args()).unwrap_or(()); io::stderr(),
"chg: {}: {}.{:06} {}",
l,
t.as_secs(),
t.subsec_micros(),
record.args()
)
.unwrap_or(());
} }
} }
fn flush(&self) { fn flush(&self) {}
}
} }
fn main() { fn main() {
if env::var_os("CHGDEBUG").is_some() { if env::var_os("CHGDEBUG").is_some() {
log::set_boxed_logger(Box::new(DebugLogger::new())) log::set_boxed_logger(Box::new(DebugLogger::new()))
.expect("any logger should not be installed yet"); .expect("any logger should not be installed yet");
log::set_max_level(log::LevelFilter::Debug); log::set_max_level(log::LevelFilter::Debug);
} }
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 current_dir = env::current_dir()?; let current_dir = env::current_dir()?;
let sock_path = locator::prepare_server_socket_path()?; let sock_path = locator::prepare_server_socket_path()?;
let handler = ChgUiHandler::new(); let handler = ChgUiHandler::new();
let (result_tx, result_rx) = oneshot::channel(); let (result_tx, result_rx) = oneshot::channel();
let fut = UnixClient::connect(sock_path) let fut = UnixClient::connect(sock_path)
.and_then(|client| { .and_then(|client| client.set_current_dir(current_dir))
client.set_current_dir(current_dir) .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;
procutil::setup_signal_handler_once(pid, pgid)?; procutil::setup_signal_handler_once(pid, pgid)?;
Ok(client) Ok(client)
}) })
.and_then(|client| { .and_then(|client| client.run_command_chg(handler, env::args_os().skip(1)))
client.run_command_chg(handler, env::args_os().skip(1))
})
.map(|(_client, _handler, code)| { .map(|(_client, _handler, code)| {
procutil::restore_signal_handler_once()?; procutil::restore_signal_handler_once()?;
Ok(code) Ok(code)
}) })
.or_else(|err| Ok(Err(err))) // pass back error to caller .or_else(|err| Ok(Err(err))) // pass back error to caller
.map(|res| result_tx.send(res).unwrap()); .map(|res| result_tx.send(res).unwrap());
tokio::run(fut); tokio::run(fut);
result_rx.wait().unwrap_or(Err(io::Error::new(io::ErrorKind::Other, result_rx.wait().unwrap_or(Err(io::Error::new(
"no exit code set"))) io::ErrorKind::Other,
"no exit code set",
)))
} }

rust/chg/src/message.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.
//! Utility for parsing and building command-server messages. //! Utility for parsing and building command-server messages.
use bytes::Bytes; use bytes::Bytes;
use std::error; use std::error;
use std::ffi::{OsStr, OsString}; use std::ffi::{OsStr, OsString};
use std::io; use std::io;
use std::os::unix::ffi::OsStrExt; use std::os::unix::ffi::OsStrExt;
pub use tokio_hglib::message::*; // re-exports pub use tokio_hglib::message::*; // re-exports
/// Shell command type requested by the server. /// Shell command type requested by the server.
#[derive(Clone, Copy, Debug, Eq, PartialEq)] #[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum CommandType { pub enum CommandType {
/// Pager should be spawned. /// Pager should be spawned.
Pager, Pager,
/// Shell command should be executed to send back the result code. /// Shell command should be executed to send back the result code.
System, System,
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((OsStr::from_bytes(k).to_owned(), OsStr::from_bytes(v).to_owned())); envs.push((
OsStr::from_bytes(k).to_owned(),
OsStr::from_bytes(v).to_owned(),
));
} }
let spec = CommandSpec { let spec = CommandSpec {
command: OsStr::from_bytes(command).to_owned(), command: OsStr::from_bytes(command).to_owned(),
current_dir: OsStr::from_bytes(current_dir).to_owned(), current_dir: OsStr::from_bytes(current_dir).to_owned(),
envs: envs, envs: envs,
}; };
Ok((ctype, spec)) Ok((ctype, spec))
} }
fn parse_command_type(value: &[u8]) -> io::Result<CommandType> { fn parse_command_type(value: &[u8]) -> io::Result<CommandType> {
match value { match value {
b"pager" => Ok(CommandType::Pager), b"pager" => Ok(CommandType::Pager),
b"system" => Ok(CommandType::System), b"system" => Ok(CommandType::System),
_ => Err(new_parse_error(format!("unknown command type: {}", decode_latin1(value)))), _ => Err(new_parse_error(format!(
"unknown command type: {}",
decode_latin1(value)
))),
} }
} }
fn decode_latin1<S>(s: S) -> String fn decode_latin1<S>(s: S) -> String
where S: AsRef<[u8]>, 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<E>(error: E) -> io::Error
where E: Into<Box<error::Error + Send + Sync>>, where
E: Into<Box<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 std::os::unix::ffi::OsStringExt;
use super::*; use super::*;
use std::os::unix::ffi::OsStringExt;
#[test] #[test]
fn parse_command_spec_good() { fn parse_command_spec_good() {
let src = [b"pager".as_ref(), let src = [
b"pager".as_ref(),
b"less -FRX".as_ref(), b"less -FRX".as_ref(),
b"/tmp".as_ref(), b"/tmp".as_ref(),
b"LANG=C".as_ref(), b"LANG=C".as_ref(),
b"HGPLAIN=".as_ref()].join(&0); b"HGPLAIN=".as_ref(),
]
.join(&0);
let spec = CommandSpec { let spec = CommandSpec {
command: os_string_from(b"less -FRX"), command: os_string_from(b"less -FRX"),
current_dir: os_string_from(b"/tmp"), current_dir: os_string_from(b"/tmp"),
envs: vec![(os_string_from(b"LANG"), os_string_from(b"C")), envs: vec![
(os_string_from(b"HGPLAIN"), os_string_from(b""))], (os_string_from(b"LANG"), os_string_from(b"C")),
(os_string_from(b"HGPLAIN"), os_string_from(b"")),
],
}; };
assert_eq!(parse_command_spec(Bytes::from(src)).unwrap(), (CommandType::Pager, spec)); assert_eq!(
parse_command_spec(Bytes::from(src)).unwrap(),
(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());
} }

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 {

rust/chg/src/runcommand.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.
//! Functions to run Mercurial command in cHg-aware command server. //! Functions to run Mercurial command in cHg-aware command server.
use bytes::Bytes; use bytes::Bytes;
use futures::future::IntoFuture; use futures::future::IntoFuture;
use futures::{Async, Future, Poll}; use futures::{Async, Future, Poll};
use std::io; use std::io;
use std::mem; use std::mem;
use std::os::unix::io::AsRawFd; use std::os::unix::io::AsRawFd;
use tokio_hglib::{Client, Connection};
use tokio_hglib::codec::ChannelMessage; use tokio_hglib::codec::ChannelMessage;
use tokio_hglib::protocol::MessageLoop; use tokio_hglib::protocol::MessageLoop;
use tokio_hglib::{Client, Connection};
use super::attachio::AttachIo; use super::attachio::AttachIo;
use super::message::{self, CommandType}; use super::message::{self, CommandType};
use super::uihandler::SystemHandler; use super::uihandler::SystemHandler;
enum AsyncS<R, S> { enum AsyncS<R, S> {
Ready(R), Ready(R),
NotReady(S), NotReady(S),
PollAgain(S), PollAgain(S),
} }
enum CommandState<C, H> enum CommandState<C, H>
where C: Connection, where
C: Connection,
H: SystemHandler, H: SystemHandler,
{ {
Running(MessageLoop<C>, H), Running(MessageLoop<C>, H),
SpawningPager(Client<C>, <H::SpawnPagerResult as IntoFuture>::Future), SpawningPager(Client<C>, <H::SpawnPagerResult as IntoFuture>::Future),
AttachingPager(AttachIo<C, io::Stdin, H::PagerStdin, H::PagerStdin>, H), AttachingPager(AttachIo<C, io::Stdin, H::PagerStdin, H::PagerStdin>, H),
WaitingSystem(Client<C>, <H::RunSystemResult as IntoFuture>::Future), WaitingSystem(Client<C>, <H::RunSystemResult as IntoFuture>::Future),
Finished, Finished,
} }
type CommandPoll<C, H> = io::Result<(AsyncS<(Client<C>, H, i32), CommandState<C, H>>)>; type CommandPoll<C, H> = io::Result<(AsyncS<(Client<C>, H, i32), CommandState<C, H>>)>;
/// Future resolves to `(exit_code, client)`. /// Future resolves to `(exit_code, client)`.
#[must_use = "futures do nothing unless polled"] #[must_use = "futures do nothing unless polled"]
pub struct ChgRunCommand<C, H> pub struct ChgRunCommand<C, H>
where C: Connection, where
C: Connection,
H: SystemHandler, H: SystemHandler,
{ {
state: CommandState<C, H>, state: CommandState<C, H>,
} }
impl<C, H> ChgRunCommand<C, H> impl<C, H> ChgRunCommand<C, H>
where C: Connection + AsRawFd, where
C: Connection + AsRawFd,
H: SystemHandler, H: SystemHandler,
{ {
pub fn with_client(client: Client<C>, handler: H, packed_args: Bytes) pub fn with_client(client: Client<C>, handler: H, packed_args: Bytes) -> ChgRunCommand<C, H> {
-> ChgRunCommand<C, H> {
let msg_loop = MessageLoop::start_with_args(client, b"runcommand", packed_args); let msg_loop = MessageLoop::start_with_args(client, b"runcommand", packed_args);
ChgRunCommand { ChgRunCommand {
state: CommandState::Running(msg_loop, handler), state: CommandState::Running(msg_loop, handler),
} }
} }
} }
impl<C, H> Future for ChgRunCommand<C, H> impl<C, H> Future for ChgRunCommand<C, H>
where C: Connection + AsRawFd, where
C: Connection + AsRawFd,
H: SystemHandler, H: SystemHandler,
{ {
type Item = (Client<C>, H, i32); type Item = (Client<C>, H, i32);
type Error = io::Error; type Error = io::Error;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> { fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
loop { loop {
let state = mem::replace(&mut self.state, CommandState::Finished); let state = mem::replace(&mut self.state, CommandState::Finished);
match state.poll()? { match state.poll()? {
AsyncS::Ready((client, handler, code)) => { AsyncS::Ready((client, handler, code)) => {
return Ok(Async::Ready((client, handler, code))); return Ok(Async::Ready((client, handler, code)));
} }
AsyncS::NotReady(newstate) => { AsyncS::NotReady(newstate) => {
self.state = newstate; self.state = newstate;
return Ok(Async::NotReady); return Ok(Async::NotReady);
} }
AsyncS::PollAgain(newstate) => { AsyncS::PollAgain(newstate) => {
self.state = newstate; self.state = newstate;
} }
} }
} }
} }
} }
impl<C, H> CommandState<C, H> impl<C, H> CommandState<C, H>
where C: Connection + AsRawFd, where
C: Connection + AsRawFd,
H: SystemHandler, H: SystemHandler,
{ {
fn poll(self) -> CommandPoll<C, H> { fn poll(self) -> CommandPoll<C, H> {
match self { match self {
CommandState::Running(mut msg_loop, handler) => { CommandState::Running(mut msg_loop, handler) => {
if let Async::Ready((client, msg)) = msg_loop.poll()? { if let Async::Ready((client, msg)) = msg_loop.poll()? {
process_message(client, handler, msg) process_message(client, handler, msg)
} else { } else {
Ok(AsyncS::NotReady(CommandState::Running(msg_loop, handler))) Ok(AsyncS::NotReady(CommandState::Running(msg_loop, handler)))
} }
} }
CommandState::SpawningPager(client, mut fut) => { CommandState::SpawningPager(client, mut fut) => {
if let Async::Ready((handler, pin)) = fut.poll()? { if let Async::Ready((handler, pin)) = fut.poll()? {
let fut = AttachIo::with_client(client, io::stdin(), pin, None); let fut = AttachIo::with_client(client, io::stdin(), pin, None);
Ok(AsyncS::PollAgain(CommandState::AttachingPager(fut, handler))) Ok(AsyncS::PollAgain(CommandState::AttachingPager(
fut, handler,
)))
} else { } else {
Ok(AsyncS::NotReady(CommandState::SpawningPager(client, fut))) Ok(AsyncS::NotReady(CommandState::SpawningPager(client, fut)))
} }
} }
CommandState::AttachingPager(mut fut, handler) => { CommandState::AttachingPager(mut fut, handler) => {
if let Async::Ready(client) = fut.poll()? { if let Async::Ready(client) = fut.poll()? {
let msg_loop = MessageLoop::start(client, b""); // terminator let msg_loop = MessageLoop::start(client, b""); // terminator
Ok(AsyncS::PollAgain(CommandState::Running(msg_loop, handler))) Ok(AsyncS::PollAgain(CommandState::Running(msg_loop, handler)))
} else { } else {
Ok(AsyncS::NotReady(CommandState::AttachingPager(fut, handler))) Ok(AsyncS::NotReady(CommandState::AttachingPager(fut, handler)))
} }
} }
CommandState::WaitingSystem(client, mut fut) => { CommandState::WaitingSystem(client, mut fut) => {
if let Async::Ready((handler, code)) = fut.poll()? { if let Async::Ready((handler, code)) = fut.poll()? {
let data = message::pack_result_code(code); let data = message::pack_result_code(code);
let msg_loop = MessageLoop::resume_with_data(client, data); let msg_loop = MessageLoop::resume_with_data(client, data);
Ok(AsyncS::PollAgain(CommandState::Running(msg_loop, handler))) Ok(AsyncS::PollAgain(CommandState::Running(msg_loop, handler)))
} else { } else {
Ok(AsyncS::NotReady(CommandState::WaitingSystem(client, fut))) Ok(AsyncS::NotReady(CommandState::WaitingSystem(client, fut)))
} }
} }
CommandState::Finished => panic!("poll ChgRunCommand after it's done") CommandState::Finished => panic!("poll ChgRunCommand after it's done"),
} }
} }
} }
fn process_message<C, H>(client: Client<C>, handler: H, msg: ChannelMessage) -> CommandPoll<C, H> fn process_message<C, H>(client: Client<C>, handler: H, msg: ChannelMessage) -> CommandPoll<C, H>
where C: Connection, where
C: Connection,
H: SystemHandler, H: SystemHandler,
{ {
match msg { match msg {
ChannelMessage::Data(b'r', data) => { ChannelMessage::Data(b'r', data) => {
let code = message::parse_result_code(data)?; let code = message::parse_result_code(data)?;
Ok(AsyncS::Ready((client, handler, code))) Ok(AsyncS::Ready((client, handler, code)))
} }
ChannelMessage::Data(..) => { ChannelMessage::Data(..) => {
// just ignores data sent to optional channel // just ignores data sent to optional channel
let msg_loop = MessageLoop::resume(client); let msg_loop = MessageLoop::resume(client);
Ok(AsyncS::PollAgain(CommandState::Running(msg_loop, handler))) Ok(AsyncS::PollAgain(CommandState::Running(msg_loop, handler)))
} }
ChannelMessage::InputRequest(..) | ChannelMessage::LineRequest(..) => { ChannelMessage::InputRequest(..) | ChannelMessage::LineRequest(..) => Err(io::Error::new(
Err(io::Error::new(io::ErrorKind::InvalidData, "unsupported request")) io::ErrorKind::InvalidData,
} "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 => {
let fut = handler.spawn_pager(cmd_spec).into_future(); let fut = handler.spawn_pager(cmd_spec).into_future();
Ok(AsyncS::PollAgain(CommandState::SpawningPager(client, fut))) Ok(AsyncS::PollAgain(CommandState::SpawningPager(client, fut)))
} }
CommandType::System => { CommandType::System => {
let fut = handler.run_system(cmd_spec).into_future(); let fut = handler.run_system(cmd_spec).into_future();
Ok(AsyncS::PollAgain(CommandState::WaitingSystem(client, fut))) Ok(AsyncS::PollAgain(CommandState::WaitingSystem(client, fut)))
} }
} }
} }
} }
} }

rust/chg/src/uihandler.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.
use futures::Future;
use futures::future::IntoFuture; use futures::future::IntoFuture;
use futures::Future;
use std::io; use std::io;
use std::os::unix::io::AsRawFd; use std::os::unix::io::AsRawFd;
use std::os::unix::process::ExitStatusExt; use std::os::unix::process::ExitStatusExt;
use std::process::{Command, Stdio}; use std::process::{Command, Stdio};
use tokio; use tokio;
use tokio_process::{ChildStdin, CommandExt}; use tokio_process::{ChildStdin, CommandExt};
use super::message::CommandSpec; use super::message::CommandSpec;
/// 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).
fn run_system(self, spec: CommandSpec) -> Self::RunSystemResult; fn run_system(self, spec: CommandSpec) -> Self::RunSystemResult;
} }
/// Default cHg implementation to process requests received from server. /// Default cHg implementation to process requests received from server.
pub struct ChgUiHandler { pub struct ChgUiHandler {}
}
impl ChgUiHandler { impl ChgUiHandler {
pub fn new() -> ChgUiHandler { pub fn new() -> ChgUiHandler {
ChgUiHandler {} ChgUiHandler {}
} }
} }
impl SystemHandler for ChgUiHandler { impl SystemHandler for ChgUiHandler {
type PagerStdin = ChildStdin; type PagerStdin = ChildStdin;
type SpawnPagerResult = io::Result<(Self, Self::PagerStdin)>; type SpawnPagerResult = io::Result<(Self, Self::PagerStdin)>;
type RunSystemResult = Box<dyn Future<Item = (Self, i32), Error = io::Error> + Send>; type RunSystemResult = Box<dyn Future<Item = (Self, i32), Error = io::Error> + Send>;
fn spawn_pager(self, spec: CommandSpec) -> Self::SpawnPagerResult { fn spawn_pager(self, spec: CommandSpec) -> Self::SpawnPagerResult {
let mut pager = new_shell_command(&spec) let mut pager = new_shell_command(&spec)
.stdin(Stdio::piped()) .stdin(Stdio::piped())
.spawn_async()?; .spawn_async()?;
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);
tokio::spawn(pager.map(|_| ()).map_err(|_| ())); // just ignore errors tokio::spawn(pager.map(|_| ()).map_err(|_| ())); // just ignore errors
Ok((self, pin)) Ok((self, pin))
} }
fn run_system(self, spec: CommandSpec) -> Self::RunSystemResult { fn run_system(self, spec: CommandSpec) -> Self::RunSystemResult {
let fut = new_shell_command(&spec) let fut = new_shell_command(&spec)
.spawn_async() .spawn_async()
.into_future() .into_future()
.flatten() .flatten()
.map(|status| { .map(|status| {
let code = status.code().or_else(|| status.signal().map(|n| -n)) let code = status
.code()
.or_else(|| status.signal().map(|n| -n))
.expect("either exit code or signal should be set"); .expect("either exit code or signal should be set");
(self, code) (self, code)
}); });
Box::new(fut) Box::new(fut)
} }
} }
fn new_shell_command(spec: &CommandSpec) -> Command { fn new_shell_command(spec: &CommandSpec) -> Command {
let mut builder = Command::new("/bin/sh"); let mut builder = Command::new("/bin/sh");
builder builder
.arg("-c") .arg("-c")
.arg(&spec.command) .arg(&spec.command)
.current_dir(&spec.current_dir) .current_dir(&spec.current_dir)
.env_clear() .env_clear()
.envs(spec.envs.iter().cloned()); .envs(spec.envs.iter().cloned());
builder builder
} }

rust/hg-core/src/dirstate/status.rs

} }
pub struct StatusResult<'a> { pub struct StatusResult<'a> {
pub modified: Vec<&'a HgPath>, pub modified: Vec<&'a HgPath>,
pub added: Vec<&'a HgPath>, pub added: Vec<&'a HgPath>,
pub removed: Vec<&'a HgPath>, pub removed: Vec<&'a HgPath>,
pub deleted: Vec<&'a HgPath>, pub deleted: Vec<&'a HgPath>,
pub clean: Vec<&'a HgPath>, pub clean: Vec<&'a HgPath>,
// TODO ignored /* TODO ignored
// TODO unknown * TODO unknown */
} }
fn build_response( fn build_response(
results: Vec<(&HgPath, Dispatch)>, results: Vec<(&HgPath, Dispatch)>,
) -> (Vec<&HgPath>, StatusResult) { ) -> (Vec<&HgPath>, StatusResult) {
let mut lookup = vec![]; let mut lookup = vec![];
let mut modified = vec![]; let mut modified = vec![];
let mut added = vec![]; let mut added = vec![];

rust/hg-cpython/src/dirstate/status.rs

// status.rs // status.rs
// //
// Copyright 2019, Raphaël Gomès <rgomes@octobus.net> // Copyright 2019, Raphaël Gomès <rgomes@octobus.net>
// //
// 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.
//! Bindings for the `hg::status` module provided by the //! Bindings for the `hg::status` module provided by the
//! `hg-core` crate. From Python, this will be seen as //! `hg-core` crate. From Python, this will be seen as
//! `rustext.dirstate.status`. //! `rustext.dirstate.status`.
//!
use crate::dirstate::DirstateMap; use crate::dirstate::DirstateMap;
use cpython::exc::ValueError; use cpython::exc::ValueError;
use cpython::{ use cpython::{
PyBytes, PyErr, PyList, PyObject, PyResult, Python, PythonObject, PyBytes, PyErr, PyList, PyObject, PyResult, Python, PythonObject,
ToPyObject, ToPyObject,
}; };
use hg::utils::files::get_path_from_bytes; use hg::utils::files::get_path_from_bytes;

rust/hg-cpython/src/filepatterns.rs

// filepatterns.rs // filepatterns.rs
// //
// Copyright 2019, Georges Racinet <gracinet@anybox.fr>, // Copyright 2019, Georges Racinet <gracinet@anybox.fr>,
// Raphaël Gomès <rgomes@octobus.net> // Raphaël Gomès <rgomes@octobus.net>
// //
// 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.
//! Bindings for the `hg::filepatterns` module provided by the //! Bindings for the `hg::filepatterns` module provided by the
//! `hg-core` crate. From Python, this will be seen as `rustext.filepatterns` //! `hg-core` crate. From Python, this will be seen as `rustext.filepatterns`
//! and can be used as replacement for the the pure `filepatterns` Python //! and can be used as replacement for the the pure `filepatterns` Python
//! module. //! module.
//!
use crate::exceptions::{PatternError, PatternFileError}; use crate::exceptions::{PatternError, PatternFileError};
use cpython::{ use cpython::{
PyBytes, PyDict, PyModule, PyObject, PyResult, PyTuple, Python, ToPyObject, PyBytes, PyDict, PyModule, PyObject, PyResult, PyTuple, Python, ToPyObject,
}; };
use hg::utils::files; use hg::utils::files;
use hg::{build_single_regex, read_pattern_file, LineNumber, PatternTuple}; use hg::{build_single_regex, read_pattern_file, LineNumber, PatternTuple};
use std::path::PathBuf; use std::path::PathBuf;

rust/hg-cpython/src/parsers.rs

// parsers.rs // parsers.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// 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.
//! Bindings for the `hg::dirstate::parsers` module provided by the //! Bindings for the `hg::dirstate::parsers` module provided by the
//! `hg-core` package. //! `hg-core` package.
//! //!
//! From Python, this will be seen as `mercurial.rustext.parsers` //! From Python, this will be seen as `mercurial.rustext.parsers`
//!
use cpython::{ use cpython::{
exc, PyBytes, PyDict, PyErr, PyInt, PyModule, PyResult, PyTuple, Python, exc, PyBytes, PyDict, PyErr, PyInt, PyModule, PyResult, PyTuple, Python,
PythonObject, ToPyObject, PythonObject, ToPyObject,
}; };
use hg::{ use hg::{
pack_dirstate, parse_dirstate, utils::hg_path::HgPathBuf, pack_dirstate, parse_dirstate, utils::hg_path::HgPathBuf,
DirstatePackError, DirstateParents, DirstateParseError, PARENT_SIZE, DirstatePackError, DirstateParents, DirstateParseError, PARENT_SIZE,
}; };

rust/hgcli/build.rs

struct PythonConfig { struct PythonConfig {
python: String, python: String,
config: HashMap<String, String>, config: HashMap<String, String>,
} }
fn get_python_config() -> PythonConfig { fn get_python_config() -> PythonConfig {
// The python27-sys crate exports a Cargo variable defining the full // The python27-sys crate exports a Cargo variable defining the full
// path to the interpreter being used. // path to the interpreter being used.
let python = env::var("DEP_PYTHON27_PYTHON_INTERPRETER").expect( let python = env::var("DEP_PYTHON27_PYTHON_INTERPRETER")
"Missing DEP_PYTHON27_PYTHON_INTERPRETER; bad python27-sys crate?", .expect("Missing DEP_PYTHON27_PYTHON_INTERPRETER; bad python27-sys crate?");
);
if !Path::new(&python).exists() { if !Path::new(&python).exists() {
panic!( panic!(
"Python interpreter {} does not exist; this should never happen", "Python interpreter {} does not exist; this should never happen",
python python
); );
} }
// This is a bit hacky but it gets the job done. // This is a bit hacky but it gets the job done.
let separator = "SEPARATOR STRING"; let separator = "SEPARATOR STRING";
let script = "import sysconfig; \ let script = "import sysconfig; \
c = sysconfig.get_config_vars(); \ c = sysconfig.get_config_vars(); \
print('SEPARATOR STRING'.join('%s=%s' % i for i in c.items()))"; print('SEPARATOR STRING'.join('%s=%s' % i for i in c.items()))";
let mut command = Command::new(&python); let mut command = Command::new(&python);
command.arg("-c").arg(script); command.arg("-c").arg(script);
let out = command.output().unwrap(); let out = command.output().unwrap();
if !out.status.success() { if !out.status.success() {
panic!( panic!(

rust/hgcli/src/main.rs

// main.rs -- Main routines for `hg` program // main.rs -- Main routines for `hg` program
// //
// Copyright 2017 Gregory Szorc <gregory.szorc@gmail.com> // Copyright 2017 Gregory Szorc <gregory.szorc@gmail.com>
// //
// 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 libc;
extern crate cpython; extern crate cpython;
extern crate libc;
extern crate python27_sys; extern crate python27_sys;
use cpython::{NoArgs, ObjectProtocol, PyModule, PyResult, Python}; use cpython::{NoArgs, ObjectProtocol, PyModule, PyResult, Python};
use libc::{c_char, c_int}; use libc::{c_char, c_int};
use std::env; use std::env;
use std::path::PathBuf;
use std::ffi::{CString, OsStr}; use std::ffi::{CString, OsStr};
#[cfg(target_family = "unix")] #[cfg(target_family = "unix")]
use std::os::unix::ffi::{OsStrExt, OsStringExt}; use std::os::unix::ffi::{OsStrExt, OsStringExt};
use std::path::PathBuf;
#[derive(Debug)] #[derive(Debug)]
struct Environment { struct Environment {
_exe: PathBuf, _exe: PathBuf,
python_exe: PathBuf, python_exe: PathBuf,
python_home: PathBuf, python_home: PathBuf,
mercurial_modules: PathBuf, mercurial_modules: PathBuf,
} }