ds: favor `delete' over assigning fields to `undef'

[public-inbox.git] / lib / PublicInbox / HTTP.pm

diff --git a/lib/PublicInbox/HTTP.pm b/lib/PublicInbox/HTTP.pm
index a669eb6ed990053fc24c47646ba86f5e27407788..9497205488d4f5c1628470bbfe1312163deecaa2 100644 (file)
--- a/lib/PublicInbox/HTTP.pm
+++ b/lib/PublicInbox/HTTP.pm
@@ -19,13 +19,15 @@ use HTTP::Status qw(status_message);
 use HTTP::Date qw(time2str);
 use IO::Handle;
 require PublicInbox::EvCleanup;
-PublicInbox::DS->import('msg_more');
+PublicInbox::DS->import(qw(msg_more write_in_full));
+use PublicInbox::Syscall qw(EPOLLIN EPOLLONESHOT);
 use constant {
        CHUNK_START => -1,   # [a-f0-9]+\r\n
        CHUNK_END => -2,     # \r\n
        CHUNK_ZEND => -3,    # \r\n
        CHUNK_MAX_HDR => 256,
 };
+use Errno qw(EAGAIN);
 
 my $pipelineq = [];
 my $pipet;
@@ -56,12 +58,11 @@ sub http_date () {
 sub new ($$$) {
        my ($class, $sock, $addr, $httpd) = @_;
        my $self = fields::new($class);
-       $self->SUPER::new($sock);
+       $self->SUPER::new($sock, EPOLLIN | EPOLLONESHOT);
        $self->{httpd} = $httpd;
        $self->{rbuf} = '';
        ($self->{remote_addr}, $self->{remote_port}) =
                PublicInbox::Daemon::host_with_port($addr);
-       $self->watch_read(1);
        $self;
 }
 
@@ -81,11 +82,10 @@ sub event_step { # called by PublicInbox::DS
                return $self->close if $r == 0;
                return rbuf_process($self);
        }
-       return if $!{EAGAIN}; # no need to call watch_read(1) again
 
        # common for clients to break connections without warning,
        # would be too noisy to log here:
-       return $self->close;
+       $! == EAGAIN ? $self->watch_in1 : $self->close;
 }
 
 sub rbuf_process {
@@ -101,7 +101,7 @@ sub rbuf_process {
                        ($r == -2 && length($self->{rbuf}) > 0x4000)) {
                return quit($self, 400);
        }
-       return $self->watch_read(1) if $r < 0; # incomplete
+       return $self->watch_in1 if $r < 0; # incomplete
        $self->{rbuf} = substr($self->{rbuf}, $r);
 
        my $len = input_prepare($self, \%env);
@@ -118,14 +118,13 @@ sub read_input ($) {
 
        # env->{CONTENT_LENGTH} (identity)
        my $sock = $self->{sock};
-       my $len = $self->{input_left};
-       $self->{input_left} = undef;
+       my $len = delete $self->{input_left};
        my $rbuf = \($self->{rbuf});
        my $input = $env->{'psgi.input'};
 
        while ($len > 0) {
                if ($$rbuf ne '') {
-                       my $w = write_in_full($input, $rbuf, $len);
+                       my $w = write_in_full($input, $rbuf, $len, 0);
                        return write_err($self, $len) unless $w;
                        $len -= $w;
                        die "BUG: $len < 0 (w=$w)" if $len < 0;
@@ -144,7 +143,6 @@ sub read_input ($) {
 
 sub app_dispatch {
        my ($self, $input) = @_;
-       $self->watch_read(0);
        my $env = $self->{env};
        $env->{REMOTE_ADDR} = $self->{remote_addr};
        $env->{REMOTE_PORT} = $self->{remote_port};
@@ -237,7 +235,7 @@ sub identity_wcb ($) {
 sub next_request ($) {
        my ($self) = @_;
        if ($self->{rbuf} eq '') { # wait for next request
-               $self->watch_read(1);
+               $self->watch_in1;
        } else { # avoid recursion for pipelined requests
                push @$pipelineq, $self;
                $pipet ||= PublicInbox::EvCleanup::asap(*process_pipelineq);
@@ -247,8 +245,7 @@ sub next_request ($) {
 sub response_done_cb ($$) {
        my ($self, $alive) = @_;
        sub {
-               my $env = $self->{env};
-               $self->{env} = undef;
+               my $env = delete $self->{env};
                $self->write(\"0\r\n\r\n") if $alive == 2;
                $self->write(sub{$alive ? next_request($self) : $self->close});
        }
@@ -280,7 +277,7 @@ sub getline_cb ($$$) {
                }
        }
 
-       $self->{forward} = $self->{pull} = undef;
+       delete @$self{qw(forward pull)};
        # avoid recursion
        if ($forward) {
                eval { $forward->close };
@@ -359,34 +356,19 @@ sub write_err {
 sub recv_err {
        my ($self, $r, $len) = @_;
        return $self->close if (defined $r && $r == 0);
-       if ($!{EAGAIN}) {
+       if ($! == EAGAIN) {
                $self->{input_left} = $len;
-               return;
+               return $self->watch_in1;
        }
        err($self, "error reading for input: $! ($len bytes remaining)");
        quit($self, 500);
 }
 
-sub write_in_full {
-       my ($fh, $rbuf, $len) = @_;
-       my $rv = 0;
-       my $off = 0;
-       while ($len > 0) {
-               my $w = syswrite($fh, $$rbuf, $len, $off);
-               return ($rv ? $rv : $w) unless $w; # undef or 0
-               $rv += $w;
-               $off += $w;
-               $len -= $w;
-       }
-       $rv
-}
-
 sub read_input_chunked { # unlikely...
        my ($self) = @_;
        my $input = $self->{env}->{'psgi.input'};
        my $sock = $self->{sock};
-       my $len = $self->{input_left};
-       $self->{input_left} = undef;
+       my $len = delete $self->{input_left};
        my $rbuf = \($self->{rbuf});
 
        while (1) { # chunk start
@@ -425,7 +407,7 @@ sub read_input_chunked { # unlikely...
                # drain the current chunk
                until ($len <= 0) {
                        if ($$rbuf ne '') {
-                               my $w = write_in_full($input, $rbuf, $len);
+                               my $w = write_in_full($input, $rbuf, $len, 0);
                                return write_err($self, "$len chunk") if !$w;
                                $len -= $w;
                                if ($len == 0) {
@@ -457,11 +439,11 @@ sub quit {
 
 sub close {
        my $self = shift;
-       my $forward = $self->{forward};
-       my $env = $self->{env};
-       delete $env->{'psgix.io'} if $env; # prevent circular references
-       $self->{pull} = $self->{forward} = $self->{env} = undef;
-       if ($forward) {
+       if (my $env = delete $self->{env}) {
+               delete $env->{'psgix.io'}; # prevent circular references
+       }
+       delete $self->{pull};
+       if (my $forward = delete $self->{forward}) {
                eval { $forward->close };
                err($self, "forward ->close error: $@") if $@;
        }