An open-source, federated content repository

ModeShape 3.2 and JBoss EAP

Beginning with ModeShape 3.2, we now support installing ModeShape on top of an installation of JBoss EAP 6.1, and we no longer support installing on top of a JBoss AS7 installation. When we announced this change, there was some initial confusion about what this means for community users. Now that we’ve released 3.2.0.Final, I want to repeat that this is nothing but great news for all community users, including those already using JBoss AS7. Let’s look at why this is so.

If you have been following ModeShape for a while, you’ll probably remember that for well over a year we were building a kit that installed ModeShape as a subsystem into an AS7.1.1.Final installation, and that ModeShape then reused the Infinispan subsystem that was included in AS7 as well as all of the configuration and management tooling of AS7. Unfortunately, there were no subsequent releases of AS7.1, which meant that the Infinispan version remained unchanged despite the Infinispan community marching on with many more releases. Essentially, ModeShape was stuck on the same older Infinispan version that was included in AS7.1.1.Final.

Why is that? Well, the JBoss AS community project is focused on rapid development and evolution of features. Meanwhile, Red Hat takes certain community releases of AS and then spends a huge amount of time and effort to test, fix, improve, qualify it and then release it as JBoss EAP. Each EAP release is then supported for many years, making it a very stable platform to run in production.

However, things changed significantly in March 2013, when JBoss announced that it would start making available to the community all of the alpha, beta, and candidate releases for EAP, starting with JBoss EAP 6.1.0.Alpha1. This is a big deal because this makes the stable EAP releases (which are by definition more stable than the upstream community releases) available to the community!

Most ModeShape users want a stable platform in which they can run ModeShape and their services and application. And that’s EAP. So with ModeShape 3.2 we changed our kit to install into the EAP 6.1 platform. It was also a plus that the newer EAP 6.1 releases used some of the latest stable versions of Infinispan.

Now, one of the most-often asked questions centered around whether EAP 6.1.0.Alpha could be used for production. The FAQs make it clear that the answer is that, yes, EAP 6.1.0.Alpha1 (and any other released EAP Alphas) can be used without restriction (other than the LGPL). However, if you desire, you can easily upgrade to a free developer or paid production subscription to use later, even more stable releases.

This is a win-win for all involved. ModeShape gets a more up-to-date server platform while all our users get a far more stable server in which they can deploy their ModeShape-based applications and services!

So give ModeShape 3.2 a try.

Filed under: uncategorized

ModeShape Tools for Eclipse

ModeShape Tools is a set of Eclipse plugins for working with ModeShape and JCR repositories. The plugins have been available for a little while, but we wanted to make sure you knew about them.

Editor for CND files

The first plugin we’ll talk about is an Eclipse editor for the Compact Node Definition (CND) format defined in the JCR 2.0 (JSR-283) specification. Although a client application can connect to a JCR repository and programmatically register node types, it is usually easier to place the node type definitions inside a CND file and to use that file to register all the node types contained within it. ModeShape Tool’s CND editor makes it easy to edit such files.

(The JCR 2.0 API does not define how an implementation should support registering node types via CND files, but many of the implementations have a proprietary way to do it. ModeShape extends the javax.jcr.nodetype.NodeTypeManager interface with several “registerNodeTypes” methods that each take a, a, or an containing CND content. We’re hoping the JSR-333 effort for JCR 2.1 adopts our approach.)

The CND editor is a 2-page Eclipse editor used for editing *.cnd files. The first page is form-based and consists of sections for managing namespace mappings, node type definitions, property definitions, and child node definitions. The second page is a readonly view of the file content.

Take a look at the CND editor with the properties and child node sections collapsed:


When you select a node type, the editor shows the information about that node type on the right side. This includes the node type’s name, attributes, supertypes, and property and child node definitions. Add, change, or remove a property definition or child node definition by double-clicking the particular row in the section’s table or by using the section’s toolbar. Here’s a view of the editor with the properties and child node sections expanded:


The CND editor’s second page is a readonly source view of the *.cnd file. You can control the verbosity of the CND notation by a preference. The source page looks like this:


Here’s a few other features of the CND editor:

  • automatic validation of the CND file, with errors displayed in the header section
  • copy and paste CND elements within the same editor or between CND editors
  • automatic URI completion when adding standard (built-in) namespaces
  • the node type section has a search filter to quickly find and select a node type, even when there are hundreds of node types in the file
  • the ability to show/hide property definitions and child node definitions inherited from supertypes
  • attach comments to any CND element
  • Ctrl-space completion and “look ahead” typing for available supertypes and required types.
  • built-in help

You can read more detail about the CND Editor in our online documentation.

The CND Editor can edit any CND files for ModeShape or any other JCR 2.0 repository implementation. It is also possible to just install just this plugin. So even if you’re not using ModeShape, we think you’ll still find the CND Editor very useful.

