Minion is a job queue for the Mojolicious real-time web framework with support
for multiple backends, such as DBM::Deep and PostgreSQL.
A job queue allows you to process time and/or computationally intensive tasks
in background processes, outside of the request/response lifecycle. Among those
tasks you'll commonly find image resizing, spam filtering, HTTP downloads,
building tarballs, warming caches and basically everything else you can imagine
that's not super fast.
p5-Module-Reload
================
Similar to Apache::Reload, this module allows a running perl program to reload
all its libraries. Very useful for developing perl servers.
When Perl pulls a file via require, it stores the filename in the global hash
%INC. The next time Perl tries to 'require' the same file, it sees the file in
%INC and does not reload from disk. This module's handler iterates over %INC
and reloads the file if it has changed on disk.
MooseX::Emulate::Class::Accessor::Fast attempts to emulate the behavior
of Class::Accessor::Fast as accurately as possible using the Moose
attribute system. The public API of Class::Accessor::Fast is wholly
supported, but the private methods are not. If you are only using the
public methods (as you should) migration should be a matter of switching
your "use base" line to a "with" line.
This is a role which provides an alternate constructor for creating objects
using parameters passed in from the command line.
This module attempts to DWIM as much as possible with the command line params
by introspecting your class's attributes. It will use the name of your
attribute as the command line option, and if there is a type constraint
defined, it will configure Getopt::Long to handle the option accordingly.
MouseX::App::Cmd marries App::Cmd with MouseX::Getopt. It is a direct port of
MooseX::App::Cmd to Mouse.
Use it like App::Cmd advises (especially see App::Cmd::Tutorial), swapping
App::Cmd::Command for MouseX::App::Cmd::Command.
Then you can write your Mouse commands as Mouse classes, with MouseX::Getopt
defining the options for you instead of opt_spec returning a
Getopt::Long::Descriptive spec.
The Proc::Reliable is intended to be a method for simple, reliable
and configurable subprocess execution in PERL. It includes all the
functionality of the backticks operator and system() functions,
plus many uses of fork/exec, open2() and open3(). Proc::Reliable
incorporates a number of options, including sending data to the
subprocess on STDIN, collecting STDOUT and STDERR separately or
together, killing hung processes, timeouts and automatic retries.
Seamus Venasse <svenasse@polaris.ca>
This is a rather simplistic lexer and tokenizer for the RPSL language.
It currently does not validate the object in any way, it just tries
(rather hard) to grab the biggest ammount of information it can from the
text presented and place it in a Parse Tree (that can be passed to other
objects from the RPSL namespace for validation and more RFC2622 related
functionality).
Support for the foreach looping construct. Foreach is an idiom that
allows for iterating over elements in a collection, without the use
of an explicit loop counter. This package in particular is intended
to be used for its return value, rather than for its side effects.
In that sense, it is similar to the standard lapply function, but
doesn't require the evaluation of a function. Using foreach without
side effects also facilitates executing the loop in parallel.
Rinci is a set of extensible, language-neutral metadata specifications for your
code (functions/methods, variables, packages, classes, and so on). It allows
various helper tools, from code generator to web middleware to documentation
generator to other protocols, to act on your code, making your life easier as a
programmer. Rinci also allows better interoperability between programming
languages. It is geared towards dynamic scripting languages like Perl, Python,
Ruby, PHP, JavaScript, but is not limited to those languages.
Term::ReadKey is a compiled perl module dedicated to
providing simple control over terminal driver modes
(cbreak, raw, cooked, etc.,) support for non-blocking
reads, if the architecture allows, and some generalized
handy functions for working with terminals. One of the
main goals is to have the functions as portable as
possible, so you can just plug in "use Term::ReadKey" on
any architecture and have a good likelihood of it working.