Result:
found more than 817 distributions - search limited to the first 2001 files matching your query
( run in 2.103 )
Math-BigInt
view release on metacpan or search on metacpan
in developing the latest version, not only by cheerfully kicking my lazy butt
from time to time, but also by providing advice, bug-reports, suggestions and
nagging questions, as well as bearing with my countless ranting emails. So,
thank you very much!
Also I want to thank all the ever-busy people on p5p. You guys (and gals) rock!
List still not complete ;o)
Tels <http://bloodgate.com/>
Math-PlanePath
view release on metacpan or search on metacpan
examples/c-curve-wx.pl view on Meta::CPAN
sub OnPaint {
my ($draw, $event) = @_;
### Drawing OnPaint(): $event
### foreground: $draw->GetForegroundColour->GetAsString(4)
### background: $draw->GetBackgroundColour->GetAsString(4)
my $busy = Wx::BusyCursor->new;
my $dc = Wx::PaintDC->new ($draw);
{
my $brush = $dc->GetBackground;
$brush->SetColour ($draw->GetBackgroundColour);
Math-SymbolicX-FastEvaluator
view release on metacpan or search on metacpan
lib/Math/SymbolicX/FastEvaluator.pm view on Meta::CPAN
=head2 PERFORMANCE
Using all this combersome indirection, the evaluation of C<FastEvaluator>
expressions proceeded at a pace of over 200 million tokens per second on my
1.8GHz Core2 laptop which was busy with various desktop tasks at the same time.
A token is a number, variable or operator. Since I was
testing with a string of multiplications, this translates to roughly
100 MFLOPS. You can consider this fast or slow, but compared to Perl
evaluation, this is at least a factor of ten faster. When variables are added into
the picture, the improvement should be even larger.
Math-Telephony-ErlangC
view release on metacpan or search on metacpan
lib/Math/Telephony/ErlangC.pm view on Meta::CPAN
this must be a defined value, greater or equal to 0.
=item *
B<wait probability> is the probability that a given service request will
be put inside the wait queue, which happens when all servers are busy.
=item *
B<(average) service time> is the (average) time that each server needs to
complete a service request; it's referred to as $mst most of the time
lib/Math/Telephony/ErlangC.pm view on Meta::CPAN
=over
=item B<$wprob = wait_probability($traffic, $servers);>
Evaluate the probability that a call will have to wait in the queue
because all servers are busy.
=item B<$servers = servers_waitprob($traffic, $wait_probability)>
Maypole
view release on metacpan or search on metacpan
lib/Maypole/Manual/Flox.pod view on Meta::CPAN
=head1 DESCRIPTION
Friendster, Tribe, and now Google's Orkut - it seems like in early 2004,
everyone wanted to be a social networking site. At the time, I was too
busy to be a social networking site, as I was working on my own project
at the time - Maypole. However, I realised that if I could implement a
social networking system using Maypole, then Maypole could probably do
anything.
I'd already decided there was room for a free, open-source networking
MediaWiki-API
view release on metacpan or search on metacpan
When using the max_lag configuration, if max_lag_retries was reached - the reported number tries were incorrect.
Fixed up the api->list function not continuing due to lack of rawcontinue parameter that is needed after MediaWiki 1.26.
Thanks to Derbeth for the bug reports.
0.40 2014-09-13
Apologies for the lack of updates and the speed to implement some fixes but I have been busy on other projects.
Edit token code has been reworked somewhat to make it simpler, and a bugfix applied for an issue with downloading
images over https using the buildin Download() function.
0.39 2012-05-20
Added automatic support for handling tokens in the MediaWiki::API->Edit function for (Un)watch, Send e-mail
Memcached-libmemcached
view release on metacpan or search on metacpan
src/libmemcached/build-aux/install-sh view on Meta::CPAN
# to itself, or perhaps because mv is so ancient that it does not
# support -f.
{
# Now remove or move aside any old file at destination location.
# We try this two ways since rm can't unlink itself on some
# systems and the destination file might be busy for other
# reasons. In this case, the final cleanup might fail but the new
# file should still install successfully.
{
test ! -f "$dst" ||
$doit $rmcmd -f "$dst" 2>/dev/null ||
MetaTrans
view release on metacpan or search on metacpan
lib/MetaTrans.pm view on Meta::CPAN
Returns current state of the translator. Possible values are
VALUE MEANING
--------- --------------------------------------------------------
"ok" successfully finished a translation (initial state, too)
"busy" working on a translation
"timeout" a timeout occured when querying an online translator
"error" unknown error occured when queryign an online translator
=cut
lib/MetaTrans.pm view on Meta::CPAN
C<$dest_lang_code> language simultaneously on all enabled translators
(plug-ins), which support this translation direction. The method returns
true value on success, false on error. Use C<get_translation> method for
retrieving the results of particular translations.
The method sets the state of all plug-ins to C<"busy">. See C<get_state>
method.
There are two ways of performing parallel run. If C<$options{tk_safe}> is
undefined or set to false value, then a child process is forked for every
translator to be used and C<translate> method is called. This is generally
lib/MetaTrans.pm view on Meta::CPAN
}
}
until defined $pid;
}
${$self->{state}}{$translator} = "busy";
if ($pid)
{
# parent
push @{$self->{pids}}, $pid;
lib/MetaTrans.pm view on Meta::CPAN
}
=item $mt->stop_translators
Stop all running plug-ins. This simply kills all running child processes.
The correspondent translators will end in the C<"busy"> state.
=cut
sub stop_translators
{
Metabrik-Repository
view release on metacpan or search on metacpan
lib/Metabrik/Client/Tcpdump.pm view on Meta::CPAN
}
$self->log->debug("capture: read returned");
# We need to reset the timeout, otherwise read() will
# always return immediately after each call, causing a full CPU
# to become busy. Yes, read() is blocking until a timeout occurs.
if ($self->has_timeout) {
$self->reset_timeout;
}
last if $count && $read_count >= $count;
Minion-Backend-SQLite
view release on metacpan or search on metacpan
lib/Minion/Backend/SQLite.pm view on Meta::CPAN
sub dispatch_schedules {
my $self = shift;
my $db = $self->sqlite->db;
my $timeout = $db->dbh->sqlite_busy_timeout // 0;
$db->dbh->sqlite_busy_timeout(1000);
my ($tx, $errored, $error);
{
local $@;
unless (eval { $tx = $db->begin('immediate'); 1 }) {
my $errcode = $db->dbh->err;
if ($errcode and $errcode == SQLITE_BUSY) {
$db->dbh->sqlite_busy_timeout($timeout);
$db->dbh->rollback; # clear internal transaction state
return [];
} else {
$errored = 1;
$error = $@;
}
}
}
$db->dbh->sqlite_busy_timeout($timeout);
die $error if $errored;
my $due = $db->query(
q{select id, args, attempts, cron, expire, lax, name, strftime('%s',next_run) as next_run,
strftime('%s','now') as now, notes, priority, queue, task
Minion
view release on metacpan or search on metacpan
lib/Minion/Worker.pm view on Meta::CPAN
sub info { $_[0]->minion->backend->list_workers(0, 1, {ids => [$_[0]->id]})->{workers}[0] }
sub new {
my $self = shift->SUPER::new(@_);
$self->on(busy => sub { sleep 1 });
return $self;
}
sub process_commands {
my $self = shift;
lib/Minion/Worker.pm view on Meta::CPAN
my $jobs = $self->{jobs} ||= [];
@$jobs = map { $_->is_finished && ++$status->{performed} ? () : $_ } @$jobs;
# Job limit has been reached or worker is stopping
my @extra;
if ($self->{finished} || ($status->{jobs} + $status->{spare}) <= @$jobs) { return $self->emit('busy') }
elsif ($status->{jobs} <= @$jobs) { @extra = (min_priority => $status->{spare_min_priority}) }
# Try to get more jobs
my $tasks = desired_tasks($status->{limits}, [keys %{$self->minion->tasks}], [map { $_->task } @$jobs]);
return unless @$tasks;
lib/Minion/Worker.pm view on Meta::CPAN
=head1 EVENTS
L<Minion::Worker> inherits all events from L<Mojo::EventEmitter> and can emit the following new ones.
=head2 busy
$worker->on(busy => sub ($worker) {
...
});
Emitted in the worker process when it is performing the maximum number of jobs in parallel.
$worker->on(busy => sub ($worker) {
my $max = $worker->status->{jobs};
say "Performing $max jobs.";
});
=head2 dequeue
lib/Minion/Worker.pm view on Meta::CPAN
my $worker = Minion::Worker->new;
my $worker = Minion::Worker->new(status => {foo => 'bar'});
my $worker = Minion::Worker->new({status => {foo => 'bar'}});
Construct a new L<Minion::Worker> object and subscribe to L</"busy"> event with default handler that sleeps for one
second.
=head2 process_commands
$worker = $worker->process_commands;
Minions
view release on metacpan or search on metacpan
t/role_conflict_method_resolved.t view on Meta::CPAN
roles => [qw( Camper BaseballPro )],
);
sub pitch {
my ($self) = @_;
return "I'm so busy";
}
}
{
package BusyDude;
t/role_conflict_method_resolved.t view on Meta::CPAN
}
package main;
my $dude = BusyDude->new;
is($dude->pitch, "I'm so busy", '');
done_testing();
Modem-Vgetty
view release on metacpan or search on metacpan
I<Voice modem> is a special kind of modem, which (besides the normal
data and/or fax mode) can communicate also in voice mode. It means
it can record sounds it hears from the phone line to the file,
Play-back recorded files, it can beep to the line, and it can detect
various standard sounds coming from the line (busy tone, silence,
dual tone modulation frequency (DTMF) keypad tones, etc).
An example of the voice modem can be the ZyXEL U1496, US Robotics
Sportster (not Courier), etc.
To use this software with the voice modem you need to have the
The B<vgetty> records the voice it can hear on the line to the given file.
It uses the raw modem data format (which can be re-played using the
B<play> subroutine). B<vgetty> changes its state to "RECORDING" and
you need to manually stop the recording using the B<stop> method
after some time (or, you can set B<autostop> and wait for any event
- silence, busy tone, etc).
=item wait($seconds)
The modem waits for a given number of seconds. Changes its state to
"WAITING" and returns "READY" after the wait is finished. Example:
The modem detected a bong tone on the line.
=item BUSY_TONE
The modem detected busy tone on the line (when dialing to the busy
number or when caller finished the call).
=item CALL_WAITING
Defined in IS-101 (I think it is when the line receives another call-in
" | mail -s 'New voice message' $voicemaster";
exit 0;
See the B<examples/answering_machine.pl> in the source distribution,
which contains a more configurable version of the above text.
It first sets the event handlers for the case of busy tone (the caller
hangs up) or silence (the caller doesn't speak at all). The handler
stops B<vgetty> from anything it is currently doing and sets the $finish
variable to 1. Then the reception of the events is enabled and
the welcome message is played. Then the answering machine beeps
and starts to record the message. Note that we need to check the
Module-Advisor
view release on metacpan or search on metacpan
lib/Module/Advisor.pm view on Meta::CPAN
['Mouse' => '>= 1.07, < 1.12', 'Memory leaks in trigger'],
['Text::Xslate' => '< 1.0011', '' bug.'],
['Text::Xslate' => '< 1.5021', 'segv in "render" recursion call'],
['Text::Xslate' => '< 1.6001', 'possibly memory leaks on VM stack frames. see https://github.com/xslate/p5-Text-Xslate/issues/71'],
['Text::Xslate' => '< 2.0005', 'Nested WRAPPER broken https://github.com/xslate/p5-Text-Xslate/issues/79'],
['Furl' => '< 0.39', 'unexpected eof in reading chunked body. It makes busy loop.'],
['AnyEvent::MPRPC' => '< 0.15', 'switch to Data::MessagePack::Stream'],
['Data::MessagePack' => '< 0.46', 'fixed unpacking issue on big-endian system.'],
['Data::MessagePack' => '< 0.39', 'packing float numbers fails on some cases'],
['FCGI::Client' => '< 0.06', 'fixed large packet issue'],
['Starlet' => '< 0.12', 'fix infinite loop when connection is closed while receiving response content'],
['Starman' => '< 0.2014', '$res->[1] is broken after output (This is actualized with Plack::Middleware::AccessLog::Timed) https://github.com/miyagawa/Starman/pull/31'],
['Starman' => '< 0.1006', 'Fixed 100% CPU loop when an unexpected EOF happens'],
['Twiggy' => '< 0.1000', 'busy loop'],
['Teng', '< 0.14', 'fixed deflate bug.'],
['DBIx::Skinny', '< 0.0742', 'txn_scope bug fixed'],
['DBIx::TransactionManager', '< 1.11', 'not execute begin_work at AutoCommit=0.'],
['HTTP::MobileAgent' => '< 0.36', 'new x-up-devcap-multimedia(StandAloneGPS) support'],
['HTTP::MobileAgent' => '< 0.35', 'Updated $HTMLVerMap and $GPSModelsRe in DoCoMo.pm'],
Module-Faker
view release on metacpan or search on metacpan
lib/Data/Fake/CPAN.pm view on Meta::CPAN
beloved beneficial better best bewitched big big-hearted biodegradable
bite-sized bitter black black-and-white bland blank blaring bleak blind
blissful blond blue blushing bogus boiling bold bony boring bossy both
bouncy bountiful bowed brave breakable brief bright brilliant brisk broken
bronze brown bruised bubbly bulky bumpy buoyant burdensome burly bustling
busy buttery buzzing calculating calm candid canine capital carefree careful
careless caring cautious cavernous celebrated charming cheap cheerful cheery
chief chilly chubby circular classic clean clear clear-cut clever close
closed cloudy clueless clumsy cluttered coarse cold colorful colorless
colossal comfortable common compassionate competent complete complex
complicated composed concerned concrete confused conscious considerate
MogileFS-Client-Async
view release on metacpan or search on metacpan
0.006
- Have a much longer timeout for HTTP response than general IO as
lighty will move the temporary file before responding.
0.005
- Bump timeout on read/write to 60 seconds for when machines are busy.
0.004
- Deal with servers which reply with HTTP 1.1 to 1.0 requests.
0.003
MogileFS-Server
view release on metacpan or search on metacpan
lib/MogileFS/ConnectionPool.pm view on Meta::CPAN
my ($self, $ip, $port, $inflight_cb) = @_;
my $conn = $self->_conn_get($ip, $port);
if ($conn) {
$self->_conn_run($conn, $inflight_cb);
} else { # we're too busy right now, queue up
$self->enqueue($ip, $port, $inflight_cb);
}
}
# returns the total number of connections we have
Mojito
view release on metacpan or search on metacpan
files/jquery/jquery-ui.custom.min.js view on Meta::CPAN
* http://jqueryui.com
* Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.position.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.sortable.js, jquery.ui.accordion.js, jquery.ui.a...
* Copyright 2013 jQuery Foundation and other contributors Licensed MIT */
(function(e,t){function i(t,i){var a,n,r,o=t.nodeName.toLowerCase();return"area"===o?(a=t.parentNode,n=a.name,t.href&&n&&"map"===a.nodeName.toLowerCase()?(r=e("img[usemap=#"+n+"]")[0],!!r&&s(r)):!1):(/input|select|textarea|button|object/.test(o)?!t.d...
return isNaN(e)?d:e},f=p(u[0]),m=Math.max(f,p(u[1]||"")),f=s?Math.max(f,s.getFullYear()):f,m=n?Math.min(m,n.getFullYear()):m,t.yearshtml+="<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";m>=f;f++)t.yearshtml+="<opti...
Mojo-Collection-XS
view release on metacpan or search on metacpan
_Deparsed_XSubs.pm view on Meta::CPAN
sub _login;
sub backup_from_dbh;
sub backup_from_file;
sub backup_to_dbh;
sub backup_to_file;
sub busy_timeout;
sub collation_needed;
sub commit;
sub commit_hook;
sub create_aggregate;
sub create_collation;
_Deparsed_XSubs.pm view on Meta::CPAN
sub set_authorizer;
sub sqlite_backup_from_dbh;
sub sqlite_backup_from_file;
sub sqlite_backup_to_dbh;
sub sqlite_backup_to_file;
sub sqlite_busy_timeout;
sub sqlite_collation_needed;
sub sqlite_commit_hook;
sub sqlite_create_aggregate;
sub sqlite_create_collation;
sub sqlite_create_function;
Mojo-Feed
view release on metacpan or search on metacpan
t/samples/theguardian-rss20-media.xml view on Meta::CPAN
<dc:date>2018-05-06T05:00:12Z</dc:date>
</item>
<item>
<title>Good time girl: memories of a super groupie</title>
<link>https://www.theguardian.com/global/2018/may/06/good-time-girl-memories-of-a-super-groupie</link>
<description><p>Pamela Des Barres had the giants of rock’n’roll in the palm of her hand, as her candid memoir reveals</p><p>Barely 30 seconds in and Pamela Des Barres has not so much name-dropped as chucked her diary on th...
<category domain="https://www.theguardian.com/music/popandrock">Pop and rock</category>
<category domain="https://www.theguardian.com/music/music">Music</category>
<category domain="https://www.theguardian.com/culture/culture">Culture</category>
<category domain="https://www.theguardian.com/music/ledzeppelin">Led Zeppelin</category>
<category domain="https://www.theguardian.com/music/therollingstones">The Rolling Stones</category>
Mojo-JWT-Google
view release on metacpan or search on metacpan
lib/Mojo/JWT/Google.pm view on Meta::CPAN
scopes => [ '/my/scope/a', '/my/scope/b' ],
client_email => 'riche@cpan.org')->encode;
You can also get your information automatically from the .json you received
from Google. Your secret key is in that file, so it's best to keep it safe
somewhere. This will ease some busy work in configuring the object -- with
virtually the only things to do is determine the scopes and the user_as if you
need to impersonate.
my $gjwt = Mojo::JWT::Google
->new( from_json => '/my/secret.json',
Mojo-SMTP-Client
view release on metacpan or search on metacpan
t/02_smtp.t view on Meta::CPAN
kill 15, $pid;
# 3
($pid, $sock, $host, $port) = Utils::make_smtp_server();
$smtp = Mojo::SMTP::Client->new(address => $host, port => $port, autodie => 1, tls_verify => 0);
syswrite($sock, '500 host.net is busy'.CRLF);
eval {
$smtp->send();
};
ok($e = $@, 'bad response');
isa_ok($e, 'Mojo::SMTP::Client::Exception::Response');
Mojo-SQLite
view release on metacpan or search on metacpan
t/results.t view on Meta::CPAN
};
like $@, qr/does_not_exist/, 'right error';
is_deeply $db->query('select * from results_test where name = ?', 'tx3')
->hashes->to_array, [], 'no results';
{
my $timeout = $db->dbh->sqlite_busy_timeout // 0;
$db->dbh->sqlite_busy_timeout(100);
my $tx;
eval {
$tx = $db->begin('immediate');
$db->begin('immediate');
};
ok $@, 'transaction failed';
ok $db->dbh->err, 'database error code retained';
$db->dbh->sqlite_busy_timeout($timeout);
}
};
subtest 'Issue #2' => sub {
my $results1 = $db->query('select 1 as one');
Mojo-Webqq
view release on metacpan or search on metacpan
lib/Mojo/Webqq.pm view on Meta::CPAN
has domain => 'w.qq.com';
has account => sub{ $ENV{MOJO_WEBQQ_ACCOUNT} || 'default'};
has start_time => time;
has pwd => undef;
has security => 0;
has mode => 'online'; #online|away|busy|silent|hidden|offline|callme,
has type => 'smartqq'; #smartqq
has login_type => 'qrlogin'; #qrlogin|login
has http_debug => sub{$ENV{MOJO_WEBQQ_HTTP_DEBUG} || 0 };
has ua_debug => sub{$_[0]->http_debug};
has ua_debug_req_body => sub{$_[0]->ua_debug};
MojoMojo
view release on metacpan or search on metacpan
lib/MojoMojo/I18N/ca.po view on Meta::CPAN
#: root/base/edithelp/markdown.tt:17
msgid "bold"
msgstr "negreta"
#: root/base/page/edit.tt:59
msgid "busy spinner"
msgstr ""
#: root/base/page/search_inline.tt:35 root/base/page/view.tt:41 root/base/tag/recent.tt:26
msgid "by"
msgstr "per"
MojoX-HTTP-Async
view release on metacpan or search on metacpan
lib/MojoX/HTTP/Async.pm view on Meta::CPAN
return {
'reader' => undef,
'writer' => undef,
'socket' => undef,
'sock_no' => 0,
'is_busy' => 0,
'request' => undef,
'tx' => undef,
'exp_ts' => 0,
'tmp_response' => undef,
'reconnect_is_required' => 0,
lib/MojoX/HTTP/Async.pm view on Meta::CPAN
sub _get_free_slot ($self) {
my $slot;
my %socks2slots = map { $_->{'sock_no'} => $_ }
grep { !$_->{'is_busy'} && $_->{'socket'} && !$_->{'reconnect_is_required'} }
$self->{'_conns'}->@*;
if (%socks2slots) {
local $!;
lib/MojoX/HTTP/Async.pm view on Meta::CPAN
return $status;
}
sub _clear_slot ($self, $slot, $force = 0) {
$slot->{'is_busy'} = 0;
$slot->{'exp_ts'} = 0;
$slot->{'tx'} = undef;
$slot->{'request'} = undef;
$slot->{'tmp_response'} = undef;
if ($force) {
lib/MojoX/HTTP/Async.pm view on Meta::CPAN
}
}
sub _mark_slot_as_broken($self, $slot) {
$slot->{'reconnect_is_required'} = 1;
$slot->{'is_busy'} = 1;
$slot->{'request'} //= Mojo::Message::Request->new();
$slot->{'tx'} //= Mojo::Transaction::HTTP->new(
'req' => $slot->{'request'},
'res' => Mojo::Message::Response->new()
);
lib/MojoX/HTTP/Async.pm view on Meta::CPAN
$self->_mark_response_as_broken($slot, 524, $message);
}
sub _send_request ($self, $slot, $request, $timeout = undef) {
croak("slot is busy") if ($slot->{'is_busy'});
croak("request object is obligatory") if (!$request);
croak('request must be a descendant of Mojo::Message::Request package') if (!$request->isa('Mojo::Message::Request'));
my $required_scheme = $self->{'ssl'} ? 'https' : 'http';
my $url = $request->url();
lib/MojoX/HTTP/Async.pm view on Meta::CPAN
my $h = $request->headers();
$h->host($self->{'host'}) if (! $h->host() );
$h->user_agent($default_ua_hdr) if (! $h->user_agent() );
$slot->{'request'} = $request;
$slot->{'is_busy'} = 1;
$slot->{'exp_ts'} = ($timeout > 0) ? ( time() + $timeout ) : 0;
my $plain_request = $request->to_string();
if ($self->{'ssl'}) {
lib/MojoX/HTTP/Async.pm view on Meta::CPAN
return;
}
sub _try_to_read ($self, $slot) {
return if $slot->{'tx'} || ! $slot->{'is_busy'};
my $reader = $slot->{'reader'};
my $response = $slot->{'tmp_response'} // Mojo::Message::Response->new();
$response->parse($_) while (<$reader>);
lib/MojoX/HTTP/Async.pm view on Meta::CPAN
}
}
=head2 not_empty($self)
Returns 1 if there even one slot is busy or slot contains a not processed response.
Otherwise the method returns 0.
=cut
sub not_empty ($self) {
my $not_empty = scalar $self->{'_conns'}->@*;
for my $slot ($self->{'_conns'}->@*) {
$not_empty-- if !$slot->{'is_busy'} && !$slot->{'tx'};
}
return $not_empty ? 1 : 0;
}
lib/MojoX/HTTP/Async.pm view on Meta::CPAN
sub _get_response_from_ready_slot ($self) {
my $tx;
my %socks2slots = map { $_->{'sock_no'} => $_ }
grep { ! $_->{'tx'} && ! $_->{'reconnect_is_required'} && $_->{'is_busy'} }
$self->{'_conns'}->@*;
if (%socks2slots) {
local $!;
lib/MojoX/HTTP/Async.pm view on Meta::CPAN
for my $sock_no (keys %socks2slots) {
my $slot = $socks2slots{ $sock_no };
if ( $nfound && vec($read_handles, $sock_no, 1) == 1 ) {
$self->_try_to_read($slot);
next if ! $slot->{'tx'};
next if ! $slot->{'is_busy'};
$tx = $slot->{'tx'};
} else {
if (!$slot->{'tx'} && ($slot->{'exp_ts'} && time() > $slot->{'exp_ts'})) {
$self->_mark_response_as_timeouted($slot);
$tx = $slot->{'tx'};
lib/MojoX/HTTP/Async.pm view on Meta::CPAN
=cut
sub DESTROY ($self) {
my $in_use = 0;
while ( my $slot = shift($self->{'_conns'}->@*) ) {
$in_use++ if ($slot->{'is_busy'});
$slot->{'socket'}->close() if ($slot->{'socket'});
}
warn ref($self) ." object destroyed but still in use" if $in_use;
}
MojoX-ValidateHeadLinks
view release on metacpan or search on metacpan
t/assets/js/DataTables-1.9.4/media/js/jquery.dataTables.js view on Meta::CPAN
*
* @example
* $(document).ready( function() {
* $('#example').dataTable( {
* "oLanguage": {
* "sProcessing": "DataTables is currently busy"
* }
* } );
* } );
*/
"sProcessing": "Processing...",
Mojolicious-Plugin-ServerStatus
view release on metacpan or search on metacpan
lib/Mojolicious/Plugin/ServerStatus.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/Mojolicious/Plugin/ServerStatus.pm view on Meta::CPAN
my $pstatus = eval {
$JSON->decode($json || '{}');
};
$pstatus ||= {};
if ( $pstatus->{status} && $pstatus->{status} eq 'A' ) {
$busy++;
}
else {
$idle++;
}
lib/Mojolicious/Plugin/ServerStatus.pm view on Meta::CPAN
$process_status .= sprintf "%s\n",
join(" ", map { defined $pstatus->{$_} ? $pstatus->{$_} : '' } qw/pid status remote_addr host user method uri protocol ss/);
push @process_status, $pstatus;
}
$body .= <<EOF;
BusyWorkers: $busy
IdleWorkers: $idle
--
pid status remote_addr host user 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";
Mojolicious-Plugin-SpectreCss
view release on metacpan or search on metacpan
lib/Mojolicious/Plugin/SpectreCss/asset/public/spectre/0.5.3/core.min.css view on Meta::CPAN
/*! Spectre.css v0.5.3 | MIT License | github.com/picturepan2/spectre */html{font-family:sans-serif;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}body{margin:0}article,aside,footer,header,nav,section{display:block}h1{font-size:2em;margin:.6...
( run in 2.103 seconds using v1.01-cache-2.11-cpan-600a1bdf6e4 )