netzooid

There have been several calls for an open repository API based on AtomPub over the past few months, starting with Anne Thomas Mannes and the latest being Glen Daniels’.

I think now is probably the time. From a personal point of view, I’ve been holding off until we got Galaxy 1.0 out the door so we could learn more about how it should be done and the scope of it.

This is all of course my own personal opinion at this point and is likely to change, but I outline it here so other people can have an idea of what I’m thinking.

Scope

• Should be built on AtomPub
• Define a way to deal with hierachical collections of versioned resources. That is, we need a standard way to model folders and files in AtomPub. This would be of benefit to a lot of people.
• Define a standard way to query for resources. I’m not sure how much specifying will need to be done here, it should be based on OpenSearch and AtomPub. A good use case is being able to search for a WSDL from an IDE and generate a client for it. Another use case might be to be able to download an application (= set of resources) using a query and start it.
• This may not need to be a spec like AtomPub is a spec. Since we will be using a lot of standard tools, this may be as simple as saying “yes we’re ALL using these things (AtomPub, OpenSearch, etc) in the same manner and here’s how the big picture comes together”

Not in scope

Or at least a separate optional specification:

• Dealing with metadata about artifacts (although I’m tempted to roll this into the above)
• Lifecycle management
• Dependency management

Participants

Besides WSO2 who I’ve talked with about this before, I would think the following open source projects may be interested as well:

• JBoss Drools BRMS team
• Sonatype’s Nexus team - they’ve expressed interest in having an AtomPub API to browse their repository/metadata
• IDE developers (NetBeans, Eclipse) - we definitely could use some IDE plugins.
• Anyone else who wants to have a say

Next Steps

We should probably set up a mailing list and wiki. Maybe at the Codehaus? We can then figure out where this thing goes from there.

I’m doing two talks in the coming months on the rise of AtomPub - one at Jazoon in June and a BOF at JavaOne in May.

Its interesting to watch AtomPub work its way through the enterprise a bit. I’m hearing many reports of people who have AtomPub services in production, people are building services, and those who are evaluating it.

If you’re using AtomPub for your company, shoot me an email. Its nice to learn from other experience beside my own and spread the wealth of knowledge about how to use APP.

After many months of refactoring and much incubator pain (I now understand the rules to get a release out of the incubator - at least until they change next week ;-)) - the Abdera 0.4.0 release is out!

I’m pretty excited about this. I’m hoping it’ll enable developers to build AtomPub services much more easily. Which means we could see a lot more AtomPub servics crop up. I’m already hearing from people inside big enterprises who are developing their services using AtomPub instead of a custom RESTful service or SOAP service.

This also sets us on the road to 1.0 and graduation. I have two things on my list for 1.0. First, I’ve written a small XHTML databinding thingy using XStream. We don’t quite have the proper hooks in Abdera though. Second, I would to ensure that the ManagedProvider (i.e. the out of the box adapters for JDBC, JCR, Filesystems, etc) work well with the Spring configuration.

Update: please check out the wiki for documentation. We’re in process of revamping the website.

I finished up the first draft of a guide on how to develop your first AtomPub service with Abdera. This shows the much simplified server code base in action, so beware - this requires the latest trunk/ code. 0.4.0 should be out soon though.

There is definitely more one way to skin a cat and develop services with Abdera. But, I’m kind of fond of the above method if you’re integrating with some existing application and are not looking for just a generic Atom store.

Feedback/comments welcome.

I’m happy to announce the availability of the Galaxy 1.0-beta-2 release. Galaxy is our open source governance platform which is just a fancy of way of saying, its an open source registry/repository. There are some cool new features in this release….

Mule NetBoot

You can now boot a Mule instance directly from the repository. You simply upload a Mule distribution to the repository and then use Mule NetBoot to boot this instance over the network. This can greatly simplify deployments.

Maven Publish Plugin

The Maven Publish Plugin allows you to easily push resources and artifacts from your build to the repository as part of the release cycle. You can publish individual resources, your project’s jar, and/or your project’s dependencies. This works great with Mule NetBoot…

XML Schema Support

We now index XML schemas. Which allows you to do things like this.

Improved AtomPub API

The number of things you can do with the AtomPub API has been greatly expanded. It features a much improved URI space which allows you to do a number of things you couldn’t do before:

• List individual workspaces easily (No more GQL needed)
• List child workspaces
• Add/delete workspaces
• Edit artifact metadata
• Edit artifact lifecycle information

Feedback

Your comments, suggestions, criticisms, etc are all very welcome. Please sign up for the mailing list and let us know what you think!

I feel the need to repost my latest posting from The Server Side here…

James Watson writes:

Personally I would like to see a good open source framework for REST based web services. I’m not sure if it’s the way to go but WSDL 2.0 spec should theoretically support REST. I’m unaware of any tools that help with creating these types of WSDLs.

