view release on metacpan or  search on metacpan

t/lib/Hailo/Test/TimToady.trn  view on Meta::CPAN

my throng of female groupies I can count on the fingers of one hand, and that's about all I'm allowed to do with 'em. :)
who says mine aren't?
Gloria tends to transcend groupiehood in various ways.
have you seen the Pugs Manifest from Audrey?
we shoulda put a link to it...
I'm busy revising S02 again, and it looks like it's working out very nicely.
Particularly since we still get a shorthand . . that is taken to be equivalent to .#. .
The other comments are naturally defined to make the "extra" newline into the whitespace.
So #... only extends *to* the newline at the end.
and =begin doesn't hide the newline before it.
or actually, ". ." is equivalent to ".#. .." so it still does the "long dot" trick visually.

t/lib/Hailo/Test/TimToady.trn  view on Meta::CPAN

the Internet is a big place
it's possible that there are universes in which Perl 6 is done already, and maybe the Internet leaks between universes.
sorry, he's rocket lee in that universe
it's a strange quirk of english that jets aren't rockets, but rockets use jet propulsion
we'll release as soon as we get up to about 40,000 passing regression tests.
so you'd better get busy :)
to the first approximation, a capture is just a list of generators
some of which are marked as invocant or named, but to begin with they could just live in a list
and the methods could comb them out of the list on demand
well, $ @ % & are essentially just methods too
I don't see why they have to return containers

t/lib/Hailo/Test/TimToady.trn  view on Meta::CPAN

I don't recall every doing a distclean
*ever
testing a fix
that should fix it
so I can understand all the eu folks staying bundled up in their beds, but what's the excuse of all those hardy usians?  all out snowmobiling or somethin'?  :)
maybe they're all too busy hacking to waste time on irc :)
well, taking care of yourself is also important; we're in this for the long haul
the author of elf is a hare rather than a tortoise, and he's been haring off for a while now
only roles
but roles used as classes will attempt to pun themselves into a class
however...

 view release on metacpan or  search on metacpan

lib/Ham/Device/FT950.pm  view on Meta::CPAN

# Returns 0 if OFF
# Return undef is error or don't know
eval {
sub statBSY {
    my $self = shift;
    my ($busy, $result);
    unless ($result = $self->writeCmd('BY;')) { return undef; }
    $busy = $self->readResult();
    $busy =~ /BY(\d+)\;/;
    my $b = $1;
        if ($b == 10) { return 1;
        } else { return 0; }
}
};

lib/Ham/Device/FT950.pm  view on Meta::CPAN

