view release on metacpan or search on metacpan
lib/Gepok.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
gperl-gtypes.c view on Meta::CPAN
{ G_SPAWN_ERROR_NAMETOOLONG, "G_SPAWN_ERROR_NAMETOOLONG", "nametoolong" },
{ G_SPAWN_ERROR_NOENT, "G_SPAWN_ERROR_NOENT", "noent" },
{ G_SPAWN_ERROR_NOMEM, "G_SPAWN_ERROR_NOMEM", "nomem" },
{ G_SPAWN_ERROR_NOTDIR, "G_SPAWN_ERROR_NOTDIR", "notdir" },
{ G_SPAWN_ERROR_LOOP, "G_SPAWN_ERROR_LOOP", "loop" },
{ G_SPAWN_ERROR_TXTBUSY, "G_SPAWN_ERROR_TXTBUSY", "txtbusy" },
{ G_SPAWN_ERROR_IO, "G_SPAWN_ERROR_IO", "io" },
{ G_SPAWN_ERROR_NFILE, "G_SPAWN_ERROR_NFILE", "nfile" },
{ G_SPAWN_ERROR_MFILE, "G_SPAWN_ERROR_MFILE", "mfile" },
{ G_SPAWN_ERROR_INVAL, "G_SPAWN_ERROR_INVAL", "inval" },
{ G_SPAWN_ERROR_ISDIR, "G_SPAWN_ERROR_ISDIR", "isdir" },
view release on metacpan or search on metacpan
lib/DBI/Gofer/Transport/mod_perl.pm view on Meta::CPAN
my @rr_resp_dur = map { $_->{duration} } @$queue;
push @s, sprintf "Response time: min %.3fs, avg %.3fs, max %.3fs\n",
min(@rr_resp_dur), sum(@rr_resp_dur)/@rr_resp_dur, max(@rr_resp_dur), sum(@rr_resp_dur);
push @s, sprintf "Request rate: %.1f/min (occupancy: %.1f%% with %.3fs busy and %.3fs idle)\n",
@$queue/($time_span/60),
$dur_total/($dur_total+$idle_total)*100, $dur_total, $idle_total
if $queue_name eq 'recent_requests';
if ( my @dups = grep { $_ > 1 } values %dup_reqs ) {
view release on metacpan or search on metacpan
lib/Google/RestApi/CalendarApi3.pm view on Meta::CPAN
params => $p->{params},
($p->{page_callback} ? (page_callback => $p->{page_callback}) : ()),
);
}
sub freebusy {
my $self = shift;
state $check = signature(
bless => !!0,
named => [
time_min => Str,
lib/Google/RestApi/CalendarApi3.pm view on Meta::CPAN
=item * Calendar list management (user's view of calendars)
=item * Colors and settings (read-only)
=item * Free/busy queries
=back
It is assumed that you are familiar with the Google Calendar API:
L<https://developers.google.com/calendar/api/v3/reference>
lib/Google/RestApi/CalendarApi3.pm view on Meta::CPAN
C<max_pages> limits the number of pages fetched (default 0 = unlimited).
Supports C<page_callback>, see L<Google::RestApi/PAGE CALLBACKS>.
Returns a list of calendar hashrefs with id and summary.
=head2 freebusy(%args)
Queries free/busy information for a set of calendars.
my $result = $cal_api->freebusy(
time_min => '2026-03-01T00:00:00Z',
time_max => '2026-03-02T00:00:00Z',
items => [{ id => 'primary' }],
);
view release on metacpan or search on metacpan
lib/Graph/Maker/Catalans.pm view on Meta::CPAN
Taking C<Lweights> as coordinates allows the graph to be drawn as an N-1
dimensional rectangular figure. The first Lweights entry is always 1 so can
be ignored as a coordinate. Each edge is then forward along one axis. For
N=4 in 3 dimensions the effect is good. Geyer draws N=4 and N=5 in this
style. N=5 or more, in 2D projection at least, tends to become too busy to
see much.
=cut
# Winfried Geyer, "On Tamari Lattices", Discrete Mathematics, volume 133,
view release on metacpan or search on metacpan
t/05-corpus.yml view on Meta::CPAN
ComputerSet:
type: object
properties:
_class:
type: string
busyExecutors:
type: integer
computer:
type: array
items:
$ref: '#/definitions/HudsonMasterComputer'
view release on metacpan or search on metacpan
Gnome/samples/lamp.pl view on Meta::CPAN
$h->pack_start($lamp1, 1, 1, 0);
show $h;
$lamp2 = new Gnome::Lamp;
$lamp2->set_type('busy');
show $lamp2;
$h->pack_start($lamp2, 1, 1, 0);
$lamp3 = new Gnome::Lamp;
view release on metacpan or search on metacpan
lib/Gtk2/CV/Jobber.pm view on Meta::CPAN
=cut
our %jobs;
our @jobs; # global job order
our %busy; # exists if this path is executing a job
our %hide; # which paths to hide
our %type;
our @type; # type order
lib/Gtk2/CV/Jobber.pm view on Meta::CPAN
for my $idx (1 .. (@jobs < 10 ? @jobs : 10)) {
return if $disabled;
my $path = $jobs[-$idx];
next if exists $busy{$path};
my $types = $jobs{$path};
my @types = keys %$types;
if (@types) {
lib/Gtk2/CV/Jobber.pm view on Meta::CPAN
my $job = bless delete $types->{$type}, Gtk2::CV::Jobber::Job::;
$job->{path} = $path;
$job->{type} = $type;
undef $busy{$path};
$job->run;
}
next job;
lib/Gtk2/CV/Jobber.pm view on Meta::CPAN
} else {
unless (delete $job->{event}) {
my $type = $type{$job->{type}};
++$class_limit{$type->{class}};
delete $hide{$job->{path}} if $type->{hide};
delete $busy{$job->{path}};
scheduler;
}
client_update $_[0];
view release on metacpan or search on metacpan
examples/busy.pl view on Meta::CPAN
#
# You should have received a copy of the GNU General Public License along
# with Gtk2-Ex-Dragger. If not, see <http://www.gnu.org/licenses/>.
# This example shows the interaction between the WidgetCursor "busy"
# mechanism and a Dragger.
#
# Basically the busy cursor is shown, but the Dragger state isn't lost and
# the cursor is restored when unbusy - which is pretty much what you want if
# a scroll provokes some time consuming activity.
#
# As noted in the text below, if you keep wiggling the mouse around the busy
# cursor will continue to show. That's because it's only removed when idle,
# and the main loop activity you create by wiggling means it's not idle yet.
# This is logical, and you do normally want the busy cursor to stay while
# doing drawing for such wiggling, even if in this case the program is
# interacting and therefore from the user's point of view not really busy.
#
use 5.008;
use strict;
use warnings;
examples/busy.pl view on Meta::CPAN
to move
this
up and
down.
The
busy
indication
comes and
goes on
a timer
and if
examples/busy.pl view on Meta::CPAN
the
mouse
you can
extend
the
busy
since
it doesn't
get
back to
idle
examples/busy.pl view on Meta::CPAN
return Gtk2::EVENT_PROPAGATE;
}
});
sub busy {
Gtk2::Ex::WidgetCursor->busy;
Time::HiRes::usleep (400_000); # 400 milliseconds
return Glib::SOURCE_CONTINUE;
}
Glib::Timeout->add (1200, \&busy); # 800 milliseconds
$toplevel->show_all;
Gtk2->main;
exit 0;
view release on metacpan or search on metacpan
lib/Gtk2/Ex/FormFactory.pm view on Meta::CPAN
=item $form_factory->B<change_mouse_cursor> ( $type [, $gtk_widget] )
This convenience method changes the mouse cursor of the
window of this FormFactory, or of an arbitrary widget passed
as $gtk_widget. $type is the cursor type, e.g. "watch" for
a typical busy / sandglass cursor. Refer to the Gtk
documentation for a complete list of possible mouse cursors.
=back
=head1 AUTHORS
view release on metacpan or search on metacpan
lib/Gtk2/Ex/Splash.pm view on Meta::CPAN
mouse" window manager style though?) It does consume mouse button clicks
though.
The splash contents are shown as the window background, so it doesn't
require any redraws etc from the application and so continues to display
even if the application is busy doing other things.
=head2 X Request Flushing
The Splash code tries to flush the outgoing X request queue at suitable
times to ensure that a C<< $splash->show() >> etc immediately shows the
view release on metacpan or search on metacpan
lib/Gtk2/Ex/TickerView.pm view on Meta::CPAN
Scroll movements are calculated from elapsed time using
C<clock_gettime(CLOCK_REALTIME)> when available or high-res system time
otherwise (see C<Time::HiRes>). This means the display moves at the
C<speed> setting even if drawing is not keeping up with the requested
C<frame-rate>. Slow frame rates can occur on the client side if the main
loop is busy doing other things (or momentarily blocked completely), or can
be on the X server side if it's busy with other drawing etc.
=head1 SEE ALSO
L<Gtk2::CellLayout>, L<Gtk2::TreeModel>, L<Gtk2::CellRenderer>,
L<Gtk2::Ex::CellLayout::Base>
view release on metacpan or search on metacpan
devel/busy-two.pl view on Meta::CPAN
# You should have received a copy of the GNU General Public License along
# with Gtk2-Ex-WidgetCursor. If not, see <http://www.gnu.org/licenses/>.
# The Busy/Open now has the new window noticed, the same as the way
# Busy/Open/Rebusy had to be done in WidgetCursor version 1.
#
use strict;
use warnings;
use Gtk2 '-init';
devel/busy-two.pl view on Meta::CPAN
});
{
my $button = Gtk2::Button->new_with_label ("Busy");
$button->signal_connect (clicked => sub {
print "$progname: busy\n";
Gtk2::Ex::WidgetCursor->busy;
$toplevel->get_display->flush;
sleep (2);
});
$vbox->pack_start ($button, 1,1,0);
}
view release on metacpan or search on metacpan
gtk-demo/assistant.pl view on Meta::CPAN
$assistant->append_page($page);
$assistant->set_page_type($page, 'GTK_ASSISTANT_PAGE_PROGRESS');
$assistant->set_page_title($page, "Applying changes");
# This prevents the assistant window from being
# closed while we're "busy" applying changes.
$assistant->set_page_complete($page, FALSE);
}
sub do {
my $do_widget = shift;
view release on metacpan or search on metacpan
share/public/guaclite.js view on Meta::CPAN
* @type {Number}
*/
"SERVER_ERROR": 0x0200,
/**
* The operation could not be performed as the server is busy.
*
* @type {Number}
*/
"SERVER_BUSY": 0x0201,
share/public/guaclite.js view on Meta::CPAN
// Codes which indicate the server is not reachable
case 1006: // Abnormal Closure (also signalled by JavaScript when the connection cannot be opened in the first place)
case 1015: // TLS Handshake
return Guacamole.Status.Code.UPSTREAM_NOT_FOUND;
// Codes which indicate the server is reachable but busy/unavailable
case 1001: // Going Away
case 1012: // Service Restart
case 1013: // Try Again Later
case 1014: // Bad Gateway
return Guacamole.Status.Code.UPSTREAM_UNAVAILABLE;
view release on metacpan or search on metacpan
t/testpages/cnn.html view on Meta::CPAN
<BR><br>FIND LOW FARES FAST WITH:
<BR><BR>
Air deals at a glance<BR>
Speedy roundtrip flight search<BR>
Low-fare desktop ticker
<BR><BR>The <A HREF="http://reservationdesk.com">online booking source</A> for busy people
</font>
<br>
<br>
view release on metacpan or search on metacpan
lib/HTML/DOM/_TreeBuilder.pm view on Meta::CPAN
}
# end of strict-p block.
}
# And now, get busy...
#----------------------------------------------------------------------
if ( !$self->{'_implicit_tags'} ) { # bimskalabim
# do nothing
print $indent, " * _implicit_tags is off. doing nothing\n"
if DEBUG > 1;
view release on metacpan or search on metacpan
lib/HTML/Dojo/src.pm view on Meta::CPAN
this.name = "VJOURNAL";
this._ValidProperties = VJournalProperties;
dojo.cal.iCalendar.Component.call(this, body);
};
dojo.inherits(dojo.cal.iCalendar.VJournal, dojo.cal.iCalendar.Component);
var VFreeBusyProperties = [_P("contact"), _P("dtstart", 1), _P("dtend"), _P("duration"), _P("organizer", 1), _P("dtstamp", 1), _P("uid", 1), _P("url", 1), _P("attendee"), _P("comment"), _P("freebusy"), _P("rstatus")];
dojo.cal.iCalendar.VFreeBusy = function (body) {
this.name = "VFREEBUSY";
this._ValidProperties = VFreeBusyProperties;
dojo.cal.iCalendar.Component.call(this, body);
};
lib/HTML/Dojo/src.pm view on Meta::CPAN
this.name = "VJOURNAL";
this._ValidProperties = VJournalProperties;
dojo.cal.iCalendar.Component.call(this, body);
};
dojo.inherits(dojo.cal.iCalendar.VJournal, dojo.cal.iCalendar.Component);
var VFreeBusyProperties = [_P("contact"), _P("dtstart", 1), _P("dtend"), _P("duration"), _P("organizer", 1), _P("dtstamp", 1), _P("uid", 1), _P("url", 1), _P("attendee"), _P("comment"), _P("freebusy"), _P("rstatus")];
dojo.cal.iCalendar.VFreeBusy = function (body) {
this.name = "VFREEBUSY";
this._ValidProperties = VFreeBusyProperties;
dojo.cal.iCalendar.Component.call(this, body);
};
view release on metacpan or search on metacpan
lib/HTML/EntityReference.pm view on Meta::CPAN
);
=head1 Functions
The function calls also provide for an easy way to check multiple tables in one go. They also abstract the way data is actually stored, and provide handling of simple cases, and take care of busy details that you might not have thought of like multi...
=head2 (parameters)
In general, the functions take the thing to be converted as the first parameter, and can take one or two additonal optional arguments. Only the C<format> function doesn't follow this pattern exactly, taking another parameter first.
view release on metacpan or search on metacpan
t/repeatable/list.t view on Meta::CPAN
has_field 'tags' => ( type => 'Repeatable' );
has_field 'tags.contains';
sub validate_tags_contains {
my ( $self, $field ) = @_;
if ( $field->value eq 'busybee' ) {
$field->add_error('That tag is not allowed');
}
}
}
t/repeatable/list.t view on Meta::CPAN
};
is_deeply( $form->fif, $fif, 'fif is correct' );
is_deeply( $form->values, $params, 'values are correct' );
$params = { name => 'sally', tags => ['busybee', 'sillysally', 'missymim'] };
$form->process($params);
ok( $form->has_errors, 'form has errors' );
done_testing;
view release on metacpan or search on metacpan
lib/HTML/Mason/Cache/BaseCache.pm view on Meta::CPAN
$HTML::Mason::Cache::BaseCache::VERSION = '1.60';
use strict;
use warnings;
#
# Override to handle busy_lock and expire_if.
#
sub get
{
my ($self, $key, %params) = @_;
die "must specify key" unless defined($key);
foreach my $param (keys(%params)) {
unless ($param =~ /^(busy_lock|expire_if)$/) {
die "unknown param '$param'";
}
}
$self->_conditionally_auto_purge_on_get();
lib/HTML/Mason/Cache/BaseCache.pm view on Meta::CPAN
my $object = $self->get_object($key) or
return undef;
if (Cache::BaseCache::Object_Has_Expired($object))
{
if ($params{busy_lock}) {
# If busy_lock value provided, set a new "temporary"
# expiration time that many seconds forward, and return
# undef so that this process will start recomputing.
my $busy_lock_time = Cache::BaseCache::Canonicalize_Expiration_Time($params{busy_lock});
$object->set_expires_at(time + $busy_lock_time);
$self->set_object($key, $object);
} else {
$self->remove($key);
}
return undef;
lib/HTML/Mason/Cache/BaseCache.pm view on Meta::CPAN
non-existent or expired. This is extended with the following optional
name/value parameters:
=over
=item busy_lock => duration
If the value has expired, set its expiration time to the current time plus
I<duration> (instead of removing it from the cache) before returning undef.
This is used to prevent multiple processes from recomputing the same
expensive value simultaneously. The I<duration> may be of any form acceptable
view release on metacpan or search on metacpan
examples/misc/example5.pl view on Meta::CPAN
<span class="attendee vcard">
<span class="cn">Toby Inkster</span>
<span class="rsvp">true</span>
</span>
</p>
<div class="vfreebusy">
<span class="freebusy">
<span class="fbtype">free</span>
<span class="value">2001-01-01/P6M</span>
<span class="value"><i class="start">2002-01-01</i> <i class="d">182</i></span>
</span>
<span class="summary">freetime</span>
view release on metacpan or search on metacpan
t/data/DataFlow.pm.html view on Meta::CPAN
<h2><a class='u' href='#___top' title='click to go to top of document'
name="Internet_Relay_Chat"
>Internet Relay Chat</a></h2>
<p>You can get live help by using IRC ( Internet Relay Chat ). If you don't know what IRC is, please read this excellent guide: <a href="http://en.wikipedia.org/wiki/Internet_Relay_Chat" class="podlinkurl"
>http://en.wikipedia.org/wiki/Internet_Relay_Chat</a>. 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:</p>
<ul>
<li>irc.perl.org
<p>You can connect to the server at 'irc.perl.org' and join this channel: #opendata-br to get help.</p>
</li>
view release on metacpan or search on metacpan
lib/HTML/TreeBuilder.pm view on Meta::CPAN
}
# end of strict-p block.
}
# And now, get busy...
#----------------------------------------------------------------------
if ( !$self->{'_implicit_tags'} ) { # bimskalabim
# do nothing
print $indent, " * _implicit_tags is off. doing nothing\n"
if DEBUG > 1;
view release on metacpan or search on metacpan
lib/HTML/Valid/Tagset.pm view on Meta::CPAN
'alt' => 'pcdata',
'archive' => 'urls',
'aria-activedescendant' => 'pcdata',
'aria-atomic' => 'pcdata',
'aria-autocomplete' => 'pcdata',
'aria-busy' => 'pcdata',
'aria-checked' => 'pcdata',
'aria-controls' => 'pcdata',
'aria-describedby' => 'pcdata',
'aria-disabled' => 'pcdata',
'aria-dropeffect' => 'pcdata',
view release on metacpan or search on metacpan
lib/HTTP/DownloadLimit.pm view on Meta::CPAN
# ÏÐÒÅÄÅÌÉÔØ ÄÏÓÔÕÐ Ë ÆÁÊÌÕ ÄÌÑ ÏÄÎÁÇÏ ÉÌÉ ÎÅÓËÏÌØËÉÈ ËÌÉÅÎÔÏ× ( *Option )
if( $self->_check_pid && ! $$self{'MULTI'} )
{
print $self->_http_status_403;
$self->_logwrite("403 file is busy $$self{'FILE_NAME'}") if $$self{'DEBUG'};
}
else
{
## ÐÒÏ×ÅÒÉÔØ ÓÏÏÔ×ÅÃÔ×ÉÅ ÚÁÐÒÁÛÉ×ÁÅÍÏÇÏ ÆÁÊÌÁ ÄÏÐÕÓÔÉÍÙÍ ÆÏÒÍÁÔÁÍ
unless( $self->_permission )
view release on metacpan or search on metacpan
lib/HTTP/Proxy/Engine/ScoreBoard.pm view on Meta::CPAN
flock $lockfh, LOCK_UN or do {
$proxy->log( HTTP::Proxy::ERROR, "ERROR", "Cannot unflock: $!" );
exit;
};
5 == syswrite $status_write, pack "NA", $$, "B" # go busy
or $proxy->log( HTTP::Proxy::ERROR, "ERROR", "status B: short write");
$slave->autoflush(1);
$proxy->serve_connections($slave); # the real work is done here
view release on metacpan or search on metacpan
lib/HTTP/Server/Daemon.pm view on Meta::CPAN
undef $port;
undef $quit;
my $quit = 0;
my $caller = $0;
local $SIG{HUP} = sub {$0 = "$caller busy hup"; $quit++; exit 0;};
while(!$quit and $max_request--)
{
my $sock;
syswrite $pipe_write, "$$ idle\n";
$0 = "$caller life=$max_request idle";
lib/HTTP/Server/Daemon.pm view on Meta::CPAN
{
local $SIG{HUP} = sub {$0 = "$caller idle hup"; $quit++; die;};
accept($sock, $server);
};
syswrite $pipe_write, "$$ busy\n";
$0 = "$caller life=$max_request busy";
&$child_func($sock);
close $sock;
}
close $server;
view release on metacpan or search on metacpan
lib/HTTP/Server/Multiplex.pod view on Meta::CPAN
between processes and very simple caching. Most importantly: the whole
code is a critical section which avoid the need for locking. Very fast
and very simple -in concept.
Disadvantages are also plentifold: you have to be careful with any IO
to use the IO::Multiplex select loop, and busy-waits (for reading files,
acquiring locks, database output, hostname lookups, sleep) are blocking
all other clients. Any bug in your software can break the daemon,
and therewith the whole service.
=head2 Features