Free ubuntu tweak repository software for linux

Ubuntu LiveCD Creator proposes a set of tools and graphical user interface to create and maintain custom Ubuntu LiveCDs.
LiveCD tools should provide a robust enough environment for the Ubuntu developers to generate the official CDs from them. Required functionality includes:
- Creating LiveCDs based on templates, such as bare minimum installing ubuntu-minimal
- Selects repositories
- Selects default packages
- Adjusting the packages on the LiveCD by adding or removing through a Synaptic-like interface
- Adding files directly to the LiveCD just before finalizing
- Modifying the default X11 environment
- Execute a GNOME, KDE, or XFCE log-in in Xnest
- Save the home directory as the /etc/skel
- Saving and updating LiveCD templates
- Save the package list, /etc/skel, and additional files
- Update by adjusting repositories and performing upgrades or dist-upgrades
- Adding the Ubiquity installer

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.
Main features:
- 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).
Enhancements:
- 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]

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

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.

guglhupf commons resource repository is a tool that manages dependencies between program resources (e.g., Java jar files).
guglhupf commons resource repository comes with a mechanism to download needed resources from a central repository and stores these resources in a local repository. This allows reuse of resources between different projects.
Main features:
- Central resource repository to share resources between multiple projects.
- Needed resource are downloaded and stored in a local repository.
- Dependencies between resources are solved.
- Setup the classpath with all needed resources (jars).
- Start java progams with the needed resources.
- Ant integration to setup the classpath.
- Modular ant build script support
- Eclipse classpath builder to setup the classpath in eclipse.

Ubuntu Multimedia Center is a complete Linux-based operating system, freely available with community and professional support. Ubuntu Multimedia Center is developed by Zach Thibeau but I want you to participate too!

WARNING! Users in countries that dont allow use of mp3 playback or DVD playback are advised to remain using the regular release of Ubuntu.

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.