Don’t use WSDL 2.0 for REST. It’s an ugly way of doing RESTful services IMNSHO. There are plenty of great toolkits out there for helping you build RESTful web services. The ones I have my eye on are:

• Restlets
• JAX-RS RI - aka Jersey allows you to build services easily with annotations. CXF has support in the works too.
• Apache Abdera - Build AtomPub services with Abdera. These are quite powerful…

Please keep in mind that REST and SOAP programming models don’t mix well. There is this complete fallacy going around (I succumbed to it too at one point) that you can use the same service class or description to build a RESTful and a SOAP based service. However, the interactions and mappings should end up being completely different from one to the other! One is message based and one is resource based. You’re going to have to design your service differently as they’re two completely different beasts.

Use the best tool for the job. You’ll save yourself time and a lot of hassle.

If you are producing an Atom feed, make sure your IDs are properly unique! I recommend reading this if you haven’t already.

Thank you Mark.

Now that Galaxy is announced, I can unleash my fury of blogging again. Or, as we all know will probably happen, I can blog just slightly less sporadically again.

One of the recent posts I’ve wanted to comment on is Atom is the New JCR (prompted by Sam Ruby). Adrian Sutton writes:

When the Java Content Repository (JCR) standard first came out it was supposed to bring in a new era of compatibility between content repositories and put an end to the content silo. There was, and still is, a lot of talk about it and just about everyone added JCR compliance to their marketing materials. Unfortunately, that’s mostly where things stopped - the implementation work that followed was generally done was buggy or incomplete and the only viable JCR implementations that I’ve seen have come out of Day Software, who lead the JCR spec effort.

We use JCR inside Galaxy for all our storage needs at the moment. Using it has been an interesting experience to say the least. One of my favorite “features” of JCR has been the fact that you can not have two seperate threads create a child node with the same name at the same time. Which means in our activity log, we can’t add two nodes called “/activity” to “/activities” at the same time.
The main reason we decided to go with JCR is that it supports both simple database type data and file type data via the same interface transparently. I’m not 100% sure it was the right choice though. I had to write an ORM like framework as the one in Jackrabbit seemed pretty immature and I didn’t have time to delve into the rabbit hole of the jcr-mapping module in Jackrabbit. Mine is limited but as least I could figure out how to use it. We’ll be reevaluating this for the future though now that Jackrabbit 1.4 is nearly out.

Adrian continues:

Then along came Atom which is all about remote access and manipulation of data and missing probably 90% of the functionality that JCR offers. It really isn’t a competitor to JCR at all and yet it’s doing more to break down content silos than JCR ever has. Atom support isn’t just being added to the marketing materials, it’s actually shipping and is usable in a lot of places - IBM’s Lotus Connections has Atom APIs to everything and, as best I can tell, only Atom APIs to it’s repository.

I completely agree that JCR isn’t very worthwhile as something that will break down content silos. It does have value as an API to work with data though. Atom is quite limited in the granularity it can work with data (which coincidentally is one of the reasons Web3S exists as well). And you still need to store your data somewhere.

Atom has not replaced JCR it has supplemented it. We use JCR as a content store for Galaxy. I’ve also written a generic JCR content store for AtomPub inside of Abdera. Sure, the vendor promises are probably wrong about the content-silos, but it sure simplifies some things when writing applications - which is what really counts!

Update: David Nuescheler has written a great follow up to this whole discussion.

Also, Jackrabbit 1.4 is out. 

AtomPub services documents return a content type of application/atomsvc+xml. How does one tell Firefox to just view this in the browser and NOT save it to disk? This question came up on the Abdera list as well, but no one had a good solution.

I presented my talk yesterday on AtomPub. You can find the slides here.

Its been quite interesting to research and I’ve learned a lot about building services on the web. Thanks to James Snell and others on the Abdera list for helping me with some larger APP questions that I had. The answers were worked into this presentation.

While APP is not the one true protocol, I think I’m hooked. I’ve been doing a fair amount of work on Abdera in my spare time and have put together a Mule Abdera transport as well. It makes it pretty trivial to consume feeds, publish entries and build services with Abdera. One of my broader goals is to make integration as easy as possible with HTTP for those bringing together a variety of platforms and systems. Mule is a great platform to help do that, but more details on that next week when I have more time to write!

The other talks at the QCon SOA track were great. I thoroughly enjoyed all of them and it was probably one of the best tracks I’ve ever attended. Some highlights:

• Sanjiva being heckled in every talk about WSDL
• Pete Lacey’s discussion of Microformats. I don’t know that it all really clicked for me until yesterday.
• Jim Webber’s non-family friendly version of REST which was hilarious
• Steve Vinoski’s use of the word serendipitous which will most certainly be a larger part of my vocabulary now