PanicHandler - work in progress

util/src/lib.rs

@@ -21,6 +21,7 @@
 #![feature(plugin)]
 #![plugin(clippy)]
 #![allow(needless_range_loop, match_bool)]
+#![feature(std_panic, recover)]
 //! Ethcore-util library
 //!
 //! ### Rust version:
@@ -129,6 +130,7 @@ pub mod semantic_version;
 pub mod io;
 pub mod network;
 pub mod log;
+pub mod panics;
 
 pub use common::*;
 pub use misc::*;

util/src/panics.rs

@@ -0,0 +1,148 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// 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::panic;
+use std::sync::Mutex;
+use std::any::Any;
+use std::ops::DerefMut;
+
+pub trait OnPanicListener<T>: Send + Sync + 'static {
+	fn call(&mut self, arg: &T);
+}
+
+impl<F, T> OnPanicListener<T> for F
+	where F: FnMut(&T) + Send + Sync + 'static {
+	fn call(&mut self, arg: &T) {
+		self(arg)
+	}
+}
+
+pub trait ArgsConverter<T> {
+	fn convert(&self, t: &Box<Any + Send>) -> Option<T>;
+}
+
+pub trait MayPanic<T> {
+	fn on_panic<F>(&mut self, closure: F)
+		where F: OnPanicListener<T>;
+}
+
+pub trait PanicHandler<T, C: ArgsConverter<T>> : MayPanic<T>{
+	fn new(converter: C) -> Self;
+	fn catch_panic<G, R>(&mut self, g: G) -> thread::Result<R>
+		where G: FnOnce() -> R + panic::RecoverSafe;
+}
+
+
+pub struct StringConverter;
+impl ArgsConverter<String> for StringConverter {
+	fn convert(&self, t: &Box<Any + Send>) -> Option<String> {
+		t.downcast_ref::<&'static str>().map(|t| t.clone().to_owned())
+	}
+}
+
+pub struct BasePanicHandler<T, C>
+	where C: ArgsConverter<T>, T: 'static {
+	converter: C,
+	listeners: Mutex<Vec<Box<OnPanicListener<T>>>>
+}
+
+impl<T, C> BasePanicHandler<T, C>
+	where C: ArgsConverter<T>, T: 'static {
+	fn notify_all(&mut self, res: Option<T>) {
+		if let None = res {
+			return;
+		}
+		let r = res.unwrap();
+		let mut listeners = self.listeners.lock().unwrap();
+		for listener in listeners.deref_mut() {
+			listener.call(&r);
+		}
+	}
+}
+
+impl<T, C> PanicHandler<T, C> for BasePanicHandler<T, C>
+	where C: ArgsConverter<T>, T: 'static {
+
+	fn new(converter: C) -> Self {
+		BasePanicHandler {
+			converter: converter,
+			listeners: Mutex::new(vec![])
+		}
+	}
+
+	fn catch_panic<G, R>(&mut self, g: G) -> thread::Result<R>
+		where G: FnOnce() -> R + panic::RecoverSafe {
+			let result = panic::recover(g);
+
+			println!("After calling function");
+			if let Err(ref e) = result {
+				let res = self.converter.convert(e);
+				println!("Got error. Notifying");
+				self.notify_all(res);
+			}
+
+			result
+		}
+}
+
+impl<T, C> MayPanic<T> for BasePanicHandler<T, C>
+	where C: ArgsConverter<T>, T: 'static {
+	fn on_panic<F>(&mut self, closure: F)
+		where F: OnPanicListener<T> {
+		self.listeners.lock().unwrap().push(Box::new(closure));
+	}
+}
+
+#[test]
+fn should_notify_listeners_about_panic () {
+	use std::sync::{Arc, RwLock};
+
+	// given
+	let invocations = Arc::new(RwLock::new(vec![]));
+	let i = invocations.clone();
+	let mut p = BasePanicHandler::new(StringConverter);
+	p.on_panic(move |t: &String| i.write().unwrap().push(t.clone()));
+
+	// when
+	p.catch_panic(|| panic!("Panic!"));
+
+	// then
+	assert!(invocations.read().unwrap()[0] == "Panic!");
+}
+
+#[test]
+fn should_notify_listeners_about_panic_in_other_thread () {
+	use std::thread;
+	use std::sync::{Arc, RwLock};
+
+	// given
+	let invocations = Arc::new(RwLock::new(vec![]));
+	let i = invocations.clone();
+	let mut p = BasePanicHandler::new(StringConverter);
+	p.on_panic(move |t: &String| i.write().unwrap().push(t.clone()));
+
+	// when
+	let t = thread::spawn(move ||
+		p.catch_panic(|| panic!("Panic!"))
+	);
+	t.join();
+
+	// then
+	assert!(invocations.read().unwrap()[0] == "Panic!");
+}