repositories

Railroad Repository provides a standards-based repository for large binary files.

Railroad is a standards-based repository for large binary files such as digital media, along with their metadata. It is designed to be easy to integrate with content management systems and other client software.

Many CMS’s are more suitable for document-style content than they are for managing large files. Managing such binary content in a CMS can result in scalability issues and deteriorating performance. Railroad instead is dedicated to the task of managing large files and their metadata.

Railroad can be seamlessly integrated into CMS’s, leveraging the open WebDAV protocol and simple HTTP messaging. While uploads and downloads of files are fully managed by Railroad and thus routed ‘around’ the application server, authorization of who can upload or download is still under full control of the CMS using whatever authorization scheme it needs.

Railroad allows multiple clients (such as CMS’s and DAM systems) to access the resources in the repository at the same time, thus keeping large data files and their metadata centrally managed and shared.

Railroad also makes management of file data on the filesystem easier for the system administrator. Railroad takes care to categorize files of a different type into separate directories. If a system administrator determines one file type is taking up a lot of space, it is simple to move this information off onto another, larger, partition. It is also possible to run multiple repositories in one Apache instance, or on different machines but using the same database.

App::Repository is a logical data access layer for the App::Context Framework, providing a uniform API to access data in databases, file systems, remote web sites, etc.

This is the App-Repository distribution, adding the data access layer service to App-Context.

For more information, see the web pages at

http://www.officevision.com/pub/App-Repository http://www.officevision.com/pub/App-Context

The mailing list is described at

http://p5ee.perl.org/mailinglist/
http://lists.perl.org/showlist.cgi?name=p5ee

HOW DO I INSTALL IT?

To install this module, cd to the directory that contains this README file and type the following:

perl Makefile.PL
make
make test
make install

Fedora Digital Object Repository is an open source software which gives organizations a flexible service-oriented architecture for managing and delivering their digital content. At its core is a powerful digital object model that supports multiple views of each digital object and the relationships among digital objects.

Digital objects can encapsulate locally-managed content or make reference to remote content. Dynamic views are possible by associating web services with objects. Digital objects exist within a repository architecture that supports a variety of management functions. All functions of Fedora, both at the object and repository level, are exposed as web services. These functions can be protected with fine-grained access control policies.

This unique combination of features makes Fedora an attractive solution in a variety of domains. Some examples of applications that are built upon Fedora include library collections management, multimedia authoring systems, archival repositories, institutional repositories, and digital libraries for education.

Whats New in This Release:

· This is a significant release of Fedora that includes a complete repackaging as a proper Web application.
· A new installer application makes it easy to setup and run.
· It now uses Servlet Filters for authentication.
· The Fedora repository can also be configured to calculate and store checksums for content.
· The RDF-based Resource Index has been tuned for better performance.
· A new high-performing RDBMS-backed triplestore has been developed that can now be plugged into the RI.

Repository::Simple is a simple hierarchical repository for Perl.

SYNOPSIS

use Repository::Simple;

my $repository = Repository::Simple->attach(
FileSystem => root => /home/foo
);

NOTICE: This software is still in development and the interface WILL CHANGE.
This is the main module of a hierarchical repository system, which is loosely based upon the File::System module Ive written combined with ideas from the JSR 170, a.k.a. Content Repository API for the Java API Specification.

The goal of this package is to provide a content repository system with a similar feature set. I think it would be a good goal to aim for loose compatibility, but it is not my intent to adhere to the strict letter of that standard.

Cache::Repository is a Perl module used to cache generic file repository.

SYNOPSIS

my $rep = Cache::Repository->new(
style => Filesys,
# options for the F::R driver
);
$rep->add_files(tag => groupname,
files => @filenames,
basedir => /tmp,
move => 1,
);
$rep->add_filehandle(tag => anothergroup,
filename => blah,
filehandle => $fh,
mode => 0755);
$rep->set_meta(tag => groupname,
meta => {
title => blah,
author => foo,
});

$rep->retrieve(tag => groupname, dest => /newdir);
my $data = $rep->get_meta(tag => groupname);

This module is intended to serve as a repository for files, whether those files are local or remote. Different drivers can work independantly to provide differing backing stores. For example, one driver can use a locally-mounted filesystem (even if that is a network filesystem), another could use FTP or HTTP, another could use gmail, and another could use a relational database such as MySQL or DB2.

Drivers may choose to compress the repository, unless explicitly told otherwise.
Keeping this in mind, the API presented here cannot expose things that are not generic to other possible implementations. That said, some possible implementations may not allow adding ("sending" to a web server) - it is expected that they will either throw an exception, or take extra params for FTPing to the server.

Password Repository is a native Mac OS X program to manage passwords using an essential and powerful Mac interface.

Password Repository saves data on disk automatically encrypted, using Blowfish algorithm and are unreadable without opening them with the right password.

Password Repository shows data in a table view and let the user order items by any columns with just a click. Any content is searchable using a search field with data displayed as-you-type.

Password Repository is really simple and effective allowing the user to store his precious data on disk in a safe way.

Here are some key features of "Password Repository":

· Native for Mac OS X
· Written using Cocoa
· Easy to use and powerful
· Data encrypted automatically
· Blowfish encryption
· True Mac OS X interface
· Intuitive operation
· Point-and-Click sort
· Find-as-You-Type
· Import from other source via text file
· Export to text file to import in other software.