# Returns 2 if Radio TX ON  CAT TX OFF
# Return undef is error or don't know
eval {
sub statTX {
    my $self = shift;
    my ($busy, $result);
    unless ($result = $self->writeCmd('TX;')) { return undef; }
    $busy = $self->readResult();
    $busy =~ /TX(\d)\;/;
    my $b = $1;
        if ($b == 0)      {
            return 1;
        } elsif ($b == 1) {
            return 1;

lib/Ham/Device/FT950.pm  view on Meta::CPAN

# Returns 1 for ON
# Return undef is error or don't know
eval {
sub statFastStep {
    my $self = shift;
    my ($busy, $result);
    unless ($result = $self->writeCmd('FS;')) { return undef; }
    $busy = $self->readResult();
    $busy =~ /FS(\d)\;/;
    my $b = $1;
        if ($b == 0)      {
            return 0;
        } elsif ($b == 1) {
            return 1;

 view release on metacpan or  search on metacpan

lib/Ham/Reference/Qsignals.pm  view on Meta::CPAN

	'qnz' => 'Zero beat your signal with mine.',
	'qrg' => 'Will you tell me my exact frequency?',
	'qrh' => 'Does my frequency vary?',
	'qrj' => 'Are you receiving me badly?',
	'qrk' => 'What is the intelligibility of my signals?',
	'qrl' => 'Are you busy?',
	'qrm' => 'Is my transmission being interfered with?',
	'qrn' => 'Are you troubled by static?',
	'qro' => 'Shall I increase power?',
	'qrp' => 'Shall I decrease power?',
	'qrq' => 'Shall I send faster?',

 view release on metacpan or  search on metacpan

lib/Hardware/Simulator/MIX.pm  view on Meta::CPAN

# Usage: $self->wait_until_device_ready($devnum)
#
# Used only before IN/OUT operations. 
# 
# If the device is busy, that is, the current time - last started < delay,
# increase the current time, so that the device would be ready
sub wait_until_device_ready
{
    my ($self, $devnum) = @_;

    return if $devnum < 0 || $devnum > 19;

    my $devstat = @{$self->{devstat}}[$devnum];
    my $laststarted = $devstat->{laststarted};

    # See whether the device is still busy
    if ($self->{time} - $laststarted < $devstat->{delay})
    {
        # advance the current system time to the point
        # that the device would be ready
        $self->{time} = $laststarted + $devstat->{delay};

lib/Hardware/Simulator/MIX.pm  view on Meta::CPAN

	$self->{message} = "invalid ioc for device(#$f)";
    }
    return 1;
}

# Jump when device busy: always no busy
sub X_JBUS {
    my ($self, $c, $f, $r, $l, $i, $a, $m) = @_;
    return 1;
}

 view release on metacpan or  search on metacpan

Word/adjective.txt  view on Meta::CPAN

brisk,brisker,briskest
broad,broader,broadest
brown,browner,brownest
bulky,bulkier,bulkiest
busty,bustier,bustiest
busy,busier,busiest
calm,calmer,calmest
cheap,cheaper,cheapest
cheeky,cheekier,cheekiest
cheery,cheerier,cheeriest
chief,chiefer,chiefest

 view release on metacpan or  search on metacpan

lib/Hash/Wrap.pm  view on Meta::CPAN

        # do a two-step initialization of the constructor.  If
        # the initialization sub is stored in $recurse_into_hash, and then
        # $recurse_into_hash is set to the actual constructor I worry that
        # Perl may decide to garbage collect the setup subroutine while it's
        # busy setting $recurse_into_hash.  So, store the
        # initialization sub in something other than $recurse_into_hash.

        $dict{recursion_constructor} = <<'END';
our $recurse_into_hash;
our $setup_recurse_into_hash = sub {

 view release on metacpan or  search on metacpan

BCM2835/src/doc/Doxyfile.in  view on Meta::CPAN

# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
# determine which symbols to keep in memory and which to flush to disk.
# When the cache is full, less often used symbols will be written to disk.
# For small to medium size projects (<1000 input files) the default value is
# probably good enough. For larger projects a too small cache size can cause
# doxygen to be busy swapping symbols to and from disk most of the time
# causing a significant performance penalty.
# If the system has enough physical memory increasing the cache will improve the
# performance by keeping more symbols in memory. Note that the value works on
# a logarithmic scale so increasing the size by one will roughly double the
# memory usage. The cache size is given by this formula:

 view release on metacpan or  search on metacpan

lib/HiPi/Huawei/Errors.pm  view on Meta::CPAN

    
    '400'       => 'error in http request / response',
    
    '100002'    => 'call not supported',
    '100003'    => 'access forbidden in current session context',
    '100004'    => 'system busy',
    '100005'    => 'system system reports request failed',
    '100006'    => 'invalid request parameter',
    '108001'    => 'invalid username',
    '108002'    => 'invalid password',
    '108003'    => 'user already logged in',
    '108006'    => 'invalid username or password',
    '108007'    => 'maximum session login attempts exceeded',
    '120001'    => 'voice busy',
    '125001'    => 'invalid token',
    '125002'    => 'invalid session',
    '125003'    => 'invalid token or session',
    
    '103024'    => 'serial number check failed',

 view release on metacpan or  search on metacpan

share/root/static/yui/assets/yui.css  view on Meta::CPAN

#yui-theater h2 {margin:0 0 10px 0; padding:0; border:none; color:#000;  font-size:122%; font-weight:bold;}
#yui-theater p {margin:7px 0 0 0;}
#yui-theater div {float:right; font-size:85%;}

/*rss reader styles*/
p.loading-content {background-image:url(http://us.i1.yimg.com/us.yimg.com/i/ydn/yuiweb/img/busy_arrow.gif); background-position:top left; background-repeat:no-repeat; height:20px;padding:4px 0 0 25px; margin:0;}
#doc3 ul.yuirssreader {margin:0; padding:0;}
#doc3 ul.yuirssreader li {list-style-type:none;padding:5px 0 0 12px; margin:0;}
#doc3 ul.yuirssreader li p {margin:0; padding:0;}
ul.yuirssreader cite {color:#666666; margin:0;}
span.yuirssreader-date {font-size:77%; color:#E76300;}

 view release on metacpan or  search on metacpan

lib/Hopkins/Config/XML.pm  view on Meta::CPAN

Hopkins::Config::XML - hopkins configuration via XML

=head1 DESCRIPTION

Hopkins::Config encapsulates all of the busywork associated
in the reading and post-processing of the XML configuration
in addition to providing a simple interface to accessing
values when required.

Hopkins::Config::XML will validate your configuration using

 view release on metacpan or  search on metacpan

examples/rss-llq  view on Meta::CPAN

   ll_free_objs($query);
   ll_deallocate($query);

   $title_string = "Jobs: R=$jobs_run, I=$jobs_idle, H=$jobs_held, NQ=$jobs_not_queued";

   $nodes_busy = 0;
   $nodes_idle = 0;
   $nodes_running = 0;
   $nodes_down = 0;

   #

examples/rss-llq  view on Meta::CPAN

      # Get the startd status for each machine
      #

      $sts=ll_get_data($machine,LL_MachineStartdState);

      $nodes_busy++    if ($sts =~ /^Busy/);
      $nodes_idle++    if ($sts =~ /^Idle/);
      $nodes_running++ if ($sts =~ /^Running/);
      $nodes_down++    if ($sts =~ /^Down/);

      $machine=ll_next_obj($query);

examples/rss-llq  view on Meta::CPAN

   ll_free_objs($query);
   ll_deallocate($query);


   $title_string .= ". Nodes: B=$nodes_busy, R=$nodes_running, I=$nodes_idle, D=$nodes_down";

   open (RDF,">/web/htdocs/loadl.rdf");
   print RDF  "<?xml version=\"1.0\"?>\n";
   print RDF  "   <!DOCTYPE rss PUBLIC \"-//Netscape Communications//DTD RSS 0.91//EN\"\n";
   print RDF  "             \"http://my.netscape.com/publish/formats/rss-0.91.dtd\" >\n";

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

		instead of automatically climbing up the tree.

	- be more smart (follow RFC) when filling {*_full} members
		of envelope addresses
	- defined but empty (or 0) disposition should mean `inline'
	- speed up several busy regexen by a factor of 2-5.
	- ->charset will never return mysterious '' or '0' instead
	  of `undef'.

0.96  2005/11/16
	- ->{parts} for singlepart messages is now a '[]'.

 view release on metacpan or  search on metacpan

getCite.pl  view on Meta::CPAN

	print "ERROR!!\n";
	print "Couldn't find the citation in INSPEC databse]--!!\n";
	print "Reasons:\n(1) The citation is too old (i.e older than 1968).\n";
	print "(2) The journal [".$jname."] is not contained in the INSPEC database.\n";
	print "(3) The volume[".$volume."], page number[".$page."], and journal code[".$journal."] were incorrectly specified.\n";
	print "(4) The AXION INPSEC server is down or too busy.  Goto axiom.iop.org/S/ARKAN/search and try a manual search to see.\n";
}

 view release on metacpan or  search on metacpan

AIO.pm  view on Meta::CPAN

                       accept4 tee splice pipe2 pipesize
                       fexecve mount umount memfd_create eventfd
                       timerfd_create timerfd_settime timerfd_gettime
                       pidfd_open pidfd_send_signal pidfd_getfd);

   push @AIO_REQ, qw(aio_busy); # not exported

   @IO::AIO::GRP::ISA = 'IO::AIO::REQ';

   require XSLoader;
   XSLoader::load ("IO::AIO", $VERSION);

AIO.pm  view on Meta::CPAN

phase and still requires a worker thread. Thus, the callback will not
be executed immediately but only after other requests in the queue have
entered their execution phase. This can be used to measure request
latency.

=item IO::AIO::aio_busy $fractional_seconds, $callback->()  *NOT EXPORTED*

Mainly used for debugging and benchmarking, this aio request puts one of
the request workers to sleep for the given time.

While it is theoretically handy to have simple I/O scheduling requests

 view release on metacpan or  search on metacpan

lib/IO/Async/Function.pm  view on Meta::CPAN

               # Shut down atmost one idle worker, starting from the highest
               # ID. Since we search from lowest to assign work, this tries
               # to ensure we'll shut down the least useful ones first,
               # keeping more useful ones in memory (page/cache warmth, etc..)
               foreach my $id ( reverse sort keys %$workers ) {
                  next if $workers->{$id}{busy};

                  $workers->{$id}->stop;
                  last;
               }

lib/IO/Async/Function.pm  view on Meta::CPAN

=head2 call

   @result = await $function->call( %params );

Schedules an invocation of the contained function to be executed on one of the
worker processes. If a non-busy worker is available now, it will be called
immediately. If not, it will be queued and sent to the next free worker that
becomes available.

The request will already have been serialised by the marshaller, so it will be
safe to modify any referenced data structures in the arguments after this call

lib/IO/Async/Function.pm  view on Meta::CPAN

{
   my $self = shift;
   return scalar keys %{ $self->{workers} };
}

=head2 workers_busy

   $count = $function->workers_busy;

Returns the number of worker processes that are currently busy

=cut

sub workers_busy
{
   my $self = shift;
   return scalar grep { $_->{busy} } $self->_worker_objects;
}

=head2 workers_idle

   $count = $function->workers_idle;

lib/IO/Async/Function.pm  view on Meta::CPAN

=cut

sub workers_idle
{
   my $self = shift;
   return scalar grep { !$_->{busy} } $self->_worker_objects;
}

sub _new_worker
{
   my $self = shift;

lib/IO/Async/Function.pm  view on Meta::CPAN

sub _get_worker
{
   my $self = shift;

   foreach ( sort keys %{ $self->{workers} } ) {
      return $self->{workers}{$_} if !$self->{workers}{$_}{busy};
   }

   if( $self->workers < $self->{max_workers} ) {
      return $self->_new_worker;
   }

lib/IO/Async/Function.pm  view on Meta::CPAN

   $ret = $worker->result_future if defined wantarray;

   if( my $function = $worker->parent ) {
      delete $function->{workers}{$worker->id};

      if( $worker->{busy} ) {
         $worker->{remove_on_idle}++;
      }
      else {
         $function->remove_child( $worker );
      }

lib/IO/Async/Function.pm  view on Meta::CPAN

   my $worker = shift;
   my ( $args ) = @_;

   $worker->{arg_channel}->send_encoded( $args );

   $worker->{busy} = 1;
   $worker->{max_calls}--;

   return $worker->{ret_channel}->recv->then(
      # on recv
      $worker->_capture_weakself( sub {

lib/IO/Async/Function.pm  view on Meta::CPAN

         return Future->fail( "closed", "closed" );
      } )
   )->on_ready( $worker->_capture_weakself( sub {
      my ( $worker, $f ) = @_;
      $worker->{busy} = 0;

      my $function = $worker->parent;
      $function->_dispatch_pending if $function;

      $function->remove_child( $worker ) if $function and $worker->{remove_on_idle};

 view release on metacpan or  search on metacpan

lib/IO/Busy.pm  view on Meta::CPAN

    #"Okay, fine. Type whatever you like. Whatever makes you happy.\n",
    #"La la la la. I can't hear you.\n",
    "",
);

sub busy (&) :Export(:MANDATORY) {
    my ($block_ref) = @_;
    my $count = 0;

    my ($read, $write);
    pipe $read, $write;

lib/IO/Busy.pm  view on Meta::CPAN

=head1 SYNOPSIS

    use IO::Busy;

    my $fh = busy {
        non_interactive_stuff();
    };

  
=head1 DESCRIPTION

This module exports a single subroutine, named C<busy>. That subroutine takes
a single argument, which must be a block of code. C<busy> forks off a separate
process that intercepts and stores any input, then executes the block (in the
original process). 

If the user types anything during the execution of the block, that input
does not appear on the STDIN of the original process. Instead the busy
block informs the user that their input is not being received, and
stores the input in a separate filehandle. That filehandle is then
returned by the C<busy> call, at the end of the block's execution, at which
time STDIN is reconnected to the process.


=head1 INTERFACE 

=head2 $FH = busy {...}

The C<busy> subroutine expects a code block as its only argument. It executes
the block, intercepting any input during that execution. It returns a
filehandle opened for reading, from which the intercepted input can be re-read
if desired.

lib/IO/Busy.pm  view on Meta::CPAN

=over

=item That input was ignored. %s

You typed something whilst the C<busy> block was executing. The C<busy> did
its job and ignored the input, warning you of the fact.

=back

=head1 CONFIGURATION AND ENVIRONMENT

lib/IO/Busy.pm  view on Meta::CPAN

=head1 BUGS AND LIMITATIONS

No bugs have been reported.

Please report any bugs or feature requests to
C<bug-io-busy@rt.cpan.org>, or through the web interface at
L<http://rt.cpan.org>.


=head1 AUTHOR

 view release on metacpan or  search on metacpan

brotli/tests/testdata/alice29.txt  view on Meta::CPAN

rustling in the wind, and the pool rippling to the waving of the
reeds--the rattling teacups would change to tinkling sheep-
bells, and the Queen's shrill cries to the voice of the shepherd
boy--and the sneeze of the baby, the shriek of the Gryphon, and
all thy other queer noises, would change (she knew) to the
confused clamour of the busy farm-yard--while the lowing of the
cattle in the distance would take the place of the Mock Turtle's
heavy sobs.

  Lastly, she pictured to herself how this same little sister of
hers would, in the after-time, be herself a grown woman; and how

 view release on metacpan or  search on metacpan

lib/IO/EPP/Test/Server.pm  view on Meta::CPAN

    $doms->{'nssdom.best'}{reg_id} = $doms->{admin_id}[0];

    # Add new ns
    push @{$doms->{'nssdom.best'}{nss}}, 'ns9.reg.com';

    $doms->{'new_busy_domain.com'} = { avail => 0, reason => 'in use' };

See IO::EPP::Test::Base also.

=cut

 view release on metacpan or  search on metacpan

lib/IO/Handle/Record.pm  view on Meta::CPAN

	      ? sub { sendmsg( $_[0], $_[1], $_[2], (@_>3?$_[3]:0) ); }
	      : sub { syswrite $_[0], $_[1], $_[2], (@_>3?$_[3]:()); });

  my $can_fds_to_send=$I->can('fds_to_send');
  if( @_ ) {
    croak "IO::Handle::Record: busy"
      if( defined $I->write_buffer );
    my $L=($I->record_opts && $I->record_opts->{local_encoding}) ? 'L' : 'N';
    my $msg=eval {
      local $Storable::Deparse;
      local $Storable::forgive_me;

lib/IO/Handle/Record.pm  view on Meta::CPAN

=item * C<IO::Handle::Record: premature end of file>

thrown in C<read_record> on end of file if according to the internal
protocol more input is expected.

=item * C<IO::Handle::Record: busy>

thrown in C<write_record> if a non-blocking write is not yet finished. There
may be only one write operation at a time. If that hits you organise a queue.

=item * C<IO::Handle::Record: syswrite>

 view release on metacpan or  search on metacpan

lib/IO/Interactive.pm  view on Meta::CPAN

    vec($read_bits, fileno($fh), 1) = 1;
    select $read_bits, undef, undef, 0.1;
    return $read_bits;
}

sub busy (&) {
    my ($block_ref) = @_;

    # Non-interactive busy-ness is easy...just do it
    if (!is_interactive()) {
        $block_ref->();
        open my $fh, '<', \ "";
        return $fh;
    }

lib/IO/Interactive.pm  view on Meta::CPAN

This document describes IO::Interactive version 1.02

=head1 SYNOPSIS

    use IO::Interactive qw(is_interactive interactive busy);

    if ( is_interactive() ) {
        print "Running interactively\n";
    }

    # or...

    print {interactive} "Running interactively\n";


    $fh = busy {
        do_noninteractive_stuff();
    }


=head1 DESCRIPTION

lib/IO/Interactive.pm  view on Meta::CPAN

writes to that filehandle if it is connected to a terminal (instead of
writing to C<*STDOUT>). Once again, the usual suspect is C<*STDERR>:

    print {interactive(*STDERR)} $warning;

=item C<busy {...}>

This subroutine takes a block as its single argument and executes that block.
Whilst the block is executed, C<*ARGV> is temporarily replaced by a closed
filehandle. That is, no input from C<*ARGV> is possible in a C<busy> block.
Furthermore, any attempts to send input into the C<busy> block through
C<*ARGV> is intercepted and a warning message is printed to C<*STDERR>.
The C<busy> call returns a filehandle that contains the intercepted input.

A C<busy> block is therefore useful to prevent attempts at input when the
program is busy at some non-interactive task.

=back

=head1 DIAGNOSTICS

 view release on metacpan or  search on metacpan

t/24_combinations.t  view on Meta::CPAN

                    serviceAccountName            => 'webapp-sa',
                    terminationGracePeriodSeconds  => 60,
                    initContainers => [
                        {
                            name    => 'init-db',
                            image   => 'busybox:1.36',
                            command => ['/bin/sh', '-c', 'until nslookup db; do sleep 2; done'],
                            resources => {
                                requests => { cpu => '50m', memory => '64Mi' },
                                limits   => { cpu => '100m', memory => '128Mi' },
                            },

 view release on metacpan or  search on metacpan

lib/IO/Lambda/DNS.pm  view on Meta::CPAN

	my $err = unpack('i', getsockopt($sock, SOL_SOCKET, SO_ERROR));
	if ( $err) {
		$! = $err;
		return "socket error: $!";
	}
	return again if $obj-> bgbusy($bg_obj);

	my $packet = $obj-> bgread( $bg_obj);
	undef $sock;
	undef $bg_obj;
	

 view release on metacpan or  search on metacpan

lib/IO/Socket/SSL.pod  view on Meta::CPAN

=back

The function should return 1 or 0, depending on whether it thinks the
certificate is valid or invalid.  The default is to let OpenSSL do all of the
busy work.

The callback will be called for each element in the certificate chain.

See the OpenSSL documentation for SSL_CTX_set_verify for more information.

 view release on metacpan or  search on metacpan

README.md  view on Meta::CPAN

    cpanm Dist::Zilla
    dzil listdeps | cpanm
    dzil build

While Dist::Zilla takes the busywork and mistakes out of module authorship,
it fails to address the need of XS authors to easily compile XS projects
and run single testcases, rather than the whole test suite.  For this, you
might find the following script handy:

    ./dzil-prove t/01-load.t  # or any other testcase

 view release on metacpan or  search on metacpan

ChangeLog  view on Meta::CPAN

  * Remove ‘use File::Spec’ from IO::File (It is not using it any more.)
  * [RT #36079] Convert ` to '.
  * use :raw to avoid interference from PERL_UNICODE when creating test data
  * Make IO::Handle::getline(s) respect the open pragma (RT 66474)
  * Fix setting sockets nonblocking in Win32
  * Use the exception set in select (connect()) to early return when remote end is busy or in non existing port
  * Keep verbatim pod within 79 cols
  * Keep verbatim pod in IO.pm within 80 cols
  * [perl #88486] IO::File does not always export SEEK*
  * Explicitly force the load of IO::File in IO::Handle (see the discussion in [perl #87940]).
  * Remove various indirect method calls in IO's docs

 view release on metacpan or  search on metacpan

lib/IOLayer/MD5.pm  view on Meta::CPAN

} #PUSHED

#-----------------------------------------------------------------------
#  IN: 1 instantiated object
#      2 handle to read from
# OUT: 1 empty string (when still busy) or the digest string (when done)

sub FILL {

# Read the line from the handle
# If there is something to be added

 view release on metacpan or  search on metacpan

README  view on Meta::CPAN

  
  The included application 'maint_ip_world_db' checks whether the 
  included IP::World database needs updating during installation, and 
  can be run or scheduled to keep it current.  WIPmania.com releases
  new source data bimonthly. On a server, 'maint_ip_world_db' can be
  scheduled (cron'ed on Unix/Linux) to run at an unbusy time.
  
LICENSE INFORMATION

  This module is free software; you may redistribute it and/or modify
  it under the same terms as Perl 5.10.1.  For more details, see the

 view release on metacpan or  search on metacpan

lib/IPC/Concurrency.pm  view on Meta::CPAN

    use IPC::Concurrency;
    
    my $c = IPC::Concurrency->new('SCNR');
    
    while (not $c->get_slot(1)) {
        print 'Scanner is busy', $/;
        sleep 4;
    }
    
    run_scanner_gui();

 view release on metacpan or  search on metacpan

lib/IPC/DirQueue.pm  view on Meta::CPAN

    # pickup_queued_job(). all is well.  But then, E enqueues another job
    # inside the same 1-second period "t", and since the stat() has already
    # happened for "t", and since we've already picked up the job in "t", we
    # don't recheck; result is, we miss this enqueue event.
    #
    # Avoid this by checking in a busy-loop until time(2) says we're out of
    # that "danger zone" 1-second period.  Any further enq's would then
    # cause stat(2) to report a different timestamp.

    while (time == $qdirlaststat) {
      Time::HiRes::usleep ($pollintvl);

 view release on metacpan or  search on metacpan

lib/IPC/Locker.pm  view on Meta::CPAN

about to be retried.  The first argument is self.  Defaults to a print
message.

=item print_waiting

A function to print a message when the lock is busy and needs to be waited
for.  The first argument is self, second the name of the lock.  Defaults to
print a message if verbose is set.

=item timeout