[ViewVC] Diff of: cvs/AnyEvent/README

Comparing AnyEvent/README (file contents):
Revision 1.45 by root, Fri Jul 17 14:57:03 2009 UTC vs.
Revision 1.50 by root, Sat Aug 1 09:14:54 2009 UTC

 NAME
-    AnyEvent - provide framework for multiple event loops
+    AnyEvent - the DBI of event loop programming
-    EV, Event, Glib, Tk, Perl, Event::Lib, Qt and POE are various supported
+    EV, Event, Glib, Tk, Perl, Event::Lib, Irssi, rxvt-unicode, IO::Async,
-    event loops.
+    Qt and POE are various supported event loops/environments.
 SYNOPSIS
        use AnyEvent;
        # file descriptor readable
 INTRODUCTION/TUTORIAL
     This manpage is mainly a reference manual. If you are interested in a
     tutorial or some gentle introduction, have a look at the AnyEvent::Intro
     manpage.
+SUPPORT
+    There is a mailinglist for discussing all things AnyEvent, and an IRC
+    channel, too.
+    See the AnyEvent project page at the Schmorpforge Ta-Sa Software
+    Repository, at <http://anyevent.schmorp.de>, for more info.
 WHY YOU SHOULD USE THIS MODULE (OR NOT)
     Glib, POE, IO::Async, Event... CPAN offers event models by the dozen
     nowadays. So what is different about AnyEvent?
     Note that "my $w; $w =" combination. This is necessary because in Perl,
     my variables are only visible after the statement in which they are
     declared.
   I/O WATCHERS
+       $w = AnyEvent->io (
+          fh   => <filehandle_or_fileno>,
+          poll => <"r" or "w">,
+          cb   => <callback>,
+       );
     You can create an I/O watcher by calling the "AnyEvent->io" method with
     the following mandatory key-value pairs as arguments:
     "fh" is the Perl *file handle* (or a naked file descriptor) to watch for
     events (AnyEvent might or might not keep a reference to this file
           warn "read: $input\n";
           undef $w;
        });
   TIME WATCHERS
+       $w = AnyEvent->timer (after => <seconds>, cb => <callback>);
+       $w = AnyEvent->timer (
+          after    => <fractional_seconds>,
+          interval => <fractional_seconds>,
+          cb       => <callback>,
+       );
     You can create a time watcher by calling the "AnyEvent->timer" method
     with the following mandatory arguments:
     "after" specifies after how many seconds (fractional values are
     supported) the callback should be invoked. "cb" is the callback to
         the event loop's idea of "current time".
         Note that updating the time *might* cause some events to be handled.
   SIGNAL WATCHERS
+       $w = AnyEvent->signal (signal => <uppercase_signal_name>, cb => <callback>);
     You can watch for signals using a signal watcher, "signal" is the signal
     *name* in uppercase and without any "SIG" prefix, "cb" is the Perl
     callback to be invoked whenever a signal occurs.
     Although the callback might get passed parameters, their value and
     invocation, and callback invocation will be synchronous. Synchronous
     means that it might take a while until the signal gets handled by the
     process, but it is guaranteed not to interrupt any other callbacks.
     The main advantage of using these watchers is that you can share a
-    signal between multiple watchers.
+    signal between multiple watchers, and AnyEvent will ensure that signals
+    will not interrupt your program at bad times.
-    This watcher might use %SIG, so programs overwriting those signals
+    This watcher might use %SIG (depending on the event loop used), so
-    directly will likely not work correctly.
+    programs overwriting those signals directly will likely not work
+    correctly.
     Example: exit on SIGINT
        my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });
+   Signal Races, Delays and Workarounds
+    Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching
+    callbacks to signals in a generic way, which is a pity, as you cannot do
+    race-free signal handling in perl, requiring C libraries for this.
+    AnyEvent will try to do it's best, which means in some cases, signals
+    will be delayed. The maximum time a signal might be delayed is specified
+    in $AnyEvent::MAX_SIGNAL_LATENCY (default: 10 seconds). This variable
+    can be changed only before the first signal watcher is created, and
+    should be left alone otherwise. This variable determines how often
+    AnyEvent polls for signals (in case a wake-up was missed). Higher values
+    will cause fewer spurious wake-ups, which is better for power and CPU
+    saving.
+    All these problems can be avoided by installing the optional
+    Async::Interrupt module, which works with most event loops. It will not
+    work with inherently broken event loops such as Event or Event::Lib (and
+    not with POE currently, as POE does it's own workaround with one-second
+    latency). For those, you just have to suffer the delays.
   CHILD PROCESS WATCHERS
