( )⚙ D12068 test-http-bad-server: introduce socket closing after reading a pattern

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12068

test-http-bad-server: introduce socket closing after reading a pattern
ClosedPublic

Authored by marmoute on Jan 24 2022, 9:48 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG5154f2025d8a: test-http-bad-server: introduce socket closing after reading a pattern
Summary

We introduce the close-after-recv-patterns option. It has the same goal as
close-after-send-patterns with a slightly different implementation.

Reading "up to a pattern" is hard. As we can only check the pattern from what we
have already read (inlike writing, were we can check what we are about to
write).

So instead we make the close-after-recv-patterns alter the behavior of the
existing close-after-recv-bytes. The value from close-after-recv-bytes only
gets into play after we have seen the pattern from close-after-recv-patterns.

This allow us to achieve the target benefit without changing the read pattern
too much.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

marmoute created this revision.Jan 24 2022, 9:48 AM
Alphare accepted this revision.Jan 24 2022, 10:43 AM
This revision is now accepted and ready to land.Jan 24 2022, 10:43 AM
baymax updated this revision to Diff 31892.Jan 24 2022, 1:19 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Revision Contents
Changeset List

PathPackages
Mtests/testlib/badserverext.py (39 lines)

Diff 31944

tests/testlib/badserverext.py

