www: implement generic help text

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

diff --git a/lib/PublicInbox/HTTP.pm b/lib/PublicInbox/HTTP.pm
index 0454f607777e7b972956fee5f5002159beac5fc4..729d46fb20bcd3729043de518710bf50650cb342 100644 (file)
--- a/lib/PublicInbox/HTTP.pm
+++ b/lib/PublicInbox/HTTP.pm
@@ -4,7 +4,7 @@
 # Generic PSGI server for convenience.  It aims to provide
 # a consistent experience for public-inbox admins so they don't have
 # to learn different ways to admin both NNTP and HTTP components.
-# There's nothing public-inbox-specific, here.
+# There's nothing which depends on public-inbox, here.
 # Each instance of this class represents a HTTP client socket
 
 package PublicInbox::HTTP;
@@ -25,15 +25,6 @@ use constant {
        CHUNK_MAX_HDR => 256,
 };
 
-# FIXME: duplicated code with NNTP.pm
-my $WEAKEN = {}; # string(inbox) -> inbox
-my $weakt;
-sub weaken_task () {
-       $weakt = undef;
-       $_->weaken_all for values %$WEAKEN;
-       $WEAKEN = {};
-}
-
 my $pipelineq = [];
 my $pipet;
 sub process_pipelineq () {
@@ -107,7 +98,7 @@ sub rbuf_process {
        $self->{rbuf} = substr($self->{rbuf}, $r);
 
        my $len = input_prepare($self, \%env);
-       defined $len or return write_err($self); # EMFILE/ENFILE
+       defined $len or return write_err($self, undef); # EMFILE/ENFILE
 
        $len ? event_read_input($self) : app_dispatch($self);
 }
@@ -127,7 +118,7 @@ sub event_read_input ($) {
        while ($len > 0) {
                if ($$rbuf ne '') {
                        my $w = write_in_full($input, $rbuf, $len);
-                       return write_err($self) unless $w;
+                       return write_err($self, $len) unless $w;
                        $len -= $w;
                        die "BUG: $len < 0 (w=$w)" if $len < 0;
                        if ($len == 0) { # next request may be pipelined
@@ -223,7 +214,10 @@ sub chunked_wcb ($) {
                return if $_[0] eq '';
                more($self, sprintf("%x\r\n", bytes::length($_[0])));
                more($self, $_[0]);
-               $self->write("\r\n");
+
+               # use $self->write("\n\n") if you care about real-time
+               # streaming responses, public-inbox WWW does not.
+               more($self, "\r\n");
        }
 }
 
@@ -249,32 +243,51 @@ sub response_done ($$) {
        $self->{env} = undef;
        $self->write("0\r\n\r\n") if $alive == 2;
        $self->write(sub { $alive ? next_request($self) : $self->close });
-       if (my $obj = $env->{'pi-httpd.inbox'}) {
-               # grace period for reaping resources
-               $WEAKEN->{"$obj"} = $obj;
-               PublicInbox::EvCleanup::later(*weaken_task);
+}
+
+sub getline_cb ($$$) {
+       my ($self, $write, $close) = @_;
+       local $/ = \8192;
+       my $forward = $self->{forward};
+       # limit our own running time for fairness with other
+       # clients and to avoid buffering too much:
+       if ($forward) {
+               my $buf = eval { $forward->getline };
+               if (defined $buf) {
+                       $write->($buf); # may close in Danga::Socket::write
+                       unless ($self->{closed}) {
+                               my $next = $self->{pull};
+                               if ($self->{write_buf_size}) {
+                                       $self->write($next);
+                               } else {
+                                       PublicInbox::EvCleanup::asap($next);
+                               }
+                               return;
+                       }
+               } elsif ($@) {
+                       err($self, "response ->getline error: $@");
+                       $forward = undef;
+                       $self->close;
+               }
        }
+
+       $self->{forward} = $self->{pull} = undef;
+       # avoid recursion
+       if ($forward) {
+               eval { $forward->close };
+               if ($@) {
+                       err($self, "response ->close error: $@");
+                       $self->close; # idempotent
+               }
+       }
+       $close->();
 }
 
 sub getline_response {
        my ($self, $body, $write, $close) = @_;
        $self->{forward} = $body;
        weaken($self);
-       my $pull = $self->{pull} = sub {
-               local $/ = \8192;
-               my $forward = $self->{forward};
-               while ($forward && defined(my $buf = $forward->getline)) {
-                       $write->($buf);
-                       last if $self->{closed};
-                       if ($self->{write_buf_size}) {
-                               $self->write($self->{pull});
-                               return;
-                       }
-               }
-               $self->{forward} = $self->{pull} = undef;
-               $forward->close if $forward; # avoid recursion
-               $close->();
-       };
+       my $pull = $self->{pull} = sub { getline_cb($self, $write, $close) };
        $pull->();
 }
 
@@ -338,11 +351,15 @@ sub input_prepare {
 
 sub env_chunked { ($_[0]->{HTTP_TRANSFER_ENCODING} || '') =~ /\bchunked\b/i }
 
+sub err ($$) {
+       eval { $_[0]->{httpd}->{env}->{'psgi.errors'}->print($_[1]."\n") };
+}
+
 sub write_err {
-       my ($self) = @_;
-       my $err = $self->{httpd}->{env}->{'psgi.errors'};
+       my ($self, $len) = @_;
        my $msg = $! || '(zero write)';
-       $err->print("error buffering to input: $msg\n");
+       $msg .= " ($len bytes remaining)" if defined $len;
+       err($self, "error buffering to input: $msg");
        quit($self, 500);
 }
 
@@ -353,8 +370,7 @@ sub recv_err {
                $self->{input_left} = $len;
                return;
        }
-       my $err = $self->{httpd}->{env}->{'psgi.errors'};
-       $err->print("error reading for input: $! ($len bytes remaining)\n");
+       err($self, "error reading for input: $! ($len bytes remaining)");
        quit($self, 500);
 }
 
@@ -417,7 +433,7 @@ sub event_read_input_chunked { # unlikely...
                until ($len <= 0) {
                        if ($$rbuf ne '') {
                                my $w = write_in_full($input, $rbuf, $len);
-                               return write_err($self) unless $w;
+                               return write_err($self, "$len chunk") if !$w;
                                $len -= $w;
                                if ($len == 0) {
                                        # we may have leftover data to parse
@@ -457,7 +473,10 @@ sub close {
        my $env = $self->{env};
        delete $env->{'psgix.io'} if $env; # prevent circular referernces
        $self->{pull} = $self->{forward} = $self->{env} = undef;
-       $forward->close if $forward;
+       if ($forward) {
+               eval { $forward->close };
+               err($self, "forward ->close error: $@") if $@;
+       }
        $self->SUPER::close(@_);
 }