Free store software for linux

Email::Store is a framework for database-backed email storage.

SYNOPSIS

use Email::Store dbi:mysql:mailstore;
Email::Store->setup; # Do this once

Email::Store::Mail->store( $rfc822 );
Email::Store::Mail->retrieve( $msgid );

...

Email::Store is the ideal basis for any application which needs to deal with databases of email: archiving, searching, or even storing mail for implementing IMAP or POP3 servers.

Email::Store itself is a very lightweight framework, meaning it does not provide very much functionality itself; in effect, it is merely a Class::DBI interface to a database schema which is designed for storing email. Incidentally, if you dont know much about Class::DBI, youre going to need to in order to get much out of this.

Despite its minimalist nature, Email::Store is incredibly powerful. Its power comes from its extensibility, through plugin modules and hooks which allow you to add new database tables and concepts to the system, and so access the mail store from a "different direction". In a sense, Email::Store is a blank canvas, onto which you can pick and choose (or even write!) the plugins which you want for your application.

For instance, the core Email::Store::Entity plugin module addresses the idea of "people" in the email universe, allowing you to search for mails to or from particular people; (despite their changing names or email addresses) Email::Store::Thread interfaces Email::Store to Mail::Thread allowing you to navigate mails by their position in a mail thread; the planned non-core Email::Store::Plucene module plugs into the indexing process and stores information about emails in a Plucene search index for quick retrieval later, and so on.

Class::DataStore is a Perl module for generic OO data storage/retrieval.

SYNOPSIS

my %values = ( one => 1, two => 2 );
my $store = Class::DataStore->new( %values );

# using get/set methods
$store->set( three, 3 );
my $three = $store->get( three );

# using AUTOLOAD method
$store->four( 4 );
my $four = $store->four;
my @four = $store->four; # returns a list

my $exists = $store->exists( three ); # $exists = 1
my $data_hashref = $store->dump;
$store->clear;

Class::DataStore implements a simple storage system for object data. This data can be accessed via get/set methods and AUTOLOAD. AUTOLOAD calls are not added to the symbol table, so using get/set will be faster. Using AUTOLOAD also means that you will not be able to store data with a key that is already used by a instance method, such as "get" or "exists".
This module was written originally as part of a website framework that was used for the Democratic National Committee website in 2004. Some of the implementations here, such as get() optionally returning a list if called in array context, reflect the way this module was originally used for building web applications.

Class::DataStore is most useful when subclassed. To preserve the AUTOLOAD functionality, be sure to add the following when setting up the subclass:

use base Class::DataStore;
*AUTOLOAD = &Class::DataStore::AUTOLOAD;
This module is also a useful add-on for modules that need quick and simple data storage, e.g. to store configuration data:
$self->{_config} = Class::Datastore->new( $config_data );
sub config { return $_[0]->{_config}; }
my $server = $self->config->server;
my $sender = $self->config->get( sender );

Wiki::Toolkit::Store::Mediawiki is a Mediawiki (MySQL) storage backend for Wiki::Toolkit.

SYNOPSIS

Implementation of Wiki::Toolkit::Store::Database which reads and writes to a Mediawiki 1.6 database running in MySQL. This is module is intended to be capable of running concurrently with a Mediawiki 1.6 installation without data corruption. That said, use it at your own risk.

If you are looking for a general Wiki implementation, you might be better off looking at Wiki::Toolkit::Kwiki. It is simpler, more general, and does not require the database to be initialized by outside software. Currently, initializing the database for this module requires a working (PHP) Mediawiki installation.

I initially wrote this module because I was sick of running both PHP and Perl on my web server so that I could have the only wiki I could find with the full featureset I wanted running in parallel with the Perl scripts which generate the rest of my content dynamically. Generating my Perl content was much faster than my Mediawiki installation and I like Perl better, so PHP lost. Converting the old Mediawiki database into a format that a less fully featured wiki could read looked generally unrewarding, so here we are.

All date and time values are returned as Time::Piece::Adaptive objects. This should be transparent for most uses.

