GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  MOJO::REACTOR (3)

.ds Aq ’

NAME

Mojo::Reactor - Low-level event reactor base class

CONTENTS

SYNOPSIS



  package Mojo::Reactor::MyEventLoop;
  use Mojo::Base Mojo::Reactor;

  sub again      {...}
  sub io         {...}
  sub is_running {...}
  sub next_tick  {...}
  sub one_tick   {...}
  sub recurring  {...}
  sub remove     {...}
  sub reset      {...}
  sub start      {...}
  sub stop       {...}
  sub timer      {...}
  sub watch      {...}



DESCRIPTION

Mojo::Reactor is an abstract base class for low-level event reactors, like Mojo::Reactor::EV and Mojo::Reactor::Poll.

EVENTS

Mojo::Reactor inherits all events from Mojo::EventEmitter and can emit the following new ones.

    error



  $reactor->on(error => sub {
    my ($reactor, $err) = @_;
    ...
  });



Emitted for exceptions caught in callbacks, fatal if unhandled. Note that if this event is unhandled or fails it might kill your program, so you need to be careful.



  $reactor->on(error => sub {
    my ($reactor, $err) = @_;
    say "Something very bad happened: $err";
  });



METHODS

Mojo::Reactor inherits all methods from Mojo::EventEmitter and implements the following new ones.

    again



  $reactor->again($id);



Restart timer. Meant to be overloaded in a subclass. Note that this method requires an active timer.

    detect



  my $class = Mojo::Reactor->detect;



Detect and load the best reactor implementation available, will try the value of the MOJO_REACTOR environment variable, Mojo::Reactor::EV or Mojo::Reactor::Poll.



  # Instantiate best reactor implementation available
  my $reactor = Mojo::Reactor->detect->new;



    io



  $reactor = $reactor->io($handle => sub {...});



Watch handle for I/O events, invoking the callback whenever handle becomes readable or writable. Meant to be overloaded in a subclass.



  # Callback will be executed twice if handle becomes readable and writable
  $reactor->io($handle => sub {
    my ($reactor, $writable) = @_;
    say $writable ? Handle is writable : Handle is readable;
  });



    is_running



  my $bool = $reactor->is_running;



Check if reactor is running. Meant to be overloaded in a subclass.

    next_tick



  my $undef = $reactor->next_tick(sub {...});



Execute callback as soon as possible, but not before returning or other callbacks that have been registered with this method, always returns undef. Meant to be overloaded in a subclass.

    one_tick



  $reactor->one_tick;



Run reactor until an event occurs. Note that this method can recurse back into the reactor, so you need to be careful. Meant to be overloaded in a subclass.



  # Dont block longer than 0.5 seconds
  my $id = $reactor->timer(0.5 => sub {});
  $reactor->one_tick;
  $reactor->remove($id);



    recurring



  my $id = $reactor->recurring(0.25 => sub {...});



Create a new recurring timer, invoking the callback repeatedly after a given amount of time in seconds. Meant to be overloaded in a subclass.

    remove



  my $bool = $reactor->remove($handle);
  my $bool = $reactor->remove($id);



Remove handle or timer. Meant to be overloaded in a subclass.

    reset



  $reactor->reset;



Remove all handles and timers. Meant to be overloaded in a subclass.

    start



  $reactor->start;



Start watching for I/O and timer events, this will block until stop is called. Note that some reactors stop automatically if there are no events being watched anymore. Meant to be overloaded in a subclass.



  # Start reactor only if it is not running already
  $reactor->start unless $reactor->is_running;



    stop



  $reactor->stop;



Stop watching for I/O and timer events. Meant to be overloaded in a subclass.

    timer



  my $id = $reactor->timer(0.5 => sub {...});



Create a new timer, invoking the callback after a given amount of time in seconds. Meant to be overloaded in a subclass.

    watch



  $reactor = $reactor->watch($handle, $readable, $writable);



Change I/O events to watch handle for with true and false values. Meant to be overloaded in a subclass. Note that this method requires an active I/O watcher.



  # Watch only for readable events
  $reactor->watch($handle, 1, 0);

  # Watch only for writable events
  $reactor->watch($handle, 0, 1);

  # Watch for readable and writable events
  $reactor->watch($handle, 1, 1);

  # Pause watching for events
  $reactor->watch($handle, 0, 0);



SEE ALSO

Mojolicious, Mojolicious::Guides, <http://mojolicious.org>.
Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 MOJO::REACTOR (3) 2016-03-15

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.