view release on metacpan or  search on metacpan

lib/CGI/ProgressBar.pm  view on Meta::CPAN

		p('This example will update a JS/CSS progress bar.'),
		progress_bar( -from=>1, -to=>100 );
	# We're set to go.
	for (1..10){
		print update_progress_bar;
		# Simulate being busy:
		sleep 1;
	}
	# Now we're done, get rid of the bar:
	print hide_progress_bar;
	print p('All done.');

 view release on metacpan or  search on metacpan

lib/CGI/SpeedyCGI.pm  view on Meta::CPAN

=item If another request comes in while SpeedyCGI 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/CGI/Wiki/Plugin/Categoriser.pm  view on Meta::CPAN

  use CGI::Wiki::Plugin::Categoriser;

  my $wiki = CGI::Wiki->new( ... );
  $wiki->write_node( "Red Lion", "nice beer", $checksum,
                     { category => [ "Pubs", "Pub Food" ] } );
  $wiki->write_node( "Holborn Station", "busy at peak times", $checksum,
                     { category => "Tube Station" } );

  my $categoriser = CGI::Wiki::Plugin::Categoriser->new;
  $wiki->register_plugin( plugin => $categoriser );

 view release on metacpan or  search on metacpan

lib/CHI/Cascade.pm  view on Meta::CPAN

=item chi

B<Required>. Instance of L<CHI> object. The L<CHI::Cascade> doesn't construct this
object for you. Please create instance of C<CHI> yourself.

=item busy_lock

B<Optional>. Default is I<never>. I<This is not C<busy_lock> option of CHI!>
This is amount of time (to see L<CHI/"DURATION EXPRESSIONS">) until all target
locks expire. When a target is to being computing it is locked. If process which
is to be computing target and it will die or OS will be hangs up we can dead
locks and locked target will never recomputed again. This option helps to avoid
it. You can set up a special busy_lock for rules too.

=item target_chi

B<Optional>. This is CHI cache for target markers. Default value is value of
L</chi> option. It can be useful if you use a L<CHI/l1_cache> option. So you can

lib/CHI/Cascade.pm  view on Meta::CPAN

B<Optional>. You can pass in your code any additional parameters by this option.
These parameters are accessed in your rule's code through
L<CHI::Cascade::Rule/params> method of L<CHI::Cascade::Rule> instance object.

=item busy_lock

B<Optional>. Default is L</busy_lock> of constructor or I<never> if first is not
defined. I<This is not C<busy_lock> option of CHI!> This is amount of time (to
see L<CHI/"DURATION EXPRESSIONS">) until target lock expires. When a target is
to being computed it is locked. If process which to be recomputing a target and
it will die or OS will be hangs up we can dead locks and locked target will
never recomputed again. This option helps to avoid it.

 view release on metacpan or  search on metacpan

lib/CHI/Memoize.pm  view on Meta::CPAN

our @EXPORT      = qw(memoize);
our @EXPORT_OK   = qw(memoize memoized unmemoize NO_MEMOIZE);
our %EXPORT_TAGS = ( all => \@EXPORT_OK );

my %memoized;
my @get_set_options = qw( busy_lock expire_if expires_at expires_in expires_variance );
my %is_get_set_option = map { ( $_, 1 ) } @get_set_options;

sub memoize {
    my ( $func, %options ) = @_;

lib/CHI/Memoize.pm  view on Meta::CPAN

=item set and get options

You can pass any of CHI's L<set|CHI/set> options (e.g.
L<expires_in|CHI/expires_in>, L<expires_variance|CHI/expires_variance>) or
L<get|CHI/get> options (e.g. L<expire_if|CHI/expire_if>,
L<busy_lock|CHI/busy_lock>). e.g.

    # Expire after one hour
    memoize('func', expires_in => '1h');
    
    # Expire when a particular condition occurs

 view release on metacpan or  search on metacpan

lib/CHI.pm  view on Meta::CPAN

Multilevel caches

=item *

Probabilistic expiration and busy locks, to reduce cache miss stampedes

=item *

Optional logging and statistics collection of cache activity

lib/CHI.pm  view on Meta::CPAN

were expired. For example, to treat the cache as expired if I<$file> has
changed since the value was computed:

    $cache->get('foo', expire_if => sub { $_[0]->created_at < (stat($file))[9] });

=item busy_lock [DURATION]