See Wiki::Toolkit::Store::Database for more on the general API.

CGI::Application::Plugin::Authentication::Store::Cookie is a Cookie based Store.

SYNOPSIS

use base qw(CGI::Application);
use CGI::Application::Plugin::Session;
use CGI::Application::Plugin::Authentication;

__PACKAGE__->authen->config(
STORE => [Cookie, SECRET => "Shhh, dont tell anyone", NAME => CAPAUTH_DATA, EXPIRY => +1y],
);

This module uses a cookie to store authentication information across multiple requests. It works by creating a cookie that contains the information we would like to store (like the name of the user that is currently authenticated), and then base64 encoding the data. In order to ensure that the information is not manipulated by the end-user, we include a CRC checksum that is generated along with our secret. Since the user does not know the value of the secret, they will not be able to recreate the checksum if they change some of the values, so we will be able to tell if the information in the cookie has been manipulated.

Storable package contains persistence for Perl data structures.

SYNOPSIS

use Storable;
store %table, file;
$hashref = retrieve(file);

use Storable qw(nstore store_fd nstore_fd freeze thaw dclone);

# Network order
nstore %table, file;
$hashref = retrieve(file); # There is NO nretrieve()

# Storing to and retrieving from an already opened file
store_fd @array, *STDOUT;
nstore_fd %table, *STDOUT;
$aryref = fd_retrieve(*SOCKET);
$hashref = fd_retrieve(*SOCKET);

# Serializing to memory
$serialized = freeze %table;
%table_clone = %{ thaw($serialized) };

# Deep (recursive) cloning
$cloneref = dclone($ref);

# Advisory locking
use Storable qw(lock_store lock_nstore lock_retrieve)
lock_store %table, file;
lock_nstore %table, file;
$hashref = lock_retrieve(file);

The Storable package brings persistence to your Perl data structures containing SCALAR, ARRAY, HASH or REF objects, i.e. anything that can be conveniently stored to disk and retrieved at a later time.

It can be used in the regular procedural way by calling store with a reference to the object to be stored, along with the file name where the image should be written.

The routine returns undef for I/O problems or other internal error, a true value otherwise. Serious errors are propagated as a die exception.

To retrieve data stored to disk, use retrieve with a file name. The objects stored into that file are recreated into memory for you, and a reference to the root object is returned. In case an I/O error occurs while reading, undef is returned instead. Other serious errors are propagated via die.

Since storage is performed recursively, you might want to stuff references to objects that share a lot of common data into a single array or hash table, and then store that object. That way, when you retrieve back the whole thing, the objects will continue to share what they originally shared.

At the cost of a slight header overhead, you may store to an already opened file descriptor using the store_fd routine, and retrieve from a file via fd_retrieve. Those names arent imported by default, so you will have to do that explicitly if you need those routines. The file descriptor you supply must be already opened, for read if youre going to retrieve and for write if you wish to store.

store_fd(%table, *STDOUT) || die "cant store to stdoutn";
$hashref = fd_retrieve(*STDIN);

You can also store data in network order to allow easy sharing across multiple platforms, or when storing on a socket known to be remotely connected. The routines to call have an initial n prefix for network, as in nstore and nstore_fd. At retrieval time, your data will be correctly restored so you dont have to know whether youre restoring from native or network ordered data. Double values are stored stringified to ensure portability as well, at the slight risk of loosing some precision in the last decimals.

When using fd_retrieve, objects are retrieved in sequence, one object (i.e. one recursive tree) per associated store_fd.

If youre more from the object-oriented camp, you can inherit from Storable and directly store your objects by invoking store as a method. The fact that the root of the to-be-stored tree is a blessed reference (i.e. an object) is special-cased so that the retrieve does not provide a reference to that object but rather the blessed object reference itself. (Otherwise, youd get a reference to that blessed object).

Storable module is a persistence for Perl data structures.

SYNOPSIS

use Storable;
store %table, file;
$hashref = retrieve(file);

use Storable qw(nstore store_fd nstore_fd freeze thaw dclone);

