IPA_SDB -- IPA simple database module
Main features:
- Distribution consists of database ipa_db_sdb(8) module, statistics
ipa_st_mod(8) module and ipa_sdb_dump(8) utility;
- Modules completely support dynamic and static rules, limits and
thresholds;
- All database files are stored in own record based database formats;
- Formats of database files are machine architecture independent;
- Sizes of database records are relatively small (binary data formats);
- Access to statistics can be granted accordingly to the user group;
- The ipa_sdb_dump(8) utility converts ipa_sdb(5) database files to text
representation and back.
DBIx::Abstract - DBI SQL abstraction.
This module provides methods for doing manipulating database tables
This module provides methods retrieving and storing data in SQL
databases. It provides methods for all of the more important SQL
commands (like SELECT, INSERT, REPLACE, UPDATE, DELETE).
It endeavors to produce an interface that will be intuitive to those
already familiar with SQL.
Notable features include:
* data_source generation for some DBD drivers.
* Can check to make sure the connection is not stale and reconnect
if it is.
* Controls statement handles for you.
* Can delay writes.
* Generates complex where clauses from hashes and arrays.
* Shortcuts (convenience functions) for some common cases. (Like
select_all_to_hashref.)
This perl library contains functions for dealing with databases. It's
mainly used as the foundation for all the other Relations modules. It
may be useful for people that deal with databases in Perl as well.
Relations has functions for creating SQL clauses (like where, from etc.)
from hashes, arrays and strings. It also has functions for converting
strings to arrays or hashes, if they're not hashes or arrays already. It
even has an argument parser, which is used quite heavily by the other
Relations modules.
This generates HTML (and non-HTML) reports from an SQLite database, taking
care of the query-building and the report formatting. This also has methods
for adding and updating the database.
Reports can have nested headers which depend on the sort-order given. One can
select the columns and order in which the values are displayed. The HTML page
generated can be customized with templates.
The SQLite::Work::CGI module has extra methods which deal with CGI using the
CGI module.
The sqlreport script uses SQLite::Work to generate reports from the
command-line.
Gnome Screen Ruler is an on-screen ruler for measuring horizontal and
vertical distances in any application. It has the following features:
* Horizontal and vertical display
* Multiple units: pixels, inches, centimeters, picas, points,
percentage
* Configurable colors and font
* Can be set always-on-top
* Measurement lines track mouse cursor to help measure
anything on screen
* Move and resize via click-and-drag with the mouse
* Align with other windows while dragging (hold Shift key)
* Move using the keyboard for precision (arrow keys)
* Resize using keyboard (Alt+arrow keys)
* Speed up keyboard operations (hold Shift key)
Wammu Mobile Phone Manager
It works with any phone that Gammu supports, including many models from
Nokia, Siemens, and Alcatel. It has complete support (read, edit,
delete, copy) for contacts, todo, and calendar. It can read, save, and
send SMS. It includes an SMS composer for multi-part SMS messages, and
it can display SMS messages that include pictures. Currently, only text
and predefined bitmaps or sounds can be edited in the SMS composer. It
can export messages to an IMAP4 server (or other email storage).
This program does not support browsing files in phone.
MooseX::MarkAsMethods allows one to easily mark certain functions as Moose
methods. This will allow other packages such as namespace::autoclean to operate
without blowing away your overloads. After using MooseX::MarkAsMethods your
overloads will be recognized by Class::MOP as being methods, and class extension
as well as composition from roles with overloads will "just work".
By default we check for overloads, and mark those functions as methods.
If 'autoclean => 1' is passed to import on use'ing this module, we will invoke
namespace::autoclean to clear out non-methods.
This test module is intended to simplify testing of external commands.
It does so by running the command under IPC::Open3, closing the stdin
immediately, and reading everything from the command's stdout and
stderr. It then makes the output available to be tested.
It is not (yet?) as feature-rich as Test::Cmd, but I think the interface
to this is much simpler. Tests also plug directly into the Test::Builder
framework, which plays nice with Test::More.
As compared to Test::Command, this module is simpler, relying on the
user to feed rc, stdout, and stderr to the appropriate other tests,
presumably in Test::More, but not necessarily.
The Tie::RefHash module can be used to access hashes by reference. This is
useful when you index by object, for example.
The problem with Tie::RefHash, and cross indexing, is that sometimes the
index should not contain strong references to the objecs. Tie::RefHash's
internal structures contain strong references to the key, and provide no
convenient means to make those references weak.
This subclass of Tie::RefHash has weak keys, instead of strong ones. The
values are left unaltered, and you'll have to make sure there are no strong
references there yourself.
Celery is an open source asynchronous task queue/job queue based on distributed
message passing. It is focused on real-time operation, but supports scheduling
as well.
The execution units, called tasks, are executed concurrently on one
or more worker nodes. Tasks can execute asynchronously (in the
background) or synchronously (wait until ready).
Celery is written in Python, but the protocol can be implemented
in any language. It can also operate with other languages using
webhooks.
The recommended message broker is RabbitMQ, but limited support for Redis,
Beanstalk, MongoDB, CouchDB, and databases (using SQLAlchemy or the Django
ORM) is also available.