diff --git a/src/action.rs b/src/action.rs
new file mode 100644
index 0000000..ac0d04b
--- /dev/null
+++ b/src/action.rs
@@ -0,0 +1,10 @@
+use state::State;
+use dispatcher::response::ResponseSender;
+use context::base::BaseContext;
+
+pub use config::action::message::Alert;
+
+pub trait Action {
+    fn on_opened(&self, state: &State, context: &BaseContext, &mut ResponseSender);
+    fn on_closed(&self, state: &State, context: &BaseContext, &mut ResponseSender);
+}
diff --git a/src/action/message/mod.rs b/src/action/message/mod.rs
deleted file mode 100644
index ce02a78..0000000
--- a/src/action/message/mod.rs
+++ /dev/null
@@ -1,151 +0,0 @@
-use action::Action;
-use config;
-use config::action::ExecCondition;
-use config::action::message::InjectMode;
-use context::base::BaseContext;
-use dispatcher::Response;
-use dispatcher::response::ResponseSender;
-use message::{Message, MessageBuilder};
-
-use handlebars::{Context, Handlebars};
-use std::borrow::Borrow;
-use std::collections::BTreeMap;
-use state::State;
-use self::error::Error;
-use self::renderer_context::RendererContext;
-
-mod error;
-mod renderer_context;
-#[cfg(test)]
-mod test;
-
-pub const CONTEXT_UUID: &'static str = "context_uuid";
-pub const CONTEXT_NAME: &'static str = "context_name";
-pub const CONTEXT_LEN: &'static str = "context_len";
-pub const MESSAGES: &'static str = "messages";
-const MESSAGE: &'static str = "MESSAGE";
-
-pub struct MessageAction {
-    sender: Box<ResponseSender<Response>>,
-    uuid: String,
-    name: Option<String>,
-    values: Handlebars,
-    when: ExecCondition,
-    inject_mode: InjectMode,
-}
-
-impl MessageAction {
-    pub fn new(sender: Box<ResponseSender<Response>>,
-               action: config::action::MessageAction)
-               -> MessageAction {
-        let config::action::MessageAction { uuid, name, message, values, when, inject_mode } =
-            action;
-        let mut handlebars = Handlebars::new();
-        for (name, template) in values.into_iter() {
-            handlebars.register_template(&name, template);
-        }
-        handlebars.register_template(MESSAGE, message);
-
-        MessageAction {
-            sender: sender,
-            uuid: uuid,
-            name: name,
-            values: handlebars,
-            when: when,
-            inject_mode: inject_mode,
-        }
-    }
-
-    fn render_value(&self, key: &String, template_context: &Context) -> Result<String, Error> {
-        let mut writer = Vec::new();
-        {
-            try!(self.values.renderw(key, &template_context, &mut writer));
-        }
-        let string = try!(String::from_utf8(writer));
-        Ok(string)
-    }
-
-    fn render_values(&self, template_context: &Context) -> Result<BTreeMap<String, String>, Error> {
-        let mut rendered_values = BTreeMap::new();
-        for (key, _) in self.values.get_templates() {
-            let rendered_value = try!(self.render_value(key, &template_context));
-            rendered_values.insert(key.to_string(), rendered_value);
-        }
-        Ok(rendered_values)
-    }
-
-    fn render_message(&self, state: &State, context: &BaseContext) -> Result<Message, Error> {
-        let template_context = {
-            use handlebars::Context;
-            let context = RendererContext::new(state, context);
-            Context::wraps(&context)
-        };
-
-        let mut rendered_values = try!(self.render_values(&template_context));
-        MessageAction::extend_with_context_information(&mut rendered_values, state, context);
-        let message = rendered_values.remove(MESSAGE)
-                                     .expect(&format!("There is no '{}' key in the renderer \
-                                                       key-value pairs",
-                                                      MESSAGE));
-        let name = self.name.as_ref().map(|name| name.borrow());
-        let message = MessageBuilder::new(&self.uuid, message)
-                          .name(name)
-                          .values(rendered_values)
-                          .build();
-        Ok(message)
-    }
-
-    fn extend_with_context_information(values: &mut BTreeMap<String, String>,
-                                       state: &State,
-                                       context: &BaseContext) {
-        values.insert(CONTEXT_UUID.to_string(),
-                      context.uuid().to_hyphenated_string());
-        values.insert(CONTEXT_LEN.to_string(), state.messages().len().to_string());
-        if let Some(name) = context.name() {
-            values.insert(CONTEXT_NAME.to_string(), name.to_string());
-        }
-    }
-
-    fn execute(&self, _state: &State, _context: &BaseContext) {
-        match self.render_message(_state, _context) {
-            Ok(message) => {
-                let response = Alert {
-                    message: message,
-                    inject_mode: self.inject_mode.clone(),
-                };
-                self.sender.send_response(Response::Alert(response));
-            }
-            Err(error) => {
-                error!("{}", error);
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Alert {
-    message: Message,
-    inject_mode: InjectMode,
-}
-
-impl Alert {
-    pub fn message(&self) -> &Message {
-        &self.message
-    }
-}
-
-impl Action for MessageAction {
-    fn on_opened(&self, _state: &State, _context: &BaseContext) {
-        if self.when.on_opened {
-            trace!("MessageAction: on_opened()");
-            self.execute(_state, _context);
-        }
-    }
-
-    fn on_closed(&self, _state: &State, _context: &BaseContext) {
-        if self.when.on_closed {
-            trace!("MessageAction: on_closed()");
-            self.execute(_state, _context);
-        }
-    }
-}
diff --git a/src/action/message/test.rs b/src/action/message/test.rs
deleted file mode 100644
index fe8de11..0000000
--- a/src/action/message/test.rs
+++ /dev/null
@@ -1,127 +0,0 @@
-use context::base::BaseContextBuilder;
-use super::{CONTEXT_LEN, CONTEXT_NAME, CONTEXT_UUID, MessageAction};
-
-use conditions::ConditionsBuilder;
-use config;
-use dispatcher::Response;
-use dispatcher::response::ResponseSender;
-use message::MessageBuilder;
-use state::State;
-
-use env_logger;
-use handlebars::Template;
-use std::cell::RefCell;
-use std::time::Duration;
-use std::rc::Rc;
-use uuid::Uuid;
-
-#[derive(Clone)]
-struct DummyResponseSender {
-    responses: Rc<RefCell<Vec<Response>>>,
-}
-
-impl ResponseSender<Response> for DummyResponseSender {
-    fn send_response(&self, response: Response) {
-        self.responses.borrow_mut().push(response);
-    }
-
-    fn boxed_clone(&self) -> Box<ResponseSender<Response>> {
-        Box::new(self.clone())
-    }
-}
-
-#[test]
-fn test_given_dummy_response_handler_can_be_cloned() {
-    let responses = Rc::new(RefCell::new(Vec::new()));
-    let response_sender = DummyResponseSender { responses: responses.clone() };
-    let _ = response_sender.boxed_clone();
-}
-
-#[test]
-fn test_given_a_message_action_when_it_is_executed_then_it_adds_the_name_and_uuid_of_the_context_to_the_message
-    () {
-    let name = Some("name".to_string());
-    let base_context = {
-        let conditions = ConditionsBuilder::new(Duration::from_millis(100)).build();
-        let uuid = Uuid::new_v4();
-        BaseContextBuilder::new(uuid, conditions).name(name.clone()).build()
-    };
-    let state = State::new();
-    let responses = Rc::new(RefCell::new(Vec::new()));
-    let message_action = {
-        let response_sender = DummyResponseSender { responses: responses.clone() };
-        let message = Template::compile("message".to_string())
-                          .ok()
-                          .expect("Failed to compile a handlebars template");
-        let config_action = config::action::message::MessageActionBuilder::new("uuid", message)
-                                .build();
-        MessageAction::new(Box::new(response_sender), config_action)
-    };
-
-    message_action.execute(&state, &base_context);
-    assert_eq!(1, responses.borrow().len());
-    let responses = responses.borrow();
-    if let &Response::Alert(ref response) = responses.get(0).unwrap() {
-        assert_eq!(name.as_ref().unwrap(),
-                   response.message().get(CONTEXT_NAME).unwrap());
-        assert_eq!(&base_context.uuid().to_hyphenated_string(),
-                   response.message().get(CONTEXT_UUID).unwrap());
-        assert_eq!("0", response.message().get(CONTEXT_LEN).unwrap());
-    } else {
-        unreachable!();
-    }
-}
-
-#[test]
-fn test_given_message_action_when_it_is_executed_then_it_uses_the_messages_to_render_the_message_and_additonal_templated_values
-    () {
-    let _ = env_logger::init();
-    let name = Some("name".to_string());
-    let base_context = {
-        let conditions = ConditionsBuilder::new(Duration::from_millis(100)).build();
-        let uuid = Uuid::new_v4();
-        BaseContextBuilder::new(uuid, conditions).name(name.clone()).build()
-    };
-    let state = {
-        let messages = vec![Rc::new(MessageBuilder::new("uuid1", "message1")
-                                        .pair("key1", "value1")
-                                        .build()),
-                            Rc::new(MessageBuilder::new("uuid2", "message2")
-                                        .pair("key2", "value2")
-                                        .build())];
-        State::with_messages(messages)
-    };
-    let responses = Rc::new(RefCell::new(Vec::new()));
-    let message_action = {
-        let response_sender = DummyResponseSender { responses: responses.clone() };
-        let message = Template::compile("key1={{{messages.[0].values.key1}}} \
-                                         key2={{{messages.[1].values.key2}}}"
-                                            .to_string())
-                          .ok()
-                          .expect("Failed to compile a handlebars template");
-        let config_action = config::action::message::MessageActionBuilder::new("uuid", message)
-                                .pair("message_num",
-                                      Template::compile("we have {{context_len}} messages"
-                                                            .to_string())
-                                          .ok()
-                                          .expect("Failed to compile a handlebars template"))
-                                .build();
-        MessageAction::new(Box::new(response_sender), config_action)
-    };
-
-    message_action.execute(&state, &base_context);
-    assert_eq!(1, responses.borrow().len());
-    let responses = responses.borrow();
-    if let &Response::Alert(ref response) = responses.get(0).unwrap() {
-        assert_eq!(name.as_ref().unwrap(),
-                   response.message().get(CONTEXT_NAME).unwrap());
-        assert_eq!(&base_context.uuid().to_hyphenated_string(),
-                   response.message().get(CONTEXT_UUID).unwrap());
-        let message = response.message();
-        assert_eq!("we have 2 messages",
-                   message.get("message_num").expect("Failed to get an inserted key from a map"));
-        assert_eq!("key1=value1 key2=value2", message.message());
-    } else {
-        unreachable!();
-    }
-}
diff --git a/src/action/mod.rs b/src/action/mod.rs
deleted file mode 100644
index 1ab83da..0000000
--- a/src/action/mod.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use config::action::ActionType;
-use state::State;
-use dispatcher::Response;
-use dispatcher::response::ResponseSender;
-use context::base::BaseContext;
-
-pub mod message;
-
-pub use self::message::Alert;
-
-pub trait Action {
-    fn on_opened(&self, state: &State, context: &BaseContext);
-    fn on_closed(&self, state: &State, context: &BaseContext);
-}
-
-pub fn from_config(config: ActionType, _sender: Box<ResponseSender<Response>>) -> Box<Action> {
-    match config {
-        ActionType::Message(action) => Box::new(self::message::MessageAction::new(_sender, action)),
-    }
-}
diff --git a/src/bin/test.rs b/src/bin/test.rs
index 01b0349..c836370 100644
--- a/src/bin/test.rs
+++ b/src/bin/test.rs
@@ -3,7 +3,8 @@ extern crate maplit;
 extern crate correlation;
 extern crate uuid;
 
-use correlation::{config, Correlator};
+use correlation::Correlator;
+use correlation::config::ContextConfigBuilder;
 use correlation::conditions::ConditionsBuilder;
 use correlation::message::MessageBuilder;
 use uuid::Uuid;
@@ -25,11 +26,10 @@ fn main() {
                         .first_opens(true)
                         .last_closes(true)
                         .build();
-    let actions = vec![];
     let contexts = vec![
-        config::ContextBuilder::new(Uuid::new_v4(), condition.clone()).actions(actions.clone()).build(),
-        config::ContextBuilder::new(Uuid::new_v4(), condition.clone()).actions(actions.clone()).build(),
-        config::ContextBuilder::new(Uuid::new_v4(), condition.clone()).actions(actions.clone()).build(),
+        ContextConfigBuilder::new(Uuid::new_v4(), condition.clone()).actions(Vec::new()).build(),
+        ContextConfigBuilder::new(Uuid::new_v4(), condition.clone()).actions(Vec::new()).build(),
+        ContextConfigBuilder::new(Uuid::new_v4(), condition.clone()).actions(Vec::new()).build(),
     ];
     let mut correlator = Correlator::new(contexts);
     let _ = correlator.push_message(MessageBuilder::new(&uuid1, "message").build());
diff --git a/src/condition.rs b/src/condition.rs
deleted file mode 100644
index 2d50368..0000000
--- a/src/condition.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-use std::cell::RefCell;
-use std::rc::Rc;
-
-#[derive(Clone, Debug)]
-pub struct Condition(Rc<RefCell<bool>>);
-
-impl Condition {
-    pub fn new(state: bool) -> Condition {
-        Condition(Rc::new(RefCell::new(state)))
-    }
-
-    pub fn is_active(&self) -> bool {
-        *self.0.borrow()
-    }
-
-    pub fn activate(&mut self) {
-        *self.0.borrow_mut() = true;
-    }
-
-    pub fn deactivate(&mut self) {
-        *self.0.borrow_mut() = false;
-    }
-}
diff --git a/src/conditions.rs b/src/conditions.rs
index 4af395e..54da593 100644
--- a/src/conditions.rs
+++ b/src/conditions.rs
@@ -29,7 +29,7 @@ impl Conditions {
 
     pub fn is_opening(&self, message: &Message) -> bool {
         if self.first_opens {
-            message.ids().any(|x| x == self.patterns.first().unwrap())
+            self.patterns.first().iter().any(|first| message.ids().any(|id| &id == first))
         } else {
             true
         }
@@ -51,8 +51,9 @@ impl Conditions {
 
     fn is_closing_message(&self, state: &State) -> bool {
         if self.last_closes {
-            let last_message = state.messages().last().unwrap();
-            last_message.ids().any(|x| x == self.patterns.last().unwrap())
+            state.messages().last().iter().any(|last_message| {
+                self.patterns.last().iter().any(|last| last_message.ids().any(|id| &id == last))
+            })
         } else {
             false
         }
@@ -115,7 +116,7 @@ impl ConditionsBuilder {
 mod test {
     use serde_json::from_str;
     use super::Conditions;
-    use std::rc::Rc;
+    use std::sync::Arc;
 
     use message::MessageBuilder;
     use state::State;
@@ -123,6 +124,7 @@ mod test {
     use context::BaseContextBuilder;
     use uuid::Uuid;
     use std::time::Duration;
+    use dispatcher::response::MockResponseSender;
 
     #[test]
     fn test_given_condition_when_an_opening_message_is_received_then_the_state_becomes_opened() {
@@ -144,6 +146,7 @@ mod test {
 
     #[test]
     fn test_given_condition_when_a_closing_message_is_received_then_the_state_becomes_closed() {
+        let mut responder = MockResponseSender::new();
         let timeout = Duration::from_millis(100);
         let msg_id1 = "11eaf6f8-0640-460f-aee2-a72d2f2ab258".to_string();
         let msg_id2 = "21eaf6f8-0640-460f-aee2-a72d2f2ab258".to_string();
@@ -157,12 +160,12 @@ mod test {
                              .last_closes(true)
                              .build();
         let context = BaseContextBuilder::new(Uuid::new_v4(), conditions).build();
-        let msg_opening = Rc::new(MessageBuilder::new(&msg_id1, "message").build());
-        let msg_closing = Rc::new(MessageBuilder::new(&msg_id2, "message").build());
+        let msg_opening = Arc::new(MessageBuilder::new(&msg_id1, "message").build());
+        let msg_closing = Arc::new(MessageBuilder::new(&msg_id2, "message").build());
         assert_false!(state.is_open());
-        state.on_message(msg_opening, &context);
+        state.on_message(msg_opening, &context, &mut responder);
         assert_true!(state.is_open());
-        state.on_message(msg_closing, &context);
+        state.on_message(msg_closing, &context, &mut responder);
         assert_false!(state.is_open());
     }
 
@@ -240,13 +243,14 @@ mod test {
                             .patterns(patterns)
                             .first_opens(true)
                             .build();
-        let msg = MessageBuilder::new(&uuid, "message").name(Some(&msg_id)).build();
+        let msg = MessageBuilder::new(&uuid, "message").name(Some(msg_id)).build();
         assert_true!(condition.is_opening(&msg));
     }
 
     #[test]
     fn test_given_conditions_when_last_closes_is_set_and_the_message_has_a_name_then_we_check_that_name
         () {
+        let mut responder = MockResponseSender::new();
         let timeout = Duration::from_millis(100);
         let patterns = vec!["p1".to_string(), "p2".to_string()];
         let p1_uuid = "e4f3f8b2-3135-4916-a5ea-621a754dab0d".to_string();
@@ -259,14 +263,46 @@ mod test {
                              .first_opens(true)
                              .last_closes(true)
                              .build();
-        let p1_msg = MessageBuilder::new(&p1_uuid, "message").name(Some(&p1)).build();
-        let p2_msg = MessageBuilder::new(&p2_uuid, "message").name(Some(&p2)).build();
+        let p1_msg = MessageBuilder::new(&p1_uuid, "message").name(Some(p1)).build();
+        let p2_msg = MessageBuilder::new(&p2_uuid, "message").name(Some(p2)).build();
         let context = BaseContextBuilder::new(Uuid::new_v4(), conditions).build();
         assert_false!(state.is_open());
-        state.on_message(Rc::new(p1_msg), &context);
-        state.on_message(Rc::new(p2_msg), &context);
+        state.on_message(Arc::new(p1_msg), &context, &mut responder);
+        state.on_message(Arc::new(p2_msg), &context, &mut responder);
         assert_false!(state.is_open());
     }
+
+    #[test]
+    fn test_given_condition_when_first_opens_is_set_but_there_are_no_patterns_then_we_do_not_panic
+        () {
+        let mut responder = MockResponseSender::new();
+        let msg = MessageBuilder::new("e4f3f8b2-3135-4916-a5ea-621a754dab0d", "message")
+                      .name(Some("p1"))
+                      .build();
+        let conditions = ConditionsBuilder::new(Duration::from_millis(100))
+                             .patterns(Vec::new())
+                             .first_opens(true)
+                             .build();
+        let context = BaseContextBuilder::new(Uuid::new_v4(), conditions).build();
+        let mut state = State::new();
+        state.on_message(Arc::new(msg), &context, &mut responder);
+    }
+
+    #[test]
+    fn test_given_condition_when_last_closes_is_set_but_there_are_no_patterns_then_we_do_not_panic
+        () {
+        let mut responder = MockResponseSender::new();
+        let msg = MessageBuilder::new("e4f3f8b2-3135-4916-a5ea-621a754dab0d", "message")
+                      .name(Some("p1"))
+                      .build();
+        let conditions = ConditionsBuilder::new(Duration::from_millis(100))
+                             .patterns(Vec::new())
+                             .last_closes(true)
+                             .build();
+        let context = BaseContextBuilder::new(Uuid::new_v4(), conditions).build();
+        let mut state = State::new();
+        state.on_message(Arc::new(msg), &context, &mut responder);
+    }
 }
 
 mod deser {
diff --git a/src/config/action/deser/test.rs b/src/config/action/deser/test.rs
index 5d3c831..a066812 100644
--- a/src/config/action/deser/test.rs
+++ b/src/config/action/deser/test.rs
@@ -13,7 +13,6 @@ fn test_given_action_when_it_is_deserialized_then_we_get_the_right_result() {
     "#;
 
     let result = from_str::<ActionType>(text);
-    println!("{:?}", &result);
     let action = result.ok().expect("Failed to deserialize a valid ActionType");
     match action {
         ActionType::Message(message) => {
@@ -26,7 +25,6 @@ fn test_given_action_when_it_is_deserialized_then_we_get_the_right_result() {
 fn test_given_unknown_action_when_it_is_deserialized_then_we_get_an_error() {
     let text = r#"{ "unknown": {} }"#;
     let result = from_str::<ActionType>(text);
-    println!("{:?}", &result);
     let _ = result.err().expect("Successfully deserialized an unknown action");
 }
 
diff --git a/src/config/action/message/builder.rs b/src/config/action/message/builder.rs
index 22594cc..0a42499 100644
--- a/src/config/action/message/builder.rs
+++ b/src/config/action/message/builder.rs
@@ -1,63 +1,67 @@
 use handlebars::Template;
-use std::collections::BTreeMap;
+use handlebars::Handlebars;
 use super::MessageAction;
 use super::InjectMode;
+use super::MESSAGE;
 use config::action::ExecCondition;
 
 pub struct MessageActionBuilder {
     uuid: String,
     name: Option<String>,
     message: Template,
-    values: BTreeMap<String, Template>,
+    values: Handlebars,
     when: ExecCondition,
     inject_mode: InjectMode,
 }
 
 impl MessageActionBuilder {
     pub fn new<S: Into<String>>(uuid: S, message: Template) -> MessageActionBuilder {
+        let mut values = Handlebars::new();
+        values.register_template(MESSAGE, message.clone());
         MessageActionBuilder {
             uuid: uuid.into(),
             name: None,
             message: message,
-            values: BTreeMap::new(),
+            values: values,
             when: ExecCondition::new(),
             inject_mode: Default::default(),
         }
     }
 
-    pub fn name<S: Into<String>>(&mut self, name: Option<S>) -> &mut MessageActionBuilder {
+    pub fn name<S: Into<String>>(mut self, name: Option<S>) -> MessageActionBuilder {
         self.name = name.map(|name| name.into());
         self
     }
 
-    pub fn when(&mut self, when: ExecCondition) -> &mut MessageActionBuilder {
+    pub fn when(mut self, when: ExecCondition) -> MessageActionBuilder {
         self.when = when;
         self
     }
 
-    pub fn values(&mut self, values: BTreeMap<String, Template>) -> &mut MessageActionBuilder {
+    pub fn values(mut self, values: Handlebars) -> MessageActionBuilder {
         self.values = values;
+        self.values.register_template(MESSAGE, self.message.clone());
         self
     }
 
-    pub fn pair<S: Into<String>>(&mut self, key: S, value: Template) -> &mut MessageActionBuilder {
-        self.values.insert(key.into(), value);
+    pub fn pair<S: AsRef<str>>(mut self, key: S, value: Template) -> MessageActionBuilder {
+        self.values.register_template(key.as_ref(), value);
         self
     }
 
-    pub fn inject_mode(&mut self, mode: InjectMode) -> &mut MessageActionBuilder {
+    pub fn inject_mode(mut self, mode: InjectMode) -> MessageActionBuilder {
         self.inject_mode = mode;
         self
     }
 
-    pub fn build(&self) -> MessageAction {
+    pub fn build(self) -> MessageAction {
         MessageAction {
-            uuid: self.uuid.clone(),
-            name: self.name.clone(),
-            message: self.message.clone(),
-            values: self.values.clone(),
-            when: self.when.clone(),
-            inject_mode: self.inject_mode.clone(),
+            uuid: self.uuid,
+            name: self.name,
+            message: self.message,
+            values: self.values,
+            when: self.when,
+            inject_mode: self.inject_mode,
         }
     }
 }
diff --git a/src/config/action/message/deser.rs b/src/config/action/message/deser.rs
index 820039a..527abaf 100644
--- a/src/config/action/message/deser.rs
+++ b/src/config/action/message/deser.rs
@@ -1,11 +1,12 @@
 use super::MessageAction;
-use super::MessageActionBuilder;
 use super::InjectMode;
 use config::action::ExecCondition;
 
 use handlebars::Template;
+use handlebars::Handlebars;
 use serde::de::{Deserialize, Deserializer, Error, MapVisitor, Visitor};
 use std::collections::BTreeMap;
+use super::MESSAGE;
 
 impl Deserialize for MessageAction {
     fn deserialize<D>(deserializer: &mut D) -> Result<MessageAction, D::Error>
@@ -107,26 +108,30 @@ impl Visitor for MessageActionVisitor {
             }
         };
 
-        let values = match values {
+        let mut values = match values {
             Some(values) => {
-                let mut converted_values = BTreeMap::new();
+                let mut registry = Handlebars::new();
                 for (key, value) in values.into_iter() {
                     let template = try!(MessageActionVisitor::compile_template::<V>(value, &uuid));
-                    converted_values.insert(key, template);
+                    registry.register_template(&key, template);
                 }
-                converted_values
+                registry
             }
-            None => BTreeMap::new(),
+            None => Handlebars::new(),
         };
 
         try!(visitor.end());
 
-        Ok(MessageActionBuilder::new(uuid, message)
-               .name(name)
-               .values(values)
-               .when(when)
-               .inject_mode(inject_mode)
-               .build())
+        values.register_template(MESSAGE, message.clone());
+
+        Ok(MessageAction {
+            uuid: uuid,
+            message: message,
+            name: name,
+            values: values,
+            when: when,
+            inject_mode: inject_mode,
+        })
     }
 }
 
@@ -162,6 +167,12 @@ mod test {
     use handlebars::Template;
     use serde_json::from_str;
 
+    fn assert_message_action_eq(expected: &MessageAction, actual: &MessageAction) {
+        assert_eq!(expected.uuid(), actual.uuid());
+        assert_eq!(expected.name(), actual.name());
+        assert_eq!(expected.message(), actual.message());
+    }
+
     #[test]
     fn test_given_message_as_a_json_string_when_it_is_deserialized_then_we_get_the_expected_message
         () {
@@ -192,9 +203,8 @@ mod test {
                                    .pair("key2", value2)
                                    .build();
         let result = from_str::<MessageAction>(text);
-        println!("{:?}", &result);
         let message = result.ok().expect("Failed to deserialize a valid MessageAction object");
-        assert_eq!(expected_message, message);
+        assert_message_action_eq(&expected_message, &message);
     }
 
     #[test]
@@ -212,9 +222,8 @@ mod test {
                           .expect("Failed to compile a handlebars template");
         let expected_message = MessageActionBuilder::new("UUID", message).build();
         let result = from_str::<MessageAction>(text);
-        println!("{:?}", &result);
         let message = result.ok().expect("Failed to deserialize a valid MessageAction object");
-        assert_eq!(expected_message, message);
+        assert_message_action_eq(&expected_message, &message);
     }
 
     #[test]
@@ -226,7 +235,6 @@ mod test {
         "#;
 
         let result = from_str::<MessageAction>(text);
-        println!("{:?}", &result);
         let _ = result.err().expect("Successfully deserialized an invalid MessageAction object");
     }
 
@@ -274,8 +282,7 @@ mod test {
                                    .inject_mode(InjectMode::Forward)
                                    .build();
         let result = from_str::<MessageAction>(text);
-        println!("{:?}", &result);
         let message = result.ok().expect("Failed to deserialize a valid MessageAction object");
-        assert_eq!(expected_message, message);
+        assert_message_action_eq(&expected_message, &message);
     }
 }
diff --git a/src/action/message/error.rs b/src/config/action/message/error.rs
similarity index 100%
rename from src/action/message/error.rs
rename to src/config/action/message/error.rs
diff --git a/src/config/action/message/mod.rs b/src/config/action/message/mod.rs
index 420c4ee..53accba 100644
--- a/src/config/action/message/mod.rs
+++ b/src/config/action/message/mod.rs
@@ -1,5 +1,30 @@
-use handlebars::Template;
+use action::Action;
+use context::base::BaseContext;
+use dispatcher::Response;
+use dispatcher::response::ResponseSender;
+use message::{Message, MessageBuilder};
+
+use handlebars::Context;
+use std::borrow::Borrow;
 use std::collections::BTreeMap;
+use state::State;
+use self::error::Error;
+use self::renderer_context::RendererContext;
+
+mod error;
+mod renderer_context;
+#[cfg(test)]
+mod test;
+
+pub const CONTEXT_UUID: &'static str = "context_uuid";
+pub const CONTEXT_NAME: &'static str = "context_name";
+pub const CONTEXT_LEN: &'static str = "context_len";
+pub const MESSAGES: &'static str = "messages";
+const MESSAGE: &'static str = "MESSAGE";
+
+use handlebars::Template;
+use handlebars::Handlebars;
+
 
 use super::ActionType;
 use super::ExecCondition;
@@ -9,14 +34,13 @@ mod builder;
 
 pub use self::builder::MessageActionBuilder;
 
-#[derive(Clone, Debug, PartialEq)]
 pub struct MessageAction {
-    pub uuid: String,
-    pub name: Option<String>,
-    pub message: Template,
-    pub values: BTreeMap<String, Template>,
-    pub when: ExecCondition,
-    pub inject_mode: InjectMode,
+    uuid: String,
+    name: Option<String>,
+    message: Template,
+    values: Handlebars,
+    when: ExecCondition,
+    inject_mode: InjectMode,
 }
 
 impl MessageAction {
@@ -29,12 +53,77 @@ impl MessageAction {
     pub fn message(&self) -> &Template {
         &self.message
     }
-    pub fn values(&self) -> &BTreeMap<String, Template> {
+    pub fn values(&self) -> &Handlebars {
         &self.values
     }
     pub fn inject_mode(&self) -> &InjectMode {
         &self.inject_mode
     }
+
+    fn render_value(&self, key: &String, template_context: &Context) -> Result<String, Error> {
+        let mut writer = Vec::new();
+        {
+            try!(self.values.renderw(key, &template_context, &mut writer));
+        }
+        let string = try!(String::from_utf8(writer));
+        Ok(string)
+    }
+
+    fn render_values(&self, template_context: &Context) -> Result<BTreeMap<String, String>, Error> {
+        let mut rendered_values = BTreeMap::new();
+        for (key, _) in self.values.get_templates() {
+            let rendered_value = try!(self.render_value(key, &template_context));
+            rendered_values.insert(key.to_string(), rendered_value);
+        }
+        Ok(rendered_values)
+    }
+
+    fn render_message(&self, state: &State, context: &BaseContext) -> Result<Message, Error> {
+        let template_context = {
+            use handlebars::Context;
+            let context = RendererContext::new(state, context);
+            Context::wraps(&context)
+        };
+
+        let mut rendered_values = try!(self.render_values(&template_context));
+        MessageAction::extend_with_context_information(&mut rendered_values, state, context);
+        let message = rendered_values.remove(MESSAGE)
+                                     .expect(&format!("There is no '{}' key in the renderer \
+                                                       key-value pairs",
+                                                      MESSAGE));
+        let name = self.name.as_ref().map(|name| name.borrow());
+        let message = MessageBuilder::new(&self.uuid, message)
+                          .name(name)
+                          .values(rendered_values)
+                          .build();
+        Ok(message)
+    }
+
+    fn extend_with_context_information(values: &mut BTreeMap<String, String>,
+                                       state: &State,
+                                       context: &BaseContext) {
+        values.insert(CONTEXT_UUID.to_string(),
+                      context.uuid().to_hyphenated_string());
+        values.insert(CONTEXT_LEN.to_string(), state.messages().len().to_string());
+        if let Some(name) = context.name() {
+            values.insert(CONTEXT_NAME.to_string(), name.to_string());
+        }
+    }
+
+    fn execute(&self, _state: &State, _context: &BaseContext, responder: &mut ResponseSender) {
+        match self.render_message(_state, _context) {
+            Ok(message) => {
+                let response = Alert {
+                    message: message,
+                    inject_mode: self.inject_mode.clone(),
+                };
+                responder.send_response(Response::Alert(response));
+            }
+            Err(error) => {
+                error!("{}", error);
+            }
+        }
+    }
 }
 
 impl From<MessageAction> for super::ActionType {
@@ -55,3 +144,31 @@ impl Default for InjectMode {
         InjectMode::Log
     }
 }
+
+#[derive(Debug, Clone)]
+pub struct Alert {
+    message: Message,
+    inject_mode: InjectMode,
+}
+
+impl Alert {
+    pub fn message(&self) -> &Message {
+        &self.message
+    }
+}
+
+impl Action for MessageAction {
+    fn on_opened(&self, _state: &State, _context: &BaseContext, responder: &mut ResponseSender) {
+        if self.when.on_opened {
+            trace!("MessageAction: on_opened()");
+            self.execute(_state, _context, responder);
+        }
+    }
+
+    fn on_closed(&self, _state: &State, _context: &BaseContext, responder: &mut ResponseSender) {
+        if self.when.on_closed {
+            trace!("MessageAction: on_closed()");
+            self.execute(_state, _context, responder);
+        }
+    }
+}
diff --git a/src/action/message/renderer_context.rs b/src/config/action/message/renderer_context.rs
similarity index 92%
rename from src/action/message/renderer_context.rs
rename to src/config/action/message/renderer_context.rs
index 31b736f..929b4f2 100644
--- a/src/action/message/renderer_context.rs
+++ b/src/config/action/message/renderer_context.rs
@@ -5,12 +5,12 @@ use context::BaseContext;
 use uuid::Uuid;
 use rustc_serialize::json::{Json, ToJson};
 use std::collections::BTreeMap;
-use std::rc::Rc;
+use std::sync::Arc;
 
 use super::{CONTEXT_LEN, CONTEXT_NAME, CONTEXT_UUID, MESSAGES};
 
 pub struct RendererContext<'m, 'c> {
-    messages: &'m [Rc<Message>],
+    messages: &'m [Arc<Message>],
     context_name: Option<&'c String>,
     context_uuid: &'c Uuid,
 }
@@ -39,7 +39,7 @@ impl<'m, 'c> ToJson for RendererContext<'m, 'c> {
     }
 }
 
-fn rc_message_to_json(messages: &[Rc<Message>]) -> Json {
+fn rc_message_to_json(messages: &[Arc<Message>]) -> Json {
     let mut array: Vec<&Message> = Vec::new();
     for i in messages {
         array.push(i);
diff --git a/src/config/action/message/test.rs b/src/config/action/message/test.rs
index 77c6c4a..ef90f6b 100644
--- a/src/config/action/message/test.rs
+++ b/src/config/action/message/test.rs
@@ -1,21 +1,100 @@
-use message::Message;
 use config::action::message::MessageActionBuilder;
 use message::MessageBuilder;
+use context::base::BaseContextBuilder;
+use super::{CONTEXT_LEN, CONTEXT_NAME, CONTEXT_UUID};
+
+use conditions::ConditionsBuilder;
+use config;
+use dispatcher::Response;
+use dispatcher::response::MockResponseSender;
+use state::State;
+use action::Action;
+
+use env_logger;
+use handlebars::Template;
+use std::time::Duration;
+use std::sync::Arc;
+use uuid::Uuid;
 
 #[test]
-fn test_given_message_when_it_is_created_from_a_message_action_then_every_fields_are_copied_into_it() {
-    let uuid = "uuid";
-    let name = "name";
-    let expected_message = MessageBuilder::new(uuid)
-                                            .name(Some(name))
-                                            .pair("key1", "value1")
-                                            .pair("key2", "value1")
-                                            .build();
-    let action = MessageActionBuilder::new(uuid)
-                                        .name(name)
-                                        .pair("key1", "value1")
-                                        .pair("key2", "value1")
-                                        .build();
-    let message = Message::from(&action);
-    assert_eq!(&expected_message, &message);
+fn test_given_a_message_action_when_it_is_executed_then_it_adds_the_name_and_uuid_of_the_context_to_the_message
+    () {
+    let mut responder = MockResponseSender::new();
+    let name = Some("name".to_string());
+    let base_context = {
+        let conditions = ConditionsBuilder::new(Duration::from_millis(100)).build();
+        let uuid = Uuid::new_v4();
+        BaseContextBuilder::new(uuid, conditions).name(name.clone()).build()
+    };
+    let state = State::new();
+    let message_action = {
+        let message = Template::compile("message".to_string())
+                          .ok()
+                          .expect("Failed to compile a handlebars template");
+        config::action::message::MessageActionBuilder::new("uuid", message).build()
+    };
+
+    message_action.on_closed(&state, &base_context, &mut responder);
+    assert_eq!(1, responder.0.len());
+    let responses = responder.0;
+    if let &Response::Alert(ref response) = responses.get(0).unwrap() {
+        assert_eq!(name.as_ref().unwrap(),
+                   response.message().get(CONTEXT_NAME).unwrap());
+        assert_eq!(&base_context.uuid().to_hyphenated_string(),
+                   response.message().get(CONTEXT_UUID).unwrap());
+        assert_eq!("0", response.message().get(CONTEXT_LEN).unwrap());
+    } else {
+        unreachable!();
+    }
+}
+
+#[test]
+fn test_given_message_action_when_it_is_executed_then_it_uses_the_messages_to_render_the_message_and_additonal_templated_values
+    () {
+    let mut responder = MockResponseSender::new();
+    let _ = env_logger::init();
+    let name = Some("name".to_string());
+    let base_context = {
+        let conditions = ConditionsBuilder::new(Duration::from_millis(100)).build();
+        let uuid = Uuid::new_v4();
+        BaseContextBuilder::new(uuid, conditions).name(name.clone()).build()
+    };
+    let state = {
+        let messages = vec![Arc::new(MessageBuilder::new("uuid1", "message1")
+                                         .pair("key1", "value1")
+                                         .build()),
+                            Arc::new(MessageBuilder::new("uuid2", "message2")
+                                         .pair("key2", "value2")
+                                         .build())];
+        State::with_messages(messages)
+    };
+    let message_action = {
+        let message = Template::compile("key1={{{messages.[0].values.key1}}} \
+                                         key2={{{messages.[1].values.key2}}}"
+                                            .to_string())
+                          .ok()
+                          .expect("Failed to compile a handlebars template");
+        config::action::message::MessageActionBuilder::new("uuid", message)
+            .pair("message_num",
+                  Template::compile("we have {{context_len}} messages".to_string())
+                      .ok()
+                      .expect("Failed to compile a handlebars template"))
+            .build()
+    };
+
+    message_action.on_closed(&state, &base_context, &mut responder);
+    assert_eq!(1, responder.0.len());
+    let responses = responder.0;
+    if let &Response::Alert(ref response) = responses.get(0).unwrap() {
+        assert_eq!(name.as_ref().unwrap(),
+                   response.message().get(CONTEXT_NAME).unwrap());
+        assert_eq!(&base_context.uuid().to_hyphenated_string(),
+                   response.message().get(CONTEXT_UUID).unwrap());
+        let message = response.message();
+        assert_eq!("we have 2 messages",
+                   message.get("message_num").expect("Failed to get an inserted key from a map"));
+        assert_eq!("key1=value1 key2=value2", message.message());
+    } else {
+        unreachable!();
+    }
 }
diff --git a/src/config/action/mod.rs b/src/config/action/mod.rs
index e51a52b..7d725a1 100644
--- a/src/config/action/mod.rs
+++ b/src/config/action/mod.rs
@@ -1,13 +1,30 @@
+use action::Action;
+use state::State;
+use context::BaseContext;
+use dispatcher::response::ResponseSender;
+
 pub use self::message::MessageAction;
 
 pub mod message;
 mod deser;
 
-#[derive(Clone, Debug, PartialEq)]
 pub enum ActionType {
     Message(self::message::MessageAction),
 }
 
+impl Action for ActionType {
+    fn on_opened(&self, state: &State, context: &BaseContext, responder: &mut ResponseSender) {
+        match *self {
+            ActionType::Message(ref action) => action.on_opened(state, context, responder),
+        }
+    }
+    fn on_closed(&self, state: &State, context: &BaseContext, responder: &mut ResponseSender) {
+        match *self {
+            ActionType::Message(ref action) => action.on_closed(state, context, responder),
+        }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct ExecCondition {
     pub on_opened: bool,
diff --git a/src/config/deser.rs b/src/config/deser.rs
index 9e1bf0a..ac295ee 100644
--- a/src/config/deser.rs
+++ b/src/config/deser.rs
@@ -1,4 +1,4 @@
-use config::Context;
+use config::ContextConfig;
 use serde::de::{Deserialize, Deserializer, MapVisitor, Error, Visitor};
 
 use handlebars::Template;
@@ -6,8 +6,8 @@ use uuid::Uuid;
 
 const FIELDS: &'static [&'static str] = &["name", "uuid", "conditions", "actions"];
 
-impl Deserialize for Context {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Context, D::Error>
+impl Deserialize for ContextConfig {
+    fn deserialize<D>(deserializer: &mut D) -> Result<ContextConfig, D::Error>
         where D: Deserializer
     {
         deserializer.visit_struct("Context", FIELDS, ContextVisitor)
@@ -102,9 +102,9 @@ impl ContextVisitor {
 }
 
 impl Visitor for ContextVisitor {
-    type Value = Context;
+    type Value = ContextConfig;
 
-    fn visit_map<V>(&mut self, mut visitor: V) -> Result<Context, V::Error>
+    fn visit_map<V>(&mut self, mut visitor: V) -> Result<ContextConfig, V::Error>
         where V: MapVisitor
     {
         let mut name = None;
@@ -129,7 +129,7 @@ impl Visitor for ContextVisitor {
 
         try!(visitor.end());
 
-        Ok(Context {
+        Ok(ContextConfig {
             name: name,
             uuid: uuid,
             conditions: conditions.unwrap(),
@@ -144,7 +144,7 @@ mod test {
     use config::action::{ActionType, ExecCondition};
     use config::action::message::MessageActionBuilder;
     use conditions::ConditionsBuilder;
-    use config::Context;
+    use config::ContextConfig;
     use handlebars::Template;
     use serde_json::from_str;
     use uuid::Uuid;
@@ -180,8 +180,7 @@ mod test {
         }
         "#;
 
-        let result = from_str::<Context>(text);
-        println!("{:?}", &result);
+        let result = from_str::<ContextConfig>(text);
         let expected_name = "TEST_NAME".to_string();
         let expected_uuid = Uuid::parse_str("86ca9f93-84fb-4813-b037-6526f7a585a3").ok().unwrap();
         let expected_conditions = ConditionsBuilder::new(Duration::from_millis(100))
@@ -202,30 +201,31 @@ mod test {
                                                                                   message)
                                                             .when(expected_exec_cond)
                                                             .build())];
-        let context = result.ok().expect("Failed to deserialize a valid Context");
+        let context = result.ok().expect("Failed to deserialize a valid ContextConfig");
         assert_eq!(&Some(expected_name), &context.name);
         assert_eq!(&expected_uuid, &context.uuid);
         assert_eq!(&expected_conditions, &context.conditions);
-        assert_eq!(&expected_actions, &context.actions);
+        assert_eq!(&expected_actions.len(), &context.actions.len());
     }
 
     #[test]
     fn test_given_config_context_when_it_does_not_have_uuid_then_it_cannot_be_deserialized() {
         let text = r#"{ "conditions": { "timeout": 100 }}"#;
-        let result = from_str::<Context>(text);
-        println!("{:?}", &result);
-        let _ = result.err().expect("Successfully deserialized a config context without an uuid key");
+        let result = from_str::<ContextConfig>(text);
+        let _ = result.err()
+                      .expect("Successfully deserialized a config context without an uuid key");
     }
 
     #[test]
-    fn test_given_config_context_when_it_contains_an_unknown_key_then_it_cannot_be_deserialized() {
+    fn test_given_config_context_when_it_contains_an_unknown_key_then_it_cannot_be_deserialized
+        () {
         let text = r#"
             {"uuid": "86ca9f93-84fb-4813-b037-6526f7a585a3",
             "conditions": { "timeout": 100},
             "unknown": "unknown" }"#;
-        let result = from_str::<Context>(text);
-        println!("{:?}", &result);
-        let _ = result.err().expect("Successfully deserialized a config context with an unknown key");
+        let result = from_str::<ContextConfig>(text);
+        let _ = result.err()
+                      .expect("Successfully deserialized a config context with an unknown key");
     }
 
     #[test]
@@ -240,11 +240,10 @@ mod test {
         }
         "#;
 
-        let result = from_str::<Context>(text);
-        println!("{:?}", &result);
+        let result = from_str::<ContextConfig>(text);
         let expected_uuid = Uuid::parse_str("86ca9f93-84fb-4813-b037-6526f7a585a3").ok().unwrap();
         let expected_conditions = ConditionsBuilder::new(Duration::from_millis(100)).build();
-        let context = result.ok().expect("Failed to deserialize a valid Context");
+        let context = result.ok().expect("Failed to deserialize a valid ContextConfig");
         assert_eq!(&expected_uuid, &context.uuid);
         assert_eq!(&expected_conditions, &context.conditions);
     }
@@ -261,10 +260,10 @@ mod test {
         }
         "#;
 
-        let result = from_str::<Context>(text);
-        println!("{:?}", &result);
+        let result = from_str::<ContextConfig>(text);
         let _ = result.err()
-                      .expect("Successfully deserialized an invalid Context (UUID is invalid)");
+                      .expect("Successfully deserialized an invalid ContextConfig (UUID is \
+                               invalid)");
     }
 
     #[test]
@@ -279,9 +278,8 @@ mod test {
         }
         "#;
         let expected_context_id = "{{HOST}}{{PROGRAM}}".to_string();
-        let result = from_str::<Context>(text);
-        println!("{:?}", &result);
-        let context = result.ok().expect("Failed to deserialize a valid Context");
+        let result = from_str::<ContextConfig>(text);
+        let context = result.ok().expect("Failed to deserialize a valid ContextConfig");
         assert_eq!(&expected_context_id,
                    &context.context_id.as_ref().unwrap().to_string());
     }
diff --git a/src/config/mod.rs b/src/config/mod.rs
index d3b1696..b8d4ade 100644
--- a/src/config/mod.rs
+++ b/src/config/mod.rs
@@ -7,8 +7,7 @@ use conditions::Conditions;
 mod deser;
 pub mod action;
 
-#[derive(Debug, Clone)]
-pub struct Context {
+pub struct ContextConfig {
     pub name: Option<String>,
     pub uuid: Uuid,
     pub conditions: Conditions,
@@ -16,7 +15,7 @@ pub struct Context {
     pub actions: Vec<ActionType>,
 }
 
-pub struct ContextBuilder {
+pub struct ContextConfigBuilder {
     name: Option<String>,
     uuid: Uuid,
     conditions: Conditions,
@@ -24,9 +23,9 @@ pub struct ContextBuilder {
     actions: Vec<ActionType>,
 }
 
-impl ContextBuilder {
-    pub fn new(uuid: Uuid, conditions: Conditions) -> ContextBuilder {
-        ContextBuilder {
+impl ContextConfigBuilder {
+    pub fn new(uuid: Uuid, conditions: Conditions) -> ContextConfigBuilder {
+        ContextConfigBuilder {
             name: None,
             uuid: uuid,
             conditions: conditions,
@@ -35,28 +34,28 @@ impl ContextBuilder {
         }
     }
 
-    pub fn context_id(&mut self, context_id: Option<Template>) -> &mut ContextBuilder {
+    pub fn context_id(mut self, context_id: Option<Template>) -> ContextConfigBuilder {
         self.context_id = context_id;
         self
     }
 
-    pub fn actions(&mut self, actions: Vec<ActionType>) -> &mut ContextBuilder {
+    pub fn actions(mut self, actions: Vec<ActionType>) -> ContextConfigBuilder {
         self.actions = actions;
         self
     }
 
-    pub fn name(&mut self, name: String) -> &mut ContextBuilder {
+    pub fn name(mut self, name: String) -> ContextConfigBuilder {
         self.name = Some(name);
         self
     }
 
-    pub fn build(&self) -> Context {
-        Context {
-            name: self.name.clone(),
-            uuid: self.uuid.clone(),
-            conditions: self.conditions.clone(),
-            context_id: self.context_id.clone(),
-            actions: self.actions.clone(),
+    pub fn build(self) -> ContextConfig {
+        ContextConfig {
+            name: self.name,
+            uuid: self.uuid,
+            conditions: self.conditions,
+            context_id: self.context_id,
+            actions: self.actions,
         }
     }
 }
diff --git a/src/context/base.rs b/src/context/base.rs
index b6a1c02..1cd3046 100644
--- a/src/context/base.rs
+++ b/src/context/base.rs
@@ -1,13 +1,13 @@
 use uuid::Uuid;
 
-use action::Action;
+use config::action::ActionType;
 use conditions::Conditions;
 
 pub struct BaseContext {
     name: Option<String>,
     uuid: Uuid,
     conditions: Conditions,
-    actions: Vec<Box<Action>>,
+    actions: Vec<ActionType>,
 }
 
 impl BaseContext {
@@ -23,7 +23,7 @@ impl BaseContext {
         self.name.as_ref()
     }
 
-    pub fn actions(&self) -> &[Box<Action>] {
+    pub fn actions(&self) -> &[ActionType] {
         &self.actions
     }
 }
@@ -32,7 +32,7 @@ pub struct BaseContextBuilder {
     name: Option<String>,
     uuid: Uuid,
     conditions: Conditions,
-    actions: Vec<Box<Action>>,
+    actions: Vec<ActionType>,
 }
 
 impl BaseContextBuilder {
@@ -50,7 +50,7 @@ impl BaseContextBuilder {
         self
     }
 
-    pub fn actions(mut self, actions: Vec<Box<Action>>) -> BaseContextBuilder {
+    pub fn actions(mut self, actions: Vec<ActionType>) -> BaseContextBuilder {
         self.actions = actions;
         self
     }
diff --git a/src/context/context_map.rs b/src/context/context_map.rs
index 9a18b80..83013da 100644
--- a/src/context/context_map.rs
+++ b/src/context/context_map.rs
@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 
+use config::ContextConfig;
 use context::Context;
 
 pub struct ContextMap {
@@ -15,6 +16,14 @@ impl ContextMap {
         }
     }
 
+    pub fn from_configs(configs: Vec<ContextConfig>) -> ContextMap {
+        let mut context_map = ContextMap::new();
+        for i in configs {
+            context_map.insert(i.into());
+        }
+        context_map
+    }
+
     pub fn insert(&mut self, context: Context) {
         self.contexts.push(context);
         let last_context = self.contexts
@@ -95,7 +104,7 @@ mod tests {
     use super::*;
 
     use conditions::ConditionsBuilder;
-    use context::{Context, LinearContext};
+    use context::{Context, LinearContext, BaseContextBuilder};
     use uuid::Uuid;
     use std::time::Duration;
 
@@ -119,7 +128,8 @@ mod tests {
                 let patterns = vec!["A".to_string(), "B".to_string()];
                 ConditionsBuilder::new(Duration::from_millis(100)).patterns(patterns).build()
             };
-            LinearContext::new(uuid.clone(), conditions)
+            let base = BaseContextBuilder::new(uuid.clone(), conditions).build();
+            LinearContext::new(base)
         };
         context_map.insert(Context::Linear(context1));
         assert_eq!(context_map.contexts_mut().len(), 1);
diff --git a/src/context/linear.rs b/src/context/linear.rs
index afcb3c5..493dc26 100644
--- a/src/context/linear.rs
+++ b/src/context/linear.rs
@@ -1,12 +1,12 @@
 use uuid::Uuid;
-use std::rc::Rc;
+use std::sync::Arc;
 
-use conditions::Conditions;
 use message::Message;
 use state::State;
 use timer::TimerEvent;
-use dispatcher::request::{InternalRequest, Request};
-use context::base::{BaseContext, BaseContextBuilder};
+use dispatcher::request::Request;
+use dispatcher::response::ResponseSender;
+use context::base::BaseContext;
 
 pub struct LinearContext {
     base: BaseContext,
@@ -14,29 +14,28 @@ pub struct LinearContext {
 }
 
 impl LinearContext {
-    #[allow(dead_code)]
-    pub fn new(uuid: Uuid, conditions: Conditions) -> LinearContext {
+    pub fn new(base: BaseContext) -> LinearContext {
         LinearContext {
-            base: BaseContextBuilder::new(uuid, conditions).build(),
+            base: base,
             state: State::new(),
         }
     }
 
-    pub fn on_event(&mut self, event: InternalRequest) {
+    pub fn on_event(&mut self, event: Request, responder: &mut ResponseSender) {
         trace!("LinearContext: received event");
         match event {
-            Request::Timer(event) => self.on_timer(&event),
-            Request::Message(message) => self.on_message(message),
+            Request::Timer(event) => self.on_timer(&event, responder),
+            Request::Message(message) => self.on_message(message, responder),
             _ => {}
         }
     }
 
-    pub fn on_timer(&mut self, event: &TimerEvent) {
-        self.state.on_timer(event, &self.base);
+    pub fn on_timer(&mut self, event: &TimerEvent, responder: &mut ResponseSender) {
+        self.state.on_timer(event, &self.base, responder);
     }
 
-    pub fn on_message(&mut self, event: Rc<Message>) {
-        self.state.on_message(event, &self.base);
+    pub fn on_message(&mut self, event: Arc<Message>, responder: &mut ResponseSender) {
+        self.state.on_message(event, &self.base, responder);
     }
 
     #[allow(dead_code)]
@@ -53,12 +52,3 @@ impl LinearContext {
         self.base.uuid()
     }
 }
-
-impl From<BaseContext> for LinearContext {
-    fn from(context: BaseContext) -> LinearContext {
-        LinearContext {
-            base: context,
-            state: State::new(),
-        }
-    }
-}
diff --git a/src/context/map/map.rs b/src/context/map/map.rs
index e885ed5..71cdb46 100644
--- a/src/context/map/map.rs
+++ b/src/context/map/map.rs
@@ -1,12 +1,13 @@
 use handlebars::{Handlebars, Template};
 use std::collections::BTreeMap;
-use std::rc::Rc;
+use std::sync::Arc;
 
 use message::Message;
 use state::State;
 use timer::TimerEvent;
 use context::base::BaseContext;
-use dispatcher::request::{Request, InternalRequest};
+use dispatcher::request::Request;
+use dispatcher::response::ResponseSender;
 
 const CONTEXT_ID: &'static str = ".context.id";
 
@@ -27,18 +28,18 @@ impl MapContext {
         }
     }
 
-    pub fn on_event(&mut self, event: InternalRequest) {
+    pub fn on_event(&mut self, event: Request, responder: &mut ResponseSender) {
         trace!("MapContext: received event");
         match event {
-            Request::Timer(event) => self.on_timer(&event),
-            Request::Message(message) => self.on_message(message),
+            Request::Timer(event) => self.on_timer(&event, responder),
+            Request::Message(message) => self.on_message(message, responder),
             _ => {}
         }
     }
 
-    pub fn on_timer(&mut self, event: &TimerEvent) {
+    pub fn on_timer(&mut self, event: &TimerEvent, responder: &mut ResponseSender) {
         for (_, mut state) in self.map.iter_mut() {
-            state.on_timer(event, &self.base);
+            state.on_timer(event, &self.base, responder);
         }
         self.remove_closed_states();
     }
@@ -62,18 +63,18 @@ impl MapContext {
         }
     }
 
-    pub fn on_message(&mut self, event: Rc<Message>) {
-        self.update_state(event);
+    pub fn on_message(&mut self, event: Arc<Message>, responder: &mut ResponseSender) {
+        self.update_state(event, responder);
         self.remove_closed_states();
     }
 
-    fn update_state(&mut self, event: Rc<Message>) {
+    fn update_state(&mut self, event: Arc<Message>, responder: &mut ResponseSender) {
         let id = self.context_id
                      .render(CONTEXT_ID, event.values())
                      .ok()
                      .expect("Failed to render the compiled Handlebars template");
         let state = self.map.entry(id).or_insert(State::new());
-        state.on_message(event, &self.base);
+        state.on_message(event, &self.base, responder);
     }
 
     #[allow(dead_code)]
diff --git a/src/context/map/test.rs b/src/context/map/test.rs
index 172df94..f6dba0d 100644
--- a/src/context/map/test.rs
+++ b/src/context/map/test.rs
@@ -2,14 +2,16 @@ use conditions::ConditionsBuilder;
 use context::{BaseContextBuilder, MapContext};
 use timer::TimerEvent;
 use message::MessageBuilder;
+use dispatcher::response::MockResponseSender;
 
 use handlebars::Template;
 use uuid::Uuid;
-use std::rc::Rc;
+use std::sync::Arc;
 use std::time::Duration;
 
 #[test]
 fn test_given_map_context_when_messages_have_the_same_kvpairs_then_they_go_to_the_same_context() {
+    let mut responder = MockResponseSender::new();
     let delta = Duration::from_millis(10);
     let timeout = Duration::from_millis(30);
     let event = TimerEvent(delta);
@@ -47,14 +49,14 @@ fn test_given_map_context_when_messages_have_the_same_kvpairs_then_they_go_to_th
                    .build();
 
     assert_false!(context.is_open());
-    context.on_message(Rc::new(msg1));
+    context.on_message(Arc::new(msg1), &mut responder);
     assert_true!(context.is_open());
-    context.on_timer(&event);
-    context.on_message(Rc::new(msg2));
-    context.on_message(Rc::new(msg3));
-    context.on_timer(&event);
-    context.on_timer(&event);
+    context.on_timer(&event, &mut responder);
+    context.on_message(Arc::new(msg2), &mut responder);
+    context.on_message(Arc::new(msg3), &mut responder);
+    context.on_timer(&event, &mut responder);
+    context.on_timer(&event, &mut responder);
     assert_true!(context.is_open());
-    context.on_timer(&event);
+    context.on_timer(&event, &mut responder);
     assert_false!(context.is_open());
 }
diff --git a/src/context/mod.rs b/src/context/mod.rs
index c837b2c..e117428 100644
--- a/src/context/mod.rs
+++ b/src/context/mod.rs
@@ -1,4 +1,6 @@
-use dispatcher::request::InternalRequest;
+use dispatcher::request::Request;
+use dispatcher::response::ResponseSender;
+use config::ContextConfig;
 
 pub use self::linear::LinearContext;
 pub use self::map::MapContext;
@@ -17,11 +19,12 @@ pub enum Context {
     Linear(LinearContext),
     Map(MapContext),
 }
+
 impl Context {
-    pub fn on_event(&mut self, event: InternalRequest) {
+    pub fn on_event(&mut self, event: Request, responder: &mut ResponseSender) {
         match *self {
-            Context::Linear(ref mut context) => context.on_event(event),
-            Context::Map(ref mut context) => context.on_event(event),
+            Context::Linear(ref mut context) => context.on_event(event, responder),
+            Context::Map(ref mut context) => context.on_event(event, responder),
         }
     }
 
@@ -32,3 +35,20 @@ impl Context {
         }
     }
 }
+
+impl From<ContextConfig> for Context {
+    fn from(config: ContextConfig) -> Context {
+        let ContextConfig {name, uuid, conditions, context_id, actions} = config;
+
+        let base = BaseContextBuilder::new(uuid, conditions);
+        let base = base.name(name);
+        let base = base.actions(actions);
+        let base = base.build();
+
+        if let Some(context_id) = context_id {
+            Context::Map(MapContext::new(base, context_id))
+        } else {
+            Context::Linear(LinearContext::new(base))
+        }
+    }
+}
diff --git a/src/context/test.rs b/src/context/test.rs
index 3898600..3536040 100644
--- a/src/context/test.rs
+++ b/src/context/test.rs
@@ -1,111 +1,121 @@
 use uuid::Uuid;
-use std::rc::Rc;
+use std::sync::Arc;
 use std::time::Duration;
 
 use message::MessageBuilder;
 use timer::TimerEvent;
 use context::LinearContext;
+use context::BaseContextBuilder;
 use conditions::ConditionsBuilder;
+use dispatcher::response::MockResponseSender;
 
 #[test]
 fn test_given_close_condition_with_timeout_when_the_timeout_expires_then_the_condition_is_met() {
+    let mut responder = MockResponseSender::new();
     let timeout = Duration::from_millis(100);
     let msg_id = "11eaf6f8-0640-460f-aee2-a72d2f2ab258".to_string();
     let patterns = vec![
         msg_id.clone(),
     ];
-    let mut context = LinearContext::new(Uuid::new_v4(),
-                                         ConditionsBuilder::new(timeout)
-                                             .patterns(patterns)
-                                             .build());
+    let conditions = ConditionsBuilder::new(timeout)
+                         .patterns(patterns)
+                         .build();
+    let base = BaseContextBuilder::new(Uuid::new_v4(), conditions).build();
+    let mut context = LinearContext::new(base);
     let msg1 = MessageBuilder::new(&msg_id, "message").build();
-    let event = Rc::new(msg1);
+    let event = Arc::new(msg1);
     assert_false!(context.is_open());
-    context.on_message(event);
+    context.on_message(event, &mut responder);
     assert_true!(context.is_open());
-    context.on_timer(&mut TimerEvent::from_millis(50));
+    context.on_timer(&mut TimerEvent::from_millis(50), &mut responder);
     assert_true!(context.is_open());
-    context.on_timer(&mut TimerEvent::from_millis(49));
+    context.on_timer(&mut TimerEvent::from_millis(49), &mut responder);
     assert_true!(context.is_open());
-    context.on_timer(&mut TimerEvent::from_millis(1));
+    context.on_timer(&mut TimerEvent::from_millis(1), &mut responder);
     assert_false!(context.is_open());
 }
 
 #[test]
 fn test_given_close_condition_with_max_size_when_the_max_size_reached_then_the_condition_is_met
     () {
+    let mut responder = MockResponseSender::new();
     let timeout = Duration::from_millis(100);
     let max_size = 3;
     let msg_id = "11eaf6f8-0640-460f-aee2-a72d2f2ab258".to_string();
     let patterns = vec![
         msg_id.clone(),
     ];
-    let mut context = LinearContext::new(Uuid::new_v4(),
-                                         ConditionsBuilder::new(timeout)
-                                             .max_size(max_size)
-                                             .patterns(patterns)
-                                             .build());
+    let conditions = ConditionsBuilder::new(timeout)
+                         .max_size(max_size)
+                         .patterns(patterns)
+                         .build();
+    let base = BaseContextBuilder::new(Uuid::new_v4(), conditions).build();
+    let mut context = LinearContext::new(base);
     let msg1 = MessageBuilder::new(&msg_id, "message").build();
-    let event = Rc::new(msg1);
-    context.on_message(event.clone());
+    let event = Arc::new(msg1);
+    context.on_message(event.clone(), &mut responder);
     assert_true!(context.is_open());
-    context.on_message(event.clone());
+    context.on_message(event.clone(), &mut responder);
     assert_true!(context.is_open());
-    context.on_message(event.clone());
+    context.on_message(event.clone(), &mut responder);
     assert_false!(context.is_open());
 }
 
 #[test]
 fn test_given_close_condition_with_renew_timeout_when_the_timeout_expires_without_renewing_messages_then_the_condition_is_met
     () {
+    let mut responder = MockResponseSender::new();
     let timeout = Duration::from_millis(100);
     let renew_timeout = Duration::from_millis(10);
     let msg_id = "11eaf6f8-0640-460f-aee2-a72d2f2ab258".to_string();
     let patterns = vec![
         msg_id.clone(),
     ];
-    let mut context = LinearContext::new(Uuid::new_v4(),
-                                         ConditionsBuilder::new(timeout)
-                                             .renew_timeout(renew_timeout)
-                                             .patterns(patterns)
-                                             .build());
+    let conditions = ConditionsBuilder::new(timeout)
+                         .renew_timeout(renew_timeout)
+                         .patterns(patterns)
+                         .build();
+    let base = BaseContextBuilder::new(Uuid::new_v4(), conditions).build();
+    let mut context = LinearContext::new(base);
     let msg1 = MessageBuilder::new(&msg_id, "message").build();
-    let event = Rc::new(msg1);
-    context.on_message(event.clone());
+    let event = Arc::new(msg1);
+    context.on_message(event.clone(), &mut responder);
     assert_true!(context.is_open());
-    context.on_timer(&mut TimerEvent::from_millis(8));
+    context.on_timer(&mut TimerEvent::from_millis(8), &mut responder);
     assert_true!(context.is_open());
-    context.on_timer(&mut TimerEvent::from_millis(1));
+    context.on_timer(&mut TimerEvent::from_millis(1), &mut responder);
     assert_true!(context.is_open());
-    context.on_timer(&mut TimerEvent::from_millis(1));
+    context.on_timer(&mut TimerEvent::from_millis(1), &mut responder);
     assert_false!(context.is_open());
 }
 
 #[test]
 fn test_given_close_condition_with_renew_timeout_when_the_timeout_expires_with_renewing_messages_then_the_context_is_not_closed
     () {
+    let mut responder = MockResponseSender::new();
     let timeout = Duration::from_millis(100);
     let renew_timeout = Duration::from_millis(10);
     let msg_id = "11eaf6f8-0640-460f-aee2-a72d2f2ab258".to_string();
     let patterns = vec![
         msg_id.clone(),
     ];
-    let mut context = LinearContext::new(Uuid::new_v4(),
-                                         ConditionsBuilder::new(timeout)
-                                             .renew_timeout(renew_timeout)
-                                             .patterns(patterns)
-                                             .build());
+    let conditions = ConditionsBuilder::new(timeout)
+                         .renew_timeout(renew_timeout)
+                         .patterns(patterns)
+                         .build();
+    let base = BaseContextBuilder::new(Uuid::new_v4(), conditions).build();
+    let mut context = LinearContext::new(base);
     let msg1 = MessageBuilder::new(&msg_id, "message").build();
-    let event = Rc::new(msg1);
+    let event = Arc::new(msg1);
     assert_false!(context.is_open());
-    context.on_message(event.clone());
+    context.on_message(event.clone(), &mut responder);
     assert_true!(context.is_open());
-    context.on_timer(&mut TimerEvent::from_millis(8));
+    context.on_timer(&mut TimerEvent::from_millis(8), &mut responder);
     assert_true!(context.is_open());
-    context.on_timer(&mut TimerEvent::from_millis(1));
+    context.on_timer(&mut TimerEvent::from_millis(1), &mut responder);
     assert_true!(context.is_open());
-    context.on_message(event.clone());
+    context.on_message(event.clone(), &mut responder);
     assert_true!(context.is_open());
-    context.on_timer(&mut TimerEvent::from_millis(1));
+    context.on_timer(&mut TimerEvent::from_millis(1), &mut responder);
     assert_true!(context.is_open());
 }
diff --git a/src/correlator/exit_handler.rs b/src/correlator/exit_handler.rs
index af06d31..e7cf77d 100644
--- a/src/correlator/exit_handler.rs
+++ b/src/correlator/exit_handler.rs
@@ -1,40 +1,25 @@
 use std::sync::mpsc;
 
 use Response;
-use message::Message;
-use condition::Condition;
 use dispatcher::request::Request;
-use dispatcher::ResponseHandler;
+use dispatcher::ResponseHandle;
 use reactor::EventHandler;
 
-pub struct ExitHandler {
-    channel: mpsc::Sender<Request<Message>>,
-    exits_received: u32,
-    condition: Condition,
-}
+pub struct ExitHandler;
 
 impl ExitHandler {
-    pub fn new(condition: Condition, channel: mpsc::Sender<Request<Message>>) -> ExitHandler {
-        ExitHandler {
-            channel: channel,
-            exits_received: 0,
-            condition: condition,
-        }
+    pub fn new() -> ExitHandler {
+        ExitHandler
     }
 }
 
-impl EventHandler<Response, mpsc::Sender<Request<Message>>> for ExitHandler {
-    fn handle_event(&mut self, event: Response, _: &mut mpsc::Sender<Request<Message>>) {
+impl EventHandler<Response, mpsc::Sender<Request>> for ExitHandler {
+    fn handle_event(&mut self, event: Response, channel: &mut mpsc::Sender<Request>) {
         if let Response::Exit = event {
-            self.exits_received += 1;
-            let _ = self.channel.send(Request::Exit);
-
-            if self.exits_received >= 1 {
-                self.condition.activate()
-            }
+            let _ = channel.send(Request::Exit);
         }
     }
-    fn handler(&self) -> ResponseHandler {
-        ResponseHandler::Exit
+    fn handle(&self) -> ResponseHandle {
+        ResponseHandle::Exit
     }
 }
diff --git a/src/correlator/mod.rs b/src/correlator/mod.rs
index 8a993c3..cd54a78 100644
--- a/src/correlator/mod.rs
+++ b/src/correlator/mod.rs
@@ -6,19 +6,18 @@ use std::sync::mpsc;
 use std::thread;
 use std::result::Result;
 use std::time::Duration;
+use std::sync::Arc;
 
-use {action, config, context, Message, Response};
-use condition::Condition;
-use context::base::BaseContextBuilder;
-use context::{Context, ContextMap};
-use context::linear::LinearContext;
-use context::map::MapContext;
+use {Message, Response};
+use config::ContextConfig;
+use context::ContextMap;
 use dispatcher::request::Request;
 use dispatcher::reactor::RequestReactor;
-use dispatcher::{ResponseSender, ResponseHandler};
-use dispatcher::response;
+use dispatcher::ResponseHandle;
 use dispatcher::demux::Demultiplexer;
-use dispatcher::handlers;
+use dispatcher::handlers::exit::ExitEventHandler;
+use dispatcher::handlers::timer::TimerEventHandler;
+use dispatcher::handlers::message::MessageEventHandler;
 pub use self::error::Error;
 use reactor::{Event, Reactor, EventHandler};
 use timer::Timer;
@@ -33,42 +32,10 @@ mod exit_handler;
 mod test;
 
 pub struct Correlator {
-    dispatcher_input_channel: mpsc::Sender<Request<Message>>,
+    dispatcher_input_channel: mpsc::Sender<Request>,
     dispatcher_output_channel: mpsc::Receiver<Response>,
     dispatcher_thread_handle: thread::JoinHandle<()>,
-    handlers: HashMap<ResponseHandler, Box<EventHandler<Response, mpsc::Sender<Request<Message>>>>>,
-}
-
-fn create_context(config_context: config::Context,
-                  response_sender: Box<response::ResponseSender<Response>>)
-                  -> Context {
-    let config::Context{name, uuid, conditions, context_id, actions} = config_context;
-    let mut boxed_actions = Vec::new();
-
-    for i in actions.into_iter() {
-        let action = action::from_config(i, response_sender.boxed_clone());
-        boxed_actions.push(action);
-    }
-    let base = BaseContextBuilder::new(uuid, conditions);
-    let base = base.name(name);
-    let base = base.actions(boxed_actions);
-    let base = base.build();
-    if let Some(context_id) = context_id {
-        Context::Map(MapContext::new(base, context_id))
-    } else {
-        Context::Linear(LinearContext::from(base))
-    }
-}
-
-fn create_context_map(contexts: Vec<config::Context>,
-                      response_sender: Box<response::ResponseSender<Response>>)
-                      -> ContextMap {
-    let mut context_map = ContextMap::new();
-    for i in contexts.into_iter() {
-        let context: context::Context = create_context(i, response_sender.boxed_clone());
-        context_map.insert(context);
-    }
-    context_map
+    handlers: HashMap<ResponseHandle, Box<EventHandler<Response, mpsc::Sender<Request>>>>,
 }
 
 impl Correlator {
@@ -76,31 +43,28 @@ impl Correlator {
         let mut file = try!(File::open(path));
         let mut buffer = String::new();
         try!(file.read_to_string(&mut buffer));
-        let contexts = try!(from_str::<Vec<config::Context>>(&buffer));
+        let contexts = try!(from_str::<Vec<ContextConfig>>(&buffer));
         trace!("Correlator: loading contexts from file; len={}",
                contexts.len());
         Ok(Correlator::new(contexts))
     }
 
-    pub fn new(contexts: Vec<config::Context>) -> Correlator {
+    pub fn new(contexts: Vec<ContextConfig>) -> Correlator {
+        let context_map = ContextMap::from_configs(contexts);
         let (dispatcher_input_channel, rx) = mpsc::channel();
         let (dispatcher_output_channel_tx, dispatcher_output_channel_rx) = mpsc::channel();
         let _ = Timer::from_chan(Duration::from_millis(TIMER_STEP_MS),
                                  dispatcher_input_channel.clone());
 
         let handle = thread::spawn(move || {
-            let exit_condition = Condition::new(false);
-            let dmux = Demultiplexer::new(rx, exit_condition.clone());
-            let response_sender = Box::new(ResponseSender::new(dispatcher_output_channel_tx)) as Box<response::ResponseSender<Response>>;
-
-            let exit_handler =
-                Box::new(handlers::exit::ExitEventHandler::new(exit_condition,
-                                                               response_sender.boxed_clone()));
-            let timer_event_handler = Box::new(handlers::timer::TimerEventHandler::new());
-            let message_event_handler = Box::new(handlers::message::MessageEventHandler::new());
-
-            let context_map = create_context_map(contexts, response_sender);
-            let mut reactor = RequestReactor::new(dmux, context_map);
+            let dmux = Demultiplexer::new(rx);
+            let response_sender = Box::new(dispatcher_output_channel_tx);
+
+            let exit_handler = Box::new(ExitEventHandler::new());
+            let timer_event_handler = Box::new(TimerEventHandler::new());
+            let message_event_handler = Box::new(MessageEventHandler::new());
+
+            let mut reactor = RequestReactor::new(dmux, context_map, response_sender);
             reactor.register_handler(exit_handler);
             reactor.register_handler(timer_event_handler);
             reactor.register_handler(message_event_handler);
@@ -117,19 +81,17 @@ impl Correlator {
     }
 
     pub fn register_handler(&mut self,
-                            handler: Box<EventHandler<Response, mpsc::Sender<Request<Message>>>>) {
-        self.handlers.insert(handler.handler(), handler);
+                            handler: Box<EventHandler<Response, mpsc::Sender<Request>>>) {
+        self.handlers.insert(handler.handle(), handler);
     }
 
-    pub fn push_message(&mut self,
-                        message: Message)
-                        -> Result<(), mpsc::SendError<Request<Message>>> {
+    pub fn push_message(&mut self, message: Message) -> Result<(), mpsc::SendError<Request>> {
         self.handle_events();
-        self.dispatcher_input_channel.send(Request::Message(message))
+        self.dispatcher_input_channel.send(Request::Message(Arc::new(message)))
     }
 
     fn handle_event(&mut self, event: Response) {
-        if let Some(handler) = self.handlers.get_mut(&event.handler()) {
+        if let Some(handler) = self.handlers.get_mut(&event.handle()) {
             handler.handle_event(event, &mut self.dispatcher_input_channel);
         } else {
             trace!("no event handler found for handling a Response");
@@ -149,15 +111,11 @@ impl Correlator {
     }
 
     fn stop_dispatcher(&mut self) {
-        let exit_condition = Condition::new(false);
-        let exit_handler = Box::new(ExitHandler::new(exit_condition.clone(),
-                                                     self.dispatcher_input_channel.clone()));
+        let exit_handler = Box::new(ExitHandler::new());
         self.register_handler(exit_handler);
         let _ = self.dispatcher_input_channel.send(Request::Exit);
-        while !exit_condition.is_active() {
-            if let Ok(event) = self.dispatcher_output_channel.recv() {
-                self.handle_event(event);
-            }
+        while let Ok(event) = self.dispatcher_output_channel.recv() {
+            self.handle_event(event);
         }
     }
 }
diff --git a/src/correlator/test.rs b/src/correlator/test.rs
index 3489722..923a221 100644
--- a/src/correlator/test.rs
+++ b/src/correlator/test.rs
@@ -1,4 +1,4 @@
-use config;
+use config::{ContextConfigBuilder, ContextConfig};
 use config::action::message::MessageActionBuilder;
 use conditions::ConditionsBuilder;
 use Correlator;
@@ -103,11 +103,10 @@ fn test_given_manually_built_correlator_when_it_closes_a_context_then_the_action
     let message = Template::compile("message".to_string())
                       .ok()
                       .expect("Failed to compile a handlebars template");
-    let actions = vec![MessageActionBuilder::new("uuid", message).build().into()];
     let contexts = vec![
-        config::ContextBuilder::new(Uuid::new_v4(), condition.clone()).actions(actions.clone()).build(),
-        config::ContextBuilder::new(Uuid::new_v4(), condition.clone()).actions(actions.clone()).build(),
-        config::ContextBuilder::new(Uuid::new_v4(), condition.clone()).actions(actions.clone()).build(),
+        ContextConfigBuilder::new(Uuid::new_v4(), condition.clone()).actions(vec![MessageActionBuilder::new("uuid", message.clone()).build().into()]).build(),
+        ContextConfigBuilder::new(Uuid::new_v4(), condition.clone()).actions(vec![MessageActionBuilder::new("uuid", message.clone()).build().into()]).build(),
+        ContextConfigBuilder::new(Uuid::new_v4(), condition.clone()).actions(vec![MessageActionBuilder::new("uuid", message).build().into()]).build(),
     ];
     let responses = Rc::new(RefCell::new(Vec::new()));
     let message_event_handler = Box::new(MessageEventHandler { responses: responses.clone() });
@@ -124,11 +123,11 @@ fn test_given_manually_built_correlator_when_it_closes_a_context_then_the_action
 
 #[test]
 fn test_given_correlator_when_it_is_built_from_json_then_we_get_the_expected_correlator() {
-    let result = from_str::<Vec<config::Context>>(JSON_CONFIG);
+    let result = from_str::<Vec<ContextConfig>>(JSON_CONFIG);
     let expected_name = "CONTEXT_NAME_1".to_string();
     let expected_uuid = "185e96da-c00e-454b-b4fe-9d0a14a86335".to_string();
-    println!("{:?}", &result);
-    let mut contexts = result.ok().expect("Failed to deserialize a config::Context from JSON");
+    let mut contexts = result.ok()
+                             .expect("Failed to deserialize a config::ContextConfig from JSON");
     for i in &contexts {
         assert_eq!(true, i.name.is_some());
     }
@@ -143,9 +142,8 @@ fn test_given_correlator_when_it_is_built_from_json_then_it_produces_the_expecte
     let uuid1 = "1b47ba91-d867-4a8c-9553-a5dfd6ea1274".to_string();
     let uuid2 = "2b47ba91-d867-4a8c-9553-a5dfd6ea1274".to_string();
     let uuid3 = "3b47ba91-d867-4a8c-9553-a5dfd6ea1274".to_string();
-    let result = from_str::<Vec<config::Context>>(JSON_CONFIG);
-    println!("{:?}", &result);
-    let contexts = result.ok().expect("Failed to deserialize a config::Context from JSON");
+    let result = from_str::<Vec<ContextConfig>>(JSON_CONFIG);
+    let contexts = result.ok().expect("Failed to deserialize a config::ContextConfig from JSON");
     let responses = Rc::new(RefCell::new(Vec::new()));
     let message_event_handler = Box::new(MessageEventHandler { responses: responses.clone() });
     let mut correlator = Correlator::new(contexts);
diff --git a/src/dispatcher/demux.rs b/src/dispatcher/demux.rs
index 39b95db..973adf3 100644
--- a/src/dispatcher/demux.rs
+++ b/src/dispatcher/demux.rs
@@ -1,31 +1,36 @@
 use std::sync::mpsc::Receiver;
 
-use dispatcher::request::{InternalRequest, ExternalRequest};
+use dispatcher::request::Request;
 use reactor::EventDemultiplexer;
-use condition::Condition;
 
 pub struct Demultiplexer<T> {
     channel: Receiver<T>,
-    condition: Condition,
+    stops: u32,
 }
 
 impl<T> Demultiplexer<T> {
-    pub fn new(channel: Receiver<T>, condition: Condition) -> Demultiplexer<T> {
+    pub fn new(channel: Receiver<T>) -> Demultiplexer<T> {
         Demultiplexer {
             channel: channel,
-            condition: condition,
+            stops: 0,
         }
     }
 }
 
-impl EventDemultiplexer for Demultiplexer<ExternalRequest> {
-    type Event = InternalRequest;
+impl EventDemultiplexer for Demultiplexer<Request> {
+    type Event = Request;
     fn select(&mut self) -> Option<Self::Event> {
-        if !self.condition.is_active() {
-            let data = self.channel.recv().ok();
-            data.map(|request| request.into())
+        let data = self.channel.recv().ok();
+
+        if let Some(Request::Exit) = data {
+            if self.stops >= 1 {
+                None
+            } else {
+                self.stops += 1;
+                Some(Request::Exit)
+            }
         } else {
-            None
+            data
         }
     }
 }
diff --git a/src/dispatcher/handlers/exit.rs b/src/dispatcher/handlers/exit.rs
index 1f59c3d..acd758b 100644
--- a/src/dispatcher/handlers/exit.rs
+++ b/src/dispatcher/handlers/exit.rs
@@ -1,45 +1,25 @@
-use std::rc::Rc;
-
-use context::ContextMap;
 use dispatcher::response::ResponseSender;
 use dispatcher::Response;
-use dispatcher::request::{Request, RequestHandler};
-use condition::Condition;
-use message::Message;
-use reactor::EventHandler;
+use dispatcher::request::{Request, RequestHandle};
+use reactor::{EventHandler, SharedData};
 
-pub struct ExitEventHandler {
-    condition: Condition,
-    response_handler: Box<ResponseSender<Response>>,
-    stops: u32,
-}
+pub struct ExitEventHandler;
 
 impl ExitEventHandler {
-    pub fn new(condition: Condition,
-               response_handler: Box<ResponseSender<Response>>)
-               -> ExitEventHandler {
-        ExitEventHandler {
-            condition: condition,
-            response_handler: response_handler,
-            stops: 0,
-        }
+    pub fn new() -> ExitEventHandler {
+        ExitEventHandler
     }
 }
 
-impl EventHandler<Request<Rc<Message>>, ContextMap> for ExitEventHandler {
-    fn handle_event(&mut self, event: Request<Rc<Message>>, _: &mut ContextMap) {
+impl<'a> EventHandler<Request, SharedData<'a>> for ExitEventHandler {
+    fn handle_event(&mut self, event: Request, data: &mut SharedData) {
         if let Request::Exit = event {
-            self.stops += 1;
-            self.response_handler.send_response(Response::Exit);
-
-            if self.stops >= 2 {
-                self.condition.activate();
-            }
+            data.responder.send_response(Response::Exit);
         } else {
             unreachable!("An ExitEventHandler should only receive Exit events");
         }
     }
-    fn handler(&self) -> RequestHandler {
-        RequestHandler::Exit
+    fn handle(&self) -> RequestHandle {
+        RequestHandle::Exit
     }
 }
diff --git a/src/dispatcher/handlers/message.rs b/src/dispatcher/handlers/message.rs
index 1889406..fc8df75 100644
--- a/src/dispatcher/handlers/message.rs
+++ b/src/dispatcher/handlers/message.rs
@@ -1,7 +1,6 @@
-use dispatcher::request::{InternalRequest, Request, RequestHandler};
-use context::ContextMap;
+use dispatcher::request::{Request, RequestHandle};
 use context::context_map::StreamingIterator;
-use reactor;
+use reactor::{EventHandler, SharedData};
 
 pub struct MessageEventHandler;
 
@@ -11,21 +10,21 @@ impl MessageEventHandler {
     }
 }
 
-impl reactor::EventHandler<InternalRequest, ContextMap> for MessageEventHandler {
-    fn handle_event(&mut self, event: InternalRequest, data: &mut ContextMap) {
+impl<'a> EventHandler<Request, SharedData<'a>> for MessageEventHandler {
+    fn handle_event(&mut self, event: Request, data: &mut SharedData) {
         trace!("MessageEventHandler: handle_event()");
         if let Request::Message(event) = event {
             for i in event.ids() {
-                let mut iter = data.contexts_iter_mut(i);
+                let mut iter = data.map.contexts_iter_mut(i);
                 while let Some(context) = iter.next() {
-                    context.on_event(Request::Message(event.clone()));
+                    context.on_event(Request::Message(event.clone()), data.responder);
                 }
             }
         } else {
             unreachable!("MessageEventHandler should only handle Message events");
         }
     }
-    fn handler(&self) -> RequestHandler {
-        RequestHandler::Message
+    fn handle(&self) -> RequestHandle {
+        RequestHandle::Message
     }
 }
diff --git a/src/dispatcher/handlers/timer.rs b/src/dispatcher/handlers/timer.rs
index b72ceea..d5cb592 100644
--- a/src/dispatcher/handlers/timer.rs
+++ b/src/dispatcher/handlers/timer.rs
@@ -1,6 +1,5 @@
-use dispatcher::request::{InternalRequest, RequestHandler};
-use context::ContextMap;
-use reactor::EventHandler;
+use dispatcher::request::{Request, RequestHandle};
+use reactor::{EventHandler, SharedData};
 
 pub struct TimerEventHandler;
 
@@ -10,13 +9,13 @@ impl TimerEventHandler {
     }
 }
 
-impl EventHandler<InternalRequest, ContextMap> for TimerEventHandler {
-    fn handle_event(&mut self, event: InternalRequest, data: &mut ContextMap) {
-        for i in data.contexts_mut() {
-            i.on_event(event.clone());
+impl<'a> EventHandler<Request, SharedData<'a>> for TimerEventHandler {
+    fn handle_event(&mut self, event: Request, data: &mut SharedData) {
+        for i in data.map.contexts_mut() {
+            i.on_event(event.clone(), data.responder);
         }
     }
-    fn handler(&self) -> RequestHandler {
-        RequestHandler::Timer
+    fn handle(&self) -> RequestHandle {
+        RequestHandle::Timer
     }
 }
diff --git a/src/dispatcher/mod.rs b/src/dispatcher/mod.rs
index d0c4c1e..1a1669a 100644
--- a/src/dispatcher/mod.rs
+++ b/src/dispatcher/mod.rs
@@ -1,9 +1,8 @@
 use std::sync::mpsc::Sender;
-use std::rc::Rc;
-use std::cell::RefCell;
 
 use action::Alert;
 use reactor::Event;
+use self::response::ResponseSender;
 
 pub mod demux;
 pub mod handlers;
@@ -11,46 +10,30 @@ pub mod response;
 pub mod request;
 pub mod reactor;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Response {
     Exit,
     Alert(Alert),
 }
 
 #[derive(Debug, Eq, Hash, PartialEq)]
-pub enum ResponseHandler {
+pub enum ResponseHandle {
     Exit,
-    Message,
+    Alert,
 }
 
 impl Event for Response {
-    type Handler = ResponseHandler;
-    fn handler(&self) -> Self::Handler {
+    type Handle = ResponseHandle;
+    fn handle(&self) -> Self::Handle {
         match *self {
-            Response::Exit => ResponseHandler::Exit,
-            Response::Alert(_) => ResponseHandler::Message,
+            Response::Exit => ResponseHandle::Exit,
+            Response::Alert(_) => ResponseHandle::Alert,
         }
     }
 }
 
-#[derive(Clone)]
-pub struct ResponseSender {
-    sender: Rc<RefCell<Sender<Response>>>,
-}
-
-impl ResponseSender {
-    pub fn new(sender: Sender<Response>) -> ResponseSender {
-        ResponseSender { sender: Rc::new(RefCell::new(sender)) }
-    }
-}
-
-impl self::response::ResponseSender<Response> for ResponseSender {
-    fn send_response(&self, response: Response) {
-        let sender = self.sender.borrow_mut();
-        let _ = sender.send(response);
-    }
-
-    fn boxed_clone(&self) -> Box<self::response::ResponseSender<Response>> {
-        Box::new(self.clone())
+impl ResponseSender for Sender<Response> {
+    fn send_response(&mut self, response: Response) {
+        let _ = self.send(response);
     }
 }
diff --git a/src/dispatcher/reactor.rs b/src/dispatcher/reactor.rs
index b790999..502aef3 100644
--- a/src/dispatcher/reactor.rs
+++ b/src/dispatcher/reactor.rs
@@ -2,43 +2,49 @@ use std::collections::BTreeMap;
 
 use context::ContextMap;
 use dispatcher::demux::Demultiplexer;
-use dispatcher::request::{RequestHandler, InternalRequest, ExternalRequest};
-use reactor::{Event, EventDemultiplexer, EventHandler, Reactor};
+use dispatcher::request::{RequestHandle, Request};
+use reactor::{Event, EventDemultiplexer, EventHandler, Reactor, SharedData};
+use dispatcher::response::ResponseSender;
 
 pub struct RequestReactor {
-    handlers: BTreeMap<RequestHandler, Box<EventHandler<InternalRequest, ContextMap>>>,
-    demultiplexer: Demultiplexer<ExternalRequest>,
+    handlers: BTreeMap<RequestHandle, Box<for<'a> EventHandler<Request, SharedData<'a>>>>,
+    demultiplexer: Demultiplexer<Request>,
     context_map: ContextMap,
+    responder: Box<ResponseSender>,
 }
 
 impl RequestReactor {
-    pub fn new(demultiplexer: Demultiplexer<ExternalRequest>,
-               context_map: ContextMap)
+    pub fn new(demultiplexer: Demultiplexer<Request>,
+               context_map: ContextMap,
+               responder: Box<ResponseSender>)
                -> RequestReactor {
         RequestReactor {
             demultiplexer: demultiplexer,
             context_map: context_map,
             handlers: BTreeMap::new(),
+            responder: responder,
         }
     }
 }
 
-impl Reactor<ContextMap> for RequestReactor {
-    type Event = InternalRequest;
+impl Reactor for RequestReactor {
+    type Event = Request;
     fn handle_events(&mut self) {
+        let mut shared_data = SharedData::new(&mut self.context_map, &mut *self.responder);
         while let Some(request) = self.demultiplexer.select() {
             trace!("RequestReactor: got event");
-            if let Some(handler) = self.handlers.get_mut(&request.handler()) {
-                handler.handle_event(request, &mut self.context_map);
+            if let Some(handler) = self.handlers.get_mut(&request.handle()) {
+                handler.handle_event(request, &mut shared_data);
             } else {
                 trace!("RequestReactor: no handler found for event");
             }
         }
     }
-    fn register_handler(&mut self, handler: Box<EventHandler<Self::Event, ContextMap>>) {
-        self.handlers.insert(handler.handler(), handler);
+    fn register_handler(&mut self,
+                        handler: Box<for<'a> EventHandler<Self::Event, SharedData<'a>>>) {
+        self.handlers.insert(handler.handle(), handler);
     }
-    fn remove_handler_by_handler(&mut self, handler: &RequestHandler) {
+    fn remove_handler_by_handle(&mut self, handler: &RequestHandle) {
         self.handlers.remove(handler);
     }
 }
diff --git a/src/dispatcher/request.rs b/src/dispatcher/request.rs
index 6b2f9bd..b00bbe7 100644
--- a/src/dispatcher/request.rs
+++ b/src/dispatcher/request.rs
@@ -1,43 +1,30 @@
-use std::rc::Rc;
+use std::sync::Arc;
 
 use message::Message;
 use reactor;
 use timer::TimerEvent;
 
 #[derive(Clone, Debug)]
-pub enum Request<M> {
-    Message(M),
+pub enum Request {
+    Message(Arc<Message>),
     Timer(TimerEvent),
     Exit,
 }
 
-pub type InternalRequest = Request<Rc<Message>>;
-pub type ExternalRequest = Request<Message>;
-
 #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
-pub enum RequestHandler {
+pub enum RequestHandle {
     Message,
     Timer,
     Exit,
 }
 
-impl reactor::Event for Request<Rc<Message>> {
-    type Handler = RequestHandler;
-    fn handler(&self) -> Self::Handler {
+impl reactor::Event for Request {
+    type Handle = RequestHandle;
+    fn handle(&self) -> Self::Handle {
         match *self {
-            Request::Message(_) => RequestHandler::Message,
-            Request::Timer(_) => RequestHandler::Timer,
-            Request::Exit => RequestHandler::Exit,
-        }
-    }
-}
-
-impl From<Request<Message>> for Request<Rc<Message>> {
-    fn from(request: Request<Message>) -> Request<Rc<Message>> {
-        match request {
-            Request::Message(message) => Request::Message(Rc::new(message)),
-            Request::Timer(event) => Request::Timer(event),
-            Request::Exit => Request::Exit,
+            Request::Message(_) => RequestHandle::Message,
+            Request::Timer(_) => RequestHandle::Timer,
+            Request::Exit => RequestHandle::Exit,
         }
     }
 }
diff --git a/src/dispatcher/response.rs b/src/dispatcher/response.rs
index c8d1f81..cb827e0 100644
--- a/src/dispatcher/response.rs
+++ b/src/dispatcher/response.rs
@@ -1,4 +1,20 @@
-pub trait ResponseSender<T> {
-    fn send_response(&self, response: T);
-    fn boxed_clone(&self) -> Box<ResponseSender<T>>;
+use super::Response;
+
+pub trait ResponseSender {
+    fn send_response(&mut self, response: Response);
+}
+
+#[derive(Clone)]
+pub struct MockResponseSender(pub Vec<Response>);
+
+impl MockResponseSender {
+    pub fn new() -> MockResponseSender {
+        MockResponseSender(Vec::new())
+    }
+}
+
+impl ResponseSender for MockResponseSender {
+    fn send_response(&mut self, response: Response) {
+        self.0.push(response);
+    }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 799be35..c85534f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -21,7 +21,6 @@ pub use message::Message;
 pub mod conditions;
 pub mod config;
 pub mod action;
-pub mod condition;
 mod context;
 pub mod correlator;
 pub mod dispatcher;
diff --git a/src/message/builder.rs b/src/message/builder.rs
index c15a5c7..2fb0e3b 100644
--- a/src/message/builder.rs
+++ b/src/message/builder.rs
@@ -19,12 +19,8 @@ impl MessageBuilder {
         }
     }
 
-    pub fn name(&mut self, name: Option<&str>) -> &mut MessageBuilder {
-        if let Some(name) = name {
-            self.name = Some(name.to_string());
-        } else {
-            self.name = None;
-        }
+    pub fn name<S: Into<String>>(&mut self, name: Option<S>) -> &mut MessageBuilder {
+        self.name = name.map(|name| name.into());
         self
     }
 
diff --git a/src/reactor.rs b/src/reactor.rs
index cafe5b6..12a64c9 100644
--- a/src/reactor.rs
+++ b/src/reactor.rs
@@ -1,6 +1,23 @@
+use dispatcher::response::ResponseSender;
+use context::ContextMap;
+
+pub struct SharedData<'a> {
+    pub responder: &'a mut ResponseSender,
+    pub map: &'a mut ContextMap,
+}
+
+impl<'a> SharedData<'a> {
+    pub fn new(map: &'a mut ContextMap, responder: &'a mut ResponseSender) -> SharedData<'a> {
+        SharedData {
+            map: map,
+            responder: responder,
+        }
+    }
+}
+
 pub trait EventHandler<T: Event, D> {
     fn handle_event(&mut self, event: T, shared_data: &mut D);
-    fn handler(&self) -> T::Handler;
+    fn handle(&self) -> T::Handle;
 }
 
 pub trait EventDemultiplexer {
@@ -8,15 +25,16 @@ pub trait EventDemultiplexer {
     fn select(&mut self) -> Option<Self::Event>;
 }
 
-pub trait Reactor<D> {
+pub trait Reactor {
     type Event: Event;
     fn handle_events(&mut self);
-    fn register_handler(&mut self, handler: Box<EventHandler<Self::Event, D>>);
-    fn remove_handler_by_handler(&mut self,
-                                 handler: &<<Self as Reactor<D>>::Event as Event>::Handler);
+    fn register_handler(&mut self,
+                        handler: Box<for<'a> EventHandler<Self::Event, SharedData<'a>>>);
+    fn remove_handler_by_handle(&mut self,
+                                 handler: &<<Self as Reactor>::Event as Event>::Handle);
 }
 
 pub trait Event {
-    type Handler;
-    fn handler(&self) -> Self::Handler;
+    type Handle;
+    fn handle(&self) -> Self::Handle;
 }
diff --git a/src/state.rs b/src/state.rs
index 06d0ca2..ded7d47 100644
--- a/src/state.rs
+++ b/src/state.rs
@@ -1,15 +1,17 @@
-use std::rc::Rc;
+use std::sync::Arc;
 
+use action::Action;
 use Message;
 use timer::TimerEvent;
 use std::time::Duration;
 use context::BaseContext;
+use dispatcher::response::ResponseSender;
 
 #[derive(Debug)]
 pub struct State {
     elapsed_time: Duration,
     elapsed_time_since_last_message: Duration,
-    messages: Vec<Rc<Message>>,
+    messages: Vec<Arc<Message>>,
     opened: bool,
 }
 
@@ -18,7 +20,7 @@ impl State {
         State::with_messages(Vec::new())
     }
 
-    pub fn with_messages(messages: Vec<Rc<Message>>) -> State {
+    pub fn with_messages(messages: Vec<Arc<Message>>) -> State {
         State {
             elapsed_time: Duration::from_secs(0),
             elapsed_time_since_last_message: Duration::from_secs(0),
@@ -31,18 +33,18 @@ impl State {
         self.opened
     }
 
-    fn open(&mut self, context: &BaseContext) {
+    fn open(&mut self, context: &BaseContext, responder: &mut ResponseSender) {
         trace!("Context: opening state; uuid={}", context.uuid());
         for i in context.actions() {
-            i.on_opened(self, context);
+            i.on_opened(self, context, responder);
         }
         self.opened = true;
     }
 
-    fn close(&mut self, context: &BaseContext) {
+    fn close(&mut self, context: &BaseContext, responder: &mut ResponseSender) {
         trace!("Context: closing state; uuid={}", context.uuid());
         for i in context.actions() {
-            i.on_closed(self, context);
+            i.on_closed(self, context, responder);
         }
         self.reset();
     }
@@ -55,34 +57,40 @@ impl State {
         self.elapsed_time_since_last_message
     }
 
-    pub fn messages(&self) -> &[Rc<Message>] {
+    pub fn messages(&self) -> &[Arc<Message>] {
         &self.messages
     }
 
-    fn add_message(&mut self, message: Rc<Message>) {
+    fn add_message(&mut self, message: Arc<Message>) {
         self.messages.push(message);
         self.elapsed_time_since_last_message = Duration::from_secs(0);
     }
 
-    pub fn on_timer(&mut self, event: &TimerEvent, context: &BaseContext) {
+    pub fn on_timer(&mut self,
+                    event: &TimerEvent,
+                    context: &BaseContext,
+                    responder: &mut ResponseSender) {
         if self.is_open() {
             self.update_timers(event);
         }
         if context.conditions().is_closing(self) {
-            self.close(context);
+            self.close(context, responder);
         }
     }
 
-    pub fn on_message(&mut self, event: Rc<Message>, context: &BaseContext) {
+    pub fn on_message(&mut self,
+                      event: Arc<Message>,
+                      context: &BaseContext,
+                      responder: &mut ResponseSender) {
         if self.is_open() {
             self.add_message(event);
         } else if context.conditions().is_opening(&event) {
             self.add_message(event);
-            self.open(context);
+            self.open(context, responder);
         }
 
         if context.conditions().is_closing(self) {
-            self.close(context);
+            self.close(context, responder);
         }
     }
 
diff --git a/src/test_utils/correlator.rs b/src/test_utils/correlator.rs
index 2185f22..4a2b2f5 100644
--- a/src/test_utils/correlator.rs
+++ b/src/test_utils/correlator.rs
@@ -1,6 +1,5 @@
-use dispatcher::ResponseHandler;
+use dispatcher::ResponseHandle;
 use Response;
-use Message;
 
 use std::rc::Rc;
 use std::cell::RefCell;
@@ -14,13 +13,13 @@ pub struct MessageEventHandler {
     pub responses: Rc<RefCell<Vec<Alert>>>,
 }
 
-impl EventHandler<Response, mpsc::Sender<Request<Message>>> for MessageEventHandler {
-    fn handle_event(&mut self, event: Response, _: &mut mpsc::Sender<Request<Message>>) {
+impl EventHandler<Response, mpsc::Sender<Request>> for MessageEventHandler {
+    fn handle_event(&mut self, event: Response, _: &mut mpsc::Sender<Request>) {
         if let Response::Alert(event) = event {
             self.responses.borrow_mut().push(event);
         }
     }
-    fn handler(&self) -> ResponseHandler {
-        ResponseHandler::Message
+    fn handle(&self) -> ResponseHandle {
+        ResponseHandle::Alert
     }
 }
diff --git a/src/timer.rs b/src/timer.rs
index 647271f..1c7cf5c 100644
--- a/src/timer.rs
+++ b/src/timer.rs
@@ -2,7 +2,7 @@ use std::sync::mpsc;
 use std::thread;
 use std::time::Duration;
 
-use dispatcher::request::{ExternalRequest, Request};
+use dispatcher::request::Request;
 
 #[derive(Clone, Copy, Debug)]
 pub struct TimerEvent(pub Duration);
@@ -17,13 +17,10 @@ impl TimerEvent {
 pub struct Timer;
 
 impl Timer {
-    pub fn from_chan(duration: Duration, tx: mpsc::Sender<ExternalRequest>) {
+    pub fn from_chan(duration: Duration, tx: mpsc::Sender<Request>) {
         thread::spawn(move || {
-            loop {
+            while let Ok(_) = tx.send(Request::Timer(TimerEvent(duration))) {
                 thread::sleep(duration);
-                if tx.send(Request::Timer(TimerEvent(duration))).is_err() {
-                    break;
-                }
             }
         });
     }