Blogging Roller

It's been a while since the BETA (over 6 months) but we now have a release candidate for Apache Roller 5.0 available for testing. This site is running Apache Roller 5.0 RC1 right now, as you can see in the itty bitty screenshot below:

Here's a What's New in Roller 5.0 page that summarizes what has changed since 4.0. One thing I forgot to mention on that page was that Roller now uses ROME Propono 1.0 for AtomPub and Roller 5.0's AtomPub support has been successfully tested with MarsEdit and Windows Live Writer.

<img src="http://rollerweblogger.org/roller/resource/rome-logo.png" alt="ROME logo" align="right" vspace="10px" hspace="10px" />

Yesterday I wrote about OAuth support in the upcoming Roller 5.0 release. Today I'm following up with a post about OAuth support in ROME Propono.

As you may remember, ROME Propono is a subproject of ROME, the Java-based RSS/Atom feed library. ROME Propono includes an AtomPub server library and an AtomPub client. I added OAuth support to the AtomPub client and in this post, I'll show how you can use it to post to the Roller 5.0-dev (i.e. the snapshot build that I made available yesterday).

ROME 1.0 and coming soon: ROME Propono 1.0

In case you haven't already heard, thanks to the recent hard work of Nick Lothian, ROME 1.0 is now available. You can find downloads at rome.dev.java.net and a list of changes in the Change Log there. To celebrate this momentous event, I'm planning on releasing ROME Propono 1.0 as well, and in preparation, I've made a release candidate available. The new Propono includes ROME 1.0 and support for OAuth. You can get it via the links below:

rome-propono-1.0RC1.tar.gz (2.0 mb)

rome-propono-1.0RC1.zip (3 mb)

Posting to Roller via AtomPub and OAuth

To use the Propono AtomPub client, you place the Propono jars in your Java VM classpath and then call the AtomClientFactory to get started, as described in the ROME Propono 1.0 Javadocs.

Below is a Groovy example that shows how to post a blog entry to Roller via AtomPub and OAuth. You can get the consumer key, secret and URLs you need to call your instance of Roller from the OAuth Credentials page in the Roller admin interface.

  import com.sun.syndication.propono.atom.client.*
  import com.sun.syndication.feed.atom.*

  def authStrategy = new OAuthStrategy(
    "roller",                               // username
    "55132608a2fb68816bcd3d1caeafc933",     // consumer key
    "bb420783-fdea-4270-ab83-36445c18c307", // consumer secret
    "HMAC-SHA1",                            // key type
    "http://blogs.example.com/roller-services/oauth/requestToken",
    "http://blogs.example.com/roller-services/oauth/authorize",
    "http://blogs.example.com/roller-services/oauth/accessToken")

  // get the AtomPub service
  def appService = AtomClientFactory.getAtomService(
    "http://blogs.example.com/roller-services/app", authStrategy)

  // find workspace of my blog
  def blog = appService.findWorkspace("Blogging Roller")

  // find collecton that will accept entries
  def entries = blog.findCollection(null, "application/atom+xml;type=entry")

  // create and post an entry
  def entry = entries.createEntry()
  entry.title = "TestPost"
  def content = new Content()
  content.setValue("This is a test post. w00t!")
  entry.setContent([content])
  entries.addEntry(entry)

If you have questions or feedback about ROME Propono 1.0 RC1, please post them to the ROME dev mail list and I'll do my best to respond there.

