This is an archive of the discontinued Mercurial Phabricator instance.

			Path	Packages
M			rust/chg/src/attachio.rs (55 lines)
M			rust/chg/src/clientext.rs (42 lines)
M			rust/chg/src/locator.rs (32 lines)
M			rust/chg/src/main.rs (36 lines)
M			rust/chg/src/message.rs (44 lines)
M			rust/chg/src/procutil.rs (2 lines)
M			rust/chg/src/runcommand.rs (50 lines)
M			rust/chg/src/uihandler.rs (13 lines)
M			rust/hg-core/src/dirstate/status.rs (4 lines)
M			rust/hg-cpython/src/dirstate/status.rs (1 line)
M			rust/hg-cpython/src/filepatterns.rs (1 line)
M			rust/hg-cpython/src/parsers.rs (1 line)
M			rust/hgcli/build.rs (9 lines)
M			rust/hgcli/src/main.rs (4 lines)

	Status	Author	Revision
	Closed	indygreg	D7579 tests: add test for Rust formatting
	Closed	indygreg	D7578 rust: run rustfmt

Diff 18569

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,
	}			}

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	18538		Dec 7 2019, 4:11 PM	★	★
Diff 2	18569	rHGce088b38f92b6d480df2072dc45fb068443758dd	Dec 7 2019, 4:06 PM	★	★

This is an archive of the discontinued Mercurial Phabricator instance.

rust: run rustfmtClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 18569

rust/chg/src/attachio.rs

rust/chg/src/clientext.rs

rust/chg/src/locator.rs

rust/chg/src/main.rs

rust/chg/src/message.rs

rust/chg/src/procutil.rs

rust/chg/src/runcommand.rs

rust/chg/src/uihandler.rs

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

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

rust/hg-cpython/src/filepatterns.rs

rust/hg-cpython/src/parsers.rs

rust/hgcli/build.rs

rust/hgcli/src/main.rs

rust: run rustfmt
ClosedPublic

Revision Contents
Changeset List