Publishing files to ModeShape

The second ModeShape Tools plugin provides a way to upload files from your Eclipse workspace to a ModeShape repository. It can publish entire projects, folders, or just selected files. You select the ModeShape server, repository, workspace, and area within the workspace where the file(s) are to be placed.

To use, simply select the files and/or directories you want to publish, and then choose “ModeShape->Publish” from the context menu. You’ll then see a dialog that confirms the details of the publishing request:


Simply select “Finish” to publish the files to ModeShape.

The publishing tool can also:

  • un-publish (or delete) resources from a publish area of a ModeShape server
  • indicate which files should also be versioned (with “mix:versionable”) when they are published
  • show the output of the publishing operations in the message console view
  • show in a Servers view the repositories, workspaces, and publish areas for multiple ModeShape servers
  • always ignore certain file types from being included in the publishing operations, configured via preferences
  • built-in help


Each of these features can be installed separately or together by following these steps:

  1. Start up Eclipse 3.7 (Juno), then choose “Help > Install New Software…”
  2. Enter and hit “Enter”.
  3. When the site loads, select which feature(s) you want to install, or click the “Select All” button.
  4. Click “Next”, agree to the license terms, and install.

You can read more about ModeShape Tools in our documentation

Want to contribute?

These plugins are open source and are on GitHub, licensed under EPL and LGPL. We’re always looking for contributors to help out. If you would like to contribute, find a bug, want to suggest a new feature, or have any questions, please let us know in our discussion forum and we’ll get you started. The JIRA for these plugins is here.

Filed under: features, news, open source, releases, tools, uncategorized

One CND file or many?

One question people have when starting out with ModeShape and JCR is this:

Should I create one CND file with all of my node types, or should I create multiple CND files?

Naturally, the answer is “It depends”, since there really is no one way that works for everyone. So to help you figure out your own answer, here are several guidelines that we consider. (If you know of others, please let us know in the comments.)

(BTW, do you know about our CND Editor for Eclipse? If not, check it out because it really makes it easy to edit CND files. It doesn’t even require you to have or use ModeShape.)


A single CND file is easy, and can have node type names that use different namespaces. Just look at a CND file with the standard built-in typesWhere possible, keep things simple and use just a single CND file.


Perhaps you have enough node types that it’s becomes harder to keep them all in one CND file. In that case, consider putting semantically-related node type definitions in separate files.


Some node types might be more reusable than others. In this case, consider putting common or more reusable node types in separate files. For example, you might reuse a subset of your node type definitions in multiple repositories. Or multiple applications might need a common set of node type definitions, while also having their own application-specific types.

When you have reusable node types, then you might also want to consider how those common node types are governed. Are they defined by a central group of people? Are they put into their own Maven artifacts that can be easily shared, and if so are they released separately from the applications? These may all affect how you break up those common node types into one or more files.


You may also want to create separate CND files when they’re used/registered at different times. Deployment mechanisms will often dictate the ability or desire to do this.

A ModeShape repository configuration can specify a set of CND files that are to be registered immediately upon startup of the repository. But applications using that repository can also use the JCR API to register new (or updated) node types, too. So you might want some node types to be installed upon initialization, while others might be registered only when the application needs them. You’ll likely want different CND files for each purpose.

Here’s an example. Consider that you have ModeShape installed into an AS7 instance, so the ModeShape repositories are configured as part of the AS7 configuration and started when they’re needed/used. Then web application (or web service) can simply get a hold of the (running) repository via the JNDI, @Resource injection, or RepositoryFactory techniques. In fact, multiple applications can use the same repository. Perhaps some basic node types should installed as part of the repository configuration, while each application (if deployed) can register their own application-specific (or even common) node types.

Filed under: uncategorized

ModeShape 3.0.0.Alpha5 is available

We’re very proud to announce that the 5th alpha release for ModeShape 3.0 is now available. We’ve fixed quite a few issues, but we also added support for participating in JTA transactions (local and distributed). So now it’s a breeze to use JCR repositories from within container-managed EJBs – something that’s even easier when using ModeShape+AS7. Our list of features is becoming quite impressive.

As with the earlier alpha releases, the artifacts are in the JBoss Maven repository (see our Getting Started documentation for all the details). If you don’t use Maven, then look for our downloadable distributions:

Congratulations to the team for all their accomplishments and hard work!

Filed under: uncategorized

ModeShape 3.0.0.Alpha4 is available (with AS7 integration)

We’re very proud to announce that the 4th alpha release for ModeShape 3.0 is now available. Not only have we fixed quite a few issues, but we now can install ModeShape into an existing JBoss AS7.1 installation!

