[ViewVC] Diff of: cvs/AnyEvent/lib/AnyEvent/Handle.pm

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.69 by root, Sun Jun 15 21:44:56 2008 UTC vs.
Revision 1.82 by root, Thu Aug 21 18:45:16 2008 UTC

 package AnyEvent::Handle;
 no warnings;
-use strict;
+use strict qw(subs vars);
 use AnyEvent ();
 use AnyEvent::Util qw(WSAEWOULDBLOCK);
 use Scalar::Util ();
 use Carp ();
 AnyEvent::Handle - non-blocking I/O on file handles via AnyEvent
 =cut
-our $VERSION = 4.151;
+our $VERSION = 4.232;
 =head1 SYNOPSIS
    use AnyEvent;
    use AnyEvent::Handle;
 NOTE: The filehandle will be set to non-blocking (using
 AnyEvent::Util::fh_nonblocking).
 =item on_eof => $cb->($handle)
-Set the callback to be called when an end-of-file condition is detcted,
+Set the callback to be called when an end-of-file condition is detected,
 i.e. in the case of a socket, when the other side has closed the
 connection cleanly.
+For sockets, this just means that the other side has stopped sending data,
+you can still try to write data, and, in fact, one can return from the eof
+callback and continue writing data, as only the read part has been shut
+down.
-While not mandatory, it is highly recommended to set an eof callback,
+While not mandatory, it is I<highly> recommended to set an eof callback,
 otherwise you might end up with a closed socket while you are still
 waiting for data.
+If an EOF condition has been detected but no C<on_eof> callback has been
+set, then a fatal error will be raised with C<$!> set to <0>.
 =item on_error => $cb->($handle, $fatal)
 This is the error callback, which is called when, well, some error
 occured, such as not being able to resolve the hostname, failure to
 connect or a read error.
 Some errors are fatal (which is indicated by C<$fatal> being true). On
-fatal errors the handle object will be shut down and will not be
+fatal errors the handle object will be shut down and will not be usable
+(but you are free to look at the current C< ->rbuf >). Examples of fatal
+errors are an EOF condition with active (but unsatisifable) read watchers
+(C<EPIPE>) or I/O errors.
-usable. Non-fatal errors can be retried by simply returning, but it is
+Non-fatal errors can be retried by simply returning, but it is recommended
-recommended to simply ignore this parameter and instead abondon the handle
+to simply ignore this parameter and instead abondon the handle object
-object when this callback is invoked.
+when this callback is invoked. Examples of non-fatal errors are timeouts
+C<ETIMEDOUT>) or badly-formatted data (C<EBADMSG>).
 On callback entrance, the value of C<$!> contains the operating system
 error (or C<ENOSPC>, C<EPIPE>, C<ETIMEDOUT> or C<EBADMSG>).
 While not mandatory, it is I<highly> recommended to set this callback, as
 be configured to accept only so-and-so much data that it cannot act on
 (for example, when expecting a line, an attacker could send an unlimited
 amount of data without a callback ever being called as long as the line
 isn't finished).
+=item autocork => <boolean>
+When disabled (the default), then C<push_write> will try to immediately
+write the data to the handle if possible. This avoids having to register
+a write watcher and wait for the next event loop iteration, but can be
+inefficient if you write multiple small chunks (this disadvantage is
+usually avoided by your kernel's nagle algorithm, see C<low_delay>).
+When enabled, then writes will always be queued till the next event loop
+iteration. This is efficient when you do many small writes per iteration,
+but less efficient when you do a single write only.
+=item no_delay => <boolean>
+When doing small writes on sockets, your operating system kernel might
+wait a bit for more data before actually sending it out. This is called
+the Nagle algorithm, and usually it is beneficial.
+In some situations you want as low a delay as possible, which cna be
+accomplishd by setting this option to true.
+The default is your opertaing system's default behaviour, this option
+explicitly enables or disables it, if possible.
 =item read_size => <bytes>
 The default read block size (the amount of bytes this module will try to read
 during each (loop iteration). Default: C<8192>.
 You can also provide your own TLS connection object, but you have
 to make sure that you call either C<Net::SSLeay::set_connect_state>
 or C<Net::SSLeay::set_accept_state> on it before you pass it to
 AnyEvent::Handle.
-See the C<starttls> method if you need to start TLs negotiation later.
+See the C<starttls> method if you need to start TLS negotiation later.
 =item tls_ctx => $ssl_ctx
 Use the given Net::SSLeay::CTX object to create the new TLS connection
 (unless a connection object was specified directly). If this parameter is
    }
    $self->{_activity} = AnyEvent->now;
    $self->_timeout;
-   $self->on_drain (delete $self->{on_drain}) if $self->{on_drain};
+   $self->on_drain (delete $self->{on_drain}) if exists $self->{on_drain};
+   $self->no_delay (delete $self->{no_delay}) if exists $self->{no_delay};
    $self->start_read
       if $self->{on_read};
    $self
    delete $self->{_rw};
    delete $self->{_ww};
    delete $self->{fh};
    $self->stoptls;
+   delete $self->{on_read};
+   delete $self->{_queue};
 }
 sub _error {
    my ($self, $errno, $fatal) = @_;
 =cut
 sub on_timeout {
    $_[0]{on_timeout} = $_[1];
+}
+=item $handle->autocork ($boolean)
+Enables or disables the current autocork behaviour (see C<autocork>
+constructor argument).
+=cut
+=item $handle->no_delay ($boolean)
+Enables or disables the C<no_delay> setting (see constructor argument of
+the same name for details).
+=cut
+sub no_delay {
+   $_[0]{no_delay} = $_[1];
+   eval {
+      local $SIG{__DIE__};
+      setsockopt $_[0]{fh}, &Socket::IPPROTO_TCP, &Socket::TCP_NODELAY, int $_[1];
+   };
 }
 #############################################################################
 =item $handle->timeout ($seconds)
             $self->_error ($!, 1);
          }
       };
       # try to write data immediately
