This software manages a pid file for you. It will create a pid file, query the
process within to discover if it's still running, and remove the pid file.
This defines the policy for file I/O with modules such as
File::Slurp::WithinPolicy. The purpose is to allow systems administrators to
define locations and restrictions for applications' file I/O and give app
developers a policy to follow. Note that the module doesn't ENFORCE the
policy - application developers can choose to ignore it
(and systems administrators can choose not to install their applications
if they do!).
You may control which policy gets applied by creating a File::Policy::Config
module with an IMPLEMENTATION constant. You may write your own policy as a
module within the File::Policy:: namespace.
By default (if no File::Policy::Config is present), the File::Policy::Default
policy gets applied which doesn't impose any restrictions and provides
reasonable default locations for temporary and log files.
This module simplifies the routine job of selecting a random file. (As you
can find at CGI scripts). It's done, because it's boring (and
error prone), always to write something like
my @files = (<*.*>);
my $randf = $files[rand @files];
or
opendir DIR, " ... " or die " ... ";
my @files = grep {-f ...} (readdir DIR);
closedir DIR;
my $randf = $files[rand @files];
It also becomes very boring and very dangerous to write randomly selection
for subdirectory searching with special check-routines. The simple
standard job of selecting a random line from a file is implemented, too.
This module reads a file backwards line by line. It is simple to use,
memory efficient and fast. It supports both an object and a tied handle
interface.
It is intended for processing log and other similar text files which
typically have their newest entries appended to them. By default files
are assumed to be plain text and have a line ending appropriate to the
OS. But you can set the input record separator string on a per file
basis.
This module provides the ability to search a path-like environment variable
for a file (that does not necessarily have to be an executable).
Module Getopt::ArgvFile is a simple supplement to other option
handling modules. It allows script options and parameters to be
read from files instead of from the command line by interpolating
file contents into @ARGV. This way it PREPARES the final option
handling.
Getopt::ArgvFile does NOT perform any option processing itself, and
should work fine together with any other option handling module
(e.g. Getopt::Long) or even self coded option handling.
-Anton
<tobez@FreeBSD.org>
This module provides an attribute wrapper around Getopt::Long. Instead of
declaring the options in a hash with references to the variables and subroutines
affected by the options, you can use the Getopt attribute on the variables and
subroutines directly.
As you can see from the Synopsis, the attribute takes an argument of the same
format as you would give as the hash key for Getopt::Long. See the Getopt::Long
manpage for details.
GNU binutils for Atmel AVR cross-development
Prerequisite for the GCC for AVR cross-compilation environment.
Still included is the "AVR COFF beta" patch. It allows avr-objcopy to
generate AVR (extended) COFF files to be used on Atmel AVR Studio and
VMLAB. Note that this patch has known issues, see
http://www.sax.de/~joerg/README.coff-avr-patch
The support for additional devices has been synchronize with the
latest public Atmel AVR Tools package.
Gearman provides a generic framework to farm out work to other
machines or dispatch function calls to machines that are better suited
to do the work. It allows you to do work in parallel, to load balance
processing, and to call functions between languages. It can be used in
a variety of applications, from high-availability web sites to the
transport for database replication.
rth is a web-based tool designed to manage requirements, tests,
test results, and defects throughout the application life cycle.
The tool provides a structured approach to software testing and
increases the visibility of the testing process by creating a
common repository for all test assets including requirements,
test cases, test plans, and test results. Regardless of their
geographic location, rth allows testers, developers, business
analysts, and managers to monitor and gauge application
readiness. The tool includes modules for requirements management,
test planning, test execution, defect tracking, and reporting.