view release on metacpan or  search on metacpan

lib/Pcore/API/Moz.pm  view on Meta::CPAN

        return;
    }

    if ( !$self->{valid_accounts}->@* || !$self->{valid_accounts}->[0]->is_ready ) {
        $cb->( res [ 601, q[API is busy] ] );

        return;
    }

    my $acc = shift $self->{valid_accounts}->@*;

 view release on metacpan or  search on metacpan

lib/Pcore/PgSQL/DBH.pm  view on Meta::CPAN

    return;
}

sub _execute ( $self, $query, $bind, $cb, %args ) {
    if ( $self->{state} != $STATE_READY ) {
        warn 'DBI: DBH is busy';

        $cb->( undef, res [ 500, 'DBH is busy' ] );

        return;
    }

    $self->{state} = $STATE_BUSY;

 view release on metacpan or  search on metacpan

lib/Pcore/Handle/sqlite.pm  view on Meta::CPAN

    rw  => $SQLITE_OPEN_RW,
    rwc => $SQLITE_OPEN_RWC,
};

has mode         => 'rwc';        # ( is => 'ro', isa => Enum [ keys $SQLITE_OPEN->%* ] );
has busy_timeout => 1_000 * 3;    # ( is => 'ro', isa => PositiveOrZeroInt );    # milliseconds, set to 0 to disable timeout, default - 3 seconds

# SQLITE PRAGMAS
has temp_store   => 'MEMORY';      # ( is => 'ro', isa => Enum [qw[FILE MEMORY]] );
has journal_mode => 'WAL';         # ( is => 'ro', isa => Enum [qw[DELETE TRUNCATE PERSIST MEMORY WAL OFF]] );      # WAL is the best
has synchronous  => 'OFF';         # ( is => 'ro', isa => Enum [qw[FULL NORMAL OFF]] );      # OFF - data integrity on app failure, NORMAL - data integrity on app and OS failures, FULL - full data integrity on app or OS failures, slower

lib/Pcore/Handle/sqlite.pm  view on Meta::CPAN

    $dbh->do( 'PRAGMA journal_mode = ' . $self->{journal_mode} );
    $dbh->do( 'PRAGMA synchronous = ' . $self->{synchronous} );
    $dbh->do( 'PRAGMA cache_size = ' . $self->{cache_size} );
    $dbh->do( 'PRAGMA foreign_keys = ' . $self->{foreign_keys} );

    $dbh->sqlite_busy_timeout( $self->{busy_timeout} );

    # create custom functions
    $dbh->sqlite_create_function( 'uuid_generate_v1mc', 0, sub { return uuid_v1mc_str } );
    $dbh->sqlite_create_function( 'uuid_generate_v4',   0, sub { return uuid_v4_str } );
    $dbh->sqlite_create_function( 'gen_random_uuid',    0, sub { return uuid_v4_str } );

 view release on metacpan or  search on metacpan

FAQ  view on Meta::CPAN

        offer improvements, even if they're just verbal and not
        context diffs.  

    c.  Think about the concept and share your thoughts.  The
        design of Penguin is open, and apart from a strange willingness
        to do all of the busywork, I have no vested interest in
        one way of doing it over another.

    d.  Send code.  If you send me cool code, I will buy you beer.

5.  'Saaaay, what _is_ the design of Penguin?'

 view release on metacpan or  search on metacpan

lib/Perinci/Access/Simple/Server/Socket.pm  view on Meta::CPAN

Tip: You can set start_servers to 0 and 'daemonize' to false for debugging.

=head2 max_clients => INT (default 150)

Maximum number of children processes to maintain. If server is busy, number of
children will be increased from the original 'start_servers' up until this
value.

=head2 max_requests_per_child => INT (default 1000)

 view release on metacpan or  search on metacpan

share/perl-5.20/installperl  view on Meta::CPAN

	next unless -e $name;
	chmod 0777, $name if ($Is_OS2 || $Is_W32 || $Is_NetWare);
	print "  unlink $name\n" if $opts{verbose};
	next if CORE::unlink($name);
	warn "Couldn't unlink $name: $!\n";
	if ($! =~ /busy/i) {
	    print "  mv $name $name.old\n" if $opts{verbose};
	    safe_rename($name, "$name.old")
		or warn "Couldn't rename $name: $!\n";
	}
    }

 view release on metacpan or  search on metacpan

