Free jcr software for linux

Java::JCR is a module to use JSR 170 (JCR) repositories from Perl.

SYNOPSIS

use Java::JCR;
use Java::JCR::Jackrabbit;

my $repository = Java::JCR::Jackrabbit->new;
my $session = $repository->login(
Java::JCR::SimpleCredentials->new(username, password)
);

my $root = $session->get_root_node;
my $node = $root->add_node(foo, nt:unstructured);
$node->set_property(bar, 10);
$node->set_property(baz, blah);
$node->set_property(qux, 4.8);
$session->save;

The JSR 170 specification describes a Java-based API for access hierarchical databases. This is generally referred to by the abbreviation JCR, which is an abbreviation for Content Repository API for Java Technology Specification.

The biggest OSS implementation, as of this writing, is Jackrabbit, which is a project at the Apache Software Foundation, http://jackrabbit.apache.org/. Currently, this library allows Perl programmers to develop using the JCR and Jackrabbit, though, theres no reason why connectors cant be written for other implementations, such as Jaceira, CRX, eXoplatform, etc. The JCR library wrappers included are not at all specific to Jackrabbit.

Java::JCR::Nodetype is a Perl module that can load the JCR node type class wrappers.

SYNOPSIS

use Java::JCR::Nodetype;

This loads the Perl classes mapped to the javax.jcr.nodetype package.
You might notice the odd letter case of this package differs from that of the node type class (Java::JCR::Nodetype::NodeType). This has to do with the way the package was imported. This may be corrected in the future.

Java::JCR::Workspace is a Perl wrapper for javax.jcr.Workspace.
This is an automatically generated package wrapping javax.jcr.Workspace with a nice Perlish API.
For full documentation of what this class does, see the Java API documentation: http://www.day.com/maven/jsr170/javadocs/jcr-1.0/javax/jcr/Workspace.html
The deviations from the API documentation include the following:
- You will need to use Perl, intead of Java, to make any use of this API. (Duh.)
The package to use is Java::JCR::Workspace, rather than javax.jcr.Workspace.
- All method names have been changed from Java-style camelCase() to Perl-style lower_case().
Thus, if the function were named getName() in the Java API, it will be named get_name() in this API. As another example, nextEventListener() in the Java API will be next_event_listener() in this API.
- Handle exceptions just like typical Perl. Java::JCR::Exception takes care of making sure that works as expected.

Jeceira provides an implementation of JCR (JSR 170).
Jeceira is an implementation of JCR, the Content Repository for Java Technology Specification (JSR 170).
Its goal is to create a freely available, fast, and extensible layer for various content dependent applications to build upon.
Enhancements:
- Observation implemented
- Configuration of UUID generator simplified (no jug-native directory required)
- Node.orderBefore revised (including changes in the database schema)
- Bugfix in saving items (new items could be saved by calling save on them)
- Bugfix in counting of changes pending in a session
- Package item refactored
- Dependency on commons-0.1 changed to commons-0.2 due to a bugfix in the
- commons module

palaver is a multi-user chat component for Jabber and XMPP servers. The intention for this project is to support all features of JEP-0045 as well as the relevant extended discovery features of JEP-0128.

palaver is written in Python using the Twisted framework for Internet applications. It is licensed under the open source MIT license.

The main inspiration for writing palaver was to replace JCR mu-conference. While mu-conference has served the community well, its lack of maintenance has left many searching for a replacement.

Currently all basic multi-user chat features are supported, including some extra things like ban lists. More features are on the way, and the intention is to fully support the entire protocol.

palaver is licensed under the MIT open source license. It is free to use, modify and distribute by commercial and non-commercial users and developers.

Shotoku is designed to provide easy access to content repositories in which you can store data, revision content, bind metadata, and provide branching and merging strategies.
This means Shotoku can interface with repositories such as the Java Content Repository (JSR 170: JCR), Subversion, and file-system based repository implementations that aim to support basic revisioning mechanisms.
Main features:
- Three content managers: the first and default SVN-based, JCR-based and a local file system repository.
- Because a local working copy is present, data reading is very fast (SVN repository implementation).
- Data writing is reliable, because data is sent straight to the repository, without touching the working copy (SVN repository implementation).
- Shotoku can work in "embedded" mode in stand-alone applications, as well as a component in an application server.
- Shotoku allows you to "inject" content into any POJO using annotations (currently supported only in app server mode). POJOs which are Shotoku aware are automatically updated when a user updates a node in a Subversion repository Shotoku is configured to reference. Content can be anything and there are no structural requirements placed on the repository - even existing Subversion repositories can be referenced by Shotoku without modification.
- A simple search mechanism.
- Integeration with Apache Velocity - you can easily store templates in Shotoku to create higher level application features such as content and blog engines.
- Feeds component - automatic generation of rss, atom and rdf feeds/ podcasts, configured through a xml file, together with arbitrary feeds aggregation. You can see feeds already at work on JBoss Labs - just click the "Feeds" link in navigation or simply here.
- Blog component.
- A simple cache with "renewable" values - a value can be updated on regular intervals of time or when some of watched resources in a content manager change (see wiki for details).