If true, the server will close() the client socket immediately after If true, the server will close() the client socket immediately after
accept(). accept().
close-after-recv-bytes close-after-recv-bytes
If defined, close the client socket after receiving this many bytes. If defined, close the client socket after receiving this many bytes.
(The value is a list, multiple values can use used to close a series of requests (The value is a list, multiple values can use used to close a series of requests
request) request)
close-after-recv-patterns
If defined, the `close-after-recv-bytes` values only start counting after the
`read` operation that encountered the defined patterns.
(The value is a list, multiple values can use used to close a series of requests
request)
close-after-send-bytes close-after-send-bytes
If defined, close the client socket after sending this many bytes. If defined, close the client socket after sending this many bytes.
(The value is a list, multiple values can use used to close a series of requests (The value is a list, multiple values can use used to close a series of requests
request) request)
close-after-send-patterns close-after-send-patterns
If defined, close the client socket after the configured regexp is seen. If defined, close the client socket after the configured regexp is seen.
(The value is a list, multiple values can use used to close a series of requests (The value is a list, multiple values can use used to close a series of requests
) )
configitem( configitem(
b'badserver', b'badserver',
b'close-after-recv-bytes', b'close-after-recv-bytes',
default=b'0', default=b'0',
) )
configitem( configitem(
b'badserver', b'badserver',
b'close-after-recv-patterns',
default=b'',
)
configitem(
b'badserver',
b'close-after-send-bytes', b'close-after-send-bytes',
default=b'0', default=b'0',
) )
configitem( configitem(
b'badserver', b'badserver',
b'close-after-send-patterns', b'close-after-send-patterns',
default=b'', default=b'',
) )
configitem( configitem(
b'badserver', b'badserver',
b'close-before-accept', b'close-before-accept',
default=False, default=False,
) )
class ConditionTracker(object): class ConditionTracker(object):
def __init__( def __init__(
self, self,
close_after_recv_bytes, close_after_recv_bytes,
close_after_recv_patterns,
close_after_send_bytes, close_after_send_bytes,
close_after_send_patterns, close_after_send_patterns,
): ):
self._all_close_after_recv_bytes = close_after_recv_bytes self._all_close_after_recv_bytes = close_after_recv_bytes
self._all_close_after_recv_patterns = close_after_recv_patterns
self._all_close_after_send_bytes = close_after_send_bytes self._all_close_after_send_bytes = close_after_send_bytes
self._all_close_after_send_patterns = close_after_send_patterns self._all_close_after_send_patterns = close_after_send_patterns
self.target_recv_bytes = None self.target_recv_bytes = None
self.remaining_recv_bytes = None self.remaining_recv_bytes = None
self.recv_patterns = None
self.recv_data = b''
self.target_send_bytes = None self.target_send_bytes = None
self.remaining_send_bytes = None self.remaining_send_bytes = None
self.send_pattern = None self.send_pattern = None
self.send_data = b'' self.send_data = b''
def start_next_request(self): def start_next_request(self):
"""move to the next set of close condition""" """move to the next set of close condition"""
if self._all_close_after_recv_bytes: if self._all_close_after_recv_bytes:
self.target_recv_bytes = self._all_close_after_recv_bytes.pop(0) self.target_recv_bytes = self._all_close_after_recv_bytes.pop(0)
self.remaining_recv_bytes = self.target_recv_bytes self.remaining_recv_bytes = self.target_recv_bytes
else: else:
self.target_recv_bytes = None self.target_recv_bytes = None
self.remaining_recv_bytes = None self.remaining_recv_bytes = None
self.recv_data = b''
if self._all_close_after_recv_patterns:
self.recv_pattern = self._all_close_after_recv_patterns.pop(0)
else:
self.recv_pattern = None
if self._all_close_after_send_bytes: if self._all_close_after_send_bytes:
self.target_send_bytes = self._all_close_after_send_bytes.pop(0) self.target_send_bytes = self._all_close_after_send_bytes.pop(0)
self.remaining_send_bytes = self.target_send_bytes self.remaining_send_bytes = self.target_send_bytes
else: else:
self.target_send_bytes = None self.target_send_bytes = None
self.remaining_send_bytes = None self.remaining_send_bytes = None
self.send_data = b'' self.send_data = b''
if self._all_close_after_send_patterns: if self._all_close_after_send_patterns:
self.send_pattern = self._all_close_after_send_patterns.pop(0) self.send_pattern = self._all_close_after_send_patterns.pop(0)
else: else:
self.send_pattern = None self.send_pattern = None
def might_close(self): def might_close(self):
"""True, if any processing will be needed""" """True, if any processing will be needed"""
if self.remaining_recv_bytes is not None: if self.remaining_recv_bytes is not None:
return True return True
if self.recv_pattern is not None:
return True
if self.remaining_send_bytes is not None: if self.remaining_send_bytes is not None:
return True return True
if self.send_pattern is not None: if self.send_pattern is not None:
return True return True
return False return False
def forward_write(self, obj, method, data, *args, **kwargs): def forward_write(self, obj, method, data, *args, **kwargs):
"""call an underlying write function until condition are met """call an underlying write function until condition are met
return result return result
def forward_read(self, obj, method, size=-1): def forward_read(self, obj, method, size=-1):
"""call an underlying read function until condition are met """call an underlying read function until condition are met
When the condition are met the socket is closed When the condition are met the socket is closed
""" """
remaining = self.remaining_recv_bytes remaining = self.remaining_recv_bytes
pattern = self.recv_pattern
orig = object.__getattribute__(obj, '_orig') orig = object.__getattribute__(obj, '_orig')
bmethod = method.encode('ascii') bmethod = method.encode('ascii')
func = getattr(orig, method) func = getattr(orig, method)
requested_size = size requested_size = size
actual_size = size actual_size = size
if remaining: if pattern is None and remaining:
if size < 0: if size < 0:
actual_size = remaining actual_size = remaining
else: else:
actual_size = min(remaining, requested_size) actual_size = min(remaining, requested_size)
result = func(actual_size) result = func(actual_size)
if remaining: if pattern is None and remaining:
remaining -= len(result) remaining -= len(result)
self.remaining_recv_bytes = remaining self.remaining_recv_bytes = remaining
if requested_size == 65537: if requested_size == 65537:
requested_repr = b'~' requested_repr = b'~'
else: else:
requested_repr = b'%d' % requested_size requested_repr = b'%d' % requested_size
if requested_size == actual_size: if requested_size == actual_size:
msg = b'%s(%s) -> (%d) %s' msg = b'%s(%s) -> (%d) %s'
msg %= (bmethod, requested_repr, len(result), result) msg %= (bmethod, requested_repr, len(result), result)
else: else:
msg = b'%s(%d from %s) -> (%d) %s' msg = b'%s(%d from %s) -> (%d) %s'
msg %= (bmethod, actual_size, requested_repr, len(result), result) msg %= (bmethod, actual_size, requested_repr, len(result), result)
obj._writelog(msg) obj._writelog(msg)
if pattern is not None:
self.recv_data += result
if pattern.search(self.recv_data):
# start counting bytes starting with the next read
self.recv_pattern = None
if remaining is not None and remaining <= 0: if remaining is not None and remaining <= 0:
obj._writelog(b'read limit reached; closing socket') obj._writelog(b'read limit reached; closing socket')
obj._cond_close() obj._cond_close()
# This is the easiest way to abort the current request. # This is the easiest way to abort the current request.
raise Exception('connection closed after receiving N bytes') raise Exception('connection closed after receiving N bytes')
return result return result
def __init__(self, ui, *args, **kwargs): def __init__(self, ui, *args, **kwargs):
self._ui = ui self._ui = ui
super(badserver, self).__init__(ui, *args, **kwargs) super(badserver, self).__init__(ui, *args, **kwargs)
all_recv_bytes = self._ui.config( all_recv_bytes = self._ui.config(
b'badserver', b'close-after-recv-bytes' b'badserver', b'close-after-recv-bytes'
) )
all_recv_bytes = process_bytes_config(all_recv_bytes) all_recv_bytes = process_bytes_config(all_recv_bytes)
all_recv_pattern = self._ui.config(
b'badserver', b'close-after-recv-patterns'
)
all_recv_pattern = process_pattern_config(all_recv_pattern)
all_send_bytes = self._ui.config( all_send_bytes = self._ui.config(
b'badserver', b'close-after-send-bytes' b'badserver', b'close-after-send-bytes'
) )
all_send_bytes = process_bytes_config(all_send_bytes) all_send_bytes = process_bytes_config(all_send_bytes)
all_send_patterns = self._ui.config( all_send_patterns = self._ui.config(
b'badserver', b'close-after-send-patterns' b'badserver', b'close-after-send-patterns'
) )
all_send_patterns = process_pattern_config(all_send_patterns) all_send_patterns = process_pattern_config(all_send_patterns)
self._cond = ConditionTracker( self._cond = ConditionTracker(
all_recv_bytes, all_recv_bytes,
all_recv_pattern,
all_send_bytes, all_send_bytes,
all_send_patterns, all_send_patterns,
) )
# Need to inherit object so super() works. # Need to inherit object so super() works.
class badrequesthandler(self.RequestHandlerClass, object): class badrequesthandler(self.RequestHandlerClass, object):
def send_header(self, name, value): def send_header(self, name, value):
# Make headers deterministic to facilitate testing. # Make headers deterministic to facilitate testing.