If the value has expired, the get will still return undef, but the expiration
time of the cache entry will be set to the current time plus the specified
L<duration|/DURATION EXPRESSIONS>.  This is used to prevent multiple processes
from recomputing the same expensive value simultaneously. The problem with this

 view release on metacpan or  search on metacpan

corpus/dists/File-Tail.changes  view on Meta::CPAN

        nonexistant file
	Alain Fauconnet <alain@ait.ac.th> and Benjamin Zwittnig <beni@arnes.si>
        provided test cases which helped me chase down another two cases where 
        File::Tail would spontaneously read too much.

0.99.2  Some operating systems sometimes return 0 for sysread on busy files.
        This should now be handled correctly.
        nowait can now be specified at object creation.
        A callback is called on every file rotation, which can be used for
        files that change their names with time.

 view release on metacpan or  search on metacpan

bin/send_reports  view on Meta::CPAN

or C<--grade> command line options.

=back

This program requires that somewhere near your machine you have a L<metabase-relayd> server running. This script will use L<Test::Reporter::Transport::Socket> to
send the reports. Reports are sent pretty quickly (depending on how busy is the metabase-relayd).

=head1 AUTHOR

Alceu Rodrigues de Freitas Junior, E<lt>arfreitas@cpan.orgE<gt>

 view release on metacpan or  search on metacpan

bin/send_reports  view on Meta::CPAN

=back

This program requires that somewhere near your machine you have a
L<metabase-relayd> server running. This script will use
L<Test::Reporter::Transport::Socket> to send the reports. Reports are sent
pretty quickly (depending on how busy is the L<metabase-relayd>).

=head1 AUTHOR

Alceu Rodrigues de Freitas Junior, E<lt>arfreitas@cpan.orgE<gt>

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

        - add error if no report found.
        - more query tests.

0.03    2014-04-22
        - return more informative error messages.
        - network may be responsive, but server may be busy.
        - fixed distribution name in META.

0.02    2014-04-01
        - fixed skip test count in 10query.t.

 view release on metacpan or  search on metacpan

vhost/html/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];

vhost/html/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/CPAN/WWW/Top100/Retrieve.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

t/data/cpanriver.01.build.log  view on Meta::CPAN

t/03_create_table.t ................................... ok
t/04_insert.t ......................................... ok
t/05_select.t ......................................... ok
t/06_tran.t ........................................... ok
t/07_error.t .......................................... ok
t/08_busy.t ........................................... ok
t/09_create_function.t ................................ ok
t/10_create_aggregate.t ............................... ok
t/12_unicode.t ........................................ ok
t/13_create_collation.t ............................... ok
t/14_progress_handler.t ............................... ok

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

	* support bzip2 compression; can be tested with 'install
	ARTURAZ/Net-Vypress-Chat-0.72.1.tar.bz2'; the CPAN indexer does
	not yet index bz2 distros but will probably start to do so as soon
	as CPANPLUS supports bzip2

	* tiny tweaks to make CPAN.pm run on a busybox (Guillaume Filion)

	* bugfix: major speedup on all commands that need expansion of
	regular expressions to module names

	* prettier r command output: the 4th column of the 'r' command

 view release on metacpan or  search on metacpan

lib/CPANPLUS/Dist/Slackware/Plugin/Mail/SpamAssassin.pm  view on Meta::CPAN

Then set the following options in /etc/spamassassin.conf:

    OPTIONS="-u spamd -x"

On a busy server, you might have to add options like "--min-children",
"--max-children", "--min-spare" and "--max-spare".  See the spamd manual page
for a complete list of options.

Finally run spamd:

 view release on metacpan or  search on metacpan