+       $w = AnyEvent->child (pid => <process id>, cb => <callback>);
     You can also watch on a child process exit and catch its exit status.
-    The child process is specified by the "pid" argument (if set to 0, it
+    The child process is specified by the "pid" argument (one some backends,
-    watches for any child process exit). The watcher will triggered only
+    using 0 watches for any child process exit, on others this will croak).
-    when the child process has finished and an exit status is available, not
+    The watcher will be triggered only when the child process has finished
-    on any trace events (stopped/continued).
+    and an exit status is available, not on any trace events
+    (stopped/continued).
     The callback will be called with the pid and exit status (as returned by
     waitpid), so unlike other watcher types, you *can* rely on child watcher
     callback arguments.
     of when you start the watcher.
     This means you cannot create a child watcher as the very first thing in
     an AnyEvent program, you *have* to create at least one watcher before
     you "fork" the child (alternatively, you can call "AnyEvent::detect").
+    As most event loops do not support waiting for child events, they will
+    be emulated by AnyEvent in most cases, in which the latency and race
+    problems mentioned in the description of signal watchers apply.
     Example: fork a process and wait for it
        my $done = AnyEvent->condvar;
        # do something else, then wait for process exit
        $done->recv;
   IDLE WATCHERS
+       $w = AnyEvent->idle (cb => <callback>);
     Sometimes there is a need to do something, but it is not so important to
     do it instantly, but only when there is nothing better to do. This
     "nothing better to do" is usually defined to be "no other events need
     attention by the event loop".
              }
           });
        });
   CONDITION VARIABLES
+       $cv = AnyEvent->condvar;
+       $cv->send (<list>);
+       my @res = $cv->recv;
     If you are familiar with some event loops you will know that all of them
     require you to run some blocking "loop", "run" or similar function that
     will actively watch for new events and call your callbacks.
     AnyEvent is slightly different: it expects somebody else to run the
     Condition variables are similar to callbacks, except that you can
     optionally wait for them. They can also be called merge points - points
     in time where multiple outstanding events have been processed. And yet
     another way to call them is transactions - each condition variable can
     be used to represent a transaction, which finishes at some point and
-    delivers a result.
+    delivers a result. And yet some people know them as "futures" - a
+    promise to compute/deliver something that you can wait for.
     Condition variables are very useful to signal that something has
     finished, for example, if you write a module that does asynchronous http
     requests, then a condition variable would be the ideal candidate to
     signal the availability of results. The user can either act when the
     $cb = $cv->cb ($cb->($cv))
         This is a mutator function that returns the callback set and
         optionally replaces it before doing so.
-        The callback will be called when the condition becomes "true", i.e.
+        The callback will be called when the condition becomes (or already
-        when "send" or "croak" are called, with the only argument being the
+        was) "true", i.e. when "send" or "croak" are called (or were
-        condition variable itself. Calling "recv" inside the callback or at
+        called), with the only argument being the condition variable itself.
+        Calling "recv" inside the callback or at any later time is
-        any later time is guaranteed not to block.
+        guaranteed not to block.
 SUPPORTED EVENT LOOPS/BACKENDS
     The available backend classes are (every class has its own manpage):
     Backends that are autoprobed when no other event loop can be found.
            AnyEvent::Impl::Glib      based on Glib, slow but very stable.
            AnyEvent::Impl::Tk        based on Tk, very broken.
            AnyEvent::Impl::EventLib  based on Event::Lib, leaks memory and worse.
            AnyEvent::Impl::POE       based on POE, very slow, some limitations.
