ds: stop distinguishing event read and write callbacks

Having separate read/write callbacks in every class is too
confusing to my easily-confused mind.  Instead, give every class
an "event_step" callback which is easier to wrap my head around.

This will make future code to support IO::Socket::SSL-wrapped
sockets easier-to-digest, since SSL_write() can require waiting
on POLLIN events, and SSL_read() can require waiting on POLLOUT
events.

1 files changed, 12 insertions, 9 deletions

diff --git a/lib/PublicInbox/NNTP.pm b/lib/PublicInbox/NNTP.pm
index fa412f8c..796ac74d 100644
--- a/lib/PublicInbox/NNTP.pm
+++ b/lib/PublicInbox/NNTP.pm
@@ -53,7 +53,7 @@ sub next_tick () {
                 } else {
                         # pipelined request, we bypassed socket-readiness
                         # checks to get here:
-                        event_read($nntp);
+                        event_step($nntp);
 
                         # maybe there's more pipelined data, or we'll have
                         # to register it for socket-readiness notifications
@@ -964,17 +964,20 @@ sub do_more ($$) {
         do_write($self, $data);
 }
 
-sub event_write {
+sub event_step {
         my ($self) = @_;
-        update_idle_time($self);
-        # only continue watching for readability when we are done writing:
-        if ($self->write(undef) == 1 && !$self->{long_res}) {
-                $self->watch_read(1);
+        return if $self->{closed};
+
+        my $wbuf = $self->{wbuf};
+        if (@$wbuf) {
+                update_idle_time($self);
+                $self->write(undef);
+                return if $self->{closed} || scalar(@$wbuf);
         }
-}
+        return if $self->{long_res};
+        # only read more requests if we've drained the write buffer,
+        # otherwise we can be buffering infinitely w/o backpressure
 
-sub event_read {
-        my ($self) = @_;
         use constant LINE_MAX => 512; # RFC 977 section 2.3
         my $rbuf = \($self->{rbuf});
         my $r;