This is really exciting. JBoss Application Server 7 is a blazingly fast, lightweight, clusterable, open source application server that you can run locally for development, in your company’s data center for testing and/or production, or even in the cloud. And with ModeShape’s kit for AS7, you can use AS7 administrative tools to deploy and manage multiple repositories. Your web applications and services can access the repositories by simply looking them up in JNDI or using the JCR 2 RepositoryFactory mechanism and then using the standard JCR API. We even provide a way for your web applications to query repository content with ModeShape’s JDBC driver.

As with the earlier alpha releases, the artifacts are in the JBoss Maven repository (see our Getting Started documentation for all the details). But for this release we also created several downloadable distributions:

Congratulations to the team for all their accomplishments and hard work!

Filed under: uncategorized

ModeShape 3.0.0.Alpha3 is available

Just a quick post to announce the availability of Alpha3 of ModeShape 3.0. It’s in the JBoss Maven repository, and ready for you to give it a spin. Alpha3 fixes fixes for several blocker issues and we wanted to release these as soon as possible. We weren’t able to get the AS7 kit working in time, but we’re close. Look for an Alpha4 release very, very soon.

Several things are not yet working:

  • AS7 kits (as mentioned above)
  • Queries that use full-text search criteria don’t work, and neither does the JDBC driver.
  • Shareable nodes don’t work.
  • The RESTful is working outside of AS7, but the WebDAV service isn’t yet.
  • Federation is not yet working; see this discussion for how we want to expand federation capabilities.

If you find any problems, please report them. Please check the known/open issues before logging bugs.

Our next step is to get the AS7 integration working (we know several of you are waiting for this). But we’ve started getting the TCK test working. We’ll also continue to implement the missing and incomplete features. Stay tuned!

Filed under: uncategorized

ModeShape 3.0.0.Alpha2 is ready

ModeShape 3.0.0.Alpha2 is now available in the JBoss Maven repository, and it’s ready for you to give it a spin. Most of the JCR features are implemented, and this second alpha release fixes quite a few issues and adds support for queries (except for full-text search) and clustering. See our release notes for details. For an overview of what’s new in 3.0, check out our Alpha1 announcement.

There are several things that are not working:

  • Queries that use full-text search criteria don’t work, and neither does the JDBC driver.
  • Shareable nodes don’t work.
  • AS7 kits are minimally complete but probably not usable, since we depend on a slightly different Infinispan version than what is in AS 7.1.1.Final.
  • The RESTful and WebDAV services aren’t working as we’d like, so we excluded them from the alpha.
  • Federation is not yet working; see this discussion for how we want to expand federation capabilities.

If you find any problems, please report them. Please check the known/open issues before logging bugs.

As we mentioned earlier, we’re also overhauling our documentation to make it even more useful. It’s a little sparse at the moment, since we’re focusing on the code. Our What’s New and Getting Started pages are pretty useful, though, and should help you get your testing going. We also have some sample (and stand-alone) example Maven projects on GitHub that you can clone, hack, and use as a template to start putting ModeShape 3 through its paces.

Our next step is to start adding TCK tests and verifying ModeShape behaves properly in as many situations as we can check. We’ll also continue to implement the missing and incomplete features. We hope our next release is a feature-complete beta, so stay tuned!

Filed under: uncategorized

New ModeShape documentation

Over the past few years, the ModeShape community has put together a simple Getting Started Guide and a much more comprehensive Reference Guide. Our goal for the latter was that it would be an asset for users when trying to figure out ModeShape’s features, how to configure ModeShape, or how and why ModeShape behaves the way it does. And over the years, the Reference Guide has become harder and harder to organize and maintain.

So we’re happy to announce that we’re moving our two guides to the new system for projects. There’s now just one link to the ModeShape documentation:

There you’ll find documentation for the upcoming 2.7 release (look for it this week!) and the drafts for the 3.0 release (still under heavy development).

The new documentation system is built with Confluence, and we think it is a great improvement over our older DocBook system:

  • Readers can leave comments. So please leave a comment if you find a mistake, have a tip for other readers, or want to clarify something. (We do prefer that you still use our forum to ask questions or report problems.)
  • Corrections can be made immediately. Right now, only contributors can make changes, but please let us know if you’re interested in contributing.
  • Interactive table of contents. The left hand side of the documentation includes a table of contents that you can collapse and expand as needed, and of course every item is a link.
  • Search. Yup, there’s a search field that only searches ModeShape documentation.
  • Next and previous page links to make it easy to keep reading.
  • Version-specific documentation. This is something that the folks have made possible through some clever extensions. When we issue a release, we can copy the documentation for the latest release and create a new set for the upcoming version.
  • Outstanding editor. Not everyone will see this, but the contributors are going to love the rich text editor and the really nice wiki markup editor.

In short, lots of great new features. You’re gonna love it.

One more thing

Since the upcoming 2.7 release contains mostly bug fixes, the content for the 2.7 documentation will be pretty similar to the 2.6 release docs, except for some formatting improvements, clarifications, and other minor changes and fixes.

