handle_* -> *

Now that we have the controller.handler decorator, the _handler prefix
stutters.

6 files changed, 46 insertions, 42 deletions

diff --git a/mitmproxy/console/__init__.py b/mitmproxy/console/__init__.py
index 9ce02e72..c3157292 100644
--- a/mitmproxy/console/__init__.py
+++ b/mitmproxy/console/__init__.py
@@ -730,28 +730,28 @@ class ConsoleMaster(flow.FlowMaster):
 
     # Handlers
     @controller.handler
-    def handle_error(self, f):
+    def error(self, f):
         f = flow.FlowMaster.handle_error(self, f)
         if f:
             self.process_flow(f)
         return f
 
     @controller.handler
-    def handle_request(self, f):
+    def request(self, f):
         f = flow.FlowMaster.handle_request(self, f)
         if f:
             self.process_flow(f)
         return f
 
     @controller.handler
-    def handle_response(self, f):
+    def response(self, f):
         f = flow.FlowMaster.handle_response(self, f)
         if f:
             self.process_flow(f)
         return f
 
     @controller.handler
-    def handle_script_change(self, script):
+    def script_change(self, script):
         if super(ConsoleMaster, self).handle_script_change(script):
             signals.status_message.send(message='"{}" reloaded.'.format(script.filename))
         else:
diff --git a/mitmproxy/controller.py b/mitmproxy/controller.py
index 5a354fd2..51d58723 100644
--- a/mitmproxy/controller.py
+++ b/mitmproxy/controller.py
@@ -66,8 +66,10 @@ class Master(object):
                 mtype, obj = self.event_queue.get(timeout=timeout)
                 if mtype not in Events:
                     raise ControlError("Unknown event %s"%repr(mtype))
