Result:
found more than 814 distributions - search limited to the first 2001 files matching your query
( run in 0.614 )
MQSeries
view release on metacpan or search on metacpan
MQSeries/ErrorLog/descriptions.pl view on Meta::CPAN
'AMQ6122' => [ "An internal $product_patt error has occurred\\." ],
'AMQ6125' => [ "An internal error has occurred with identifier ($hex_patt)\\.",
"Id" ],
'AMQ6150' => [ "$product_patt semaphore is busy\\." ],
'AMQ6162' => [ "An error has occurred reading an INI file\\." ],
'AMQ6165' => [ "Access to the MQS.INI file or a queue manager QM.INI file is denied\\." ],
MYDan
view release on metacpan or search on metacpan
lib/MYDan/Util/MIO/CMD.pm view on Meta::CPAN
{
local $| = 1;
my $self = shift;
my @node = keys %$self;
my ( $run, $ext, %run, %result, %busy ) = ( 1, "$Script.$$", %RUN, @_ );
my ( $max, $timeout, $interchange ) = @run{ qw( max timeout interchange ) };
my $input = defined $run{input} ? $run{input} : -t STDIN ? '' : <STDIN>;
$SIG{INT} = $SIG{TERM} = sub
{
print STDERR "killed\n";
$run = 0;
};
for ( my $time = time; $run && ( @node || %busy ); )
{
$run = 0 if time - $time > $timeout;
while ( @node && keys %busy < $max )
{
my $node = shift @node;
my $log = "/tmp/$node.$ext";
my $cmd = $self->{$node};
my @cmd = map { my $t = $_; $t =~ s/$interchange/$node/g; $t } @$cmd;
lib/MYDan/Util/MIO/CMD.pm view on Meta::CPAN
next;
}
print "$node started.\n" if $run{verbose};
if ( my $pid = fork() ) { $busy{$pid} = [ $log, $node ]; next }
open STDOUT, ">>$log";
open STDERR, ">>$log";
exec sprintf join ' ', @cmd;
exit 0;
}
for ( keys %busy )
{
my $pid = waitpid( -1, WNOHANG );
next if $pid <= 0;
my $stat = $? >> 8;
my ( $log, $node ) = @{ delete $busy{$pid} };
print "$node done.\n" if $run{verbose};
tie my @log, 'Tie::File', $log,recsep => "\n";
lib/MYDan/Util/MIO/CMD.pm view on Meta::CPAN
push @{ $result{output}{ join "\n", $tmp, "--- $stat", '' } }, $node;
unlink $log;
}
}
kill 9, keys %busy;
push @{ $result{output}{killed} }, map{ $busy{$_}[1]}keys %busy;
push @{ $result{output}{norun} }, @node;
unlink glob "/tmp/*.$ext";
unlink $input if $input && -f $input;
return wantarray ? %result : \%result;
Mac-Carbon
view release on metacpan or search on metacpan
MoreFiles/MoreFilesSrc/FSpCompat.h view on Meta::CPAN
bdNamErr -37 Bad filename
fnfErr -43 File not found
wPrErr -44 Hardware volume lock
fLckdErr -45 File is locked
vLckdErr -46 Software volume lock
fBsyErr -47 File busy, directory not empty, or
working directory control block open
dirNFErrdirNFErr -120 Directory not found or incomplete pathname
afpAccessDenied -5000 User does not have the correct access
*/
Mac-Errors
view release on metacpan or search on metacpan
lib/Mac/Errors.pm view on Meta::CPAN
sub vLckdErr { -46 }
=item fBsyErr
File is busy (delete)
=cut
sub fBsyErr { -47 }
lib/Mac/Errors.pm view on Meta::CPAN
sub fsmFFSNotFoundErr { -431 }
=item fsmBusyFFSErr
File system is busy, cannot be removed
=cut
sub fsmBusyFFSErr { -432 }
lib/Mac/Errors.pm view on Meta::CPAN
sub kEFAULTErr { -3213 }
=item kEBUSYErr
Device or resource busy
=cut
sub kEBUSYErr { -3215 }
lib/Mac/Errors.pm view on Meta::CPAN
sub kUSBNotSent1Err { -6902 }
=item kUSBBufUnderRunErr
Host hardware failure on data out, PCI busy?
=cut
sub kUSBBufUnderRunErr { -6903 }
=item kUSBBufOvrRunErr
Host hardware failure on data in, PCI busy?
=cut
sub kUSBBufOvrRunErr { -6904 }
lib/Mac/Errors.pm view on Meta::CPAN
sub dcmDictionaryNotOpenErr { -7104 }
=item dcmDictionaryBusyErr
dictionary is busy
=cut
sub dcmDictionaryBusyErr { -7105 }
Mac-EyeTV
view release on metacpan or search on metacpan
lib/Mac/EyeTV.pm view on Meta::CPAN
'input_source' => 'input source',
'id' => 'unique ID',
);
foreach my $prop (
qw(title description channel_number station_name input_source repeats quality enabled busy id)
)
{
my $eyetv_prop = $map{$prop} || $prop;
my $value = $eyetv_programme->prop($eyetv_prop)->get;
$programme->$prop($value);
Mac-FSEvents
view release on metacpan or search on metacpan
lib/Mac/FSEvents.pm view on Meta::CPAN
=item latency
Optional. The number of seconds the FSEvents service should wait after hearing
about an event from the kernel before passing it along. Specifying a larger value
may result in fewer callbacks and greater efficiency on a busy filesystem. Fractional
seconds are allowed.
Default: 2.0
=item since
Mail-Bulkmail
view release on metacpan or search on metacpan
Bulkmail.pm view on Meta::CPAN
Also note that these speeds are only measuring the time it takes to get from Mail::Bulkmail to your SMTP relay. There are no
measurements reflecting how long it may take your SMTP relay to send the data on to the recipients on your list.
=item Am I going to see speeds that fast?
Maybe, maybe not. It depends on how busy your SMTP server is. If you have a relatively unused SMTP server with a fair amount
of horsepower and a fast connection, you can easily get these speeds or beyond. If you have a relatively busy and/or low powered
SMTP server or slow connections, you're not going to reach speeds that fast.
=item How much faster will Mail::Bulkmail be than my current system?
This is a very tough question to answer, since it depends highly upon what your current system is. For the sake of argument,
let's assume that for your current system, you open an SMTP connection to your server, send a message, and close the connection.
And then repeat. Open, send, close, etc.
Mail::Bulkmail will I<always> be faster than this approach since it opens one SMTP connection and sends every single message across
on that one connection. How much faster depends on how busy your server is as well as the size of your list. The connection will
only be closed if you have an error or if you reach the max number of messages to send in a given server connection.
Lets assume (for simplicity's sake) that you have a list of 100,000 people. We'll also assume that you have a pretty busy
SMTP server and it takes (on average) 25 seconds for the server to respond to a connection request. We're making 100,000
connection requests (with your old system). That means 100,000 x 25 seconds = almost 29 days waiting just to make connections
to the server! Mail::Bulkmail makes one connection, takes 25 seconds for it, and ends up being 100,000x faster!
But, now lets assume that you have a very unbusy SMTP server and it responds to connection requests in .003 seconds. We're making
100,000 connection requests. That means 100,000 x .0003 seconds = about 5 minutes waiting to make connections to the server.
Mail::Bulkmail makes on connection, takes .0003 seconds for it, and ends up only being 1666x faster. But, even though being
1,666 times faster sounds impressive, the world won't stop spinning on its axis if you use your old system and take up an extra
5 minutes.
Mail-DeliveryStatus-BounceParser
view release on metacpan or search on metacpan
t/corpus/comcast-via-sendmail.unknown.msg view on Meta::CPAN
<recipient@example.net>
(reason: 551 not our customer)
----- Transcript of session follows -----
... while talking to gateway-a.comcast.net.:
<<< 450 busy - please try later
... while talking to gateway-s.comcast.net.:
>>> DATA
<<< 551 not our customer
550 5.1.1 <recipient@example.net>... User unknown
<<< 503 need RCPT command [data]
Mail-Exchange
view release on metacpan or search on metacpan
lib/Mail/Exchange/PidLidDefs.pm view on Meta::CPAN
0x80c5 => { type => 0x0102, name => "PidLidFax2OriginalEntryId", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies a one-off EntryID corresponding to this fax address.
0x80d2 => { type => 0x001f, name => "PidLidFax3AddressType", guid => "00062004-0000-0000-C000-000000000046" }, # Contains the string value "FAX".
0x80d3 => { type => 0x001f, name => "PidLidFax3EmailAddress", guid => "00062004-0000-0000-C000-000000000046" }, # Contains a user-readable display name, followed by the "@" character, followed by a fax number.
0x80d4 => { type => 0x001f, name => "PidLidFax3OriginalDisplayName", guid => "00062004-0000-0000-C000-000000000046" }, #
0x80d5 => { type => 0x0102, name => "PidLidFax3OriginalEntryId", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies a one-off EntryID that corresponds to this fax address.
0x80d8 => { type => 0x001f, name => "PidLidFreeBusyLocation", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies a URL path from which a client can retrieve free/busy status information for the contact.
0x80da => { type => 0x001f, name => "PidLidHomeAddressCountryCode", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies the country code portion of the contact's home address.
0x80db => { type => 0x001f, name => "PidLidWorkAddressCountryCode", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies the country code portion of the contact's work address.
0x80dc => { type => 0x001f, name => "PidLidOtherAddressCountryCode", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies the country code portion of the contact's other address.
0x80dd => { type => 0x001f, name => "PidLidAddressCountryCode", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies the country code portion of the contact's mailing address.
0x80de => { type => 0x0040, name => "PidLidBirthdayLocal", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies the birthday of a contact.
Mail-IMAPClient
view release on metacpan or search on metacpan
Fixed some bugs in _send_line (the "O" side of the I/O engine) that were
reported by Danny Smith.
Fixed a bug in the migrate method in the optimization code (which
gets called when socket writes are delayed due to a slow or busy target
host, aka EAGAIN errors). Thanks to Pedro Carvalho for identifying
this bug and its cause.
Fixed a bug in migrate that caused migration of unread messages to fail.
This was due to the way Mail::IMAPClient's migrate method would try to send
Mail-QmailRemoteXS
view release on metacpan or search on metacpan
qmailrem/CHANGES view on Meta::CPAN
writes a pipeful to qmail-lspawn or qmail-rspawn before they
can react (because of high concurrency, high load, or long
addresses), it will receive an incorrect -1/EAGAIN, and will
conclude that spawn died. sysadmin will have to restart qmail,
and messages will be duplicated. fix: in qmail-send.c,
busy-loop if write() to spawn returns any error other than
EPIPE.
19960501 bug: qmail-alias treated NAMETOOLONG and NOTDIR as temporary
errors. impact: qmail-alias never looked for -default; even if
mail was destined to bounce, it would have to time out first.
fix: qmail-alias now uses error_temp().
Mail-SMTP-Honeypot
view release on metacpan or search on metacpan
Honeypot.pm view on Meta::CPAN
$threads->{$DNSfileno}->{read} = \&dns_rcv; # always armed
foreach(grep(!/\D/,keys %$threads)) { # each thread key
vec($rin,$_,1) = 1 if $threads->{$_}->{read}; # set read selects
vec($win,$_,1) = 1 if $threads->{$_}->{write}; # set write selects
}
$go_listen->{read} = \&newthread; # re-arm listner if it was busy
$nfound = select($rout=$rin,$wout=$win,undef,1); # tick each second
if ($nfound > 0) {
do_thread($wout,'write') if $wout;
do_thread($rout,'read') if $rout;
Mail-SPF-Iterator
view release on metacpan or search on metacpan
1.119 2018-11-15
- quote fields like envelope-from correctly when writing Received-SPF
1.118 2018-10-29
- fixed potential busy loop with specific DNS responses
- ignore case when comparing answer from DNS to query
1.117 2018-09-24
- fixed mail header when pass_all matched to include reason etc
- add --passall option to samples/spflookup.pl
Mail-SpamAssassin
view release on metacpan or search on metacpan
lib/Mail/SpamAssassin/BayesStore/Redis.pm view on Meta::CPAN
The Redis backend for Bayes can put a Lua scripting support in a Redis
server to good use, improving performance. The Lua support is available
in Redis server since version 2.6. In absence of a Lua support, the Redis
backend uses batched (pipelined) traditional Redis commands, so it should
work with a Redis server version 2.4 (untested), although this is not
recommended for busy sites.
Expiration of token and 'seen' message id entries is left to the Redis
server. There is no provision for manually expiring a database, so it is
highly recommended to leave the setting bayes_auto_expire to its default
value 1 (i.e. enabled).
Mail-SpamCannibal
view release on metacpan or search on metacpan
contrib/mimedefang-filter view on Meta::CPAN
# Set the next one if your mail client cannot handle multiple "inline"
# parts.
$Stupidity{"NoMultipleInlines"} = 0;
# The next lines force SpamAssassin modules to be loaded and rules
# to be compiled immediately. This may improve performance on busy
# mail servers. Comment the lines out if you don't like them.
if ($Features{"SpamAssassin"}) {
spam_assassin_init()->compile_now(1) if defined(spam_assassin_init());
# If you want to use auto-whitelisting:
Mail-Summary
view release on metacpan or search on metacpan
my @mail_summaries = $ms->summaries;
=head1 DESCRIPTION
Too busy to read your mail? Subscribe to too many mailing lists?
Take two folders into the shower? Well, for the busy on the go geek
of today, here is the answer! Get all your messages summarised, to
save you having to read them, or to read them by which summary looks
better!
=cut
Mail-Toaster
view release on metacpan or search on metacpan
doc/toaster-watcher.conf view on Meta::CPAN
vpopmail_qmail_ext = 1
vpopmail_rebuild_tcpserver_file = 0
By default, vpopmail updates ~vpopmail/etc/tcp.smtp every time a new
user is added to the relay table, which is every time a user
successfully authenticates. This generates a lot of disk i/o on a busy
mail seerver but is necessary for tcpserver to "see" the update. This is
not necessary with the Mail::Toaster because we use the MySQL patch to
tcpserver to check the SQL table directly.
vpopmail_ip_alias_domains = 0
doc/toaster-watcher.conf view on Meta::CPAN
vpopmail_domain_quotas = 0
vpopmail_default_quota = 100000000S,10000C
The domain quota feature has been broken on vpopmail almost forever.
Even when it worked, it introduced extremely high CPU loads on busy mail
systems. It is to be avoided.
The default quota option is deprecated in vpopmail 5.4.0 and higher. See
~vpopmail/etc/vlimits.default to control default limits.
doc/toaster-watcher.conf view on Meta::CPAN
send_log_isoqlog = 1
This allows you to choose whether your qmail-send logs will be
post-processed by isoqlog. This will trigger isoqlog every 5 minutes at
which time it'll update the pretty HTML pages it generates. This is a
handy default but if you have a really busy mail server (see if isoqlog
takes more than a couple seconds to run) with lots of logs, it's better
to disable this and run isoqlog from cron less frequently.
send_mailbox_string = ./Maildir/
MailFolder
view release on metacpan or search on metacpan
examples/xmailfolder.pl view on Meta::CPAN
# figure why a abnormal exit doesn't cleanup the open mailbox
# key accelerators are conflicting with each other (Alt-f,c vs. c)
# actually detect error returns from MailFolder calls
# do more appropriate error handling in CoreCompose and friends
# SNIGGLES
# add busy-cursor in appropriate places
# figure how to get a Shift-(Next|Prior) to move the msg window in the
# folder window
# figure out how set width of scrollbars - normal way isn't working
require 5.00397;
Marpa-R2
view release on metacpan or search on metacpan
engine/read_only/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 ||
MarpaX-Hoonlint
view release on metacpan or search on metacpan
hoons/arvo/app/dojo.hoon view on Meta::CPAN
++ dy-edit :: handle edit
|= cal/sole-change
^+ +>+>
=^ dat say (~(transceive sole say) cal)
?: |(?=(^ per) ?=(^ pux) ?=($~ pro))
~& %dy-edit-busy
=^ lic say (~(transmit sole say) dat)
(dy-diff %mor [%det lic] [%bel ~] ~)
(dy-slam(per `dat) /edit u.pro !>((tufa buf.say)))
::
++ dy-type :: sole action
Math-3Space
view release on metacpan or search on metacpan
cpanm Dist::Zilla
dzil authordeps | cpanm
dzil build
While Dist::Zilla takes the busywork and mistakes out of module authorship,
it fails to address the need of XS authors to easily compile XS projects
and run single testcases, rather than the whole test suite. For this, you
might find the following script handy:
./dzil-prove t/04-transform.t # or any other testcase
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;
( run in 0.614 second using v1.01-cache-2.11-cpan-87723dcf8b7 )