# Network order
nstore %table, file;
$hashref = retrieve(file); # There is NO nretrieve()

# Storing to and retrieving from an already opened file
store_fd @array, *STDOUT;
nstore_fd %table, *STDOUT;
$aryref = fd_retrieve(*SOCKET);
$hashref = fd_retrieve(*SOCKET);

# Serializing to memory
$serialized = freeze %table;
%table_clone = %{ thaw($serialized) };

# Deep (recursive) cloning
$cloneref = dclone($ref);

# Advisory locking
use Storable qw(lock_store lock_nstore lock_retrieve)
lock_store %table, file;
lock_nstore %table, file;
$hashref = lock_retrieve(file);

The Storable package brings persistence to your Perl data structures containing SCALAR, ARRAY, HASH or REF objects, i.e. anything that can be conveniently stored to disk and retrieved at a later time.

It can be used in the regular procedural way by calling store with a reference to the object to be stored, along with the file name where the image should be written.
The routine returns undef for I/O problems or other internal error, a true value otherwise. Serious errors are propagated as a die exception.

To retrieve data stored to disk, use retrieve with a file name. The objects stored into that file are recreated into memory for you, and a reference to the root object is returned. In case an I/O error occurs while reading, undef is returned instead. Other serious errors are propagated via die.

Since storage is performed recursively, you might want to stuff references to objects that share a lot of common data into a single array or hash table, and then store that object. That way, when you retrieve back the whole thing, the objects will continue to share what they originally shared.
At the cost of a slight header overhead, you may store to an already opened file descriptor using the store_fd routine, and retrieve from a file via fd_retrieve. Those names arent imported by default, so you will have to do that explicitly if you need those routines. The file descriptor you supply must be already opened, for read if youre going to retrieve and for write if you wish to store.

store_fd(%table, *STDOUT) || die "cant store to stdoutn";
$hashref = fd_retrieve(*STDIN);

You can also store data in network order to allow easy sharing across multiple platforms, or when storing on a socket known to be remotely connected. The routines to call have an initial n prefix for network, as in nstore and nstore_fd. At retrieval time, your data will be correctly restored so you dont have to know whether youre restoring from native or network ordered data. Double values are stored stringified to ensure portability as well, at the slight risk of loosing some precision in the last decimals.

When using fd_retrieve, objects are retrieved in sequence, one object (i.e. one recursive tree) per associated store_fd.
If youre more from the object-oriented camp, you can inherit from Storable and directly store your objects by invoking store as a method. The fact that the root of the to-be-stored tree is a blessed reference (i.e. an object) is special-cased so that the retrieve does not provide a reference to that object but rather the blessed object reference itself. (Otherwise, youd get a reference to that blessed object).

S3OSCache project is an OSCache store implementation that uses Amazons Web Service S3 service to store the cached data. What this means is that if you are currently using oscache and storing cached objects on disk or in memory, you could easily configure this add-on to oscache and start storing your cached objects on S3.

Motivation

Youre probably asking why would you want to do this. Here is my situation... I have a website publishing system that dynamically resizes images for the user on demand. For example, it might create thumbnails or simply shrink a 2 megapixel photo to efficiently display that as a 400x300 pixel image.

Image resizing is a CPU intensive activity, especially with the Java Imaging API. From the start, I used OSCache to cache these smaller versions of the images on the app servers file system. The problem is that I can have anywhere between 2 and 7 app servers running at a time. This means that in the worst (and common) case, that image gets resized 7 times across my cluster.

I saw what could be done with OSCache storage API, so I took the Amazon S3 REST API and refactored it, since I needed to add HEAD method support and didnt need a lot else. I repackaged the REST API code so that it wont collide with the main Amazon S3 REST API jar if youre using that. The result is s3oscache

SharpMusique project is the fair interface to the iTunes Music Store.
Main features:
- Preview songs
- Signup for an account
- Buy songs and albums
- Redownload songs that were bought with SharpMusique
- Redeem Pepsi Caps
- Redeem gift certificates