Good news for ROME fans. Nick Lothian picked up the puck and is galloping towards the finish line (sorry, I'm terrible at sports analogies).

Nick Lothian on ROME dev:

I've gone and built some preview jars for the upcoming ROME 1.0RC2, ROME Fetcher 1.0RC2 and Modules 0.3 release.

Those jars can be found here: https://rome.dev.java.net/servlets/ProjectDoc...

I've created source and javadoc jars as well as the normal jars - the idea being that I'll get them uploaded to some maven repository.

If you have some spare time, please take a look at these and test them and let me know of any problems. Assuming there are no big issues found I'd like to do a proper release in a couple of days.

Guess that means I should test Propono with RC2.

Congratulations to the Apache Abdera team, who've just graduated to full Apache top level project status. The don't have the new site at abdera.apache.org up yet and they're still not quite at 1.0 yet, but this is a major milestone. They've got the best Atom format and protocol toolkit around, in my opinion.

via Garett and James.

Nick Lothian tweeted about this JavaOne presentation on LinkedIn because it mentions the ROME RSS/Atom feed parser. I'm really sorry I missed it at JavaOne. What's particularly interesting to me are the diagrams that explain how the LinkedIn architecture has evolved to scale up to 22 million users. Here's an example:

<img src="http://rollerweblogger.org/roller/resource/linkedin-today.png" alt="LinkedIn architecture diagram" />

Apparently, I spoke to soon about ROME being in maintenance mode. There's an all-new Yahoo Weather module for ROME from Robert "kerbernet" Cooper.

For Java developers starting out with RSS and Atom, here are some notes to help you figure out the differences between the Java.net ROME and Apache Abdera (incubating) projects.

ROME is a set of Java tools for parsing, fetching and generating all forms of RSS and Atom feeds. The core ROME library is relatively small and depends only on the somewhat creaky old JDOM XML parser. Available separately are modules to support various feed extensions such as OpenSearch, iTunes, GeoRSS, etc. ROME was originally developed and open sourced by Sun Portal dev team members in 2004.

ROME Propono is a subproject of ROME that supports publishing/editing entries and files to blog servers and AtomPub servers. Propono is made up of three parts: 1) a Blog Client library can publish via either the old lagacy MetaWeblog API or the shiny new AtomPub protocol, 2) an AtomPub client that publishes only via AtomPub and 3) a framework for creating AtomPub servers. Propono was developed by Ramesh Mandava and Dave Johnson, based on code from RSS and Atom in Action and open sourced as part of the Sun Web Developer Pack in 2007.

Abdera is a set of Java tools for working with Atom feeds and AtomPub protocol. This includes a parser, writers, an AtomPub client and a framework for creating AtomPub servers. Abdera's Atom feed parser uses STAX, so it uses less memory and is faster than ROME. Abdera's Atom feed support is more comprehensive than ROME's and it supports signatures, encryption, Atom to JSON, extensions for Threading, Paging, GeoRSS, OpenSearch, GoogleLogin, etc. etc. Abdera was developed by IBM and contribued to Apache in 2006.

Now let's compare frameworks. The pros and cons of ROME are:

• Pro: complete RSS support, all of the dozen various flavors
• Pro: it's generally simple and small, depending only one jar (JDOM)
• Pro: easy to understand and use the AtomPub server framework
• Pro: MetaWeblog API support
• Con: Atom feed support not as comprehensive as Abdera
• Con: parser uses lots of memory, slower, JDOM based
• Con: community not as active, seems to be in maintenance mode (See also Ohloh stats)

The pros and cons of Abdera are:

• Pro: comprehensive Atom feed support, lots more Atom extensions
• Pro: faster more efficient parser
• Pro: In the Apache Incubator with active and growing community (See also Ohloh stats)
• Con: lots of dependencies
• Con: AtomPub server framework poorly documented, overly complex (rewrite coming soon)
• Con: no RSS support (there is something in Abdera contrib, but it's incomplete).

There you have it. ROME and Abdera folks: think that's a fair comparison? Are you a ROME or Abdera user? How would you like to see these frameworks move forward?

<img src="http://rollerweblogger.org/roller/resource/rome-logo.png" alt="ROME logo" align="right" />

The first release to discuss is ROME Propono, which includes a ROME based Atom protocol client library, Atom protocol server framework and an Blog Client library abstraction that supports both Atom protocol and the MetaWeblog API.

I've been working on Propono 0.6 off-and-on since May, keeping it in sync with the latest version of the Atom protocol, testing it against Tim Bray's APE and adding various improvements needed in my other projects. Over the weekend I finally had enough time to get a release out. You can find the full-details at the link below but basically this release adds support for the final Atom Publishing Protocol specification and better support for relative URIs.

• ROME Propono 0.6 release notes / change list
• API documentation
• Propono 0.6 Binary tar.gz
• Propono 0.6 Binary zip
• Propono 0.6 Source tar.gz
• Propono 0.6 Source zip

What's next? Once ROME 1.0 is released Real Soon Now, I'll get a another release out and I'll probably call it ROME Propono 1.0.

I wasn't paying attention and this one snuck-up on me. Today at noon Pacific Time there will be an online Atom Publishing Protocol interop event. The location is IRC on the Freenode network in the #atom channel: irc://irc.freenode.net/atom.

I'm really glad I didn't miss this announcement because I spent much of the last two weekends updating the <a href= "https://rome.dev.java.net/apidocs/subprojects/propono/0.5/overview-summary.html"> ROME Propono and <a href= "http://cwiki.apache.org/confluence/display/ROLLER/What%27s+New+in+Roller+4.0">Apache Roller 4.0 implementations to work with the final version of APP (draft #17). I've got both implementations online now and ready for interop.

And in kinda sorta related news, one of the founders of the Atom effort Joe Gregorio is leaving IBM and heading over to Google. Congratulations Joe! I hope this doesn't mean you'll be leaving the Triangle behind.

ROME Propono 0.5 is a minor bug fix release of Propono. You can get the release files and updated Javadocs from the Propono 0.5 release page.

Following up on the APP interop event last week, here are the ROME Propono APP client issues we found: 

• ROME #66 BUG - don't expect entry to be returned from update (FIXED)
• ROME #67 BUG - handle relative URIs in Service Doc
• ROME #68 BUG - handle out-of-line categories in Service Doc
• ROME #69 RFE - use pluggable auth. scheme w/Google and WSSE support
  

And here are the Roller APP server issues:

• ROL-1393 BUG - attributes in service doc should not be namespaced (FIXED)
• ROL-1394 BUG - wrong content-type for service doc (FIXED)
• ROL-1395 BUG - support slugs for entries too
• ROL-1396 RFE - RSD support, auto-discovery for APP
• ROL-1397 BUG - null byte 0x0 getting into entry contents

I plan on fixing the Roller issues for this summer's Roller 4.0 release. I won't have time to fix the Propono issues for the upcoming Propono 0.5 release (due this week), so they'll be in 0.6 sometime after JavaOne.

I'm happy to announce the first release of the ROME subproject Propono. Propono is a ROME-based Java class library that supports publishing protocols, specifically the Atom Publishing Protocol and the legacy MetaWeblog API. Propono includes an Atom client library, an Atom server framework and a Blog client that supports both Atom protocol and the MetaWeblog API.

Here's the project page
  http://wiki.java.net/bin/view/Javawsxml/RomePropono

Here's the Propono 0.4 release page:
  http://wiki.java.net/bin/view/Javawsxml/RomeProponoRelease04

And here's a link to the API docs, which include details, diagrams and code examples:
  https://rome.dev.java.net/apidocs/subprojects/propono/0.4/overview-summary.html

I'll be testing Propono this week and next (at the Google-hosted APP interop meeting) so now is a great time to provide feedback and bug reports. I plan on releasing Propono 0.5 in the *very* near future.

The Sun Web Developer Pack (SWDP) finally uncloaked today, so I can talk a little more openly about what I and my Java EE co-workers have been working on. You can get the full scoop at the SWDP site, but basically SWDP is a bundle of technologies to help developers build "Web 2.0" or next-generation web applications on the Java platform. Ajax, scripting languages, REST and of course RSS/Atom are all part of that. The RSS/Atom bits are ROME 0.9 (Beta), Blogapps 2.0 (Early Access) and a ROME-based Atom Server kit based on code from Roller.  There are also example Atom server implementations in the REST API and Phobos components of the pack.

I'm pretty excited that we're putting some resources behind ROME and that both ROME and Blogapps are part of SWDP R1, but I'm even more excited about the next release. In R2 we'll drop the Atom Server Kit and Blogapps BlogClient and we'll replace them with ROME Propono a brand new Atom protocol client and server library that we're getting ready to contribute to the ROME project.

I haven't had a whole lot of time to experiment with the various components in the pack, but I have played with Phobos and I think it's pretty compelling. Phobos is a "lightweight, scripting-friendly, web application environment." It's not just for creating server-side JavaScript applications, but that's the angle the I find interesting. So many developers are creating JavaScript/Ajax applications these days that working in JavaScript on both client and server-sides makes sense -- especially when you can debug into JavaScript code in your IDE as you can with the Netbeans Phobos module. Also note that the jMaki Ajax components work with JSP, PHP and Phobos -- jMaki and Phobos look like a winning combination.

In case you're wondering what's going on lately with Roller, ROME and other projects I've been working on, here's a status update from my point-of-view.

Apache Roller graduation. The Roller team voted for graduation, the Apache Incubator PMC voted for incubation and the next step is to take the resolution to the Apache board meeting, which is coming up in the next week or so.

Roller 3.1 release. We've been moving slowly on this one. RC1 was released Nov. 20 and today RC4 just about ready to go. It's possible that 3.1 will be our first "official" Apache Roller release -- depending on what happens on the board meeting. Wonder what's coming in Roller 3.1? The What's New in Roller 3.1 page is now available on our new wiki at apache.org.

Roller 4.0 development. We started the Roller 4.0 branch a couple of weeks ago and I've been spending most of my time updating and trying to perfect Craig and Mitesh's new JPA back-end. Elias outlined a bunch of IBM contributions including an iBatis based back-end. We hope to get some of those in the 4.0 and do some JPA vs. iBatis testing, but we haven't seen any proposals or code yet.

Roller-Planet. Actually, Allen's taken over work on Roller-Planet and he's implementing many of the things I outlined in the Roller-Planet mind-map. He promoted Roller-Planet from the sandbox, built a nice Struts2 UI, added a Roller-style feed/page rendering system and Roller-style caching. Good stuff. We have not discussed when to start making standalone releases of Roller-Planet. 

ROME Propono. I've been working on a new ROME subproject called Propono that will include a blog client library, an Atom protocol client library and an Atom protocol server kit. I've been quiet on the ROME dev list, but I've been working on the client bits an they're basically done. I'm waiting for final approval to commit them to ROME CVS.

Blogapps examples and server. I'm still working on a 1.0.5 release, which will include updated Atom protocol support and some bug fixes. I just haven't had the time to get a release out, but I have had some time to work on Blogapps 2.0 where I've ditched the chapter-based directory names and switched to org.blogapps packaging. Once ROME Propono is available, I'll include it in Blogapps 2.0 and drop my old Blog Client library.

Lots of good news and stuff to blog this past week including the Sun makes a profit story, the Sun-Intel deal and more. I really like reading news like this Amid Profit, Brighter Days for Sun and this Sun turns profit after five quarters in red.

And how could I fail to mention the announcement of Lotus Connections, the product formerly known as Ventura. Connections is IBM's new Web 2.0 social networking suite and it includes Roller. IBM's James Snell posted some background info about IBM's internal use of social networking tools and how that led to Lotus Connections. Elias Torres blogged about it too and included a screen-shot of the new Connections based BlogCentral (IBM's internal blogging site).

And in other news...

My ApacheCon EU talk on 'Roller and Blogs as a Web Development Platform' was accepted. Looks like I'll have a busy May, Amsterdam for ApacheCon and (hopefully) San Francisco for JavaOne all in the space of two weeks.

Wordpress is finally gonna get Atom format support and apparently Atom protocol support is going to happen too.

The ROME project is just about ready for ROME 1.0 and there's a new subproject in the works: ROME Propono. co-worker Ramesh Mandava and I are putting together a Blog Client library (based on code from Blogapps) and an Atom client/server library (based on code from Roller). Hopefully, we'll have it ready by the time that ROME 1.0 comes out.

A new release of the RSS and Atom Utilities (ROME) project ROME 0.9 (beta) is now available on the project's Java.net website. This new release includes fixes to Atom relative URI resolution, easier parsing for RSS feeds that use <content:encoded>, better support for mapping of RSS to and from Atom and numerous small fixes. [Read More]

The ROME mailing list has been a little quiet lately. I'm hoping to change that. Roller's built-in planet aggregator uses ROME, Roller's Atom protocol implementation does too and I recommended ROME in my book, so I'd really like to see ROME continue to improve and grow. Now that I'm focusing on a standalone version of Roller-Planet, I've got some time to devote to those goals. Last week I cleared the bug list, this week I committed some improvements to ROME's summary/content handling and next I'd like to start pushing for a ROME 1.0 release. If you'd like to see ROME thrive, please join the fun.

Looks like Elias had a fun weekend creating Pundit's Monitor, a political blog monitoring tool using a heap of Java tech: the Nutch search engine/web crawler, Burton's TailRank FeedParser for auto-discovery and ROME for feed parsing (though he doesn't mention that in the post).