Limitations:

· You can download Password Repository absolutely for free and start using it right now.
· The version you can download from here is without any restriction and can be used for a period of 10 days.


Whats New in This Release:

· Now has email field to store the email you used to register and the Open url button can also open url without the http:// tag

Image Repository provides a centralized image repository capable of holding thousands of images with keyword/tag-based browsing.

Image Repository is a centralized image repository capable of holding thousands of images with keyword/tag-based browsing and filtering.

Here are some key features of "Image Repository":

· Its goal is to provide you with an easy way to have a centralized image library with thousands of images categorized by keywords, dates, etc.
· It has special handling that lets you browse the keyword space like it was a collection of nested folders. Example: Browse to keyword "Carnivores", you will get the available keywords "Cats", "Dogs", and the selection will narrow down, applying all the keywords you have selected on your path through the keyword space.
· It comes complete with a Kupu "library", meaning you can browse the keywords through the Kupu image insertion dialog to make it easy to locate images even in a large collection of images.
· It has a tagging interface that lets you tag images with a thumbnail like view, and apply keywords to multiple images at once.
· It uses whatever image type you have installed (it does need to be added as an addable type and be able to supply thumbnails like the default Plone image type, though).

Whats New in This Release:

· Added action to register the repository in Kupu. [fschulze]
· Using interfaces, views and adapters in various places to make this more flexible. [fschulze]
· Removed unused code. [fschulze]

HTTP::OAI::Repository is a documentation for building an OAI compliant repository using OAI-PERL.

Using the OAI-PERL library in a repository context requires the user to build the OAI responses to be sent to OAI harvesters.

SYNOPSIS

use HTTP::OAI::Harvester;
use HTTP::OAI::Metadata::OAI_DC;
use XML::SAX::Writer;
use XML::LibXML;

# (all of these options _must_ be supplied to comply with the OAI protocol)
# (protocolVersion and responseDate both have sensible defaults)
my $r = new HTTP::OAI::Identify(
baseURL=>http://yourhost/cgi/oai,
adminEmail=>youremail@yourhost,
repositoryName=>agoodname,
requestURL=>self_url()
);

# Include a description (an XML::LibXML Dom object)
$r->description(new HTTP::OAI::Metadata(dom=>$dom));

my $r = HTTP::OAI::GetRecord->new(
header=>HTTP::OAI::Header->new(
identifier=>oai:myrepo:10,
datestamp=>2004-10-01
),
metadata=>HTTP::OAI::Metadata::OAI_DC->new(
dc=>{title=>[Hello, World!],description=>[My Record]}
)
);
$r->about(HTTP::OAI::Metadata->new(dom=>$dom));

my $writer = XML::SAX::Writer->new();
$r->set_handler($writer);
$r->generate;

Link Repository is a powerful, easy to use bookmark manager for managing and accesing frequently visited Web sites.

Features
Integration with System Tray.
Multiple export formats.
Multiple import formats.
Internet Explorer Favorites support.
Mozilla profile support.
Mozilla Bookmarks support.
Opera Hotlist support.
Captor Group support.

RDF::Sesame::Repository is a repository on a Sesame server.

This class is the workhorse of RDF::Sesame. Adding triples, removing triples and querying the repository are all done through instances of this class. Only SELECT queries are supported at this point, but it should be fairly straightforward to add CONSTRUCT functionality. If you do it, send me a patch.

METHODS

construct ( %opts )
Evaluates a construct query and returns the RDF serialization of the resulting RDF graph. A minimal invocation looks something like:
my $q = qq(
CONSTRUCT {Parent} ex:hasChild {Child}
FROM {Child} ex:hasParent {Parent}
USING NAMESPACE
ex =
);
my $rdf = $repo->construct(
query => $q,
format => turtle,
);

If an error occurs during the construction, an exception is thrown. This is different from some RDF::Sesame methods which return undef.
format

Required: Yes

Indicates the RDF serialization format that the Sesame server should return. Acceptable values are rdfxml, turtle and ntriples.
language

Default: SeRQL

Specifies the language in which the construct query is written. This is only included for forwards-compatibility since the only query language supported by Sesame is SeRQL.

output

Default: undef

Indicates where the RDF serialization should be placed. The default value of undef means that the serialization should simply be returned as the value of the construct method.

If the value is a filehandle, the serialization is written to that filehandle. The filehandle must already be open for writing. Otherwise, the value is taken to be a filename which is opened for writing (clobbering existing contents) and the serialization is written to the file.

query

Required : Yes

The text of the construct query.

extract ( %opts )

Extract an RDF representation of all the triples in the repository. The only required option is "format" which specifies the serialization format of the resulting RDF. The minimal method invocation looks like

my $rdf = $repo->extract( format => turtle )

where $rdf is a reference to a scalar containing the serialization of all the triples in the repository. The streaming results returned by Sesame are handled appropriately so that memory usage in minimized. If the output is sent to a file (see "output"), only one "chunk" is held in memory at a time (subject to caching by your OS). The serialization may also be compressed (or otherwise processed) as its being streamed from the server (see "compress").

Error handling is done differently in this method than in other methods in RDF::Sesame. Namely, if an error occurs, an exception is thrown (rather than returning undef and setting errstr(). Eventually, Id like all methods to behave this way.