However, for 3.0 we’re doing a major overhaul on the documentation. We’re completely reorganizing the content and trying to make it just as useful for new users just starting out with ModeShape as it is for those experienced users that just need to find the details of a particular feature or behavior. For example, we’re creating a new section that just talks about how to use the JCR API.

Have a look, and let us know what you think!

Filed under: uncategorized

Announcing ModeShape 2.5.0.Beta2

ModeShape 2.5.0.Beta2 is now available. This is the second beta release for ModeShape 2.5, and eliminates the dependencies on the JCIP and Google Collections libraries, upgrades to Lucene 3.1 (with fixes and performance improvements), fixes several issues with versioning, improves performance of versioning-related methods, and fixes about twenty bug fixes. For details, see the release notes for Beta2.

If you recall, 2.5.0.Beta1 added used a new build process via Maven 3, added several javax.jcr.Credentials classes for easier anonymous and HTTP servlet authentication, added a built-in profiling framework enabling use of Byteman runtime bytecode injection, improves performance in several areas (including saves, imports, and startup), and fixes almost two dozen bugs. For details, see the release notes for Beta1.

The 2.5.0.Beta2 release is available in the JBoss Maven repository (see our Maven instructions) and on our downloads page. Give this release a spin, and let us know what you think!

We’re currently planning one more beta release in about 3-4 weeks followed by a final release about 2 weeks later.

Thanks to the ModeShape community of users and developers. Keep finding and reporting (and fixing!) those issues!

Filed under: uncategorized

Announcing JBoss DNA 0.6

We’ve just released version 0.6 of JBoss DNA. It’s in the JBoss Maven repository and in our project’s downloads area. Of course, our Getting Started guide and Reference Guide are great places to see. And we always have JavaDocs.

This release brings a lot of fixes and a number of really great new features. We’ve actually done a fair amount of additional integration, and we’re getting great feedback from our user community. Thanks to all the JBoss DNA team for all the hard work!


JBoss DNA is a JCR implementation that provides access to content stored in many different kinds of systems. A JBoss DNA repository isn’t yet another silo of isolated information, but rather it’s a JCR view of the information you already have in your environment: files systems, databases, other repositories, services, applications, etc.

We’re a little closer to JCR’s Level 1 and 2 compatibility, and in fact we’re now running the compatibility tests against multiple sources, including a simple transient in-memory store, JBoss Cache, Infinispan (see below), and relational databases (using our JPA/Hibernate connector). We also are running the read-only tests using the file system connector and the SVN connector. In short, JBoss DNA can be used as a JCR repository with a variety of storage systems and back-ends, including a combination using our federated connector.

Last release we rewrote the federation connector to use a fork-join type algorithm for parallel execution and pushdowns. This release we’ve started using the federation connector in all JCR Session and Workspaces. You see, every JCR repository can have multiple workspaces, but each of those workspaces has a “/jcr:system” branch that provides access to the repository-wide settings and metadata, including node types, namespaces, versions, etc. There really is just one of these system branches in the whole repository, so we’re using the federation connector to project that system content into each session. What’s so great is that this fits one of the federation connector’s ideal content patterns (known as “mirror-branch“), so it actually is very efficient and fast.

Infinispan Connector

There is also a new connector that allows you to store repository content using Infinispan. The Infinispan project is doing some really fascinating work to create a highly scalable, distributed, and highly available data grid platform. By using Infinispan with JBoss DNA, your application can use the JCR API to access and manage its content, while behind the scenes JBoss DNA stores this content in the Infinispan data grid. Couple this with federation to give your application easy access to all kinds of data, regardless of where that data lives.

Subversion Connector

We’ve made a number of improvements in our SVN connector, which allows you to use the JCR API to access the files stored in an SVN repository. The files appear as “nt:files” and “nt:folders” in a JCR repository. It actually is very slick, though it’s not currently operating that quickly. But that’s already on our radar for the next release.

What’s next

We actually were hoping to get query and search support in this release, and while we are about half-way done with this features, we put it on hold so we could get 0.6 out the door. Search/query (plus a few open issues) will bring us the rest of the way to JCR Level 1 and Level 2 compliance. Plus, we’re also planning on getting versioning completed as well as finishing observation. And with that will be our 1.0 release.

Stay tuned for additional posts describing what’s possible with JBoss DNA and Infinispan, as well as a lot more detail on the upcoming search and query feature.

Filed under: jcr, news, repository, uncategorized

ModeShape is

a lightweight, fast, pluggable, open-source JCR repository that federates and unifies content from multiple systems, including files systems, databases, data grids, other repositories, etc.

Use the JCR API to access the information you already have, or use it like a conventional JCR system (just with more ways to persist your content).

ModeShape used to be 'JBoss DNA'. It's the same project, same community, same license, and same software.