mirror of
https://github.com/mitmproxy/mitmproxy.git
synced 2025-02-02 11:32:55 +00:00
Clean up interfaces by making some methods pseudo-private.
This commit is contained in:
Aldo Cortesi
parent
57c653be5f
commit
9042d3f3b9
@ -62,11 +62,11 @@ class Headers:
|
||||
def add(self, key, value):
|
||||
self.lst.append([key, str(value)])
|
||||
|
||||
def get_state(self):
|
||||
def _get_state(self):
|
||||
return [tuple(i) for i in self.lst]
|
||||
|
||||
@classmethod
|
||||
def from_state(klass, state):
|
||||
def _from_state(klass, state):
|
||||
return klass([list(i) for i in state])
|
||||
|
||||
def copy(self):
|
||||
@ -85,7 +85,10 @@ class Headers:
|
||||
|
||||
def match_re(self, expr):
|
||||
"""
|
||||
Match the regular expression against each header (key, value) pair.
|
||||
Match the regular expression against each header. For each (key,
|
||||
value) pair a string of the following format is matched against:
|
||||
|
||||
"key: value"
|
||||
"""
|
||||
for k, v in self.lst:
|
||||
s = "%s: %s"%(k, v)
|
||||
@ -211,12 +214,12 @@ class Request(HTTPMsg):
|
||||
else:
|
||||
return True
|
||||
|
||||
def load_state(self, state):
|
||||
def _load_state(self, state):
|
||||
if state["client_conn"]:
|
||||
if self.client_conn:
|
||||
self.client_conn.load_state(state["client_conn"])
|
||||
self.client_conn._load_state(state["client_conn"])
|
||||
else:
|
||||
self.client_conn = ClientConnect.from_state(state["client_conn"])
|
||||
self.client_conn = ClientConnect._from_state(state["client_conn"])
|
||||
else:
|
||||
self.client_conn = None
|
||||
self.host = state["host"]
|
||||
@ -224,33 +227,33 @@ class Request(HTTPMsg):
|
||||
self.scheme = state["scheme"]
|
||||
self.method = state["method"]
|
||||
self.path = state["path"]
|
||||
self.headers = Headers.from_state(state["headers"])
|
||||
self.headers = Headers._from_state(state["headers"])
|
||||
self.content = base64.decodestring(state["content"])
|
||||
self.timestamp = state["timestamp"]
|
||||
|
||||
def get_state(self):
|
||||
def _get_state(self):
|
||||
return dict(
|
||||
client_conn = self.client_conn.get_state() if self.client_conn else None,
|
||||
client_conn = self.client_conn._get_state() if self.client_conn else None,
|
||||
host = self.host,
|
||||
port = self.port,
|
||||
scheme = self.scheme,
|
||||
method = self.method,
|
||||
path = self.path,
|
||||
headers = self.headers.get_state(),
|
||||
headers = self.headers._get_state(),
|
||||
content = base64.encodestring(self.content),
|
||||
timestamp = self.timestamp,
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def from_state(klass, state):
|
||||
def _from_state(klass, state):
|
||||
return klass(
|
||||
ClientConnect.from_state(state["client_conn"]),
|
||||
ClientConnect._from_state(state["client_conn"]),
|
||||
str(state["host"]),
|
||||
state["port"],
|
||||
str(state["scheme"]),
|
||||
str(state["method"]),
|
||||
str(state["path"]),
|
||||
Headers.from_state(state["headers"]),
|
||||
Headers._from_state(state["headers"]),
|
||||
base64.decodestring(state["content"]),
|
||||
state["timestamp"]
|
||||
)
|
||||
@ -259,7 +262,7 @@ class Request(HTTPMsg):
|
||||
return id(self)
|
||||
|
||||
def __eq__(self, other):
|
||||
return self.get_state() == other.get_state()
|
||||
return self._get_state() == other._get_state()
|
||||
|
||||
def copy(self):
|
||||
c = copy.copy(self)
|
||||
@ -395,35 +398,35 @@ class Response(HTTPMsg):
|
||||
def is_replay(self):
|
||||
return self.replay
|
||||
|
||||
def load_state(self, state):
|
||||
def _load_state(self, state):
|
||||
self.code = state["code"]
|
||||
self.msg = state["msg"]
|
||||
self.headers = Headers.from_state(state["headers"])
|
||||
self.headers = Headers._from_state(state["headers"])
|
||||
self.content = base64.decodestring(state["content"])
|
||||
self.timestamp = state["timestamp"]
|
||||
|
||||
def get_state(self):
|
||||
def _get_state(self):
|
||||
return dict(
|
||||
code = self.code,
|
||||
msg = self.msg,
|
||||
headers = self.headers.get_state(),
|
||||
headers = self.headers._get_state(),
|
||||
timestamp = self.timestamp,
|
||||
content = base64.encodestring(self.content)
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def from_state(klass, request, state):
|
||||
def _from_state(klass, request, state):
|
||||
return klass(
|
||||
request,
|
||||
state["code"],
|
||||
str(state["msg"]),
|
||||
Headers.from_state(state["headers"]),
|
||||
Headers._from_state(state["headers"]),
|
||||
base64.decodestring(state["content"]),
|
||||
state["timestamp"],
|
||||
)
|
||||
|
||||
def __eq__(self, other):
|
||||
return self.get_state() == other.get_state()
|
||||
return self._get_state() == other._get_state()
|
||||
|
||||
def copy(self):
|
||||
c = copy.copy(self)
|
||||
@ -484,16 +487,16 @@ class ClientConnect(controller.Msg):
|
||||
controller.Msg.__init__(self)
|
||||
|
||||
def __eq__(self, other):
|
||||
return self.get_state() == other.get_state()
|
||||
return self._get_state() == other._get_state()
|
||||
|
||||
def load_state(self, state):
|
||||
def _load_state(self, state):
|
||||
self.address = state
|
||||
|
||||
def get_state(self):
|
||||
def _get_state(self):
|
||||
return list(self.address) if self.address else None
|
||||
|
||||
@classmethod
|
||||
def from_state(klass, state):
|
||||
def _from_state(klass, state):
|
||||
if state:
|
||||
return klass(state)
|
||||
else:
|
||||
@ -509,21 +512,21 @@ class Error(controller.Msg):
|
||||
self.timestamp = timestamp or utils.timestamp()
|
||||
controller.Msg.__init__(self)
|
||||
|
||||
def load_state(self, state):
|
||||
def _load_state(self, state):
|
||||
self.msg = state["msg"]
|
||||
self.timestamp = state["timestamp"]
|
||||
|
||||
def copy(self):
|
||||
return copy.copy(self)
|
||||
|
||||
def get_state(self):
|
||||
def _get_state(self):
|
||||
return dict(
|
||||
msg = self.msg,
|
||||
timestamp = self.timestamp,
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def from_state(klass, state):
|
||||
def _from_state(klass, state):
|
||||
return klass(
|
||||
None,
|
||||
state["msg"],
|
||||
@ -531,7 +534,7 @@ class Error(controller.Msg):
|
||||
)
|
||||
|
||||
def __eq__(self, other):
|
||||
return self.get_state() == other.get_state()
|
||||
return self._get_state() == other._get_state()
|
||||
|
||||
def replace(self, pattern, repl, *args, **kwargs):
|
||||
"""
|
||||
@ -708,9 +711,9 @@ class Flow:
|
||||
self._backup = None
|
||||
|
||||
@classmethod
|
||||
def from_state(klass, state):
|
||||
def _from_state(klass, state):
|
||||
f = klass(None)
|
||||
f.load_state(state)
|
||||
f._load_state(state)
|
||||
return f
|
||||
|
||||
@classmethod
|
||||
@ -719,13 +722,13 @@ class Flow:
|
||||
data = json.loads(data)
|
||||
except Exception:
|
||||
return None
|
||||
return klass.from_state(data)
|
||||
return klass._from_state(data)
|
||||
|
||||
def get_state(self, nobackup=False):
|
||||
def _get_state(self, nobackup=False):
|
||||
d = dict(
|
||||
request = self.request.get_state() if self.request else None,
|
||||
response = self.response.get_state() if self.response else None,
|
||||
error = self.error.get_state() if self.error else None,
|
||||
request = self.request._get_state() if self.request else None,
|
||||
response = self.response._get_state() if self.response else None,
|
||||
error = self.error._get_state() if self.error else None,
|
||||
version = version.IVERSION
|
||||
)
|
||||
if nobackup:
|
||||
@ -734,26 +737,26 @@ class Flow:
|
||||
d["backup"] = self._backup
|
||||
return d
|
||||
|
||||
def load_state(self, state):
|
||||
def _load_state(self, state):
|
||||
self._backup = state["backup"]
|
||||
if self.request:
|
||||
self.request.load_state(state["request"])
|
||||
self.request._load_state(state["request"])
|
||||
else:
|
||||
self.request = Request.from_state(state["request"])
|
||||
self.request = Request._from_state(state["request"])
|
||||
|
||||
if state["response"]:
|
||||
if self.response:
|
||||
self.response.load_state(state["response"])
|
||||
self.response._load_state(state["response"])
|
||||
else:
|
||||
self.response = Response.from_state(self.request, state["response"])
|
||||
self.response = Response._from_state(self.request, state["response"])
|
||||
else:
|
||||
self.response = None
|
||||
|
||||
if state["error"]:
|
||||
if self.error:
|
||||
self.error.load_state(state["error"])
|
||||
self.error._load_state(state["error"])
|
||||
else:
|
||||
self.error = Error.from_state(state["error"])
|
||||
self.error = Error._from_state(state["error"])
|
||||
else:
|
||||
self.error = None
|
||||
|
||||
@ -766,11 +769,11 @@ class Flow:
|
||||
return False
|
||||
|
||||
def backup(self):
|
||||
self._backup = self.get_state(nobackup=True)
|
||||
self._backup = self._get_state(nobackup=True)
|
||||
|
||||
def revert(self):
|
||||
if self._backup:
|
||||
self.load_state(self._backup)
|
||||
self._load_state(self._backup)
|
||||
self._backup = None
|
||||
|
||||
def match(self, pattern):
|
||||
@ -1041,7 +1044,7 @@ class FlowMaster(controller.Master):
|
||||
rflow = self.server_playback.next_flow(flow)
|
||||
if not rflow:
|
||||
return None
|
||||
response = Response.from_state(flow.request, rflow.response.get_state())
|
||||
response = Response._from_state(flow.request, rflow.response._get_state())
|
||||
response.set_replay()
|
||||
flow.response = response
|
||||
if self.refresh_server_playback:
|
||||
@ -1178,7 +1181,7 @@ class FlowWriter:
|
||||
self.ns = netstring.FileEncoder(fo)
|
||||
|
||||
def add(self, flow):
|
||||
d = flow.get_state()
|
||||
d = flow._get_state()
|
||||
s = json.dumps(d)
|
||||
self.ns.write(s)
|
||||
|
||||
@ -1201,7 +1204,7 @@ class FlowReader:
|
||||
try:
|
||||
for i in self.ns:
|
||||
data = json.loads(i)
|
||||
yield Flow.from_state(data)
|
||||
yield Flow._from_state(data)
|
||||
except netstring.DecoderError:
|
||||
raise FlowReadError("Invalid data format.")
|
||||
|
||||
|
||||
@ -153,19 +153,19 @@ class uFlow(libpry.AutoTree):
|
||||
def test_getset_state(self):
|
||||
f = tutils.tflow()
|
||||
f.response = tutils.tresp(f.request)
|
||||
state = f.get_state()
|
||||
assert f.get_state() == flow.Flow.from_state(state).get_state()
|
||||
state = f._get_state()
|
||||
assert f._get_state() == flow.Flow._from_state(state)._get_state()
|
||||
|
||||
f.response = None
|
||||
f.error = flow.Error(f.request, "error")
|
||||
state = f.get_state()
|
||||
assert f.get_state() == flow.Flow.from_state(state).get_state()
|
||||
state = f._get_state()
|
||||
assert f._get_state() == flow.Flow._from_state(state)._get_state()
|
||||
|
||||
f2 = tutils.tflow()
|
||||
f2.error = flow.Error(f.request, "e2")
|
||||
assert not f == f2
|
||||
f.load_state(f2.get_state())
|
||||
assert f.get_state() == f2.get_state()
|
||||
f._load_state(f2._get_state())
|
||||
assert f._get_state() == f2._get_state()
|
||||
|
||||
def test_kill(self):
|
||||
s = flow.State()
|
||||
@ -410,7 +410,7 @@ class uSerialize(libpry.AutoTree):
|
||||
assert len(l) == 1
|
||||
|
||||
f2 = l[0]
|
||||
assert f2.get_state() == f.get_state()
|
||||
assert f2._get_state() == f._get_state()
|
||||
assert f2.request.assemble() == f.request.assemble()
|
||||
|
||||
def test_load_flows(self):
|
||||
@ -594,20 +594,20 @@ class uRequest(libpry.AutoTree):
|
||||
h["test"] = ["test"]
|
||||
c = flow.ClientConnect(("addr", 2222))
|
||||
r = flow.Request(c, "host", 22, "https", "GET", "/", h, "content")
|
||||
state = r.get_state()
|
||||
assert flow.Request.from_state(state) == r
|
||||
state = r._get_state()
|
||||
assert flow.Request._from_state(state) == r
|
||||
|
||||
r.client_conn = None
|
||||
state = r.get_state()
|
||||
assert flow.Request.from_state(state) == r
|
||||
state = r._get_state()
|
||||
assert flow.Request._from_state(state) == r
|
||||
|
||||
r2 = flow.Request(c, "testing", 20, "http", "PUT", "/foo", h, "test")
|
||||
assert not r == r2
|
||||
r.load_state(r2.get_state())
|
||||
r._load_state(r2._get_state())
|
||||
assert r == r2
|
||||
|
||||
r2.client_conn = None
|
||||
r.load_state(r2.get_state())
|
||||
r._load_state(r2._get_state())
|
||||
assert not r.client_conn
|
||||
|
||||
def test_replace(self):
|
||||
@ -694,12 +694,12 @@ class uResponse(libpry.AutoTree):
|
||||
req = flow.Request(c, "host", 22, "https", "GET", "/", h, "content")
|
||||
resp = flow.Response(req, 200, "msg", h.copy(), "content")
|
||||
|
||||
state = resp.get_state()
|
||||
assert flow.Response.from_state(req, state) == resp
|
||||
state = resp._get_state()
|
||||
assert flow.Response._from_state(req, state) == resp
|
||||
|
||||
resp2 = flow.Response(req, 220, "foo", h.copy(), "test")
|
||||
assert not resp == resp2
|
||||
resp.load_state(resp2.get_state())
|
||||
resp._load_state(resp2._get_state())
|
||||
assert resp == resp2
|
||||
|
||||
def test_replace(self):
|
||||
@ -739,14 +739,14 @@ class uResponse(libpry.AutoTree):
|
||||
class uError(libpry.AutoTree):
|
||||
def test_getset_state(self):
|
||||
e = flow.Error(None, "Error")
|
||||
state = e.get_state()
|
||||
assert flow.Error.from_state(state) == e
|
||||
state = e._get_state()
|
||||
assert flow.Error._from_state(state) == e
|
||||
|
||||
assert e.copy()
|
||||
|
||||
e2 = flow.Error(None, "bar")
|
||||
assert not e == e2
|
||||
e.load_state(e2.get_state())
|
||||
e._load_state(e2._get_state())
|
||||
assert e == e2
|
||||
|
||||
|
||||
@ -762,12 +762,12 @@ class uError(libpry.AutoTree):
|
||||
class uClientConnect(libpry.AutoTree):
|
||||
def test_state(self):
|
||||
c = flow.ClientConnect(("a", 22))
|
||||
assert flow.ClientConnect.from_state(c.get_state()) == c
|
||||
assert flow.ClientConnect._from_state(c._get_state()) == c
|
||||
|
||||
c2 = flow.ClientConnect(("a", 25))
|
||||
assert not c == c2
|
||||
|
||||
c.load_state(c2.get_state())
|
||||
c._load_state(c2._get_state())
|
||||
assert c == c2
|
||||
|
||||
c3 = c.copy()
|
||||
@ -851,8 +851,8 @@ class uHeaders(libpry.AutoTree):
|
||||
self.hd.add("foo", 1)
|
||||
self.hd.add("foo", 2)
|
||||
self.hd.add("bar", 3)
|
||||
state = self.hd.get_state()
|
||||
nd = flow.Headers.from_state(state)
|
||||
state = self.hd._get_state()
|
||||
nd = flow.Headers._from_state(state)
|
||||
assert nd == self.hd
|
||||
|
||||
def test_copy(self):
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user