openethereum/util/io/src/panics.rs

192 lines
4.9 KiB
Rust
Raw Normal View History

// Copyright 2015-2017 Parity Technologies (UK) Ltd.
2016-02-09 16:47:21 +01:00
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
//! Panic utilities
use std::thread;
use std::sync::Arc;
2016-03-11 10:57:58 +01:00
use std::default::Default;
use parking_lot::Mutex;
2016-02-09 16:47:21 +01:00
2016-02-10 15:28:43 +01:00
/// Thread-safe closure for handling possible panics
pub trait OnPanicListener: Send + Sync + 'static {
/// Invoke listener
fn call(&mut self, arg: &str);
2016-02-09 16:47:21 +01:00
}
2016-02-10 16:35:52 +01:00
/// Forwards panics from child
pub trait ForwardPanic {
/// Attach `on_panic` listener to `child` and rethrow all panics
fn forward_from<S>(&self, child: &S) where S : MayPanic;
}
2016-02-10 15:28:43 +01:00
/// Trait indicating that the structure catches some of the panics (most probably from spawned threads)
/// and it's possbile to be notified when one of the threads panics.
pub trait MayPanic {
/// `closure` will be invoked whenever panic in thread is caught
2016-02-10 16:35:52 +01:00
fn on_panic<F>(&self, closure: F) where F: OnPanicListener;
2016-02-09 16:47:21 +01:00
}
2016-02-18 23:29:41 +01:00
struct PanicGuard<'a> {
handler: &'a PanicHandler,
}
impl<'a> Drop for PanicGuard<'a> {
fn drop(&mut self) {
if thread::panicking() {
self.handler.notify_all("Panic!".to_owned());
}
}
}
2016-02-10 15:28:43 +01:00
/// Structure that allows to catch panics and notify listeners
pub struct PanicHandler {
listeners: Mutex<Vec<Box<OnPanicListener>>>
}
2016-02-09 16:47:21 +01:00
2016-03-11 10:57:58 +01:00
impl Default for PanicHandler {
fn default() -> Self {
PanicHandler::new()
}
}
2016-02-10 15:28:43 +01:00
impl PanicHandler {
/// Creates new `PanicHandler` wrapped in `Arc`
2016-03-11 10:57:58 +01:00
pub fn new_in_arc() -> Arc<Self> {
2016-02-10 15:28:43 +01:00
Arc::new(Self::new())
2016-02-09 16:47:21 +01:00
}
2016-02-10 15:28:43 +01:00
/// Creates new `PanicHandler`
2016-03-11 10:57:58 +01:00
pub fn new() -> Self {
2016-02-10 15:28:43 +01:00
PanicHandler {
2016-02-09 16:47:21 +01:00
listeners: Mutex::new(vec![])
}
}
2016-02-10 15:28:43 +01:00
/// Invoke closure and catch any possible panics.
/// In case of panic notifies all listeners about it.
2016-03-11 11:16:49 +01:00
#[cfg_attr(feature="dev", allow(deprecated))]
2016-02-10 15:28:43 +01:00
pub fn catch_panic<G, R>(&self, g: G) -> thread::Result<R> where G: FnOnce() -> R + Send + 'static {
2016-02-20 11:54:12 +01:00
let _guard = PanicGuard { handler: self };
2016-02-18 23:29:41 +01:00
let result = g();
Ok(result)
}
2016-04-23 12:29:12 +02:00
/// Notifies all listeners in case there is a panic.
/// You should use `catch_panic` instead of calling this method explicitly.
pub fn notify_all(&self, r: String) {
let mut listeners = self.listeners.lock();
for mut listener in &mut **listeners {
2016-02-10 15:28:43 +01:00
listener.call(&r);
2016-02-09 16:47:21 +01:00
}
}
2016-02-09 16:47:21 +01:00
}
2016-02-10 15:28:43 +01:00
impl MayPanic for PanicHandler {
2016-02-10 16:35:52 +01:00
fn on_panic<F>(&self, closure: F) where F: OnPanicListener {
self.listeners.lock().push(Box::new(closure));
2016-02-09 16:47:21 +01:00
}
}
2016-02-10 16:35:52 +01:00
impl ForwardPanic for Arc<PanicHandler> {
fn forward_from<S>(&self, child: &S) where S : MayPanic {
let p = self.clone();
child.on_panic(move |t| p.notify_all(t));
}
}
2016-02-10 15:28:43 +01:00
impl<F> OnPanicListener for F
where F: FnMut(String) + Send + Sync + 'static {
fn call(&mut self, arg: &str) {
self(arg.to_owned())
}
}
2016-02-09 16:47:21 +01:00
#[test]
2016-02-19 11:05:39 +01:00
#[ignore] // panic forwarding doesnt work on the same thread in beta
2016-02-09 16:47:21 +01:00
fn should_notify_listeners_about_panic () {
use parking_lot::RwLock;
2016-02-09 16:47:21 +01:00
// given
let invocations = Arc::new(RwLock::new(vec![]));
let i = invocations.clone();
2016-02-10 15:28:43 +01:00
let p = PanicHandler::new();
p.on_panic(move |t| i.write().push(t));
2016-02-09 16:47:21 +01:00
// when
p.catch_panic(|| panic!("Panic!")).unwrap_err();
2016-02-09 16:47:21 +01:00
// then
assert!(invocations.read()[0] == "Panic!");
2016-02-09 16:47:21 +01:00
}
#[test]
2016-02-19 11:05:39 +01:00
#[ignore] // panic forwarding doesnt work on the same thread in beta
fn should_notify_listeners_about_panic_when_string_is_dynamic () {
use parking_lot::RwLock;
// given
let invocations = Arc::new(RwLock::new(vec![]));
let i = invocations.clone();
2016-02-10 15:28:43 +01:00
let p = PanicHandler::new();
p.on_panic(move |t| i.write().push(t));
// when
p.catch_panic(|| panic!("Panic: {}", 1)).unwrap_err();
// then
assert!(invocations.read()[0] == "Panic: 1");
}
2016-02-09 16:47:21 +01:00
#[test]
fn should_notify_listeners_about_panic_in_other_thread () {
use std::thread;
use parking_lot::RwLock;
2016-02-09 16:47:21 +01:00
// given
let invocations = Arc::new(RwLock::new(vec![]));
let i = invocations.clone();
2016-02-10 15:28:43 +01:00
let p = PanicHandler::new();
p.on_panic(move |t| i.write().push(t));
2016-02-09 16:47:21 +01:00
// when
let t = thread::spawn(move ||
p.catch_panic(|| panic!("Panic!")).unwrap()
2016-02-09 16:47:21 +01:00
);
t.join().unwrap_err();
// then
assert!(invocations.read()[0] == "Panic!");
}
#[test]
2016-02-19 11:05:39 +01:00
#[ignore] // panic forwarding doesnt work on the same thread in beta
fn should_forward_panics () {
use parking_lot::RwLock;
// given
let invocations = Arc::new(RwLock::new(vec![]));
let i = invocations.clone();
2016-02-10 16:35:52 +01:00
let p = PanicHandler::new_in_arc();
p.on_panic(move |t| i.write().push(t));
2016-02-10 15:28:43 +01:00
let p2 = PanicHandler::new();
2016-02-10 16:35:52 +01:00
p.forward_from(&p2);
// when
p2.catch_panic(|| panic!("Panic!")).unwrap_err();
2016-02-09 16:47:21 +01:00
// then
assert!(invocations.read()[0] == "Panic!");
2016-02-09 16:47:21 +01:00
}