lib/CPANPLUS/Shell/Tk.pm  view on Meta::CPAN

                                            $self->{$_}->packForget foreach qw(HISTORY POD INFO);
                                            $self->{INFO}->pack(-fill => 'both', -expand => 1);
                                            $self->{INFO}->delete('0.0', 'end');
                                            $CP->install(modules => $self->{MODS});
                                            $self->{HISTORY}->insert('end', "install\t" . join(' ', @{$self->{MODS}}) . "\n");
                                            $MW->Unbusy;
                                          }],
                              [Button => 'Uninstall',
                              -command => sub {
                                            $MW->Busy;
                                            $self->{$_}->packForget foreach qw(HISTORY POD INFO);
                                            $self->{INFO}->pack(-fill => 'both', -expand => 1);
                                            $self->{INFO}->delete('0.0', 'end');
                                            $CP->uninstall(modules => $self->{MODS});
                                            $self->{HISTORY}->insert('end', "uninstall\t" . join(' ', @{$self->{MODS}}) . "\n");
                                            $MW->Unbusy;
                                          }],
                              [Button => 'Fetch',
                              -command => sub {
                                            $MW->Busy;
                                            $self->{$_}->packForget foreach qw(HISTORY POD INFO);
                                            $self->{INFO}->pack(-fill => 'both', -expand => 1);
                                            $self->{INFO}->delete('0.0', 'end');
                                            $CP->fetch(modules => $self->{MODS});
                                            $self->{HISTORY}->insert('end', "fetch\t" . join(' ', @{$self->{MODS}}) . "\n");
                                            $MW->Unbusy;
                                          }],
                              [Button => 'Extract',
                              -command => sub {
                                            $MW->Busy;
                                            $self->{$_}->packForget foreach qw(HISTORY POD INFO);
                                            $self->{INFO}->pack(-fill => 'both', -expand => 1);
                                            $self->{INFO}->delete('0.0', 'end');
                                            $CP->extract(modules => $self->{MODS});
                                            $self->{HISTORY}->insert('end', "extract\t" . join(' ', @{$self->{MODS}}) . "\n");
                                            $MW->Unbusy;
                                          }],
                              [Button => 'Make',
                              -command => sub {
                                            $MW->Busy;
                                            $self->{$_}->packForget foreach qw(HISTORY POD INFO);
                                            $self->{INFO}->pack(-fill => 'both', -expand => 1);
                                            $self->{INFO}->delete('0.0', 'end');
                                            $CP->make(modules => $self->{MODS});
                                            $self->{HISTORY}->insert('end', "make\t" . join(' ', @{$self->{MODS}}) . "\n");
                                            $MW->Unbusy;
                                          }],
                              [Button => 'Pod',
                              -command => sub {
                                            $self->{$_}->packForget foreach qw(HISTORY POD INFO);
                                            $self->{POD}->configure(-file => $self->{MODS}->[0]);

 view release on metacpan or  search on metacpan

inc/bundle/Archive/Tar.pm  view on Meta::CPAN

=head2 $Archive::Tar::ZERO_PAD_NUMBERS

This variable holds a boolean indicating if we will create
zero padded numbers for C<size>, C<mtime> and C<checksum>.
The default is C<0>, indicating that we will create space padded
numbers. Added for compatibility with C<busybox> implementations.

=head2 Tuning the way RESOLVE_SYMLINK will works

You can tune the behaviour by setting the $Archive::Tar::RESOLVE_SYMLINK variable,
or $ENV{PERL5_AT_RESOLVE_SYMLINK} before loading the module Archive::Tar.

 view release on metacpan or  search on metacpan

t/data/zx48.asm  view on Meta::CPAN

;   calculator stack throughout the arc loop. 
;   This ensures that the final line finishes exactly at the starting pixel 
;   removing the possibility of any inaccuracy.
;   Since the initial sx and sy values are not required until the final arc
;   is drawn, they are not shown until then.
;   As the calculator stack is quite busy, only the active parts are shown in 
;   each section.


; ------------------
; THE 'DRAW' COMMAND

 view release on metacpan or  search on metacpan

examples/Tkwic.perl  view on Meta::CPAN

    my $main_window = $self->{main_window};
    $main_window->bind('<Visibility>', '');
    $main_window->afterIdle([\&connect, $self]);
}

sub busy {
    my ($self) = @_;

    my $main_window = $self->{main_window};
    $main_window->Busy(-recurse => 1);
    my @kids = $main_window->children();
    foreach (@kids) {
        if ($_->class() eq 'Toplevel') {
            # Wenn man hier Busy() verwendet, kann es passieren, dass
            # einige Fenster trotz Unbusy() gesperrt bleiben. Damit
            # der Benutzer trotzdem ein Feedback bekommt, wird eine
            # Uhr als Mauszeiger verwendet.
            #$_->Busy(-recurse => 1);
            $_->configure(-cursor => 'watch');
        }
    }
}

sub unbusy {
    my ($self) = @_;

    my $main_window = $self->{main_window};
    my @kids = $main_window->children();
    foreach (@kids) {
        if ($_->class() eq 'Toplevel') {
            #$_->Unbusy();
            $_->configure(-cursor => 'left_ptr');
        }
    }
    $main_window->Unbusy();
}

sub bell {
    my ($self) = @_;

examples/Tkwic.perl  view on Meta::CPAN

}

sub connect {
    my ($self) = @_;

    $self->busy();
    $self->set_status_message("Connecting to server");
    my ($host, $port, $user, $passwd);
    if (@ARGV) {
        unless (@ARGV >=2 and @ARGV <= 4) {
          print STDERR "Usage:  Tkwic.perl [<user> <password> [<host> [<port>]]]\n";

examples/Tkwic.perl  view on Meta::CPAN

    $Corpora = $self->get_corpora();
    # Use the first corpus by default.
    $self->{corpus} = $Corpora->[0];
    $self->switch_corpus();
    $self->set_status_message("Connected to $host on port $port");
    $self->unbusy();
}

sub disconnect {
    my ($self) = @_;

    $self->busy();
    if ($self->{connected}) {
        $self->set_status_message("Disconnecting");
        cqi_bye();
        $self->{connected} = 0;
    }
    $self->unbusy();
}

sub get_corpora {
    my ($self) = @_;
    my @list;

examples/Tkwic.perl  view on Meta::CPAN

sub execute_query {
    my ($self) = @_;
    my ($corpus, $query, $status, $size, @match, @matchend);

    $self->busy();
    $corpus = $self->{corpus};
    $query = $self->{query} = $self->get_query();
    if ($query) {
        $self->set_status_message("Executing query");
        $status = cqi_query($corpus, "A", $query);

examples/Tkwic.perl  view on Meta::CPAN

            $self->set_status_message("Query failed", 'ERROR');
        }
    } else {
        $self->set_status_message("Cannot execute empty query", 'ERROR');
    }
    $self->unbusy();
}

sub print_kwic_line {
    my ($self, $match, $matchend) = @_;
    my ($hlist, $lb, $rb, $list_ref, $lists);

examples/Tkwic.perl  view on Meta::CPAN

}

sub show_prev_matches {
    my ($self) = @_;

    $self->busy();
    $self->show_matches($self->{query_first} - $NumberOfDisplayedMatches);
    $self->unbusy();
}

sub show_next_matches {
    my ($self) = @_;

    $self->busy();
    $self->show_matches($self->{query_first} + $NumberOfDisplayedMatches);
    $self->unbusy();
}

sub create_main_window {
    my ($self) = @_;

examples/Tkwic.perl  view on Meta::CPAN

    my ($self, $e) = @_;
    my ($hlist, $list_ref, $text_widget, $match, $matchend, $lb, $rb, $n);

    # call without 'selected line' ($e) to clear context window

    $self->busy();
    $hlist = $self->{output_list};
    $text_widget = $self->{output_text};

    if (not defined $e) {
        $self->clear_output_text();
        $self->unbusy();
        return;
    }

    $list_ref = $hlist->info('data', $e);
    $match = $list_ref->[0];

examples/Tkwic.perl  view on Meta::CPAN

    if ($n > 0) { $text_widget->insert('end', ' '); }
    $n = $self->output_context('context', $matchend+1 .. $rb);
    $text_widget->see('match.first');
    $self->set_status_message($self->get_info_attrs($match, $matchend),
                              'INFO_ATTR');
    $self->unbusy();
}

sub clear_output_list {
    my ($self) = @_;

examples/Tkwic.perl  view on Meta::CPAN

        my $corpus = $hlist->info('data', $e);
        if ($close_window)  {
            $dialog->destroy();
        }
        if ($corpus ne $self->{corpus}) {
            $self->busy();
            $self->{corpus} = $corpus;
            $self->switch_corpus();
            $self->unbusy();
        }
    }
}

sub create_corpus_dialog {

examples/Tkwic.perl  view on Meta::CPAN

}

sub show_corpus_dialog {
    my ($self) = @_;

    $self->busy();
    my $corpus_dialog = $self->{corpus_dialog};
    if (Tk::Exists($corpus_dialog)) {
        $corpus_dialog->deiconify();
        $corpus_dialog->raise();
    } else {
        $self->create_corpus_dialog();
    }
    $self->unbusy();
}

sub get_frequency_single {
    my ($self, $corpus, $subcorpus) = @_;

examples/Tkwic.perl  view on Meta::CPAN

}

sub get_frequency {
    my ($self) = @_;

    $self->busy();
    my $hlist = $self->{freq_list};
    my $corpus = $self->{corpus};
    my $query = $self->get_query();
    if ($query) {
        my $status = cqi_query($corpus, "A", $query);

examples/Tkwic.perl  view on Meta::CPAN

            $self->set_status_message("Query failed", 'ERROR');
        }
    } else {
        $self->set_status_message("Cannot execute empty query", 'ERROR');
    }
    $self->unbusy();
};

sub set_frequency_type {
    my ($self, $type_number) = @_;

examples/Tkwic.perl  view on Meta::CPAN

    my $matchref = $self->{query_matchref};
    my $matchendref = $self->{query_matchendref};

    my $ruler = '-' x 74;

    $self->busy();
    if (open TO, '>' . $filename) {
        print TO "#$ruler\n";
        print TO "#\n";
        print TO "# User:    $loginname ($username)\n";
        print TO "# Date:    $date\n";

examples/Tkwic.perl  view on Meta::CPAN

        $self->set_status_message("Done");
    } else {
        $self->set_status_message("Cannot save $filename");
        $self->bell();
    }
    $self->unbusy();
}

sub file_save_matches {
    my ($self) = @_;

examples/Tkwic.perl  view on Meta::CPAN

}

sub tools_frequency_distributions {
    my ($self) = @_;

    $self->busy();
    my $freq_dialog = $self->{freq_dialog};
    if (Tk::Exists($freq_dialog)) {
        $freq_dialog->deiconify();
        $freq_dialog->raise();
    } else {
        $self->create_freq_dialog();
        $self->update_freq_dialog();
    }
    $self->unbusy();
}

sub help_available_tags {
    my ($self) = @_;

    $self->busy();
    my $tag_dialog = $self->{tag_dialog};
    if (Tk::Exists($tag_dialog)) {
        $tag_dialog->deiconify();
        $tag_dialog->raise();
    } else {
        $self->create_tag_dialog();
    }
    $self->unbusy();
}

sub help_about {
    my ($self) = @_;

 view release on metacpan or  search on metacpan

lib/Cache/Isolator.pm  view on Meta::CPAN

If many process need to run callback, they wait until lock becomes released or able to get values.
Defaults to 1. It means no concurrency. 

=item interval

Optional. The seconds for busy loop interval. Defaults to 0.01 seconds.

=item trial

Optional. When the value is being set zero, get_or_set will be waiting until lock becomes released.
When the value is being set positive integer value, get_or_set will die on reached trial count.

 view release on metacpan or  search on metacpan

lib/Calendar/Slots.pm  view on Meta::CPAN

=head1 SYNOPSIS

	use Calendar::Slots;
	my $cal = new Calendar::Slots;
	$cal->slot( date=>'2009-10-11', start=>'10:30', end=>'11:30', name=>'busy' ); 
	my $slot = $cal->find( date=>'2009-10-11', time=>'11:00' );
	print $slot->name;    # 'busy'

=head1 DESCRIPTION

This is a simple module to manage a calendar of very generic time slots. Time slots are anything
with a start and end time on a given date or weekday. Time slots cannot overlap. If a new

 view release on metacpan or  search on metacpan

lib/CallBackery/Config.pm  view on Meta::CPAN

                    $_[0] = ($_[0] =~ /yes|true/) ? true : false;
                    return;
                },
            },
            spinner => {
                _doc => 'url for the busy animation spinner gif',
            },
            title => {
                _doc => 'title string for the application'
            },
            initial_plugin => {

 view release on metacpan or  search on metacpan

lib/Cantella/Worker/Role/Worker.pm  view on Meta::CPAN

=back

Poll for work. If we find work, schedule another poll event due to execute
after the work event. If no jobs are found, schedule the next poll for
C<interval> seconds in the future. This ensures that the worker will always be
busy while there is work, but will control it's polling for work when there
isn't any available.

=head2 _work

=over 4

 view release on metacpan or  search on metacpan

lib/Capture/Tiny/Extended.pm  view on Meta::CPAN

=head1 WHY A FORK?

The realtime teeing feature was very important for one of my current projects
and i needed it on CPAN to be able to easily distribute it to many systems.
I had provided a patch for the return value capturing on Github to David Golden
a long while ago, but due to being busy with real life, family and more
important projects than this he was not able to find time to proof and integrate
it and in the foreseeable future won't be able to either. At the same time i
lack the Perl file handle, descriptor and layer chops to take full
responsibility for Capture::Tiny itself. Usually i would have just written a
subclass of the original, but since Capture::Tiny is written in functional style

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

    layer; removed remaining TODO tests; adds Scalar::Util as a dependency

  Changed:

  - When Time::HiRes::usleep is available, tee operations will
    sleep during the busy-loop waiting for tee processes to be ready
    [rt.cpan.org #67858]

0.11      2011-05-19 23:34:23 America/New_York

  Fixed:

 view release on metacpan or  search on metacpan

lib/Catalog/dmoz.pm  view on Meta::CPAN

</pre>
<li> Click on <b>browse</b> link in the Control Panel and check that
     the catalog displays well. <b>Warning</b> the first time you click
     on <b>browse</b> Catalog will rebuild some internal tables and it
     will take some time to display. While working Catalog sends white
     space characters to keep the connection busy and prevent timeouts.
     These characters also tells you that Catalog is working and not hanging.
     One character is printed for each category. If you have 200 000 categories
     you should expect to download 200KB.
<li> Click on the <b>count</b> link in the Control Panel to calculate
     how many entries each category contains. It taks about the same time

 view release on metacpan or  search on metacpan

lib/Catalyst/Manual/Cookbook.pod  view on Meta::CPAN

Another method of caching is to cache the entire HTML page.  While this is
traditionally handled by a frontend proxy server like Squid, the Catalyst
PageCache plugin makes it trivial to cache the entire output from
frequently-used or slow actions.

Many sites have a busy content-filled front page that might look something
like this.  It probably takes a while to process, and will do the exact same
thing for every single user who views the page.

    sub front_page : Path('/') {
        my ( $self, $c ) = @_;

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/PageCache.pm  view on Meta::CPAN

        unless my $data = $cache->get( $key );

    # Time to remove page from cache?

    if ( $data->{expire_time} && $data->{expire_time} <= time ) {
        if ( my $busy_lock = $pc_config->{busy_lock} ) {
            # Extend the expiration time for others while
            # this caller refreshes the cache
            $data->{expire_time} = time() + $busy_lock;
            
            $cache->set( $key, $data );
            
            $c->log->debug( "$key has expired, being refreshed for $busy_lock seconds" )
                if ($pc_config->{debug});
        }
        else {
            $c->log->debug( "Expiring $key from page cache" )
              if ($pc_config->{debug});

lib/Catalyst/Plugin/PageCache.pm  view on Meta::CPAN

    $pc_config->{auto_cache}       ||= [];
    $pc_config->{expires}          ||= 60 * 5;
    $pc_config->{cache_headers}    ||= 0;
    $pc_config->{set_http_headers} ||= 0;
    $pc_config->{busy_lock}        ||= 0;
    $pc_config->{debug}            ||= $c->debug;

    # default the page key to include the app name to give some measure
    # of protection if the cache doesn't have a namespace set.
    $pc_config->{index_page_key} = "$c._page_cache_index"

lib/Catalyst/Plugin/PageCache.pm  view on Meta::CPAN

    index_page_key => '...'

The key string used for the index, Defaults to a string that includes the name
of the Catalyst app class.

    busy_lock => 10

On a high traffic site where page re-generation may take many seconds, a common
problem encountered is the "dog-pile" effect, where many concurrent connections all
hit a page where the cache has expired and all perform the same expensive operation
to rebuild the cache.  To prevent this situation, you can set the busy_lock option
to the maximum number of seconds any of your pages can be expected to take to
rebuild the cache.  Then, when the cache expires, the first request will rebuild the
cache while also extending the expiration time by the number of seconds specified,
allowing other requests that arrive before the cache has been rebuilt to use the
previously cached page.  This option is disabled by default.

 view release on metacpan or  search on metacpan

lib/CatalystX/ASP/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/CatalystX/ASP/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

lib/CatalystX/CRUD/YUI/TT/static/js/livegrid/build/livegrid-all-debug.js  view on Meta::CPAN

     * @param {Number}
     */
    rowIndex : 0,

    /**
    * Set to <tt>true</tt> if the store is busy with loading new data.
    * @param {Boolean}
    */
    isBuffering : false,

	/**