+           AnyEvent::Impl::Irssi     used when running within irssi.
     Backends with special needs.
         Qt requires the Qt::Application to be instantiated first, but will
         otherwise be picked up automatically. As long as the main program
         instantiates the application before any AnyEvent watchers are
         creates and installs the global IO::AIO watcher in a "post_detect"
         block to avoid autodetecting the event module at load time.
         If called in scalar or list context, then it creates and returns an
         object that automatically removes the callback again when it is
+        destroyed (or "undef" when the hook was immediately executed). See
-        destroyed. See Coro::BDB for a case where this is useful.
+        AnyEvent::AIO for a case where this is useful.
+        Example: Create a watcher for the IO::AIO module and store it in
+        $WATCHER. Only do so after the event loop is initialised, though.
+           our WATCHER;
+           my $guard = AnyEvent::post_detect {
+              $WATCHER = AnyEvent->io (fh => IO::AIO::poll_fileno, poll => 'r', cb => \&IO::AIO::poll_cb);
+           };
+           # the ||= is important in case post_detect immediately runs the block,
+           # as to not clobber the newly-created watcher. assigning both watcher and
+           # post_detect guard to the same variable has the advantage of users being
+           # able to just C<undef $WATCHER> if the watcher causes them grief.
+           $WATCHER ||= $guard;
     @AnyEvent::post_detect
         If there are any code references in this array (you can "push" to it
         before or after loading AnyEvent), then they will called directly
         after the event loop has been chosen.
         by "PERL_ANYEVENT_MODEL".
         When set to 2 or higher, cause AnyEvent to report to STDERR which
         event model it chooses.
+        When set to 8 or higher, then AnyEvent will report extra information
+        on which optional modules it loads and how it implements certain
+        features.
     "PERL_ANYEVENT_STRICT"
         AnyEvent does not do much argument checking by default, as thorough
         argument checking is very costly. Setting this variable to a true
         value will cause AnyEvent to load "AnyEvent::Strict" and then to
         thoroughly check the arguments passed to most method calls. If it
         finds any problems, it will croak.
         In other words, enables "strict" mode.
