This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8378

rust-chg: add helper to parse instructions sent from server
ClosedPublic

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

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHG82adc720c0a3: rust-chg: add helper to parse instructions sent from server
Summary

This is well structured version of runinstructions() of chg.c.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

yuja created this revision.Apr 6 2020, 10:19 AM
Alphare accepted this revision.Apr 8 2020, 4:03 AM
Alphare added a subscriber: Alphare.

I had to squint hard at the c code to find any discrepancy, of which there seems to be none.

pulkit accepted this revision.Apr 9 2020, 6:36 AM
This revision is now accepted and ready to land.Apr 9 2020, 6:36 AM
pulkit added a comment.Apr 9 2020, 6:38 AM

Queued the whole series based on @Alphare review. Many thanks to both of you.

yuja added a commit: rHG82adc720c0a3: rust-chg: add helper to parse instructions sent from server.Apr 9 2020, 3:25 PM
Closed by commit rHG82adc720c0a3: rust-chg: add helper to parse instructions sent from server (authored by yuja). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/chg/src/message.rs (85 lines)

Diff 21016

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::{BufMut, Bytes, BytesMut}; use bytes::{BufMut, Bytes, BytesMut};
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;
use std::path::PathBuf;
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,
b"system" => Ok(CommandType::System), b"system" => Ok(CommandType::System),
_ => Err(new_parse_error(format!( _ => Err(new_parse_error(format!(
"unknown command type: {}", "unknown command type: {}",
decode_latin1(value) decode_latin1(value)
))), ))),
} }
} }
/// Client-side instruction requested by the server.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum Instruction {
Exit(i32),
Reconnect,
Redirect(PathBuf),
Unlink(PathBuf),
}
/// Parses validation result into instructions.
pub fn parse_instructions(data: Bytes) -> io::Result<Vec<Instruction>> {
let mut instructions = Vec::new();
for l in data.split(|&c| c == b'\0') {
if l.is_empty() {
continue;
}
let mut s = l.splitn(2, |&c| c == b' ');
let inst = match (s.next().unwrap(), s.next()) {
(b"exit", Some(arg)) => decode_latin1(arg)
.parse()
.map(Instruction::Exit)
.map_err(|_| new_parse_error(format!("invalid exit code: {:?}", arg)))?,
(b"reconnect", None) => Instruction::Reconnect,
(b"redirect", Some(arg)) => {
Instruction::Redirect(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)));
}
};
instructions.push(inst);
}
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 '='
} }
#[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() {
let src = [
b"exit 123".as_ref(),
b"reconnect".as_ref(),
b"redirect /whatever".as_ref(),
b"unlink /someother".as_ref(),
]
.join(&0);
let insts = vec![
Instruction::Exit(123),
Instruction::Reconnect,
Instruction::Redirect(path_buf_from(b"/whatever")),
Instruction::Unlink(path_buf_from(b"/someother")),
];
assert_eq!(parse_instructions(Bytes::from(src)).unwrap(), insts);
}
#[test]
fn parse_instructions_empty() {
assert_eq!(parse_instructions(Bytes::new()).unwrap(), vec![]);
assert_eq!(
parse_instructions(Bytes::from_static(b"\0")).unwrap(),
vec![]
);
}
#[test]
fn parse_instructions_malformed_exit_code() {
assert!(parse_instructions(Bytes::from_static(b"exit foo")).is_err());
}
#[test]
fn parse_instructions_missing_argument() {
assert!(parse_instructions(Bytes::from_static(b"exit")).is_err());
assert!(parse_instructions(Bytes::from_static(b"redirect")).is_err());
assert!(parse_instructions(Bytes::from_static(b"unlink")).is_err());
}
#[test]
fn parse_instructions_unknown_command() {
assert!(parse_instructions(Bytes::from_static(b"quit 0")).is_err());
}
#[test]
fn pack_env_vars_os_good() { fn pack_env_vars_os_good() {
assert_eq!( assert_eq!(
pack_env_vars_os(vec![] as Vec<(OsString, OsString)>), pack_env_vars_os(vec![] as Vec<(OsString, OsString)>),
Bytes::new() Bytes::new()
); );
assert_eq!( assert_eq!(
pack_env_vars_os(vec![os_string_pair_from(b"FOO", b"bar")]), pack_env_vars_os(vec![os_string_pair_from(b"FOO", b"bar")]),
Bytes::from_static(b"FOO=bar") Bytes::from_static(b"FOO=bar")
fn os_string_from(s: &[u8]) -> OsString { fn os_string_from(s: &[u8]) -> OsString {
OsString::from_vec(s.to_vec()) OsString::from_vec(s.to_vec())
} }
fn os_string_pair_from(k: &[u8], v: &[u8]) -> (OsString, OsString) { fn os_string_pair_from(k: &[u8], v: &[u8]) -> (OsString, OsString) {
(os_string_from(k), os_string_from(v)) (os_string_from(k), os_string_from(v))
} }
fn path_buf_from(s: &[u8]) -> PathBuf {
os_string_from(s).into()
}
} }