www_coderepo: implement /$CODE_REPO/atom/ endpoint

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

diff --git a/lib/PublicInbox/GzipFilter.pm b/lib/PublicInbox/GzipFilter.pm
index bdd313f5a799c5f003adb61ea205219d85b60281..a11ba73fa5b13ae5c680f9664f0f382a11466022 100644 (file)
--- a/lib/PublicInbox/GzipFilter.pm
+++ b/lib/PublicInbox/GzipFilter.pm
@@ -94,25 +94,18 @@ sub gone { # what: search/over/mm
 
 # for GetlineBody (via Qspawn) when NOT using $env->{'pi-httpd.async'}
 # Also used for ->getline callbacks
-sub translate ($$) {
-       my $self = $_[0]; # $_[1] => input
+sub translate {
+       my $self = shift; # $_[1] => input
 
        # allocate the zlib context lazily here, instead of in ->new.
        # Deflate contexts are memory-intensive and this object may
        # be sitting in the Qspawn limiter queue for a while.
-       my $gz = $self->{gz} //= gzip_or_die();
-       my $zbuf = delete($self->{zbuf});
-       if (defined $_[1]) { # my $buf = $_[1];
-               my $err = $gz->deflate($_[1], $zbuf);
-               die "gzip->deflate: $err" if $err != Z_OK;
-               return $zbuf if length($zbuf) >= 8192;
-
-               $self->{zbuf} = $zbuf;
-               '';
+       $self->{gz} //= gzip_or_die();
+       if (defined $_[0]) { # my $buf = $_[1];
+               zmore($self, @_);
+               length($self->{zbuf}) >= 8192 ? delete($self->{zbuf}) : '';
        } else { # undef == EOF
-               my $err = $gz->flush($zbuf);
-               die "gzip->flush: $err" if $err != Z_OK;
-               $zbuf;
+               zflush($self);
        }
 }
 
@@ -130,40 +123,51 @@ sub http_out ($) {
 }
 
 sub write {
+       my $self = shift;
        # my $ret = bytes::length($_[1]); # XXX does anybody care?
-       http_out($_[0])->write(translate($_[0], $_[1]));
+       http_out($self)->write($self->translate(@_));
+}
+
+sub zfh {
+       $_[0]->{zfh} // do {
+               open($_[0]->{zfh}, '>>', \($_[0]->{pbuf} //= '')) or
+                       die "open: $!";
+               $_[0]->{zfh}
+       };
 }
 
 # similar to ->translate; use this when we're sure we know we have
 # more data to buffer after this
 sub zmore {
-       my $self = $_[0]; # $_[1] => input
+       my $self = shift;
+       my $zfh = delete $self->{zfh};
+       if (@_ > 1 || $zfh) {
+               print { $zfh // zfh($self) } @_;
+               @_ = (delete $self->{pbuf});
+               delete $self->{zfh};
+       };
        http_out($self);
-       my $err = $self->{gz}->deflate($_[1], $self->{zbuf});
-       die "gzip->deflate: $err" if $err != Z_OK;
-       undef;
+       my $err;
+       ($err = $self->{gz}->deflate($_[0], $self->{zbuf})) == Z_OK or
+               die "gzip->deflate: $err";
 }
 
 # flushes and returns the final bit of gzipped data
-sub zflush ($;$) {
-       my $self = $_[0]; # $_[1] => final input (optional)
-       my $zbuf = delete $self->{zbuf};
-       my $gz = delete $self->{gz};
+sub zflush ($;@) {
+       my $self = shift; # $_[1..Inf] => final input (optional)
+       zmore($self, @_) if scalar(@_) || $self->{zfh};
+       # not a bug, recursing on DS->write failure
+       my $gz = delete $self->{gz} // return '';
        my $err;
-       if (defined $_[1]) { # it's a bug iff $gz is undef w/ $_[1]
-               $err = $gz->deflate($_[1], $zbuf);
-               die "gzip->deflate: $err" if $err != Z_OK;
-       }
-       $gz // return ''; # not a bug, recursing on DS->write failure
-       $err = $gz->flush($zbuf);
-       die "gzip->flush: $err" if $err != Z_OK;
+       my $zbuf = delete $self->{zbuf};
+       ($err = $gz->flush($zbuf)) == Z_OK or die "gzip->flush: $err";
        $zbuf;
 }
 
 sub close {
        my ($self) = @_;
        my $http_out = http_out($self) // return;
-       $http_out->write(zflush($self));
+       $http_out->write($self->zflush);
        (delete($self->{http_out}) // return)->close;
 }