-        Unlike "use strict", it is definitely recommended to keep it off in
+        Unlike "use strict" (or it's modern cousin, "use common::sense", it
-        production. Keeping "PERL_ANYEVENT_STRICT=1" in your environment
+        is definitely recommended to keep it off in production. Keeping
+        "PERL_ANYEVENT_STRICT=1" in your environment while developing
-        while developing programs can be very useful, however.
+        programs can be very useful, however.
     "PERL_ANYEVENT_MODEL"
         This can be used to specify the event model to be used by AnyEvent,
         before auto detection and -probing kicks in. It must be a string
         consisting entirely of ASCII letters. The string "AnyEvent::Impl::"
     "PERL_ANYEVENT_CA_FILE", "PERL_ANYEVENT_CA_PATH".
         When neither "ca_file" nor "ca_path" was specified during
         AnyEvent::TLS context creation, and either of these environment
         variables exist, they will be used to specify CA certificate
         locations instead of a system-dependent default.
+    "PERL_ANYEVENT_AVOID_GUARD" and "PERL_ANYEVENT_AVOID_ASYNC_INTERRUPT"
+        When these are set to 1, then the respective modules are not loaded.
+        Mostly good for testing AnyEvent itself.
 SUPPLYING YOUR OWN EVENT MODEL INTERFACE
     This is an advanced topic that you do not normally need to use AnyEvent
     in a module. This section is only of use to event loop authors who want
     to provide AnyEvent compatibility.
         it is that this way, the handler will be restored to defaults on
         exec.
         Feel free to install your own handler, or reset it to defaults.
+RECOMMENDED/OPTIONAL MODULES
+    One of AnyEvent's main goals is to be 100% Pure-Perl(tm): only perl (and
+    it's built-in modules) are required to use it.
+    That does not mean that AnyEvent won't take advantage of some additional
+    modules if they are installed.
+    This section epxlains which additional modules will be used, and how
+    they affect AnyEvent's operetion.
+    Async::Interrupt
+        This slightly arcane module is used to implement fast signal
+        handling: To my knowledge, there is no way to do completely
+        race-free and quick signal handling in pure perl. To ensure that
+        signals still get delivered, AnyEvent will start an interval timer
+        to wake up perl (and catch the signals) with some delay (default is
+        10 seconds, look for $AnyEvent::MAX_SIGNAL_LATENCY).
+        If this module is available, then it will be used to implement
+        signal catching, which means that signals will not be delayed, and
+        the event loop will not be interrupted regularly, which is more
+        efficient (And good for battery life on laptops).
+        This affects not just the pure-perl event loop, but also other event
+        loops that have no signal handling on their own (e.g. Glib, Tk, Qt).
+        Some event loops (POE, Event, Event::Lib) offer signal watchers
+        natively, and either employ their own workarounds (POE) or use
+        AnyEvent's workaround (using $AnyEvent::MAX_SIGNAL_LATENCY).
+        Installing Async::Interrupt does nothing for those backends.
+    EV  This module isn't really "optional", as it is simply one of the
+        backend event loops that AnyEvent can use. However, it is simply the
+        best event loop available in terms of features, speed and stability:
+        It supports the AnyEvent API optimally, implements all the watcher
+        types in XS, does automatic timer adjustments even when no monotonic
+        clock is available, can take avdantage of advanced kernel interfaces
+        such as "epoll" and "kqueue", and is the fastest backend *by far*.
+        You can even embed Glib/Gtk2 in it (or vice versa, see EV::Glib and
+        Glib::EV).
+    Guard
+        The guard module, when used, will be used to implement
+        "AnyEvent::Util::guard". This speeds up guards considerably (and
+        uses a lot less memory), but otherwise doesn't affect guard
+        operation much. It is purely used for performance.
+    JSON and JSON::XS
+        This module is required when you want to read or write JSON data via
+        AnyEvent::Handle. It is also written in pure-perl, but can take
+        advantage of the ultra-high-speed JSON::XS module when it is
+        installed.
+        In fact, AnyEvent::Handle will use JSON::XS by default if it is
+        installed.
+    Net::SSLeay
+        Implementing TLS/SSL in Perl is certainly interesting, but not very
+        worthwhile: If this module is installed, then AnyEvent::Handle (with
+        the help of AnyEvent::TLS), gains the ability to do TLS/SSL.
+    Time::HiRes
+        This module is part of perl since release 5.008. It will be used
+        when the chosen event library does not come with a timing source on
+        it's own. The pure-perl event loop (AnyEvent::Impl::Perl) will
+        additionally use it to try to use a monotonic clock for timing
+        stability.
 FORK
     Most event libraries are not fork-safe. The ones who are usually are
     because they rely on inefficient but fork-safe "select" or "poll" calls.
     Only EV is fully fork-aware.
     If you have to fork, you must either do so *before* creating your first
-    watcher OR you must not use AnyEvent at all in the child.
+    watcher OR you must not use AnyEvent at all in the child OR you must do
+    something completely out of the scope of AnyEvent.
 SECURITY CONSIDERATIONS
     AnyEvent can be forced to load any event model via
     $ENV{PERL_ANYEVENT_MODEL}. While this cannot (to my knowledge) be used
     to execute arbitrary code or directly gain access, it can easily be used
     Event::Lib, Qt, POE.
     Implementations: AnyEvent::Impl::EV, AnyEvent::Impl::Event,
     AnyEvent::Impl::Glib, AnyEvent::Impl::Tk, AnyEvent::Impl::Perl,
     AnyEvent::Impl::EventLib, AnyEvent::Impl::Qt, AnyEvent::Impl::POE,
-    AnyEvent::Impl::IOAsync.
+    AnyEvent::Impl::IOAsync, Anyevent::Impl::Irssi.
     Non-blocking file handles, sockets, TCP clients and servers:
     AnyEvent::Handle, AnyEvent::Socket, AnyEvent::TLS.
     Asynchronous DNS: AnyEvent::DNS.

Diff Legend

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

Comparing AnyEvent/README (file contents): Revision 1.45 by root, Fri Jul 17 14:57:03 2009 UTC vs. Revision 1.50 by root, Sat Aug 1 09:14:54 2009 UTC

Diff Legend

Comparing AnyEvent/README (file contents):
Revision 1.45 by root, Fri Jul 17 14:57:03 2009 UTC vs.
Revision 1.50 by root, Sat Aug 1 09:14:54 2009 UTC