IPC::Run::Timer man page on ElementaryOS

Man page or keyword search:  
man Server   4994 pages
apropos Keyword Search (all sections)
Output format
ElementaryOS logo
[printable version]

IPC::Run::Timer(3pm)  User Contributed Perl Documentation IPC::Run::Timer(3pm)

       IPC::Run::Timer -- Timer channels for IPC::Run.

	  use IPC::Run qw( run	timer timeout );
	  ## or IPC::Run::Timer ( timer timeout );
	  ## or IPC::Run::Timer ( :all );

	  ## A non-fatal timer:
	  $t = timer( 5 ); # or...
	  $t = IO::Run::Timer->new( 5 );
	  run $t, ...;

	  ## A timeout (which is a timer that dies on expiry):
	  $t = timeout( 5 ); # or...
	  $t = IO::Run::Timer->new( 5, exception => "harness timed out" );

       This class and module allows timers and timeouts to be created for use
       by IPC::Run.  A timer simply expires when it's time is up.  A timeout
       is a timer that throws an exception when it expires.

       Timeouts are usually a bit simpler to use  than timers: they throw an
       exception on expiration so you don't need to check them:

	  ## Give @cmd 10 seconds to get started, then 5 seconds to respond
	  my $t = timeout( 10 );
	  $h = start(
	     \@cmd, \$in, \$out,
	  pump $h until $out =~ /prompt/;

	  $in = "some stimulus";
	  $out = '';
	  $t->time( 5 )
	  pump $h until $out =~ /expected response/;

       You do need to check timers:

	  ## Give @cmd 10 seconds to get started, then 5 seconds to respond
	  my $t = timer( 10 );
	  $h = start(
	     \@cmd, \$in, \$out,
	  pump $h until $t->is_expired || $out =~ /prompt/;

	  $in = "some stimulus";
	  $out = '';
	  $t->time( 5 )
	  pump $h until $out =~ /expected response/ || $t->is_expired;

       Timers and timeouts that are reset get started by start() and pump().
       Timers change state only in pump().  Since run() and finish() both call
       pump(), they act like pump() with repect to timers.

       Timers and timeouts have three states: reset, running, and expired.
       Setting the timeout value resets the timer, as does calling the reset()
       method.	The start() method starts (or restarts) a timer with the most
       recently set time value, no matter what state it's in.

   Time values
       All time values are in seconds.	Times may be specified as integer or
       floating point seconds, optionally preceded by puncuation-separated
       days, hours, and minutes.\


	  1	      1 second
	  1.1	      1.1 seconds
	  60	      60 seconds
	  1:0	      1 minute
	  1:1	      1 minute, 1 second
	  1:90	      2 minutes, 30 seconds
	  1:2:3:4.5   1 day, 2 hours, 3 minutes, 4.5 seconds

       Absolute date/time strings are *not* accepted: year, month and day-of-
       month parsing is not available (patches welcome :-).

   Interval fudging
       When calculating an end time from a start time and an interval,
       IPC::Run::Timer instances add a little fudge factor.  This is to ensure
       that no time will expire before the interval is up.

       First a little background.  Time is sampled in discrete increments.
       We'll call the exact moment that the reported time increments from one
       interval to the next a tick, and the interval between ticks as the time
       period.	Here's a diagram of three ticks and the periods between them:

	   ^		       ^		   ^
	   |<--- period 0 ---->|<--- period 1 ---->|
	   |		       |		   |
	 tick 0		     tick 1		 tick 2

       To see why the fudge factor is necessary, consider what would happen
       when a timer with an interval of 1 second is started right at the end
       of period 0:

	   ^		    ^  ^		   ^
	   |		    |  |		   |
	   |		    |  |		   |
	 tick 0		    |tick 1		 tick 2
			start $t

       Assuming that check() is called many times per period, then the timer
       is likely to expire just after tick 1, since the time reported will
       have lept from the value '0' to the value '1':

	   ^		    ^  ^   ^		   ^
	   |		    |  |   |		   |
	   |		    |  |   |		   |
	 tick 0		    |tick 1|		 tick 2
			    |	   |
			start $t   |
			       check $t

       Adding a fudge of '1' in this example means that the timer is
       guaranteed not to expire before tick 2.

       The fudge is not added to an interval of '0'.

       This means that intervals guarantee a minimum interval.	Given that the
       process running perl may be suspended for some period of time, or that
       it gets busy doing something time-consuming, there are no other
       guarantees on how long it will take a timer to expire.

       INCOMPATIBLE CHANGE: Due to the awkwardness introduced by ripping
       pseudohashes out of Perl, this class no longer uses the fields pragma.

	   A constructor function (not method) of IPC::Run::Timer instances:

	      $t = timer( 5 );
	      $t = timer( 5, name => 'stall timer', debug => 1 );

	      $t = timer;
	      $t->interval( 5 );

	      run ..., $t;
	      run ..., $t = timer( 5 );

	   This convenience function is a shortened spelling of

	      IPC::Run::Timer->new( ... );

	   .  It returns a timer in the reset state with a given interval.

	   If an exception is provided, it will be thrown when the timer
	   notices that it has expired (in check()).  The name is for
	   debugging usage, if you plan on having multiple timers around.  If
	   no name is provided, a name like "timer #1" will be provided.

	   A constructor function (not method) of IPC::Run::Timer instances:

	      $t = timeout( 5 );
	      $t = timeout( 5, exception => "kablooey" );
	      $t = timeout( 5, name => "stall", exception => "kablooey" );

	      $t = timeout;
	      $t->interval( 5 );

	      run ..., $t;
	      run ..., $t = timeout( 5 );

	   A This convenience function is a shortened spelling of

	      IPC::Run::Timer->new( exception => "IPC::Run: timeout ...", ... );

	   .  It returns a timer in the reset state that will throw an
	   exception when it expires.

	   Takes the same parameters as "timer", any exception passed in
	   overrides the default exception.

	      IPC::Run::Timer->new()  ;
	      IPC::Run::Timer->new( 5 )	 ;
	      IPC::Run::Timer->new( 5, exception => 'kablooey' )  ;

	   Constructor.	 See "timer" for details.

	      check $t;
	      check $t, $now;

	   Checks to see if a timer has expired since the last check.  Has no
	   effect on non-running timers.  This will throw an exception if one
	   is defined.

	   IPC::Run::pump() calls this routine for any timers in the harness.

	   You may pass in a version of now, which is useful in case you have
	   it lying around or you want to check several timers with a
	   consistent concept of the current time.

	   Returns the time left before end_time or 0 if end_time is no longer
	   in the future or the timer is not running (unless, of course,
	   check() expire()s the timer and this results in an exception being

	   Returns undef if the timer is not running on entry, 0 if check()
	   expires it, and the time left if it's left running.

	   Sets/gets the current setting of the debugging flag for this timer.
	   This has no effect if debugging is not enabled for the current

	      $et = $t->end_time;
	      $et = end_time $t;

	      $t->end_time( time + 10 );

	   Returns the time when this timer will or did expire.	 Even if this
	   time is in the past, the timer may not be expired, since check()
	   may not have been called yet.

	   Note that this end_time is not start_time($t) + interval($t), since
	   some small extra amount of time is added to make sure that the
	   timer does not expire before interval() elapses.  If this were not
	   so, then

	   Changing end_time() while a timer is running will set the
	   expiration time.  Changing it while it is expired has no affect,
	   since reset()ing a timer always clears the end_time().

	      $x = $t->exception;
	      $t->exception( $x );
	      $t->exception( undef );

	   Sets/gets the exception to throw, if any.  'undef' means that no
	   exception will be thrown.  Exception does not need to be a scalar:
	   you may ask that references be thrown.

	      $i = interval $t;
	      $i = $t->interval;
	      $t->interval( $i );

	   Sets the interval.  Sets the end time based on the start_time() and
	   the interval (and a little fudge) if the timer is running.

	      expire $t;

	   Sets the state to expired (undef).  Will throw an exception if one
	   is defined and the timer was not already expired.  You can expire a
	   reset timer without starting it.

	   Sets/gets this timer's name.	 The name is only used for debugging
	   purposes so you can tell which freakin' timer is doing what.

	      reset $t;

	   Resets the timer to the non-running, non-expired state and clears
	   the end_time().

	      start $t;
	      start $t, $interval;
	      start $t, $interval, $now;

	   Starts or restarts a timer.	This always sets the start_time.  It
	   sets the end_time based on the interval if the timer is running or
	   if no end time has been set.

	   You may pass an optional interval or current time value.

	   Not passing a defined interval causes the previous interval setting
	   to be re-used unless the timer is reset and an end_time has been
	   set (an exception is thrown if no interval has been set).

	   Not passing a defined current time value causes the current time to
	   be used.

	   Passing a current time value is useful if you happen to have a time
	   value lying around or if you want to make sure that several timers
	   are started with the same concept of start time.  You might even
	   need to lie to an IPC::Run::Timer, occasionally.

	   Sets/gets the start time, in seconds since the epoch.  Setting this
	   manually is a bad idea, it's better to call "start"() at the
	   correct time.

	      $s = state $t;
	      $t->state( $s );

	   Get/Set the current state.  Only use this if you really need to
	   transfer the state to/from some variable.  Use "expire", "start",
	   "reset", "is_expired", "is_running", "is_reset".

	   Note:  Setting the state to 'undef' to expire a timer will not
	   throw an exception.

       use Time::HiRes; if it's present.

       Add detection and parsing of [[[HH:]MM:]SS formatted times and

       Barrie Slaymaker <barries@slaysys.com>

perl v5.14.2			  2012-01-16		  IPC::Run::Timer(3pm)

List of man pages available for ElementaryOS

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net