Result:
found more than 705 distributions - search limited to the first 2001 files matching your query
( run in 1.192 )
Amethyst
view release on metacpan or search on metacpan
factpacks/Linux.fact view on Meta::CPAN
# Linux factpack
# 1999-Dec-29
# Author: Kimmie Dicaire <kdicaire@ispchannel.com>
# see http://novaone.linux-help.org/linuxiqs
Open CASCADE => <reply> $who, The Open CASCADE Object Libraries are reusable C++ object libraries for producing all types of domain-specific graphic modeling applications. URL: http://www.opencascade.org/downloads/down.html
nettimer => <reply> $who, netttimer is a very small, simple program that calculates the amount of time and money you've spent using the Internet. URL: http://members.xoom.com/kodgehopper/nettimer-0.02.tar.gz
TkUsr => <reply> $who, TkUsr is a small program that allows you to manage the Self-mode of a USR/3Com MessagePlus modem. URL: http://ldrolez.free.fr/tkusr-latest.tar.gz
PAG Project => <reply> $who, The PAG Project is a travel agency program that features travel registrations, client database and billing with advanced search features and a really nice looking interface. URL: http://www.jedi.claranet.fr/pag.tar.gz
3D-Stereogram => <reply> $who, Generates 3D pixelpictures which are visible without 3d-glasses.. URL: http://www.snafu.de/~mathe.kcbo/
3Dfx Banshee framebuffer driver for Linux/x86 => <reply> $who, 3Dfx Banshee driver for Linux framebuffer subsystem. URL: http://www.hut.fi/~hmallat/linux/3dfx.html
3dom => <reply> $who, A general purpose 3d object modeler.. URL: http://www.gv.kotnet.org/~kdf/3dom/
factpacks/Linux.fact view on Meta::CPAN
gfcc => <reply> $who, GTK+ firewall (ipchains). URL: http://icarus.autostock.co.kr/
gfind => <reply> $who, GUI front-end to GNU find utility. URL: http://iconmedia.com/aaron/gfind.html
GFingerPoken => <reply> $who, BlackBox-type GTK-based game. URL: http://gfpoken.bigw.org/
gfirecracker => <reply> $who, Gtk control panel for the X-10 Firecracker. URL: http://www.sector13.org/kazin/projects/gfirecracker.html
GFlash => <reply> $who, A testing/Flashcard application for Linux. URL: http://www.bgw.org/projects/gflash/
gfocustimer => <reply> $who, Tracking of X input focus for time charging. URL: http://quozl.us.netrek.org/gfocustimer/
gfontview => <reply> $who, Font Viewer. URL: http://www.geocities.com/SiliconValley/Foothills/1458/
Gforth => <reply> $who, GNU project implementation of the Forth programming language. URL: http://www.jwdt.com/~paysan/gforth.html
gfortune => <reply> $who, Enhanced fortune cookie program. URL: http://tirin.openworld.co.uk/fortune.html
gfract => <reply> $who, GTK-based fractal program. URL: http://www.iki.fi/osku/gfract/
gFTP => <reply> $who, A multithreaded ftp client for X Windows. URL: http://gftp.seul.org/
factpacks/Linux.fact view on Meta::CPAN
gTempConv => <reply> $who, Small utility for conversion between misc. URL: http://sites.inka.de/~W1752/gtc/
GTerm => <reply> $who, Abstract terminal emulator core (VT102/VT52). URL: ftp://www.techsource.com/gtermv09.tar
GTetrinet => <reply> $who, A clone of the game Tetrinet.. URL: http://gtetrinet.netpedia.net/
GTExplorer => <reply> $who, A game theory visualization tool. URL: http://www.ling.ed.ac.uk/~oliphant/gte
gTick => <reply> $who, GTK+ based metronome. URL: http://bsenet.cjb.net/gtick
GTimer => <reply> $who, Scheduler for your personal activities. URL: http://www.radix.net/~cknudsen/gtimer/
GTK File Browser => <reply> $who, Small, fast, lightweight, GTK File Browser. URL: http://members.tripod.com/Yarick/FileBrowser.html
GTK H3O.net Headline Viewer => <reply> $who, Headline grabber for your Linux desktop.. URL: http://www.h3o.net/h3o4/bin/gtk.h3opoll.tgz
GTK MikMod => <reply> $who, An advanced multi-threaded module player.. URL: http://www.gnugeneration.com/
Gtk See => <reply> $who, An image viewer based on the X-Window system and GTK+. URL: http://hotaru.clinuxworld.com/gtksee/
Gtk Undo Library => <reply> $who, A multilevel undo/redo facility for GTK.. URL: http://www-dse.doc.ic.ac.uk/~np2/software/undo.html
factpacks/Linux.fact view on Meta::CPAN
portfwd => <reply> $who, Forwards incoming TCP connections and UDP packets.. URL: http://nucleo.freeservers.com/portfwd/
PortScanner => <reply> $who, Simple and easy to use TCP port scanner. URL: http://www.ameth.org/~veilleux/portscan.html
PortSentry => <reply> $who, Detects and responds to port scans against a target host inreal-time.. URL: http://www.psionic.com/abacus/portsentry/
Portslave => <reply> $who, . URL: http://portslave.linuxrouter.org/
PortZilla => <reply> $who, Port scanner for Linux. URL: http://www.altern.org/vih/pzilla/
POSIX 1003.1b clock/timer patch => <reply> $who, Kernel patch to provide POSIX 1003.1b clocks and timers. URL: http://www.rhdv.cistron.nl/posix.html
POSIX ACLs for Linux => <reply> $who, Kernel patches for ACLs, Ext2 file system implementation, and user utilities. URL: http://major.rithus.co.at/acl/
Post Office => <reply> $who, X11 Emailer/Newsreader. URL: http://www.tarball.net/postoffice/
Postfix => <reply> $who, The Postfix MTA. URL: http://www.postfix.org/
PostgreSQL => <reply> $who, Robust, next-generation, Object-Relational DBMS(ORDBMS). URL: http://www.postgresql.org/
PostgreSQL JDBC Driver => <reply> $who, JDBC driver for the PostgreSQL DBS. URL: http://www.retep.org.uk/postgres/
factpacks/Linux.fact view on Meta::CPAN
qotdd => <reply> $who, Quote of the Day daemon. URL: http://www.zevils.com/linux/qotdd/qotdd.html
qpasswd => <reply> $who, POP3 password changing utility for qmail+poppasswd. URL: ftp://games.online.bg/pub/unix/net/qpasswd/qpasswd-1.1pl1.tar.gz
Qpopper => <reply> $who, POP3 server. URL: http://eudora.qualcomm.com/freeware/qpop.html
qpopper-mysql => <reply> $who, A patch to add a decent set of MySQL capabilities to qpopper 2.53. URL: http://www.riverstyx.net/qpopmysql/
qps => <reply> $who, Displays processes in an X11 window. URL: http://www.nada.kth.se/~f91-men/qps/
QpThread Library for C++ => <reply> $who, Thread library for C++ with support for signals, exceptions, timer etc.. URL: http://www.gncz.cz/kra/index.html
qrend => <reply> $who, Minimalist raytracer. URL: http://esh.netpedia.net/qrend/
QScheme => <reply> $who, Really fast, small and easy to interface Scheme interpreter. URL: http://www.sof.ch/dan/qscheme/index-e.html
Qstat => <reply> $who, A command-line program that displays the status of Internet Quake servers. URL: http://www.activesw.com/people/steve/qstat.html
Qt => <reply> $who, GUI software toolkit. URL: http://www.troll.no/products/qt.html
Qt Architect => <reply> $who, GUI dialog designer for the Qt widget set.. URL: http://www.qtarch.intranova.net/
factpacks/Linux.fact view on Meta::CPAN
UPSomatic => <reply> $who, UPS parcel pricing for US sources, all destinations. URL: ftp://ftp.linux.org.uk/pub/linux/alan/UPSomatic/
Uptime client => <reply> $who, Keep track of your uptime and compare it with other hosts.. URL: http://uptime.hexon.cx/
Uptime Daemon => <reply> $who, Constantly checks your current uptime against uptime records. URL: http://www.vistasafe.com/ud/
Uptime Record Suite => <reply> $who, Records the record uptime. URL: http://jaeger.festing.org/projects/uptime-record/
Uptimed => <reply> $who, Uptime record daemon keeping track of the highest uptimes the system ever had. URL: http://capsi.cx/?q=code/uptimed
uptimer => <reply> $who, Adds the current uptime to your .sig file. URL: http://212.19.67.58/
uptime_applet => <reply> $who, Gnome applet which will display your system uptime. URL: http://outsole.com/uptime.shtml
UPX => <reply> $who, powerful executable packer. URL: http://wildsau.idv.uni-linz.ac.at/mfx/upx.html
URBAN => <reply> $who, A nice shoot-'em-up game for Linux and DOS, lots of blood and gore.. URL: http://urban.home.dhs.org/
Urchin ASAP => <reply> $who, Web visitor-analysis reporting system (log analyzer). URL: http://www.urchin.com/
uredir => <reply> $who, Program to redirect UDP packets. URL: http://members.home.net/id-est/uredir.html
factpacks/Linux.fact view on Meta::CPAN
WMSysMon => <reply> $who, System monitor dock app for WindowMaker/AfterStep. URL: http://www.neotokyo.org/illusion/
wmTicTacToe => <reply> $who, Dock application game for the Window Maker window manager. URL: http://atlas.ucpel.tche.br/~acamargo/
WMTime => <reply> $who, Window Maker dockapp for displaying time and date. URL: http://windowmaker.mezaway.org/dockapps/wmtime.html
WMTime-beats => <reply> $who, WMTime with internet time (beats) hack. URL: http://lengtat.com/ronny/wmtime-itime.phtml
WMTimeBomb => <reply> $who, Mine sweeper type game for WindowMaker. URL: http://www.maliwan.org/wmtimebomb.shtml
wmtimer => <reply> $who, Alarm/Countdown timer applet for Windowmaker. URL: http://www.dwave.net/~jking/wmtimer/
wmto2deb => <reply> $who, Convert WindowMaker themes to Debian packages. URL: http://keeney180-203.keeney.brown.edu/wmto2deb
wmtool => <reply> $who, . URL: http://www.mbnet.mb.ca/~ademko/gnu/
wmtools => <reply> $who, . URL: http://www.spyda.co.za/lunglet/
wmtop => <reply> $who, Graphical WindowMaker dock app to monitor the top 3 processes. URL: http://www.tanelorn.demon.co.uk/Computing/
wmToshiba.app => <reply> $who, WindowMaker dock app. URL: http://sparc.wtic.net/~inphrar3d/
factpacks/Linux.fact view on Meta::CPAN
xwintv => <reply> $who, . URL: http://www.mathematik.uni-kl.de/~wenk/xwintv.html
xwpe-alpha => <reply> $who, A programming environment for UNIX systems. URL: http://www.identicalsoftware.com/xwpe/
Xwrits => <reply> $who, Reminds you to take wrist breaks. URL: http://www.lcdf.org/xwrits/
XwwChooser => <reply> $who, Switches X11 Window Managers. URL: http://gator.naples.net/~nfn03343/XwmC.html
Xxl => <reply> $who, Simple, easy to use and user friendly graphical spreadsheet. URL: http://www.esinsa.unice.fr/xxl.html
xy2k => <reply> $who, X11 Y2K countdown timer.. URL: http://www.ipsmart.com/x11/xy2k.c
XZip => <reply> $who, A Z-machine (Infocom games) interpreter for Unix / X windows. URL: http://www.eblong.com/zarf/xzip.html
XZX => <reply> $who, Sinclair ZX Spectrum 48K/128K/+3 emulator. URL: http://www.philosys.de/~kunze/xzx/
y2l => <reply> $who, Yacc to LaTeX grammar pretty printer. URL: http://www.alchar.org/~aedil/Projects/y2l.html
YA-EDA => <reply> $who, A complete EDA tool for Linux. URL: http://www.hashbang.org/~jarl/
ya-wipe => <reply> $who, Secure file wiper. URL: http://www.erols.com/thomassr/zero/download/wipe/
factpacks/Linux.fact view on Meta::CPAN
PHP auto prepend/append script => <reply> $who, The PHP auto-prepend/append script is a ColdFusion-type application.cfm for PHP. URL: ftp://0x00.org/pub/php/php.prepend.append.tgz
OpenH323 gatekeeper => <reply> $who, The OpenH323 gatekeeper is a freely available H.323 gatekeeper based on the OpenH323 project. URL: http://www.willamowius.de/images/gk011.tar.gz
SMM++ Mud Client => <reply> $who, SMM++ Mud Client is a mud client with extended and unique features. URL: http://www.Physik.Uni-Dortmund.DE/~issevers/SMM++/downloads/smm4r2.tar.gz
SMB-Mode => <reply> $who, SMB-Mode is a simple Emacs major mode to assist in editing Samba's smb.conf configuration file. URL: http://users.gtn.net/fraserm/smb-mode.el
mpg123-mysql => <reply> $who, mpg123-mysql consists of some patches to mpg123 which make it support MySQL. URL: http://www.nonsensss.de/domi/mpg123-mysql/mpg123-mysql-0.3.tar.gz
netttimer => <reply> $who, netttimer is a very small, simple program that calculates the amount of time and money you've spent using the internet. URL: http://members.xoom.com/kodgehopper/nettimer-0.01.tar.gz
Mserv => <reply> $who, Mserv is an MP3 server that has clients for telnet, Web and shell, and is easily extendable to other forms of interface. URL: http://www.mserv.org/download/
wmMailMenu => <reply> $who, wmMailMenu creates a Window Maker menu with mail addresses. URL: http://student.dei.uc.pt/~mtavares/wmMailMenu/wmMailMenu-latest.tgz
XPLSISNJASP => <reply> $who, XPLSISNJASP (Xplisnjasp Parport LightShow Is Not Just A Software Project) is an XMMS visualization plugin and it provides a light show via parallel port. URL: http://www.na.linux.hr/projects/xplsisnjasp/
ipacct => <reply> $who, ipacct is a script which collects IP accounting information for metered IP accounting usage. URL: ftp://ftp2.empnet.com/pub/ipacct/ipacct-1.06.tar.gz
fblogo => <reply> $who, fblogo will let you replace the penguin boot-logo you see when booting kernels with framebuffer support.. URL: http://home.sol.no/~dvedoy/fblogo-0.1.tar.gz
Amon2-Plugin-Web-FormValidator-Simple
view release on metacpan or search on metacpan
--lib
--color
--failures
--recurse
--merge
--timer
--trap
Analizo
view release on metacpan or search on metacpan
t/samples/mlpack-3.0.0/parse_command_line.hpp view on Meta::CPAN
// Add default parameters that are included in every program.
PARAM_FLAG("help", "Default help info.", "h");
PARAM_STRING_IN("info", "Get help on a specific module or option.", "", "");
PARAM_FLAG("verbose", "Display informational messages and the full list of "
"parameters and timers at the end of execution.", "v");
PARAM_FLAG("version", "Display the version of mlpack.", "V");
/**
* Parse the command line, setting all of the options inside of the CLI object
* to their appropriate given values.
Ansible-Util
view release on metacpan or search on metacpan
t/ansible-test1/ansible.cfg view on Meta::CPAN
## this is done to avoid running all of a type by default.
## These setting lists those that you want enabled for your system.
## Custom plugins should not need this unless plugin author specifies it.
# enable callback plugins, they can output to stdout but cannot be 'stdout' type.
#callback_whitelist = timer, mail
# Determine whether includes in tasks and handlers are "static" by
# default. As of 2.0, includes are dynamic by default. Setting these
# values to True will make includes behave more like they did in the
# 1.x versions.
AnyEvent-APNS
view release on metacpan or search on metacpan
t/01_simple.t view on Meta::CPAN
is($payload, '{"foo":"bar"}', 'payload ok');
});
undef $apns;
my $t; $t = AnyEvent->timer(
after => 0.5,
cb => sub {
undef $t;
is $connect_state, 'disconnected', 'disconnected ok';
$cv->send;
AnyEvent-AggressiveIdle
view release on metacpan or search on metacpan
lib/AnyEvent/AggressiveIdle.pm view on Meta::CPAN
You want to stop idle calls until You have done Your work, You can hold
guard inside Your process:
aggressive_idle {
my ($pid, $guard) = @_;
my $timer;
$timer = AE::timer 0.5, 0 => sub {
undef $timer;
undef $guard; # POINT 1
}
}
Until 'B<POINT 1>' aggressive_idle won't call its callback.
AnyEvent-Beanstalk-Worker
view release on metacpan or search on metacpan
lib/AnyEvent/Beanstalk/Worker.pm view on Meta::CPAN
$_->($event) for @{$watchers{$event->{type}}};
}
The C<@events> list (or queue, since events are read as a FIFO) might
be populated asynchronously from system events, such as receiving
signals, network data, disk I/O, timers, or other sources. The
C<handle()> subroutine checks the C<%watchers> hash to see if there
are any watchers or handlers for this event and calls those
subroutines as needed. Some of these subroutines may add more events
to the event queue. Then the loop starts again.
AnyEvent-BitTorrent
view release on metacpan or search on metacpan
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
|| return;
flock($s->files->[$i]->{fh}, LOCK_SH) || return;
weaken $s unless isweak $s;
my $x = $i;
$s->files->[$x]->{timeout}
= AE::timer(500, 0, sub { $s // return; $s->_open($x, 'c') });
}
elsif ($m eq 'w') {
AE::log trace => 'Opening %s to write', $s->files->[$i]->{path};
my @split = File::Spec->splitdir($s->files->[$i]->{path});
pop @split; # File name itself
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
if -s $s->files->[$i]->{fh}
!= $s->files->[$i]->{length}; # XXX - pre-allocate files
weaken $s unless isweak $s;
my $x = $i;
$s->files->[$x]->{timeout}
= AE::timer(60, 0, sub { $s // return; $s->_open($x, 'c') });
}
elsif ($m eq 'c') { $s->files->[$i]->{timeout} = () }
else {return}
return $s->files->[$i]->{mode} = $m;
}
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
'Read %d bytes of data from file (%d bytes collected so far)',
length $_data, length $data;
weaken $s unless isweak $s;
my $x = $file_index;
$s->files->[$x]->{timeout}
= AE::timer(500, 0, sub { $s // return; $s->_open($x, 'c') });
}
$file_index++;
$length -= $this_read;
AE::log
trace => 'Still need to read %d bytes',
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
trace => 'Wrote %d bytes of data to file (%d bytes left)',
$w, length $data;
weaken $s unless isweak $s;
my $x = $file_index;
$s->files->[$x]->{timeout}
= AE::timer(120, 0, sub { $s // return; $s->_open($x, 'c') });
}
$file_index++;
last WRITE if not defined $s->files->[$file_index];
$total_offset = 0;
}
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
remote_interested => 0,
remote_requests => [],
local_choked => 1,
local_interested => 0,
local_requests => [],
timeout => AE::timer(20, 0, sub { $s->_del_peer($h) }),
keepalive => AE::timer(
30, 120,
sub {
$s->_send_encrypted($h, build_keepalive());
}
),
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
complete => 0,
incomplete => 0,
peers => '',
peers6 => '',
announcer => undef,
ticker => AE::timer(
1,
15 * 60,
sub {
return if $s->state eq 'stopped';
$s->announce('started');
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
= compact_ipv6(
uncompact_ipv6($tier->{peers6} . $reply->{peers6}))
if $reply->{peers6};
$tier->{complete} = $reply->{complete};
$tier->{incomplete} = $reply->{incomplete};
$tier->{ticker} = AE::timer(
$reply->{interval} // (15 * 60),
$reply->{interval} // (15 * 60),
sub {
return if $s->state eq 'stopped';
$s->_announce_tier($e, $tier);
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
push @{$tier->{urls}}, shift @{$tier->{urls}};
$s->_announce_tier($e, $tier);
}
}
}
has _choke_timer => (
is => 'bare',
isa => Ref,
init_arg => undef,
required => 1,
default => sub {
my $s = shift;
AE::timer(
15, 45,
sub {
return if $s->state ne 'active';
AE::log trace => 'Choke timer...';
my @interested
= grep { $_->{remote_interested} && $_->{remote_choked} }
values %{$s->peers};
# XXX - Limit the number of upload slots
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
# XXX - Send choke to random peer
}
);
}
);
has _fill_requests_timer => (
is => 'bare',
isa => Ref,
init_arg => undef,
required => 1,
default => sub {
my $s = shift;
AE::timer(
15, 10,
sub { # XXX - Limit by time/bandwidth
return if $s->state ne 'active';
AE::log trace => 'Request fill timer...';
my @waiting
= grep { defined && scalar @{$_->{remote_requests}} }
values %{$s->peers};
return if !@waiting;
my $total_sent = 0;
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
$s->_set_uploaded($s->uploaded + $total_sent);
}
);
}
);
has _peer_timer => (is => 'ro',
lazy => 1,
isa => Ref,
init_arg => undef,
clearer => '_clear_peer_timer',
builder => '_build_peer_timer'
);
sub _build_peer_timer {
my $s = shift;
AE::timer(
1, 15,
sub {
return if !$s->_left;
AE::log trace => 'Attempting to connect to new peer...';
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
if $packet->{payload}[1] ne $s->infohash;
$s->peers->{$h}{peerid} = $packet->{payload}[2];
$s->_send_handshake($h);
$s->_send_bitfield($h);
$s->peers->{$h}{timeout}
= AE::timer(60, 0, sub { $s->_del_peer($h) });
$s->peers->{$h}{bitfield} = pack 'b*', (0 x $s->piece_count);
$h->on_read(sub { $s->_on_read(@_) });
}
else { # This should never happen
}
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
return $s->_del_peer($h)
if $packet->{payload}[1] ne $s->infohash;
$s->peers->{$h}{peerid} = $packet->{payload}[2];
$s->_send_bitfield($h);
$s->peers->{$h}{timeout}
= AE::timer(60, 0, sub { $s->_del_peer($h) });
$s->peers->{$h}{bitfield} = pack 'b*', (0 x $s->piece_count);
}
elsif ($packet->{type} == $INTERESTED) {
$s->peers->{$h}{remote_interested} = 1;
}
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
$s->_consider_peer($s->peers->{$h});
}
elsif ($packet->{type} == $UNCHOKE) {
$s->peers->{$h}{local_choked} = 0;
$s->peers->{$h}{timeout}
= AE::timer(120, 0, sub { $s->_del_peer($h) });
$s->_request_pieces($s->peers->{$h});
}
elsif ($packet->{type} == $HAVE) {
vec($s->peers->{$h}{bitfield}, $packet->{payload}, 1) = 1;
$s->_consider_peer($s->peers->{$h});
$s->peers->{$h}{timeout}
= AE::timer(60, 0, sub { $s->_del_peer($h) });
}
elsif ($packet->{type} == $BITFIELD) {
$s->peers->{$h}{bitfield} = $packet->{payload};
$s->_consider_peer($s->peers->{$h});
}
elsif ($packet->{type} == $REQUEST) {
$s->peers->{$h}{timeout}
= AE::timer(120, 0, sub { $s->_del_peer($h) });
# XXX - Make sure (index + offset + length) < $s->size
# if not, send reject if remote supports fast ext
# either way, ignore the request
push @{$s->peers->{$h}{remote_requests}}, $packet->{payload};
}
elsif ($packet->{type} == $PIECE) {
$s->peers->{$h}{timeout}
= AE::timer(120, 0, sub { $s->_del_peer($h) });
my ($index, $offset, $data) = @{$packet->{payload}};
# Make sure $index is a working piece
$s->working_pieces->{$index} // return;
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
}
elsif ($packet->{type} == $HAVE_ALL) {
$s->peers->{$h}{bitfield} = pack 'b*', (1 x $s->piece_count);
$s->_consider_peer($s->peers->{$h});
$s->peers->{$h}{timeout}
= AE::timer(120, 0, sub { $s->_del_peer($h) });
}
elsif ($packet->{type} == $HAVE_NONE) {
$s->peers->{$h}{bitfield} = pack 'b*', (0 x $s->piece_count);
$s->peers->{$h}{timeout}
= AE::timer(30, 0, sub { $s->_del_peer($h) });
}
elsif ($packet->{type} == $REJECT) {
my ($index, $offset, $length) = @{$packet->{payload}};
return # XXX - error callback if this block is not in the queue
if !grep {
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
|| ($_->[1] != $offset)
|| ($_->[2] != $length)
} @{$s->peers->{$h}{local_requests}}
];
$s->peers->{$h}{timeout}
= AE::timer(30, 0, sub { $s->_del_peer($h) });
}
elsif ($packet->{type} == $ALLOWED_FAST) {
push @{$s->peers->{$h}{local_allowed}}, $packet->{payload};
}
else {
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
; # XXX - len for last piece
$s->working_pieces->{$index}{$offset} = [
$index, $offset,
$_block_size,
$p, undef,
AE::timer(
60, 0,
sub {
$p // return;
$p->{handle} // return;
$s->_send_encrypted($p->{handle},
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
$_->[0] != $index
|| $_->[1] != $offset
|| $_->[2] != $_block_size
} @{$p->{local_requests}}
];
$p->{timeout} = AE::timer(45, 0,
sub { $s->_del_peer($p->{handle}) });
#$s->_request_pieces( $p) # XXX - Ask a different peer
}
)
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
AE::log trace => 'Announcing "stopped" event to trackers...';
$s->announce('stopped');
AE::log trace => 'Disconnecting peers...';
$s->_clear_peers;
AE::log trace => 'Stopping new peers ticker...';
$s->_clear_peer_timer;
AE::log trace => 'Closing files...';
$s->_open($_, 'c') for 0 .. $#{$s->files};
AE::log trace => 'Setting internal status...';
$s->_set_state('stopped');
}
lib/AnyEvent/BitTorrent.pm view on Meta::CPAN
my $s = shift;
AE::log debug => 'Starting...';
$s->announce('started') unless $s->state eq 'active';
$s->peers;
AE::log trace => 'Starting new peers ticker...';
$s->_peer_timer;
AE::log trace => 'Setting internal status...';
$s->_set_state('active');
}
sub pause {
my $s = shift;
AE::log debug => 'Pausing...';
$s->peers;
AE::log trace => 'Starting new peers ticker...';
$s->_peer_timer;
AE::log trace => 'Setting internal status...';
$s->_set_state('paused');
}
#
sub BUILD {
AnyEvent-Blackboard
view release on metacpan or search on metacpan
lib/AnyEvent/Blackboard.pm view on Meta::CPAN
=over 4
=item timeout SECONDS, [ KEY, [, DEFAULT ] ]
Set a timer for N seconds to provide "default" value as a value, defaults to
`undef`. This can be used to ensure that blackboard workflows do not reach a
dead-end if a required value is difficult to obtain.
=cut
lib/AnyEvent/Blackboard.pm view on Meta::CPAN
my ($self, $seconds, $key, $default) = @_;
$key = [ $key ] unless (ref $key eq "ARRAY");
unless ($self->has($key)) {
my $guard = AnyEvent->timer(
after => $seconds,
cb => sub {
unless ($self->has($key)) {
$self->put($_ => $default) for @$key;
}
}
);
# Cancel the timer if we find the object first (otherwise this is a NOOP).
$self->_watch($key, sub { undef $guard });
}
}
=item watch KEYS, WATCHER [, KEYS, WATCHER ]
AnyEvent-CacheDNS
view release on metacpan or search on metacpan
lib/AnyEvent/CacheDNS.pm view on Meta::CPAN
? $DEFAULT_TTL
: ($IS_AE_6X && @_ ? int($_[0]->[3] || 0) : 0)
;
if ($ttl > 0) {
# Create expire timer
my $wt;
$wt = AE::timer($ttl, 0, sub {
$wt = undef;
delete($cache->{$qname});
});
}
AnyEvent-Callback
view release on metacpan or search on metacpan
t/030-ae-cbs.t view on Meta::CPAN
}
for my $cv (AE::cv) {
my @res;
my $cbs = CBS;
my @timers;
for (1 .. 10) {
push @timers => AE::timer rand .1, 0, $cbs->cb;
}
push @timers => AE::timer 0, 0, $cbs->cb;
$cbs->wait(sub { @res = @_; $cv->send });
{
$cbs->cb;
AnyEvent-Capture
view release on metacpan or search on metacpan
my $time = AE::now;
$SIG{'ALRM'} = sub { die };
eval {
alarm(1);
capture { AE::timer 0.5, 0, shift };
alarm(0);
};
if ($@) {
fail("We slept successfully");
diag(" We hadn't woken up after a second and an alarm triggered");
AnyEvent-Chromi
view release on metacpan or search on metacpan
lib/AnyEvent/Chromi.pm view on Meta::CPAN
{
my ($self) = @_;
$log->info("connection failed. reconnecting in 1 second");
$self->{conn_w} = AnyEvent->timer (after => 1, cb => sub {
$self->_start_client();
});
}
sub _start_client
AnyEvent-Collect
view release on metacpan or search on metacpan
lib/AnyEvent/Collect.pm view on Meta::CPAN
use AnyEvent::Collect;
# Wait for all of a collection of events to trigger once:
my( $w1, $w2 );
collect {
$w1 = AE::timer 2, 0, event { say "two" };
$w2 = AE::timer 3, 0, event { say "three" };
}; # Returns after 3 seconds having printed "two" and "three"
# Wait for any of a collection of events to trigger:
my( $w3, $w4 );
collect_any {
$w3 = AE::timer 2, 0, event { say "two" };
$w4 = AE::timer 3, 0, event { say "three" };
};
# Returns after 2 seconds, having printed 2. Note however that
# the other event will still be emitted in another second. If
# you were to then execute the sleep below, it would print three.
AnyEvent-ConnPool
view release on metacpan or search on metacpan
lib/AnyEvent/ConnPool.pm view on Meta::CPAN
for (1 .. $conn_count) {
$self->add();
}
if ($self->{check}) {
my $guard; $guard = AnyEvent->timer (
after => $self->{check}->{interval},
interval => $self->{check}->{interval},
cb => sub {
my $temp_guard = $guard;
for (my $i = 0; $i < $self->{count}; $i++) {
AnyEvent-Connection
view release on metacpan or search on metacpan
lib/AnyEvent/Connection.pm view on Meta::CPAN
Close current connection and establish a new one
=item after($interval, $cb->())
Helper method. AE::timer(after), associated with current connection
Will be destroyed if connection is destroyed, so no timer invocation after connection destruction.
=item periodic($interval, $cb->())
Helper method. AE::timer(periodic), associated with current connection
Will be destroyed if connection is destroyed, so no timer invocation after connection destruction.
=item periodic_stop()
If called within periodic callback, periodic will be stopped.
lib/AnyEvent/Connection.pm view on Meta::CPAN
# callback will be called only 10 times;
=item destroy
Close connection, destroy all associated objects and timers, clean self
=back
=head1 CONNECT METHODS
lib/AnyEvent/Connection.pm view on Meta::CPAN
$self->{debug} ||= 0;
$self->{connected} = 0;
$self->{connecting} = 0;
$self->{reconnect} = 1 unless defined $self->{reconnect};
$self->{timeout} ||= 3;
$self->{timers} = {};
$self->{rawcon} ||= 'AnyEvent::Connection::Raw';
#warn "Init $self";
}
#sub connected {
lib/AnyEvent/Connection.pm view on Meta::CPAN
sub _reconnect_after {
weaken( my $self = shift );
$self->{reconnect} or return $self->{connecting} = 0;
$self->{timers}{reconnect} = AnyEvent->timer(
after => $self->{reconnect},
cb => sub {
$self or return;
delete $self->{timers}{reconnect};
$self->{connecting} = 0;
$self->connect;
}
);
}
lib/AnyEvent/Connection.pm view on Meta::CPAN
sub periodic {
weaken( my $self = shift );
my $interval = shift;
my $cb = shift;
#warn "Create periodic $interval";
$self->{timers}{int $cb} = AnyEvent->timer(
after => $interval,
interval => $interval,
cb => sub {
local *periodic_stop = sub {
warn "Stopping periodic ".int $cb;
delete $self->{timers}{int $cb}; undef $cb
};
$self or return;
$cb->();
},
);
defined wantarray and return AnyEvent::Util::guard(sub {
delete $self->{timers}{int $cb};
undef $cb;
});
return;
}
sub after {
weaken( my $self = shift );
my $interval = shift;
my $cb = shift;
#warn "Create after $interval";
$self->{timers}{int $cb} = AnyEvent->timer(
after => $interval,
cb => sub {
$self or return;
delete $self->{timers}{int $cb};
$cb->();
undef $cb;
},
);
defined wantarray and return AnyEvent::Util::guard(sub {
delete $self->{timers}{int $cb};
undef $cb;
});
return;
}
lib/AnyEvent/Connection.pm view on Meta::CPAN
delete $self->{con};
my $wascon = $self->{connected} || $self->{connecting};
$self->{connected} = 0;
$self->{connecting} = 0;
#$self->{reconnect} = 0;
delete $self->{timers}{reconnect};
$self->event('disconnect',@_) if $wascon;
return;
}
sub AnyEvent::Connection::destroyed::AUTOLOAD {}
AnyEvent-Consul-Exec
view release on metacpan or search on metacpan
lib/AnyEvent/Consul/Exec.pm view on Meta::CPAN
sub _start_session {
my ($self) = @_;
my $session_started_cb = sub {
$self->{_sid} = shift;
$self->{_refresh_guard} = AnyEvent->timer(after => "5s", interval => "5s", cb => sub {
$self->{_c}->session->renew(
$self->{_sid},
$self->{dc_args}->@*,
);
});
AnyEvent-CouchDB
view release on metacpan or search on metacpan
lib/AnyEvent/CouchDB/Stream.pm view on Meta::CPAN
{
Scalar::Util::weaken( my $self = $self );
my $set_timeout = $timeout
? sub {
$self->{timeout}
= AE::timer( $timeout, 0, sub { $on_error->('timeout') } );
}
: sub { };
$set_timeout->();
AnyEvent-Cron
view release on metacpan or search on metacpan
lib/AnyEvent/Cron.pm view on Meta::CPAN
default => sub { [ ] }
;
has timers => ( is => 'rw', isa => 'ArrayRef' , default => sub { [ ] } );
use Scalar::Util qw(refaddr);
sub add {
my $self = shift;
lib/AnyEvent/Cron.pm view on Meta::CPAN
}
}
}
$job->{next}{ $next_epoch } = 1;
$job->{watchers}{$next_epoch} = AnyEvent->timer(
after => $delay,
cb => sub {
$self->{_cv}->begin;
delete $job->{watchers}{$next_epoch};
AnyEvent-Curl-Multi
view release on metacpan or search on metacpan
lib/AnyEvent/Curl/Multi.pm view on Meta::CPAN
my $class = shift;
my $self = $class->SUPER::new(
multi_h => WWW::Curl::Multi->new,
state => {},
timer_w => undef,
io_w => {},
queue => [],
max_concurrency => 0,
max_redirects => 0,
timeout => undef,
lib/AnyEvent/Curl/Multi.pm view on Meta::CPAN
} else {
last;
}
}
# Start our timer
$self->{timer_w} = AE::timer(0, 0.5, sub { $self->_perform });
}
sub _perform {
my $self = shift;
lib/AnyEvent/Curl/Multi.pm view on Meta::CPAN
# We must recalculate the number of active handles here, because
# a user-provided callback may have added a new one.
my $active_handles = scalar keys %{$self->{state}};
if (! $active_handles) {
# Nothing left to do - no point keeping the watchers around anymore.
delete $self->{timer_w};
delete $self->{io_w};
return;
}
# Re-establish all I/O watchers
AnyEvent-CurrentCost
view release on metacpan or search on metacpan
t/02-timeouts.t view on Meta::CPAN
discard_timeout => 0.5,
callback => sub { $cv->send($_[0]) });
my $msg = $cv->recv;
is($msg->value, 1380, 'first value');
$cv = AnyEvent->condvar;
AnyEvent->timer(after => 1.5, sub { $cv->send });
warning_like { $msg = $cv->recv }
{carped => qr/Discarding '<msg><src>truncated'/}, 'discard timeout';
is($msg->value, 1999, 'second value');
waitpid $pid, 0;
AnyEvent-DAAP-Server
view release on metacpan or search on metacpan
eg/simple_daap_server.pl view on Meta::CPAN
use File::Basename qw(dirname);
my $daap = AnyEvent::DAAP::Server->new(port => 23689);
my %playlist;
my $w; $w = AE::timer 1, 0, sub {
foreach my $file (find name => "*.mp3", in => '.') {
my $dir = dirname $file;
my $playlist = $playlist{$dir} ||= do {
my $playlist = AnyEvent::DAAP::Server::Playlist->new(
dmap_itemname => $dir,
AnyEvent-DBD-Pg
view release on metacpan or search on metacpan
lib/AnyEvent/DBD/Pg.pm view on Meta::CPAN
warn;
$cb->();
$self->_dequeue;
};
# At all we don't need timers for the work, but if we have some bugs, it will help us to find them
push @watchers, AE::timer 1,1, $watchers[0];
push @watchers, AE::io $self->{fh}, 0, $watchers[0];
$watchers[0]() and return;
return;
}
AnyEvent-DBI-MySQL
view release on metacpan or search on metacpan
$dbh->do('SELECT SLEEP(0.1)', sub {
ok 1, 'dbh1 callback fired';
undef $t[1];
NEXT();
});
$t[1] = AnyEvent->timer(after => 0.5, cb => sub {
ok 0, 'dbh1 callback fired';
delete $dbh{1};
NEXT();
});
},
$dbh->prepare('SELECT SLEEP(0.1)')->execute(sub {
ok 1, 'dbh2 callback fired';
undef $t[2];
NEXT();
});
$t[2] = AnyEvent->timer(after => 0.5, cb => sub {
ok 0, 'dbh2 callback fired';
delete $dbh{2};
NEXT();
});
},
$dbh->selectall_arrayref('SELECT SLEEP(0.1)', sub {
ok 1, 'dbh3 callback fired';
undef $t[3];
NEXT();
});
$t[3] = AnyEvent->timer(after => 0.5, cb => sub {
ok 0, 'dbh3 callback fired';
delete $dbh{3};
NEXT();
});
},
$dbh->do('SELECT SLEEP(0.1)', sub {
ok 0, 'dbh4 callback ignored';
undef $t[4];
NEXT();
});
$t[4] = AnyEvent->timer(after => 0.5, cb => sub {
ok 1, 'dbh4 callback ignored';
NEXT();
});
},
sub {
$dbh->prepare('SELECT SLEEP(0.1)')->execute(sub {
ok 0, 'dbh5 callback ignored';
undef $t[5];
NEXT();
});
$t[5] = AnyEvent->timer(after => 0.5, cb => sub {
ok 1, 'dbh5 callback ignored';
NEXT();
});
},
sub {
$dbh->selectall_arrayref('SELECT SLEEP(0.1)', sub {
ok 0, 'dbh6 callback ignored';
undef $t[6];
NEXT();
});
$t[6] = AnyEvent->timer(after => 0.5, cb => sub {
ok 1, 'dbh6 callback ignored';
NEXT();
});
},
sub {
AnyEvent-DBI
view release on metacpan or search on metacpan
fork_template => $template;
=item timeout => seconds
If you supply a timeout parameter (fractional values are supported), then
a timer is started any time the DBI handle expects a response from the
server. This includes connection setup as well as requests made to the
backend. The timeout spans the duration from the moment the first data
is written (or queued to be written) until all expected responses are
returned, but is postponed for "timeout" seconds each time more data is
returned from the server. If the timer ever goes off then a fatal error is
generated. If you have an C<on_error> handler installed, then it will be
called, otherwise your program will die().
When altering your databases with timeouts it is wise to use
transactions. If you quit due to timeout while performing insert, update
$self->{rw} = AE::io $client, 0, sub {
my $len = Convert::Scalar::extend_read $client, $rbuf, 65536;
if ($len > 0) {
# we received data, so reset the timer
$self->{last_activity} = AE::now;
for my $res ($cbor->incr_parse_multiple ($rbuf)) {
last unless $self;
# we did time out
my $req = $self->{queue}[0];
$self->_error (timeout => $req->[1], $req->[2], 1); # timeouts are always fatal
} else {
# we need to re-set the timeout watcher
$self->{tw} = AE::timer
$self->{last_activity} + $self->{timeout} - AE::now,
0,
$self->{tw_cb},
;
}
sub timeout {
my ($self, $timeout) = @_;
$self->{timeout} = $timeout;
# reschedule timer if one was running
$self->{tw_cb}->();
}
sub _req {
my ($self, $cb, $filename, $line) = splice @_, 0, 4, ();
AnyEvent-DBus
view release on metacpan or search on metacpan
# claim we are the main reactor mainloop
*Net::DBus::Reactor::main = sub { __PACKAGE__ };
our $I = 0;
our %O; # watchers and timers, unfortunately, dbus only supports attaching integers...
sub watch_off {
delete $O{$_[1]->get_data};
}
my ($con, $w) = @_;
my $id = $w->get_data;
my $i = $w->get_interval * 0.001;
$O{$id} = $w->is_enabled && AE::timer $i, $i, sub {
$w->handle;
$con->dispatch;
};
}
AnyEvent-DNS-Cache-Simple
view release on metacpan or search on metacpan
lib/AnyEvent/DNS/Cache/Simple.pm view on Meta::CPAN
AnyEvent::DNS::Cache::Simple provides simple cache capability for AnyEvent::DNS
CPAN already has AnyEvent::CacheDNS module. It also provides simple cache.
AnyEvent::DNS::Cache::Simple support ttl, negative_ttl and can use with any cache module.
And AnyEvent::DNS::Cache::Simple does not use AnyEvent->timer for purging cache.
=head1 METHOD
=head2 register
AnyEvent-DateTime-Cron
view release on metacpan or search on metacpan
lib/AnyEvent/DateTime/Cron.pm view on Meta::CPAN
}
$self->{_cv}->end;
};
$job->{watchers}{$next_epoch} = AnyEvent->timer(
after => $delay,
cb => $run_event
);
}
}
AnyEvent-Debounce
view release on metacpan or search on metacpan
lib/AnyEvent/Debounce.pm view on Meta::CPAN
isa => 'Bool',
default => 0,
documentation => 'if true, trigger immediately after the first event is received',
);
has 'always_reset_timer' => (
is => 'ro',
isa => 'Bool',
default => 0,
documentation => 'if true, reset the timer after each event',
);
has 'delay' => (
is => 'ro',
isa => 'Num',
lib/AnyEvent/Debounce.pm view on Meta::CPAN
lazy => 1,
clearer => 'clear_queued_events',
handles => { 'queue_event' => 'push', 'event_count' => 'count' },
);
has 'timer' => (
reader => 'timer',
lazy_build => 1,
);
sub _build_timer {
my $self = shift;
return AnyEvent->timer(
after => $self->delay,
interval => 0,
cb => sub { $self->send_events_now },
);
}
sub send_events_now {
my $self = shift;
my $events = $self->queued_events;
my $count = $self->event_count;
$self->clear_timer;
$self->clear_queued_events;
$self->cb->(@$events) if $count > 0;
return;
}
sub send {
my ($self, @args) = @_;
my $timer_running = $self->has_timer;
$self->clear_timer if $self->always_reset_timer;
$self->timer; # resets the timer if we don't have one
if($self->front_triggered && !$timer_running){
$self->cb->([@args]);
}
elsif(!$self->front_triggered){
$self->queue_event([@args]);
}
lib/AnyEvent/Debounce.pm view on Meta::CPAN
=head1 delay
The time to wait after receiving an event before sending it, in case
more events happen in the interim.
=head1 always_reset_timer
Normally, when an event is received and it's the first of a series, a
timer is started, and when that timer expires, all events are sent.
If you set this initarg to a true value, then the timer is reset after
each event is received.
For example, if you set the delay to 1, and ten events arrive at 0.5
second intervals, then with this flag set to true, you will get one
event after 5 seconds. With this flag set to false, you will get an
lib/AnyEvent/Debounce.pm view on Meta::CPAN
C<delay> seconds, even if they occur. These events are lost, you will
never see them.
By default, this is false.
If you also set C<always_reset_timer> to true, the same timer-reset
logic as described above occurs.
=head1 METHODS
=head1 send
AnyEvent
view release on metacpan or search on metacpan
use AnyEvent; # not AE
# file handle or descriptor readable
my $w = AE::io $fh, 0, sub { ... };
# one-shot or repeating timers
my $w = AE::timer $seconds, 0, sub { ... }; # once
my $w = AE::timer $seconds, $interval, sub { ... }; # repeated
print AE::now; # prints current event loop time
print AE::time; # think Time::HiRes::time or simply CORE::time.
# POSIX signal
Example: wait until STDOUT becomes writable and print something.
$stdout_ready = AE::io *STDOUT, 1, sub { print STDOUT "woaw\n" };
=item $w = AE::timer $after, $interval, $cb
Creates a timer watcher that invokes the callback C<$cb> after at least
C<$after> second have passed (C<$after> can be negative or C<0>).
If C<$interval> is C<0>, then the callback will only be invoked once,
otherwise it must be a positive number of seconds that specifies the
interval between successive invocations of the callback.
Example: print "too late" after at least one second has passed.
$timer_once = AE::timer 1, 0, sub { print "too late\n" };
Example: print "blubb" once a second, starting as soon as possible.
$timer_repeated = AE::timer 0, 1, sub { print "blubb\n" };
=item $w = AE::signal $signame, $cb
Invoke the callback C<$cb> each time one or more occurrences of the
named signal C<$signame> are detected.
( run in 1.192 second using v1.01-cache-2.11-cpan-acebb50784d )