-      $cb->();
+      $cb->() unless $self->{autocork};
       # if still data left in wbuf, we need to poll
       $self->{_ww} = AnyEvent->io (fh => $self->{fh}, poll => "w", cb => $cb)
          if length $self->{wbuf};
    };
    if (
       defined $self->{rbuf_max}
       && $self->{rbuf_max} < length $self->{rbuf}
    ) {
-      return $self->_error (&Errno::ENOSPC, 1);
+      $self->_error (&Errno::ENOSPC, 1), return;
    }
    while () {
-      no strict 'refs';
       my $len = length $self->{rbuf};
       if (my $cb = shift @{ $self->{_queue} }) {
          unless ($cb->($self)) {
             if ($self->{_eof}) {
                # no progress can be made (not enough data and no data forthcoming)
-               $self->_error (&Errno::EPIPE, 1), last;
+               $self->_error (&Errno::EPIPE, 1), return;
             }
             unshift @{ $self->{_queue} }, $cb;
             last;
          }
             && !@{ $self->{_queue} }     # and the queue is still empty
             && $self->{on_read}          # but we still have on_read
          ) {
             # no further data will arrive
             # so no progress can be made
-            $self->_error (&Errno::EPIPE, 1), last
+            $self->_error (&Errno::EPIPE, 1), return
                if $self->{_eof};
             last; # more data might arrive
          }
       } else {
          delete $self->{_rw};
          last;
       }
    }
+   if ($self->{_eof}) {
+      if ($self->{on_eof}) {
-   $self->{on_eof}($self)
+         $self->{on_eof}($self)
-      if $self->{_eof} && $self->{on_eof};
+      } else {
+         $self->_error (0, 1);
+      }
+   }
    # may need to restart read watcher
    unless ($self->{_rw}) {
       $self->start_read
          if $self->{on_read} || @{ $self->{_queue} };
       $cb->($_[0], substr $_[0]{rbuf}, 0, $len, "");
       1
    }
 };
