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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 20994

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()
}
} }