This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3447

rust: make exit handling consistent with `hg`
AcceptedPublic

Authored by indygreg on May 6 2018, 12:11 AM.

Details

Reviewers
kevincox
durin42
Group Reviewers
hg-reviewers
Summary

Now that dispatch.run() handles special exit cases and always returns
an exit code, Rust's (formerly lacking) invocation of dispatch.run() can
handle the return value with minimal hassle.

In addition, we change Rust to exit 1 instead of 255 in the case
of unhandled errors, as that is actually what Python does.

This fixes a few test failures when running the test suite with rhg.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.May 6 2018, 12:11 AM
kevincox accepted this revision.May 6 2018, 3:51 AM
kevincox added inline comments.
rust/hgcli/src/main.rs
204

s/unreachable/panic/ since the code can never be hit as long as the python code returns the right type.

Also it might be a good idea to try to print out the value returned in the error message. Although if not easy it is probably not worth it.

durin42 accepted this revision.May 31 2018, 3:07 PM
This revision is now accepted and ready to land.May 31 2018, 3:07 PM

Revision Contents
Changeset List

PathPackages
Mrust/hgcli/src/main.rs (22 lines)

Diff 8462

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 libc;
extern crate cpython; extern crate cpython;
extern crate python27_sys; extern crate python27_sys;
use cpython::{NoArgs, ObjectProtocol, PyModule, PyResult, Python}; use cpython::{NoArgs, ObjectProtocol, PyModule, PyObject, 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::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};
let py = gil.python(); let py = gil.python();
// Mercurial code could call sys.exit(), which will call exit() // Mercurial code could call sys.exit(), which will call exit()
// itself. So this may not return. // itself. So this may not return.
// TODO this may cause issues on Windows due to the CRT mismatch. // TODO this may cause issues on Windows due to the CRT mismatch.
// Investigate if we can intercept sys.exit() or SystemExit() to // Investigate if we can intercept sys.exit() or SystemExit() to
// ensure we handle process exit. // ensure we handle process exit.
result = match run_py(&env, py) { result = match run_py(&env, py) {
// Print unhandled exceptions and exit code 255, as this is what // Print unhandled exceptions and exit code 1, as this is what
// `python` does. // `python` does.
Err(err) => { Err(err) => {
err.print(py); err.print(py);
Err(255) Err(1)
}
Ok(value) => {
// dispatch.run() should return an integer exit code
// between 0 and 255, inclusive.
let code = match value.extract::<i32>(py) {
Ok(value) => value,
Err(_) => panic!("non-integer value returned by dispatch.run()"),
kevincoxUnsubmitted
Not Done

s/unreachable/panic/ since the code can never be hit as long as the python code returns the right type.

Also it might be a good idea to try to print out the value returned in the error message. Although if not easy it is probably not worth it.

kevincox: s/unreachable/panic/ since the code can never be hit as long as the python code returns the…
};
Err(code)
} }
Ok(()) => Ok(()),
}; };
} }
unsafe { unsafe {
python27_sys::Py_Finalize(); python27_sys::Py_Finalize();
} }
result result
} }
fn run_py(env: &Environment, py: Python) -> PyResult<()> { fn run_py(env: &Environment, py: Python) -> PyResult<PyObject> {
let sys_mod = py.import("sys").unwrap(); let sys_mod = py.import("sys").unwrap();
update_encoding(py, &sys_mod); update_encoding(py, &sys_mod);
update_modules_path(&env, py, &sys_mod); update_modules_path(&env, py, &sys_mod);
// TODO consider a better error message on failure to import. // TODO consider a better error message on failure to import.
let demand_mod = py.import("hgdemandimport")?; let demand_mod = py.import("hgdemandimport")?;
demand_mod.call(py, "enable", NoArgs, None)?; demand_mod.call(py, "enable", NoArgs, None)?;
let dispatch_mod = py.import("mercurial.dispatch")?; let dispatch_mod = py.import("mercurial.dispatch")?;
dispatch_mod.call(py, "run", NoArgs, None)?; dispatch_mod.call(py, "run", NoArgs, None)
Ok(())
} }
fn main() { fn main() {
let exit_code = match run() { let exit_code = match run() {
Err(err) => err, Err(err) => err,
Ok(()) => 0, Ok(()) => 0,
}; };
std::process::exit(exit_code); std::process::exit(exit_code);
} }