use strict;
use bytes;
use POSIX ();
-use Time::HiRes ();
use IO::Handle qw();
use Fcntl qw(FD_CLOEXEC F_SETFD F_GETFD);
-
+use Time::HiRes qw(clock_gettime CLOCK_MONOTONIC);
+use parent qw(Exporter);
+our @EXPORT_OK = qw(now);
use warnings;
use PublicInbox::Syscall qw(:epoll);
=cut
sub AddTimer {
- my $class = shift;
- my ($secs, $coderef) = @_;
+ my ($class, $secs, $coderef) = @_;
- my $fire_time = Time::HiRes::time() + $secs;
+ if (!$secs) {
+ my $timer = bless([0, $coderef], 'PublicInbox::DS::Timer');
+ unshift(@Timers, $timer);
+ return $timer;
+ }
+
+ my $fire_time = now() + $secs;
my $timer = bless [$fire_time, $coderef], "PublicInbox::DS::Timer";
}
}
+sub now () { clock_gettime(CLOCK_MONOTONIC) }
+
# runs timers and returns milliseconds for next one, or next event loop
sub RunTimers {
return $LoopTimeout unless @Timers;
- my $now = Time::HiRes::time();
+ my $now = now();
# Run expired timers
while (@Timers && $Timers[0][0] <= $now) {
Carp::cluck("undef sock and/or fd in PublicInbox::DS->new. sock=" . ($sock || "") . ", fd=" . ($fd || ""))
unless $sock && $fd;
- $self->{wbuf} = [];
- $self->{wbuf_off} = 0;
-
my $ev = $self->{event_watch} = POLLERR|POLLHUP|POLLNVAL;
_InitPoller();
# we need to flush our write buffer, as there may
# be self-referential closures (sub { $client->close })
# preventing the object from being destroyed
- @{$self->{wbuf}} = ();
+ delete $self->{wbuf};
# if we're using epoll, we have to remove this from our epoll fd so we stop getting
# notifications about it
return 0;
}
+# returns 1 if done, 0 if incomplete
+sub flush_write ($) {
+ my ($self) = @_;
+ my $wbuf = $self->{wbuf} or return 1;
+ my $sock = $self->{sock} or return 1;
+
+ while (my $bref = $wbuf->[0]) {
+ my $ref = ref($bref);
+ if ($ref eq 'SCALAR') {
+ my $len = bytes::length($$bref);
+ my $off = $self->{wbuf_off} || 0;
+ my $to_write = $len - $off;
+ my $written = syswrite($sock, $$bref, $to_write, $off);
+ if (defined $written) {
+ if ($written == $to_write) {
+ shift @$wbuf;
+ } else {
+ $self->{wbuf_off} = $off + $written;
+ }
+ next; # keep going until EAGAIN
+ } elsif ($! == EAGAIN) {
+ $self->watch_write(1);
+ } else {
+ $self->close;
+ }
+ return 0;
+ } else { #($ref eq 'CODE') {
+ shift @$wbuf;
+ $bref->();
+ }
+ } # while @$wbuf
+
+ delete $self->{wbuf};
+ $self->watch_write(0);
+ 1; # all done
+}
+
=head2 C<< $obj->write( $data ) >>
Write the specified data to the underlying handle. I<data> may be scalar,
=cut
sub write {
- my PublicInbox::DS $self;
- my $data;
- ($self, $data) = @_;
+ my ($self, $data) = @_;
+ return flush_write($self) unless defined $data;
# nobody should be writing to closed sockets, but caller code can
# do two writes within an event, have the first fail and
# now-dead object does its second write. that is this case. we
# just lie and say it worked. it'll be dead soon and won't be
# hurt by this lie.
- return 1 unless $self->{sock};
-
- my $bref;
-
- # just queue data if there's already a wait
- my $need_queue;
- my $wbuf = $self->{wbuf};
-
- if (defined $data) {
- $bref = ref $data ? $data : \$data;
- if (scalar @$wbuf) {
- push @$wbuf, $bref;
- return 0;
- }
-
- # this flag says we're bypassing the queue system, knowing we're the
- # only outstanding write, and hoping we don't ever need to use it.
- # if so later, though, we'll need to queue
- $need_queue = 1;
- }
-
- WRITE:
- while (1) {
- return 1 unless $bref ||= $wbuf->[0];
-
- my $len;
- eval {
- $len = length($$bref); # this will die if $bref is a code ref, caught below
- };
- if ($@) {
- if (UNIVERSAL::isa($bref, "CODE")) {
- unless ($need_queue) {
- shift @$wbuf;
- }
- $bref->();
-
- # code refs are just run and never get reenqueued
- # (they're one-shot), so turn off the flag indicating the
- # outstanding data needs queueing.
- $need_queue = 0;
-
- undef $bref;
- next WRITE;
- }
- die "Write error: $@ <$bref>";
- }
-
- my $to_write = $len - $self->{wbuf_off};
- my $written = syswrite($self->{sock}, $$bref, $to_write,
- $self->{wbuf_off});
-
- if (! defined $written) {
- if ($! == EAGAIN) {
- # since connection has stuff to write, it should now be
- # interested in pending writes:
- if ($need_queue) {
- push @$wbuf, $bref;
- }
- $self->watch_write(1);
- return 0;
- }
-
- return $self->close;
- } elsif ($written != $to_write) {
- if ($need_queue) {
- push @$wbuf, $bref;
- }
- # since connection has stuff to write, it should now be
- # interested in pending writes:
- $self->{wbuf_off} += $written;
- $self->on_incomplete_write;
- return 0;
- } elsif ($written == $to_write) {
- $self->{wbuf_off} = 0;
- $self->watch_write(0);
-
- # this was our only write, so we can return immediately
- # since we avoided incrementing the buffer size or
- # putting it in the buffer. we also know there
- # can't be anything else to write.
- return 1 if $need_queue;
-
- shift @$wbuf;
- undef $bref;
- next WRITE;
+ my $sock = $self->{sock} or return 1;
+ my $ref = ref $data;
+ my $bref = $ref ? $data : \$data;
+ if (my $wbuf = $self->{wbuf}) { # already buffering, can't write more...
+ push @$wbuf, $bref;
+ return 0;
+ } elsif ($ref eq 'CODE') {
+ $bref->();
+ return 1;
+ } else {
+ my $to_write = bytes::length($$bref);
+ my $written = syswrite($sock, $$bref, $to_write);
+
+ if (defined $written) {
+ return 1 if $written == $to_write;
+ $self->{wbuf_off} = $written;
+ $self->{wbuf} = [ $bref ];
+ return flush_write($self); # try until EAGAIN
+ } elsif ($! == EAGAIN) {
+ $self->{wbuf} = [ $bref ];
+ $self->watch_write(1);
+ } else {
+ $self->close;
}
+ return 0;
}
}
-sub on_incomplete_write {
- my PublicInbox::DS $self = shift;
- $self->watch_write(1);
-}
-
=head2 C<< $obj->watch_read( $boolean ) >>
Turn 'readable' event notification on or off.