-# compatibility with older API
-sub push_read_chunk {
-   $_[0]->push_read (chunk => $_[1], $_[2]);
-}
-sub unshift_read_chunk {
-   $_[0]->unshift_read (chunk => $_[1], $_[2]);
-}
 =item line => [$eol, ]$cb->($handle, $line, $eol)
 The callback will be called only once a full line (including the end of
 line marker, C<$eol>) has been read. This line (excluding the end of line
 marker) will be passed to the callback as second argument (C<$line>), and
 =cut
 register_read_type line => sub {
    my ($self, $cb, $eol) = @_;
-   $eol = qr|(\015?\012)| if @_ < 3;
+   if (@_ < 3) {
+      # this is more than twice as fast as the generic code below
+      sub {
+         $_[0]{rbuf} =~ s/^([^\015\012]*)(\015?\012)// or return;
+         $cb->($_[0], $1, $2);
+         1
+      }
+   } else {
-   $eol = quotemeta $eol unless ref $eol;
+      $eol = quotemeta $eol unless ref $eol;
-   $eol = qr|^(.*?)($eol)|s;
+      $eol = qr|^(.*?)($eol)|s;
-   sub {
+      sub {
-      $_[0]{rbuf} =~ s/$eol// or return;
+         $_[0]{rbuf} =~ s/$eol// or return;
-      $cb->($_[0], $1, $2);
+         $cb->($_[0], $1, $2);
+         1
-      1
+      }
    }
 };
-# compatibility with older API
-sub push_read_line {
-   my $self = shift;
-   $self->push_read (line => @_);
-}
-sub unshift_read_line {
-   my $self = shift;
-   $self->unshift_read (line => @_);
-}
 =item regex => $accept[, $reject[, $skip], $cb->($handle, $data)
 Makes a regex match against the regex object C<$accept> and returns
 everything up to and including the match.
 register_read_type packstring => sub {
    my ($self, $cb, $format) = @_;
    sub {
       # when we can use 5.10 we can use ".", but for 5.8 we use the re-pack method
-      defined (my $len = eval { unpack $format, $_[0]->{rbuf} })
+      defined (my $len = eval { unpack $format, $_[0]{rbuf} })
          or return;
+      $format = length pack $format, $len;
+      # bypass unshift if we already have the remaining chunk
+      if ($format + $len <= length $_[0]{rbuf}) {
+         my $data = substr $_[0]{rbuf}, $format, $len;
+         substr $_[0]{rbuf}, 0, $format + $len, "";
+         $cb->($_[0], $data);
+      } else {
-      # remove prefix
+         # remove prefix
-      substr $_[0]->{rbuf}, 0, (length pack $format, $len), "";
+         substr $_[0]{rbuf}, 0, $format, "";
-      # read rest
+         # read remaining chunk
-      $_[0]->unshift_read (chunk => $len, $cb);
+         $_[0]->unshift_read (chunk => $len, $cb);
+      }
       1
    }
 };
    require Storable;
    sub {
       # when we can use 5.10 we can use ".", but for 5.8 we use the re-pack method
-      defined (my $len = eval { unpack "w", $_[0]->{rbuf} })
+      defined (my $len = eval { unpack "w", $_[0]{rbuf} })
          or return;
+      my $format = length pack "w", $len;
+      # bypass unshift if we already have the remaining chunk
+      if ($format + $len <= length $_[0]{rbuf}) {
+         my $data = substr $_[0]{rbuf}, $format, $len;
+         substr $_[0]{rbuf}, 0, $format + $len, "";
+         $cb->($_[0], Storable::thaw ($data));
+      } else {
-      # remove prefix
+         # remove prefix
-      substr $_[0]->{rbuf}, 0, (length pack "w", $len), "";
+         substr $_[0]{rbuf}, 0, $format, "";
-      # read rest
+         # read remaining chunk
-      $_[0]->unshift_read (chunk => $len, sub {
+         $_[0]->unshift_read (chunk => $len, sub {
-         if (my $ref = eval { Storable::thaw ($_[1]) }) {
+            if (my $ref = eval { Storable::thaw ($_[1]) }) {
-            $cb->($_[0], $ref);
+               $cb->($_[0], $ref);
-         } else {
+            } else {
-            $self->_error (&Errno::EBADMSG);
+               $self->_error (&Errno::EBADMSG);
+            }
-         }
+         });
-      });
+      }
+      1
    }
 };
 =back
 =over 4
 =item * all constructor arguments become object members.
 At least initially, when you pass a C<tls>-argument to the constructor it
-will end up in C<< $handle->{tls} >>. Those members might be changes or
+will end up in C<< $handle->{tls} >>. Those members might be changed or
 mutated later on (for example C<tls> will hold the TLS connection object).
 =item * other object member names are prefixed with an C<_>.
 All object members not explicitly documented (internal use) are prefixed

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents): Revision 1.69 by root, Sun Jun 15 21:44:56 2008 UTC vs. Revision 1.82 by root, Thu Aug 21 18:45:16 2008 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.69 by root, Sun Jun 15 21:44:56 2008 UTC vs.
Revision 1.82 by root, Thu Aug 21 18:45:16 2008 UTC