script/perl-example-endless-loop  view on Meta::CPAN

our $DATE = '2023-02-24'; # DATE
our $DIST = 'Perl-Examples'; # DIST
our $VERSION = '0.096'; # VERSION

# this script performs an endless loop using while. it should use up CPU time
# (busy loop).

1 while 1;

# ABSTRACT: Performs endless loop
# PODNAME: perl-example-endless-loop

 view release on metacpan or  search on metacpan

share/Exegesis/E07.pod  view on Meta::CPAN

    I couldn't do my English Lit homework because...

         10. Three witches told me I was going to be    
             king.                                      

          9. I was busy explaining wherefore am I Romeo.

          8. I was busy scrubbing the blood off my      
             hands.                                     

          7. Some dear friends had to charge once more  
             unto the breach.                           

 view release on metacpan or  search on metacpan

demo/demo_numlist.pl  view on Meta::CPAN

use Perl6::Form;

@reason = (
	"Three witches told me I was going to be king.",
	"I was busy explaining wherefore am I Romeo.",
	"I was busy scrubbing the blood off my hands.",
	"Some dear friends had to charge once more unto the breach.",
	"My so-called best friend tricked me into killing my wife.",
	"My so-called best friend tricked me into killing Caesar.",
	"My so-called best friend tricked me into taming a shrew.",
	"My uncle killed my father and married my mother.",

 view release on metacpan or  search on metacpan

examples/network/svnbot.pl  view on Meta::CPAN

"I configured svnbot to check for new commits every I<n> seconds, but the
commits usually take much more time to show up. Why is this so?"

If you look at svnbot's source, you'll see that it really I<tries> to check the
SVN repository after I<n> seconds elapsed. The problem is, that svnbot doesn't
have a chance to check, because C<Net::IRC> is busy reading from the socket to
the IRC server. Unfortunately, the call to C<.readline> C<Net::IRC> issues is
I<blocking>, meaning that the operating system will suspend C<svnbot.pl> until
it receives some data from the IRC server.

In Perl 5, the problem would be easy to remedy, as perl5 allows you to set

 view release on metacpan or  search on metacpan

benchmarks/app/perlfunc.pod  view on Meta::CPAN

On some older systems, it may sleep up to a full second less than what
you requested, depending on how it counts seconds.  Most modern systems
always sleep the full amount.  They may appear to sleep longer than that,
however, because your process might not be scheduled right away in a
busy multitasking system.

For delays of finer granularity than one second, you may use Perl's
C<syscall> interface to access setitimer(2) if your system supports
it, or else see L</select> above.  The Time::HiRes module (from CPAN,
and starting from Perl 5.8 part of the standard distribution) may also

 view release on metacpan or  search on metacpan

lib/PerlIO/via/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 {

    # still reading file
    my $line= readline( $_[1] );

 view release on metacpan or  search on metacpan

t/data/davblog.xml  view on Meta::CPAN

    <category term="sexism" label="sexism" scheme="http://www.sixapart.com/ns/types#tag" />
    <category term="society" label="society" scheme="http://www.sixapart.com/ns/types#tag" />
    
    <content type="html" xml:lang="en" xml:base="http://blog.dave.org.uk/">
        <![CDATA[Nadine Dorries seems to be writing her blog today from <a href="http://blog.dorries.org/id-1503-2009_9_Home_Alone.aspx">about forty years ago</a>. She's talking about single mothers.<br /><br /><blockquote>I like the idea that we can...
and nurture a baby and learn to value and respect themselves.<br /></blockquote>How you got that? Parenting skills, running a home, cooking meals and looking after babies - that's all woman's work. Presumably the men are all too busy off hunting mamm...
        
    </content>
</entry>

<entry>

t/data/davblog.xml  view on Meta::CPAN

    <category term="web" label="web" scheme="http://www.sixapart.com/ns/types#tag" />
    
    <content type="html" xml:lang="en" xml:base="http://blog.dave.org.uk/">
        <![CDATA[I'm currently in Lisbon for <a href="http://yapceurope2009.org/">YAPC Europe</a>. I very nearly didn't make it. I flew out on Friday and on Friday morning, about three hours before I was supposed to leave the house, I discovered that...
the advice. The passport remains elusive, but I'm sure I@m getting
closer. And I don't need to leave for an hour or so :-/</span></span><br /><span class="status-body"><span class="entry-content"></span></span></blockquote><span class="status-body"><span class="entry-content">The advice kept on coming.</span></span>...
        
    </content>
</entry>

<entry>

 view release on metacpan or  search on metacpan

CHANGES  view on Meta::CPAN

       the last 500 status codes returned, etc

    -- add ability to use new Danga::Socket profiling; 'profile on', 'profile data'
       to see the info so far, and 'profile off' to disable it

    -- graceful shutdown now flags sockets that are busy to die so they die when
       they're done with their current connection

    -- sockets in persist_wait now get closed immediately during a graceful shutdown

    -- fix handling of OPTIONS responses; used to do its own state clearing but

 view release on metacpan or  search on metacpan

root/static/js/OpenThought.js  view on Meta::CPAN

this.getOpenChannel = function() {

    var channelName;

    for(var i=0; i < channels.length ;i++) {
        if(! channels[i]["busy"]) {
            channels[i]["busy"] = true;
            this.log.info("Reusing channel [" + i + "].");
            return channels[i];
        }
    }

    var channel = new Object;

    var id       = channels.length;
    channels[id] = channel;

    channels[id]["busy"]    = true;
    var channel_info = this.createChannel(id);
    channels[id]["channel"] = channel_info[0];
    channels[id]["type"]    = channel_info[1];

    return channels[id];

root/static/js/OpenThought.js  view on Meta::CPAN

this.Complete = function(channel) {

    if (channel.name && channel.name >= 0) {
        this.log.info('Freeing channel [' + channel.name + ']');
        channels[channel.name]["busy"] = false;
    }

    return true;
}

 view release on metacpan or  search on metacpan

lib/Perlito5X/Benchmark.pm  view on Meta::CPAN

    # in &countit.  This, in turn, can reduce the number of calls to
    # &runloop a lot, and thus reduce additive errors.
    #
    # Note that its possible for the act of reading the system clock to
    # burn lots of system CPU while we burn very little user clock in the
    # busy loop, which can cause the loop to run for a very long wall time.
    # So gradually ramp up the duration of the loop. See RT #122003
    #
    my $tbase = Benchmark->new(0)->[1];
    my $limit = 1;
    while ( ( $t0 = Benchmark->new(0) )->[1] == $tbase ) {

 view release on metacpan or  search on metacpan

lib/PersistentPerl.pm  view on Meta::CPAN

=item If another request comes in while PersistentPerl script is running, does the client
have to wait or is another process started?  Is there a way to set a limit
on how many processes get started? 

If another request comes while all the perl processes are busy, then
another perl process is started.  Just like in regular perl there is normally
no limit on how many processes get started.  But, the processes are
only started when the load is so high that they're necessary.  If the
load goes down, the processes will die off due to inactivity, unless you
disable the timeout.

 view release on metacpan or  search on metacpan

lib/Pg/PQ.pm  view on Meta::CPAN

  $dbc->sendQuery("select * from foo");

  while (1) {
    $dbc->consumeInput;
    last unless $dbc->busy
    # do something else
    ...
  }

  my $res = $dbc->result;

lib/Pg/PQ.pm  view on Meta::CPAN

client can be handling the results of one command while the server is
still working on later queries in the same command string.

However, calling C<result> will still cause the client to block until the
server completes the next SQL command. This can be avoided by proper
use of the C<consumeInput> and L</busy> methods described next.

=item $ok = $dbc->consumeInput

If input is available from the server, consume it.

C<consumeInput> normally returns 1 indicating "no error", but returns
0 if there was some kind of trouble (in which case L</errorMessage> can
be consulted). Note that the result does not say whether any input
data was actually collected.

After calling C<consumeInput>, the application can check L</busy>
and/or L</notifies> to see if their state has changed.

C<consumeInput> can be called even if the application is not prepared
to deal with a result or notification just yet. The method will read
available data and save it in a buffer, thereby causing a C<select>
read-ready indication to go away.

=item $ok = $dbc->busy

Returns 1 if a command is busy, that is, L</result> would block waiting
for input. A 0 return indicates that C<result> can be called with
assurance of not blocking.

C<busy> will not itself attempt to read data from the server;
therefore L</consumeInput> must be invoked first, or the busy state
will never end.

=item $nb = $dbc->nonBlocking

=item $dbc->nonBlocking($bool)

lib/Pg/PQ.pm  view on Meta::CPAN

from the server, which in terms of C<select> means readable data on
the file descriptor identified by C<socket>.

When the main loop detects input ready, it should call C<consumeInput>
to read the input. It can then call C<isBusy>, followed by C<result>
if C<busy> returns false (0).

It can also call C<notifies> to detect C<NOTIFY> messages (see Section
31.7 of the PostgreSQL documentation).

A client that uses C<sendQuery>/C<result> can also attempt to cancel a

 view release on metacpan or  search on metacpan

lib/Pinto.pm  view on Meta::CPAN

=head2 Internet Relay Chat

You can get live help by using IRC ( Internet Relay Chat ). If you don't know what IRC is,
please read this excellent guide: L<http://en.wikipedia.org/wiki/Internet_Relay_Chat>. Please
be courteous and patient when talking to us, as we might be busy or sleeping! You can join
those networks/channels and get help:

=over 4

=item *

 view release on metacpan or  search on metacpan

doc/index.html  view on Meta::CPAN

  entry should exist for each build daemon. Typically, it is expected
  that there will be one builder per platform but there are no
  limits. It may well be that there is a period during which there are
  no builders and new tasks will just be queued as long as the
  platform is active. It is also possible to register extra builders
  for a platform which can be used during busy times. Note that having
  a builder registered does not necessarily mean it will take new
  jobs. The builder has to have the necessary permissions to be able
  to talk to the registry database and request new jobs, that must be
  managed separately (normally via the LCFG postgresql component).
</p>

 view release on metacpan or  search on metacpan

doc/incoming.html  view on Meta::CPAN

<p>
Note that having a task registered for an active platform does not
guarantee that a build daemon is currently available for that
platform. It is perfectly acceptable to queue tasks for a platform
which currently has no build daemons registered. It may also, of
course, be the case that a build daemon is busy or currently
unavailable due to maintenance. It is also worth noting that a
platform may have multiple build daemons. It is not possible to
guarantee which build daemon will accept a particular task, as they
should all have identical build environments this should not cause
problems. Full details of the task scheduling is available in

 view release on metacpan or  search on metacpan

lib/Plack/App/CGIBin/Streaming.pm  view on Meta::CPAN

Although multipart HTTP messages are quite exotic, there are situations
where you rather want to prevent this buffering. If your document is very
large for example, each instance of your plack server allocates the RAM
to buffer it. Also, you might perhaps send out the C<< <head> >> section
of your HTTP document as fast as possible to enable the browser load JS and
CSS while the plack server is still busy with producing the actual document.

C<Plack::App::CGIBin::Streaming> compiles the CGI scripts using
L<CGI::Compile> and provides a runtime environment similar to
C<Plack::App::CGIBin>. Compiled scripts are cached. For production
environments, it is possible to precompile and cache scripts at server

 view release on metacpan or  search on metacpan

lib/Plack/App/Gearman/Status.pm  view on Meta::CPAN

					</tr>
					<% for my $status (@{$job_server_status->{status}}) { %>
						<tr>
							<td><%= $status->name() %></td>
							<td><%= $status->running() %></td>
							<td><%= $status->busy() %></td>
							<td><%= $status->free() %></td>
							<td><%= $status->queue() %></td>
						</tr>
					<% } %>
				</table>

 view release on metacpan or  search on metacpan

local/lib/perl5/Dist/Zilla/Plugin/Config/Git.pm  view on Meta::CPAN

=head2 Internet Relay Chat

You can get live help by using IRC ( Internet Relay Chat ). If you don't know what IRC is,
please read this excellent guide: L<http://en.wikipedia.org/wiki/Internet_Relay_Chat>. Please
be courteous and patient when talking to us, as we might be busy or sleeping! You can join
those networks/channels and get help:

=over 4

=item *

 view release on metacpan or  search on metacpan

lib/Plack/Middleware/ServerStatus/Lite.pm  view on Meta::CPAN

    }

    if ( my $scoreboard = $self->{__scoreboard} ) {
        my $stats = $scoreboard->read_all();
        my $idle = 0;
        my $busy = 0;

        my @all_workers = ();
        my $parent_pid = getppid;
        
        if ( $self->skip_ps_command ) {

lib/Plack/Middleware/ServerStatus/Lite.pm  view on Meta::CPAN

            my $pstatus = eval { 
                $JSON->decode($json || '{}');
            };
            $pstatus ||= {};
            if ( $pstatus->{status} && $pstatus->{status} eq 'A' ) {
                $busy++;
            }
            else {
                $idle++;
            }

lib/Plack/Middleware/ServerStatus/Lite.pm  view on Meta::CPAN

            $process_status .= sprintf "%s\n", 
                join(" ", map { defined $pstatus->{$_} ? $pstatus->{$_} : '' } qw/pid status remote_addr host method uri protocol ss/);
            push @process_status, $pstatus;
        }
        $body .= <<EOF;
BusyWorkers: $busy
IdleWorkers: $idle
--
pid status remote_addr host method uri protocol ss
$process_status
EOF
        chomp $body;
        $status{BusyWorkers} = $busy;
        $status{IdleWorkers} = $idle;
        $status{stats} = \@process_status;
    }
    else {
       $body .= "WARN: Scoreboard has been disabled\n";

 view release on metacpan or  search on metacpan

lib/Plack/Middleware/Statsd.pm  view on Meta::CPAN

The worker PID is added to the set.

Note that this is set after the request is processed.  This means that
while the set size can be used to indicate the number of active
workers, if the workers are busy (i.e. longer request processing
times), then this will show a lower number.

This was added in v0.3.10.

=item C<psgix.harakiri>

 view release on metacpan or  search on metacpan

lib/Plack/Handler/FCGI.pm  view on Meta::CPAN

        $request->Finish;

        $proc_manager && $proc_manager->pm_post_dispatch();

        # When the fcgi-manager exits it sends a TERM signal to the workers.
        # However, if we're busy processing the cleanup handlers, testing
        # shows that the worker doesn't actually exit in that case.
        # Trapping the TERM signal and finshing up fixes that.
        my $exit_due_to_signal = 0;
        if ( @{ $env->{'psgix.cleanup.handlers'} || [] } ) {
            local $SIG{TERM} = sub { $exit_due_to_signal = 1 };

 view release on metacpan or  search on metacpan

lib/Plasp/GlobalASA.pm  view on Meta::CPAN

have a new C<$Session> upon revisiting.

A web application starts when the user visits a page in that application, and
has a new C<$Session> created. Right before the first C<$Session> is created,
the C<$Application> is created. When the last user C<$Session> expires, that
C<$Application> expires also. For some web applications that are always busy,
the C<Application_OnEnd> event may never occur.

=cut

has 'filename' => (

lib/Plasp/GlobalASA.pm  view on Meta::CPAN

Sessions end when the session timeout expires, and the C<StateManager> performs
session cleanup. The timing of the C<Session_OnEnd> does not occur immediately
after the session times out, but when the first script runs after the session
expires, and the C<StateManager> allows for that session to be cleaned up.

So on a busy site with default C<SessionTimeout> (20 minutes) and
C<StateManager> (10 times) settings, the C<Session_OnEnd> for a particular
session should be run near 22 minutes past the last activity that Session saw.
A site infrequently visited will only have the C<Session_OnEnd> run when a
subsequent visit occurs, and theoretically the last session of an application
ever run will never have its C<Session_OnEnd> run.

 view release on metacpan or  search on metacpan

t/data/book1  view on Meta::CPAN

'Wooers of my mother, men despiteful out of measure, let us
feast now and make merry and let there be no brawling; for,
lo, it is a good thing to list to a minstrel such as him,
like to the gods in voice. But in the morning let us all go
to the assembly and sit us down, that I may declare my
saying outright, to wit that ye leave these halls: and busy
yourselves with other feasts, eating your own substance,
going in turn from house to house. But if ye deem this a
likelier and a better thing, that one man's goods should
perish without atonement, then waste ye as ye will; and I
will call upon the everlasting gods, if haply Zeus may

 view release on metacpan or  search on metacpan

corpus/perlfunc.pod  view on Meta::CPAN

On some older systems, it may sleep up to a full second less than what
you requested, depending on how it counts seconds.  Most modern systems
always sleep the full amount.  They may appear to sleep longer than that,
however, because your process might not be scheduled right away in a
busy multitasking system.

For delays of finer granularity than one second, the Time::HiRes module
(from CPAN, and starting from Perl 5.8 part of the standard
distribution) provides usleep().  You may also use Perl's four-argument
version of select() leaving the first three arguments undefined, or you