+ return if $! == EAGAIN; # try again when notified
+ goto reread if $! == EINTR;
+ event_step($self, $!);
+ }
+}
+
+sub psgi_qx_start {
+ my ($self) = @_;
+ if (my $async = $self->{psgi_env}->{'pi-httpd.async'}) {
+ # PublicInbox::HTTPD::Async->new(rpipe, $cb, cb_arg, $end_obj)
+ $self->{async} = $async->($self->{rpipe},
+ \&psgi_qx_init_cb, $self, $self);
+ # init_cb will call ->async_pass or ->close
+ } else { # generic PSGI
+ psgi_qx_init_cb($self) while $self->{qx_fh};
+ }
+}
+
+# Similar to `backtick` or "qx" ("perldoc -f qx"), it calls $qx_cb with
+# the stdout of the given command when done; but respects the given limiter
+# $env is the PSGI env. As with ``/qx; only use this when output is small
+# and safe to slurp.
+sub psgi_qx {
+ my ($self, $env, $limiter, $qx_cb, $qx_arg) = @_;
+ $self->{psgi_env} = $env;
+ my $qx_buf = '';
+ open(my $qx_fh, '+>', \$qx_buf) or die; # PerlIO::scalar
+ $self->{qx_cb} = $qx_cb;
+ $self->{qx_arg} = $qx_arg;
+ $self->{qx_fh} = $qx_fh;
+ $self->{qx_buf} = \$qx_buf;
+ $limiter ||= $def_limiter ||= PublicInbox::Qspawn::Limiter->new(32);
+ start($self, $limiter, \&psgi_qx_start);
+}
+
+# this is called on pipe EOF to reap the process, may be called
+# via PublicInbox::DS event loop OR via GetlineBody for generic
+# PSGI servers.
+sub event_step {
+ my ($self, $err) = @_; # $err: $!
+ warn "psgi_{return,qx} $err" if defined($err);
+ finish($self);
+ my ($fh, $qx_fh) = delete(@$self{qw(qfh qx_fh)});
+ $fh->close if $fh; # async-only (psgi_return)
+}
+
+sub rd_hdr ($) {
+ my ($self) = @_;
+ # typically used for reading CGI headers
+ # We also need to check EINTR for generic PSGI servers.
+ my $ret;
+ my $total_rd = 0;
+ my $hdr_buf = $self->{hdr_buf};
+ my ($ph_cb, $ph_arg) = @{$self->{parse_hdr}};
+ until (defined($ret)) {
+ my $r = sysread($self->{rpipe}, $$hdr_buf, 4096,
+ length($$hdr_buf));
+ if (defined($r)) {
+ $total_rd += $r;
+ eval { $ret = $ph_cb->($total_rd, $hdr_buf, $ph_arg) };
+ if ($@) {
+ warn "parse_hdr: $@";
+ $ret = [ 500, [], [ "Internal error\n" ] ];
+ } elsif (!defined($ret) && !$r) {
+ my $cmd = $self->{cmd} // [ '(?)' ];
+ warn <<EOM;
+EOF parsing headers from @$cmd ($self->{psgi_env}->{REQUEST_URI})
+EOM
+ $ret = [ 500, [], [ "Internal error\n" ] ];
+ }
+ } else {
+ # caller should notify us when it's ready:
+ return if $! == EAGAIN;
+ next if $! == EINTR; # immediate retry
+ warn "error reading header: $!";
+ $ret = [ 500, [], [ "Internal error\n" ] ];
+ }
+ }
+ delete $self->{parse_hdr}; # done parsing headers
+ $ret;
+}
+
+sub psgi_return_init_cb { # this may be PublicInbox::HTTPD::Async {cb}
+ my ($self) = @_;
+ my $r = rd_hdr($self) or return;
+ my $env = $self->{psgi_env};
+ my $filter;
+
+ # this is for RepoAtom since that can fire after parse_cgi_headers
+ if (ref($r) eq 'ARRAY' && blessed($r->[2]) && $r->[2]->can('attach')) {
+ $filter = pop @$r;
+ }
+ $filter //= delete($env->{'qspawn.filter'}) // (ref($r) eq 'ARRAY' ?
+ PublicInbox::GzipFilter::qsp_maybe($r->[1], $env) : undef);
+
+ my $wcb = delete $env->{'qspawn.wcb'};
+ my $async = delete $self->{async}; # PublicInbox::HTTPD::Async
+ if (ref($r) ne 'ARRAY' || scalar(@$r) == 3) { # error
+ if ($async) { # calls rpipe->close && ->event_step
+ $async->close; # PublicInbox::HTTPD::Async::close
+ } else { # generic PSGI:
+ delete($self->{rpipe})->close;
+ event_step($self);
+ waitpid_err($self);
+ }
+ if (ref($r) eq 'ARRAY') { # error
+ $wcb->($r)
+ } elsif (ref($r) eq 'CODE') { # chain another command
+ $r->($wcb);
+ $self->{passed} = 1;
+ }
+ # else do nothing
+ } elsif ($async) {
+ # done reading headers, handoff to read body
+ my $fh = $wcb->($r); # scalar @$r == 2
+ $fh = $filter->attach($fh) if $filter;
+ $self->{qfh} = $fh;
+ $async->async_pass($env->{'psgix.io'}, $fh,
+ delete($self->{hdr_buf}));
+ } else { # for synchronous PSGI servers
+ require PublicInbox::GetlineBody;
+ my $buf = delete $self->{hdr_buf};
+ $r->[2] = PublicInbox::GetlineBody->new($self->{rpipe},
+ \&event_step, $self, $$buf, $filter);
+ $wcb->($r);
+ }
+}
+
+sub psgi_return_start { # may run later, much later...
+ my ($self) = @_;
+ if (my $cb = $self->{psgi_env}->{'pi-httpd.async'}) {
+ # PublicInbox::HTTPD::Async->new(rpipe, $cb, $cb_arg, $end_obj)
+ $self->{async} = $cb->($self->{rpipe},
+ \&psgi_return_init_cb, $self, $self);
+ } else { # generic PSGI
+ psgi_return_init_cb($self) while $self->{parse_hdr};
+ }
+}
+
+# Used for streaming the stdout of one process as a PSGI response.
+#
+# $env is the PSGI env.
+# optional keys in $env:
+# $env->{'qspawn.wcb'} - the write callback from the PSGI server
+# optional, use this if you've already
+# captured it elsewhere. If not given,
+# psgi_return will return an anonymous
+# sub for the PSGI server to call
+#
+# $env->{'qspawn.filter'} - filter object, responds to ->attach for
+# pi-httpd.async and ->translate for generic
+# PSGI servers
+#
+# $limiter - the Limiter object to use (uses the def_limiter if not given)
+#
+# $parse_hdr - Initial read function; often for parsing CGI header output.
+# It will be given the return value of sysread from the pipe
+# and a string ref of the current buffer. Returns an arrayref
+# for PSGI responses. 2-element arrays in PSGI mean the
+# body will be streamed, later, via writes (push-based) to
+# psgix.io. 3-element arrays means the body is available
+# immediately (or streamed via ->getline (pull-based)).
+sub psgi_return {
+ my ($self, $env, $limiter, $parse_hdr, $hdr_arg) = @_;
+ $self->{psgi_env} = $env;
+ $self->{hdr_buf} = \(my $hdr_buf = '');
+ $self->{parse_hdr} = [ $parse_hdr, $hdr_arg ];
+ $limiter ||= $def_limiter ||= PublicInbox::Qspawn::Limiter->new(32);
+
+ # the caller already captured the PSGI write callback from
+ # the PSGI server, so we can call ->start, here:
+ $env->{'qspawn.wcb'} and
+ return start($self, $limiter, \&psgi_return_start);
+
+ # the caller will return this sub to the PSGI server, so
+ # it can set the response callback (that is, for
+ # PublicInbox::HTTP, the chunked_wcb or identity_wcb callback),
+ # but other HTTP servers are supported:
+ sub {
+ $env->{'qspawn.wcb'} = $_[0];
+ start($self, $limiter, \&psgi_return_start);