-                handle_func = getattr(self, "handle_" + mtype)
-                if not handle_func.func_dict.get("handler"):
+                handle_func = getattr(self, mtype)
+                if not hasattr(handle_func, "func_dict"):
+                    raise ControlError("Handler %s not a function"%mtype)
+                if not handle_func.func_dict.get("__handler"):
                     raise ControlError(
                         "Handler function %s is not decorated with controller.handler"%(
                             handle_func
@@ -187,7 +189,7 @@ def handler(f):
         if handling and not message.reply.acked and not message.reply.taken:
             message.reply()
         return ret
-    wrapper.func_dict["handler"] = True
+    wrapper.func_dict["__handler"] = True
     return wrapper
 
 
diff --git a/mitmproxy/dump.py b/mitmproxy/dump.py
index cbf4b3da..4443995a 100644
--- a/mitmproxy/dump.py
+++ b/mitmproxy/dump.py
@@ -10,7 +10,6 @@ from . import flow, filt, contentviews, controller
 from .exceptions import ContentViewException, FlowReadException, ScriptException
 
 
-
 class DumpError(Exception):
     pass
 
@@ -326,22 +325,25 @@ class DumpMaster(flow.FlowMaster):
 
         self.echo_flow(f)
 
-    def handle_request(self, f):
-        flow.FlowMaster.handle_request(self, f)
+    @controller.handler
+    def request(self, f):
+        flow.FlowMaster.request(self, f)
         self.state.delete_flow(f)
         if f:
             f.reply()
         return f
 
-    def handle_response(self, f):
-        flow.FlowMaster.handle_response(self, f)
+    @controller.handler
+    def response(self, f):
+        flow.FlowMaster.response(self, f)
         if f:
             f.reply()
             self._process_flow(f)
         return f
 
-    def handle_error(self, f):
-        flow.FlowMaster.handle_error(self, f)
+    @controller.handler
+    def error(self, f):
+        flow.FlowMaster.error(self, f)
         if f:
             self._process_flow(f)
         return f
diff --git a/mitmproxy/flow.py b/mitmproxy/flow.py
index 716d9a17..407f0d7b 100644
--- a/mitmproxy/flow.py
+++ b/mitmproxy/flow.py
@@ -208,9 +208,9 @@ class ClientPlaybackState:
                 master.replay_request(self.current)
             else:
                 self.current.reply = controller.DummyReply()
-                master.handle_request(self.current)
+                master.request(self.current)
                 if self.current.response:
-                    master.handle_response(self.current)
+                    master.response(self.current)
 
 
 class ServerPlaybackState:
@@ -894,23 +894,23 @@ class FlowMaster(controller.Master):
 
             f.reply = controller.DummyReply()
             if f.request:
-                self.handle_request(f)
+                self.request(f)
             if f.response:
-                self.handle_responseheaders(f)
-                self.handle_response(f)
+                self.responseheaders(f)
+                self.response(f)
             if f.error:
-                self.handle_error(f)
+                self.error(f)
         elif isinstance(f, TCPFlow):
             messages = f.messages
             f.messages = []
             f.reply = controller.DummyReply()
-            self.handle_tcp_open(f)
+            self.tcp_open(f)
             while messages:
                 f.messages.append(messages.pop(0))
-                self.handle_tcp_message(f)
+                self.tcp_message(f)
             if f.error:
-                self.handle_tcp_error(f)
-            self.handle_tcp_close(f)
+                self.tcp_error(f)
+            self.tcp_close(f)
         else:
             raise NotImplementedError()
 
@@ -987,31 +987,31 @@ class FlowMaster(controller.Master):
                 rt.join()
 
     @controller.handler
-    def handle_log(self, l):
+    def log(self, l):
         self.add_event(l.msg, l.level)
 
     @controller.handler
-    def handle_clientconnect(self, root_layer):
+    def clientconnect(self, root_layer):
         self.run_script_hook("clientconnect", root_layer)
 
     @controller.handler
-    def handle_clientdisconnect(self, root_layer):
+    def clientdisconnect(self, root_layer):
         self.run_script_hook("clientdisconnect", root_layer)
 
     @controller.handler
-    def handle_serverconnect(self, server_conn):
+    def serverconnect(self, server_conn):
         self.run_script_hook("serverconnect", server_conn)
 
     @controller.handler
-    def handle_serverdisconnect(self, server_conn):
+    def serverdisconnect(self, server_conn):
         self.run_script_hook("serverdisconnect", server_conn)
 
     @controller.handler
-    def handle_next_layer(self, top_layer):
+    def next_layer(self, top_layer):
         self.run_script_hook("next_layer", top_layer)
 
     @controller.handler
-    def handle_error(self, f):
+    def error(self, f):
         self.state.update_flow(f)
         self.run_script_hook("error", f)
         if self.client_playback:
@@ -1019,7 +1019,7 @@ class FlowMaster(controller.Master):
         return f
 
     @controller.handler
-    def handle_request(self, f):
+    def request(self, f):
         if f.live:
             app = self.apps.get(f.request)
             if app:
@@ -1042,7 +1042,7 @@ class FlowMaster(controller.Master):
         return f
 
     @controller.handler
-    def handle_responseheaders(self, f):
+    def responseheaders(self, f):
         try:
             if self.stream_large_bodies:
                 self.stream_large_bodies.run(f, False)
@@ -1053,7 +1053,7 @@ class FlowMaster(controller.Master):
         return f
 
     @controller.handler
-    def handle_response(self, f):
+    def response(self, f):
         self.active_flows.discard(f)
         self.state.update_flow(f)
         self.replacehooks.run(f)
@@ -1101,14 +1101,14 @@ class FlowMaster(controller.Master):
         return ok
 
     @controller.handler
-    def handle_tcp_open(self, flow):
+    def tcp_open(self, flow):
         # TODO: This would break mitmproxy currently.
         # self.state.add_flow(flow)
         self.active_flows.add(flow)
         self.run_script_hook("tcp_open", flow)
 
     @controller.handler
-    def handle_tcp_message(self, flow):
+    def tcp_message(self, flow):
         self.run_script_hook("tcp_message", flow)
         message = flow.messages[-1]
         direction = "->" if message.from_client else "<-"
@@ -1120,7 +1120,7 @@ class FlowMaster(controller.Master):
         self.add_event(clean_bin(message.content), "debug")
 
     @controller.handler
-    def handle_tcp_error(self, flow):
+    def tcp_error(self, flow):
         self.add_event("Error in TCP connection to {}: {}".format(
             repr(flow.server_conn.address),
             flow.error
@@ -1128,7 +1128,7 @@ class FlowMaster(controller.Master):
         self.run_script_hook("tcp_error", flow)
 
     @controller.handler
-    def handle_tcp_close(self, flow):
+    def tcp_close(self, flow):
         self.active_flows.discard(flow)
         if self.stream:
             self.stream.add(flow)
diff --git a/mitmproxy/models/flow.py b/mitmproxy/models/flow.py
index 1019c9fb..8797fcd8 100644
--- a/mitmproxy/models/flow.py
+++ b/mitmproxy/models/flow.py
@@ -152,7 +152,7 @@ class Flow(stateobject.StateObject):
         self.error = Error("Connection killed")
         self.intercepted = False
         self.reply(Kill)
-        master.handle_error(self)
+        master.error(self)
 
     def intercept(self, master):
         """
diff --git a/mitmproxy/web/__init__.py b/mitmproxy/web/__init__.py
index 7fef6df1..f8102ed8 100644
--- a/mitmproxy/web/__init__.py
+++ b/mitmproxy/web/__init__.py
@@ -197,17 +197,17 @@ class WebMaster(flow.FlowMaster):
             f.reply.take()
 
     @controller.handler
-    def handle_request(self, f):
+    def request(self, f):
         super(WebMaster, self).handle_request(f)
         self._process_flow(f)
 
     @controller.handler
-    def handle_response(self, f):
+    def response(self, f):
         super(WebMaster, self).handle_response(f)
         self._process_flow(f)
 
     @controller.handler
-    def handle_error(self, f):
+    def error(self, f):
         super(WebMaster, self).handle_error(f)
         self._process_flow(f)