kylefang/mitmproxy
1
0
Fork 0
mirror of https://github.com/zhigang1992/mitmproxy.git synced 2026-04-28 20:24:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

handle_* -> *

Browse Source 
Now that we have the controller.handler decorator, the _handler prefix
stutters.
This commit is contained in:
Aldo Cortesi
2016-05-29 12:49:01 +12:00
parent 8bb9285678
commit 0a875421c5
12 changed files with 104 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
mitmproxy/console/__init__.py
View File

@@ -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:

8
mitmproxy/controller.py
View File

@@ -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

16
mitmproxy/dump.py
View File

@@ -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

48
mitmproxy/flow.py
View File

@@ -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)

2
mitmproxy/models/flow.py
View File

@@ -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):
"""

6
mitmproxy/web/__init__.py
View File

@@ -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)

2
test/mitmproxy/test_controller.py
View File

@@ -18,7 +18,7 @@ class TestMaster(object):
def test_simple(self):
class DummyMaster(controller.Master):
@controller.handler
def handle_log(self, _):
def log(self, _):
m.should_exit.set()
def tick(self, timeout):

22
test/mitmproxy/test_dump.py
View File

@@ -64,14 +64,14 @@ class TestDumpMaster:
f = tutils.tflow(req=netlib.tutils.treq(content=content))
l = Log("connect")
l.reply = mock.MagicMock()
m.handle_log(l)
m.handle_clientconnect(f.client_conn)
m.handle_serverconnect(f.server_conn)
m.handle_request(f)
m.log(l)
m.clientconnect(f.client_conn)
m.serverconnect(f.server_conn)
m.request(f)
if not f.error:
f.response = HTTPResponse.wrap(netlib.tutils.tresp(content=content))
f = m.handle_response(f)
m.handle_clientdisconnect(f.client_conn)
f = m.response(f)
m.clientdisconnect(f.client_conn)
return f
def _dummy_cycle(self, n, filt, content, **options):
@@ -95,8 +95,8 @@ class TestDumpMaster:
o = dump.Options(flow_detail=1)
m = dump.DumpMaster(None, o, outfile=cs)
f = tutils.tflow(err=True)
m.handle_request(f)
assert m.handle_error(f)
m.request(f)
assert m.error(f)
assert "error" in cs.getvalue()
def test_missing_content(self):
@@ -105,10 +105,10 @@ class TestDumpMaster:
m = dump.DumpMaster(None, o, outfile=cs)
f = tutils.tflow()
f.request.content = None
m.handle_request(f)
m.request(f)
f.response = HTTPResponse.wrap(netlib.tutils.tresp())
f.response.content = None
m.handle_response(f)
m.response(f)
assert "content missing" in cs.getvalue()
def test_replay(self):
@@ -160,7 +160,7 @@ class TestDumpMaster:
assert o.verbosity == 2
def test_filter(self):
assert not "GET" in self._dummy_cycle(1, "~u foo", "", verbosity=1)
assert "GET" not in self._dummy_cycle(1, "~u foo", "", verbosity=1)
def test_app(self):
o = dump.Options(app=True)

50
test/mitmproxy/test_flow.py
View File

@@ -53,7 +53,7 @@ class TestStickyCookieState:
assert s.domain_match("www.google.com", ".google.com")
assert s.domain_match("google.com", ".google.com")
def test_handle_response(self):
def test_response(self):
c = "SSID=mooo; domain=.google.com, FOO=bar; Domain=.google.com; Path=/; "\
"Expires=Wed, 13-Jan-2021 22:23:01 GMT; Secure; "
@@ -100,7 +100,7 @@ class TestStickyCookieState:
assert len(s.jar[googlekey].keys()) == 1
assert s.jar[googlekey]["somecookie"].items()[0][1] == "newvalue"
def test_handle_request(self):
def test_request(self):
s, f = self._response("SSID=mooo", "www.google.com")
assert "cookie" not in f.request.headers
s.handle_request(f)
@@ -109,7 +109,7 @@ class TestStickyCookieState:
class TestStickyAuthState:
def test_handle_response(self):
def test_response(self):
s = flow.StickyAuthState(filt.parse(".*"))
f = tutils.tflow(resp=True)
f.request.headers["authorization"] = "foo"
@@ -798,8 +798,8 @@ class TestFlowMaster:
fm = flow.FlowMaster(None, s)
fm.load_script(tutils.test_data.path("scripts/reqerr.py"))
f = tutils.tflow()
fm.handle_clientconnect(f.client_conn)
assert fm.handle_request(f)
fm.clientconnect(f.client_conn)
assert fm.request(f)
def test_script(self):
s = flow.State()
@@ -807,18 +807,18 @@ class TestFlowMaster:
fm.load_script(tutils.test_data.path("scripts/all.py"))
f = tutils.tflow(resp=True)
fm.handle_clientconnect(f.client_conn)
fm.clientconnect(f.client_conn)
assert fm.scripts[0].ns["log"][-1] == "clientconnect"
fm.handle_serverconnect(f.server_conn)
fm.serverconnect(f.server_conn)
assert fm.scripts[0].ns["log"][-1] == "serverconnect"
fm.handle_request(f)
fm.request(f)
assert fm.scripts[0].ns["log"][-1] == "request"
fm.handle_response(f)
fm.response(f)
assert fm.scripts[0].ns["log"][-1] == "response"
# load second script
fm.load_script(tutils.test_data.path("scripts/all.py"))
assert len(fm.scripts) == 2
fm.handle_clientdisconnect(f.server_conn)
fm.clientdisconnect(f.server_conn)
assert fm.scripts[0].ns["log"][-1] == "clientdisconnect"
assert fm.scripts[1].ns["log"][-1] == "clientdisconnect"
@@ -828,7 +828,7 @@ class TestFlowMaster:
fm.load_script(tutils.test_data.path("scripts/all.py"))
f.error = tutils.terr()
fm.handle_error(f)
fm.error(f)
assert fm.scripts[0].ns["log"][-1] == "error"
def test_duplicate_flow(self):
@@ -853,20 +853,20 @@ class TestFlowMaster:
fm.anticache = True
fm.anticomp = True
f = tutils.tflow(req=None)
fm.handle_clientconnect(f.client_conn)
fm.clientconnect(f.client_conn)
f.request = HTTPRequest.wrap(netlib.tutils.treq())
fm.handle_request(f)
fm.request(f)
assert s.flow_count() == 1
f.response = HTTPResponse.wrap(netlib.tutils.tresp())
fm.handle_response(f)
fm.response(f)
assert s.flow_count() == 1
fm.handle_clientdisconnect(f.client_conn)
fm.clientdisconnect(f.client_conn)
f.error = Error("msg")
f.error.reply = controller.DummyReply()
fm.handle_error(f)
fm.error(f)
fm.load_script(tutils.test_data.path("scripts/a.py"))
fm.shutdown()
@@ -895,7 +895,7 @@ class TestFlowMaster:
assert fm.state.flow_count()
f.error = Error("error")
fm.handle_error(f)
fm.error(f)
def test_server_playback(self):
s = flow.State()
@@ -976,12 +976,12 @@ class TestFlowMaster:
fm.set_stickycookie(".*")
f = tutils.tflow(resp=True)
f.response.headers["set-cookie"] = "foo=bar"
fm.handle_request(f)
fm.handle_response(f)
fm.request(f)
fm.response(f)
assert fm.stickycookie_state.jar
assert not "cookie" in f.request.headers
f = f.copy()
fm.handle_request(f)
fm.request(f)
assert f.request.headers["cookie"] == "foo=bar"
def test_stickyauth(self):
@@ -996,12 +996,12 @@ class TestFlowMaster:
fm.set_stickyauth(".*")
f = tutils.tflow(resp=True)
f.request.headers["authorization"] = "foo"
fm.handle_request(f)
fm.request(f)
f = tutils.tflow(resp=True)
assert fm.stickyauth_state.hosts
assert not "authorization" in f.request.headers
fm.handle_request(f)
fm.request(f)
assert f.request.headers["authorization"] == "foo"
def test_stream(self):
@@ -1017,15 +1017,15 @@ class TestFlowMaster:
f = tutils.tflow(resp=True)
fm.start_stream(file(p, "ab"), None)
fm.handle_request(f)
fm.handle_response(f)
fm.request(f)
fm.response(f)
fm.stop_stream()
assert r()[0].response
f = tutils.tflow()
fm.start_stream(file(p, "ab"), None)
fm.handle_request(f)
fm.request(f)
fm.shutdown()
assert not r()[1].response

2
test/mitmproxy/test_script.py
View File

@@ -7,7 +7,7 @@ def test_duplicate_flow():
fm = flow.FlowMaster(None, s)
fm.load_script(tutils.test_data.path("scripts/duplicate_flow.py"))
f = tutils.tflow()
fm.handle_request(f)
fm.request(f)
assert fm.state.flow_count() == 2
assert not fm.state.view[0].request.is_replay
assert fm.state.view[1].request.is_replay

32
test/mitmproxy/test_server.py
View File

@@ -191,8 +191,8 @@ class TcpMixin:
assert i_cert == i2_cert == n_cert
# Make sure that TCP messages are in the event log.
assert any("305" in m for m in self.master.log)
assert any("306" in m for m in self.master.log)
assert any("305" in m for m in self.master.tlog)
assert any("306" in m for m in self.master.tlog)
class AppMixin:
@@ -261,7 +261,7 @@ class TestHTTP(tservers.HTTPProxyTest, CommonMixin, AppMixin):
p = self.pathoc()
assert p.request(req % self.server.urlbase)
assert p.request(req % self.server2.urlbase)
assert switched(self.proxy.log)
assert switched(self.proxy.tlog)
def test_blank_leading_line(self):
p = self.pathoc()
@@ -500,7 +500,7 @@ class TestHttps2Http(tservers.ReverseProxyTest):
def test_sni(self):
p = self.pathoc(ssl=True, sni="example.com")
assert p.request("get:'/p/200'").status_code == 200
assert all("Error in handle_sni" not in msg for msg in self.proxy.log)
assert all("Error in handle_sni" not in msg for msg in self.proxy.tlog)
def test_http(self):
p = self.pathoc(ssl=False)
@@ -625,7 +625,7 @@ class MasterRedirectRequest(tservers.TestMaster):
redirect_port = None # Set by TestRedirectRequest
@controller.handler
def handle_request(self, f):
def request(self, f):
if f.request.path == "/p/201":
# This part should have no impact, but it should also not cause any exceptions.
@@ -636,13 +636,13 @@ class MasterRedirectRequest(tservers.TestMaster):
# This is the actual redirection.
f.request.port = self.redirect_port
super(MasterRedirectRequest, self).handle_request(f)
super(MasterRedirectRequest, self).request(f)
@controller.handler
def handle_response(self, f):
def response(self, f):
f.response.content = str(f.client_conn.address.port)
f.response.headers["server-conn-id"] = str(f.server_conn.source_address.port)
super(MasterRedirectRequest, self).handle_response(f)
super(MasterRedirectRequest, self).response(f)
class TestRedirectRequest(tservers.HTTPProxyTest):
@@ -693,7 +693,7 @@ class MasterStreamRequest(tservers.TestMaster):
Enables the stream flag on the flow for all requests
"""
@controller.handler
def handle_responseheaders(self, f):
def responseheaders(self, f):
f.response.stream = True
@@ -742,7 +742,7 @@ class TestStreamRequest(tservers.HTTPProxyTest):
class MasterFakeResponse(tservers.TestMaster):
@controller.handler
def handle_request(self, f):
def request(self, f):
resp = HTTPResponse.wrap(netlib.tutils.tresp())
f.reply(resp)
@@ -763,14 +763,14 @@ class TestServerConnect(tservers.HTTPProxyTest):
def test_unnecessary_serverconnect(self):
"""A replayed/fake response with no_upstream_cert should not connect to an upstream server"""
assert self.pathod("200").status_code == 200
for msg in self.proxy.tmaster.log:
for msg in self.proxy.tmaster.tlog:
assert "serverconnect" not in msg
class MasterKillRequest(tservers.TestMaster):
@controller.handler
def handle_request(self, f):
def request(self, f):
f.reply(Kill)
@@ -787,7 +787,7 @@ class TestKillRequest(tservers.HTTPProxyTest):
class MasterKillResponse(tservers.TestMaster):
@controller.handler
def handle_response(self, f):
def response(self, f):
f.reply(Kill)
@@ -817,7 +817,7 @@ class TestTransparentResolveError(tservers.TransparentProxyTest):
class MasterIncomplete(tservers.TestMaster):
@controller.handler
def handle_request(self, f):
def request(self, f):
resp = HTTPResponse.wrap(netlib.tutils.tresp())
resp.content = None
f.reply(resp)
@@ -949,14 +949,14 @@ class TestProxyChainingSSLReconnect(tservers.HTTPUpstreamProxyTest):
kill_requests(
self.chain[1].tmaster,
"handle_request",
"request",
exclude = [
# fail first request
2, # allow second request
]
)
kill_requests(self.chain[0].tmaster, "handle_request",
kill_requests(self.chain[0].tmaster, "request",
exclude=[
1, # CONNECT
# fail first request

16
test/mitmproxy/tservers.py
View File

@@ -39,19 +39,11 @@ class TestMaster(flow.FlowMaster):
self.apps.add(errapp, "errapp", 80)
self.clear_log()
@controller.handler
def handle_request(self, f):
flow.FlowMaster.handle_request(self, f)
@controller.handler
def handle_response(self, f):
flow.FlowMaster.handle_response(self, f)
def clear_log(self):
self.log = []
self.tlog = []
def add_event(self, message, level=None):
self.log.append(message)
self.tlog.append(message)
class ProxyThread(threading.Thread):
@@ -68,8 +60,8 @@ class ProxyThread(threading.Thread):
return self.tmaster.server.address.port
@property
def log(self):
return self.tmaster.log
def tlog(self):
return self.tmaster.tlog
def run(self):
self.tmaster.run()