Blogging Roller

Building an Open Source J2EE Weblogger

2022-04-17T16:42:50+00:00

I wrote this article for O'Reilly's OnJava.com over twenty years ago and it was published on April 17, 2002. Roller would not become Apache Roller until about five years later. Publishing this article changed my life and set my career on a new trajectory. I can't find it online anymore so to celebrate this anniversay, i'm going to publish it here on Roller.

As a Java developer, you should be aware of the tremendous wealth of open source development software that is available for your use -- even if you have no desire to release any of your own software as open source. In this article, I will introduce you to some of the most useful open source Java development tools by showing you how I used these tools to develop a complete database-driven Web application called Roller.

Roller fits into the relatively new category of software called webloggers: applications that make it easy for you to maintain a weblog, also known as a blog -- a public diary where you link to recent reading on the Web and comment on items of interest to you.

The Roller Web application allows you to maintain a Web site that consists of a weblog, an organized collection of favorite Web bookmarks, and a collection of favorite news feeds. You can define Web pages to display your weblog, bookmarks, and news feeds. By editing the HTML templates that define these pages, you have almost total control over the layout and appearance of these pages. Most importantly, you can do all of this without leaving the Roller Web application -- no programming is required.

I used over a dozen open source development tools to develop Roller, the most useful of which are listed in Table 1; however, this article focuses on just four tools: the XDoclet code generator, the Castor persistence framework, the Struts Servlet/JSP framework, and the Velocity code-generation engine. In this article I will describe the Roller application, its architecture, and specifically how I used XDoclet, Castor, Struts, and Velocity in its development.

Table 1: Open source tools used in Roller Development

Name	Description	Developer	Type of License*
Castor	Persistence framework	Exolab	Similar to BSD license
HSQL	Small but powerful Java database	Thomas Meuller	Similar to BSD license
Jakarta Ant	XML-driven Java build system	Apache	Apache Public License
Jakarta Commons	Collections, utilities	Apache	Apache Public License
Jakarta Struts	Servlet/JSP framework	Apache	Apache Public License
Jakarta Tomcat	Servlet/JSP Server	Apache	Apache Public License
Jakarta Velocity	Template-driven code generator	Apache	Apache Public License
Netbeans	Integrated Dev. Environment		Sun Public License
Xerces	XML parser	Apache	Apache Public License
XDoclet	Code generator	Dreambean	Similar to MIT License

* For more information on open source licenses see opensource.org

The Roller Application

Roller does not support all of the features of commercial weblogging software (such as Userland's Radio or Pyra Labs' Blogger products), but Roller does support what I consider the essential weblogging features. With Roller you can:

Maintain a weblog, with user-defined categories. You can write new weblog entries and edit entries that have already been posted. You can define a set of weblog categories and can assign weblog entries to different categories. This allows you to maintain several different weblogs, each covering a different topic.
Publish your weblog as an RSS news feed. Roller makes your weblog available as a standard Rich Site Summary (RSS) news feed so that readers can subscribe to and read your weblog without visiting your Roller site.
Maintain a collection of favorite bookmarks, organized by bookmark folders. You can define new bookmark folders and can add, delete, and edit the bookmarks within these folders. You can then display these bookmarks on one or more of your Roller site's pages. This allows you to do blogrolling -- displaying links to your favorite weblogs.
Maintain a collection of favorite RSS news feeds. This allows you to display headlines with links to news stories from your favorite news sources or weblogs.
Define a set of Web pages to display your weblog, bookmarks, and news feeds. Pages are defined using HTML templates with embedded macros for each type of data. For example, there is a $Bookmarks macro that will draw a portion of your bookmark collection on a Web page and a $WeblogCalendar macro that will draw a calendar view of your past weblog entries. These templates allow you almost complete control over the layout and look-and-feel of your Web pages.

There are two types of Roller users: readers and editors. Readers are simply anonymous visitors to the Roller Web site. Editors have user accounts and must log in by providing a user name and password. Editors have the ability to edit their weblog entries, bookmarks, newsfeeds, and page templates.

Figure 1 illustrates the Roller application by showing the Roller Web page navigation tree. The boxes represent Web pages and the arrows represent links between pages. The gray pages are the public pages that any visitor may access, the yellow pages are the login pages, and the red pages are the pages that only editors can access.

Figure 1: Roller Web Pages

Roller Architecture

Internally, Roller is divided into a presentation tier and a business tier, as recommended in Sun's J2EE Pattern Catalog. The presentation tier is responsible for Roller's user interface, and the business tier is responsible for Roller's application logic and the persistence of application data. Figure 2 provides an overview of the Roller architecture.

Figure 2: Roller Architecture

The presentation tier is implemented using the Model-View-Controller (MVC) pattern and the Struts MVC framework. The Model is an abstraction of the application logic and application data and is represented by a set of interfaces defined in the org.roller.model package. The View is implemented using Servlets, JSP pages, and Velocity page templates. The Controller is Struts, which is responsible for receiving incoming requests and dispatching them to the View. The implementation of the presentation tier is further discussed in the sections on Struts and Velocity.

The business tier implements the interfaces in the org.roller.model package, using the Castor JDO persistence framework. The business tier exchanges data with the presentation tier in the form of simple, lightweight JavaBeans known as Value Objects. Value Objects are yet another of the Sun J2EE patterns. Each Value Object maps to a table in the Roller database.

Figure 3 shows the Roller Value Objects, their properties, and the relationships between them. Each editor is represented by a User object. Each User has a Website object, which represents the editor's Web site and which has weblog entries, bookmark folders, newsfeeds, and page templates. The Website object also specifies the default page template of the Web site and which page template is used for rendering a day of weblog entries.

Figure 3: Roller Value Objects

The business tier uses Castor JDO to store and retrieve Value Objects to and from a JDBC-accessible database. Castor JDO is part of the larger Castor data-binding framework, which according to the Castor Web site is "the shortest path between Java objects, XML documents, SQL databases, and LDAP."

As a persistence framework, Castor JDO is similar to commercial object-relational mappers such as TopLink and Cocobase. Castor JDO fulfills a role similar to that of Sun's Java Data Objects, but Castor JDO is not an implementation of Sun's JDO specification (JSR-000012). Castor JDO allows you to define a mapping between Java classes and tables in a relational database. You can then issue queries using Castor's own Object Query Language (OQL) and receive the results as collections of Java objects.

Before you can use Castor JDO, you must provide a mapping file -- an XML file that maps each class to a database table and each class property to a field within a database table. Below is a portion of Roller's mapping file.

<mapping> 
<class name=org.roller.model.BookmarkData" identity="id"
    access="shared" key-generator="UUID" auto-complete="false">
    <map-to table="bookmark"/> 
    <cache-type type="count-limited"/>
    <field name="folderId" type="java.lang.String"></field>
    <field name="id" type="java.lang.String"></field>
    <field name="image" type="java.lang.String"></field>
    <field name="name" type="java.lang.String"></field>
    <field name="priority" type="java.lang.Integer"></field>
    <field name="url" type="java.lang.String"></field>
</class>
...
</mapping>

Once you provide Castor with a mapping file, retrieving a collection of objects from the database can be as simple as the code snippet shown below:

// Construct a new query and bind its parameters
String query = "SELECT p FROM BookmarkData p WHERE websiteId=$";
OQLQuery oql = db.getOQLQuery( query );
oql.bind( websiteId );

// Retrieve results and print each one
QueryResults results = oql.execute();
while ( results.hasMore() ) {
   BookmarkData bookmark = (BookmarkData)results.next();
   System.out.println( bookmark.toString() );
}

XDoclet

XDoclet is a code generator that is implemented as a Javadoc extension, a Doclet. To use XDoclet, you place special Javadoc tags in your Java source code. Based on these tags, XDoclet can generate additional Java code that supports your classes, mapping files that map your classes to database tables, and deployment descriptors that assist in deploying your classes.

XDoclet started out its life as EJBDoclet, a tool that allows you to implement an Enterprise JavaBean by writing just one source code file. Now, the XDoclet product includes two Doclets: EJBDoclet and WebDoclet. EJBDoclet is for generating EJB classes, value objects, and database mappings. WebDoclet is for generating all sorts of Servlet Web Application deployment descriptors, including web.xml files, Tag Library Descriptors, and Struts configuration files.

The Roller build process uses both EJBDoclet and WebDoclet, as shown in Figure 4. In Step 1, EJBDoclet is used to process a set of abstract classes of type javax.ejb.EntityBean -- one for each one of the Roller Value Objects. From these classes, EJBDoclet generates a Castor mapping file, the Roller Value Object classes, and a set of corresponding Struts form classes. In Step 2, WebDoclet is used to process a source directory that contains JSP tags, Servlet classes, and Struts classes. The output of the WebDoclet is the complete set of Roller Web Application deployment descriptors.

Figure 4: XDoclet and the Roller Build Process

Below is a simple example bean that shows the EJBDoclet tags necessary to create a Value Object. The @castor tags provide the information needed to generate the Castor mapping entries for the bean. The @ejb tags provide the information needed to generate the Value Object and a complete EJB entity bean (which Roller does not use).

/**
 * Represents a single URL in a user's favorite web-bookmarks collection.
 * @ejb:bean name="Bookmark" type="CMP" jndi-name="roller/Bookmark"
 * @ejb:data-object extends="org.roller.model.ValueObject"
 * @struts:form 
 * @castor:class name="bookmark" table="bookmark" xml="bookmark"
 *               id="id" key-generator="UUID"
 */

public abstract class BookmarkBean implements EntityBean 
{

  /** @ejb:interface-method 
   *  @ejb:transaction type="Required" */
   public abstract void setData(org.roller.model.BookmarkData dataHolder);

  /** @ejb:interface-method */
   public abstract org.roller.model.BookmarkData getData();

  /** @castor:field set-method="setId"
   *  @castor:field-xml node="attribute"
   *  @castor:field-sql name="id" sql-dirty="check" dirty="true" 
   *  @ejb:interface-method 
   *  @ejb:pk-field
   *  @ejb:persistent-field */
    public abstract String getId();

  /** @ejb:pk-field
   *  @ejb:persistent-field */
    public abstract void setId( String value );
    ...
}

Struts

The Roller presentation tier is implemented using Struts and Velocity. Struts is a Servlet application framework that is based on the MVC pattern. In a typical Struts application, the Model is a set of JavaBeans that hold the data to be presented in the View; the View is a set of JSP pages that render HTML; and the Controller is a Servlet and set of action classes that are registered to handle incoming requests.

Roller's Edit-Bookmark form provides a nice, simple example of how Struts works. There are four parts to the Edit-Bookmark form implementation: the edit-bookmark.jsp page, the BookmarkForm JavaBean class, the BookmarkFormAction action handler, and some entries in Roller's struts-config.xml file that tie the first three items together. So, let's introduce the players:

The edit-bookmark.jsp page looks just like an HTML page, except that it uses the Struts HTML form tags instead of standard HTML form tags. The Struts HTML form tags know how to find the BookmarkForm JavaBean and how to use its properties to populate the form with data.
The BookmarkForm class is a dumb JavaBean that just holds data -- it has the exact same properties as the Bookmark Value Object. As you may recall, the BookmarkForm class and all of its sibling form classes are generated by XDoclet. In Struts, form classes must extend org.apache.struts.action.ActionForm.
The BookmarkFormAction is essentially an action handler. It is registered (in the struts-config.xml file) to handle incoming requests that include the pattern /bookmark.do. In Struts, action classes must extend org.apache.struts.action.Action.

Figure 5 shows the sequence of events that occurs when a request for the Edit-Bookmark form comes into the system. Roller needs to respond to this request by creating an HTML form populated with data for the bookmark that is to be edited.

Figure 5: Incoming request for Edit-Bookmark page

Here are the steps in processing an incoming request for the Edit-Bookmark page:

The Struts Controller Servlet receives a request for the Edit-Bookmark action. The Controller uses the URI of the request to look up the FormAction that should handle the request.
The Struts Controller Servlet dispatches the request to the BookmarkFormAction.edit() method. Knowing that the user has requested the Edit-Bookmark page, the BookmarkFormAction looks for a request parameter that specifies the bookmark that is to be edited.
The BookmarkFormAction calls the BookmarkManager to retrieve the bookmark information that is to be edited.
The BookmarkFormAction creates the BookmarkForm bean and adds that bean to the request's attributes so that it can be accessed by the JSP page.
The BookmarkFormAction finally forwards the request to edit-bookmark.jsp so that the page may be rendered.
The Struts form tags on the edit-bookmark.jsp page reads data from the BookmarkForm bean and uses that data to populate the Edit-Bookmark form. After that, the HTML page is returned to the user's browser for display.

Figure 6 shows the sequence of events that occurs when the request that contains posted data from the Edit-Bookmark page comes into the system. Roller needs to take the incoming form data and use it to update the bookmark that is stored in the data store managed by the business tier.

Figure 6: Request with data posted from Edit-Bookmark page

Here are the steps in processing a request with data from a posted Edit-Bookmark page:

The Struts Controller Servlet receives a request for the Update-Bookmark action. The Struts Controller determines which action should handle the request and which form bean should receive the data from the incoming form post.
The Struts Controller Servlet populates the BookmarkForm bean with data from the incoming request.
The Controller calls the BookmarkFormAction and passes in the form bean.
The BookmarkFormAction retrieves the data from the BookmarkForm bean.
The action calls upon the BookmarkManager to store the updated bookmark information.

Velocity

While JSP pages work well for the Roller editor pages, which rarely change, JSP does not work so well for the user pages. Weblog authors are not programmers, and they cannot be required to learn JSP and Java programming just to customize their weblog and associated Web pages. Furthermore, allowing Roller users to add new JSP pages, and thus new Java code, to the Roller application at runtime is a security risk.

Figure 7: Velocity-generated public page

The best solution to the user pages problem is Velocity. Velocity is a general purpose template-based code-generation engine. That may sound complicated, but from the user's point of view, it is simple and easy-to-use. For example, the weblog page shown in Figure 7 is generated by a simple Velocity template. This template is shown below:

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
;<head>
<title>$macros.showWebsiteTitle()</title>     
<style type="text/css">$macros.includePage("_css")</style>
</head>
;<body> 
<table cellpadding="5" cellspacing="15" 
   border="0" align="center" width="95%">   
   <tr>    
   <td width="20%" valign="top" bgcolor="#ffffff">      
      $macros.showNavBar(true)<br>       
      $macros.showEditorNavBar(true)<br>
      $macros.showBookmarks("Blogrolling",true)<br>       
      $macros.showBookmarks("News",true)    
   </td>    
   <td width="60%" valign="top" bgcolor="#ffffff">                
      <h2>$macros.showWebsiteTitle()</h2>                       
      $macros.showWeblogCategoryChooser()<br>       
      $macros.showWeblogEntries()    
   </td>    
   <td valign="top" bgcolor="#ffffff" width="20%">         
      $macros.showWeblogCalendar()<br>       
      $macros.showRSSBadge()    
   </td> 
   </tr>
</table>                  
</body>
</html>

The items that start with $ are Velocity expressions, most of which result in calls to JSP tags that have been specially designed to work with Velocity. For example, the $macros.showWeblogCategoryChooser() expression results in the generation of the navigation bar at the top of the page -- the one that reads "All | Technology | News | Entertainment." The navigation bar is implemented in a custom JSP tag class named org.roller.presentation.tags.NavigationTag, which is also used in the JSP-based Roller editor pages.

Each user can define any number of pages, and since these pages are simply HTML pages, they can be customized using Front Page or any other HTML editor. The user just has to put the Velocity expressions in the right place. Below is a list of some of the Velocity expressions that are available for use in user-defined Roller Web pages.

Macro	Emits HTML for:
$macros.showNavBar()	Navigation bar, with a link to each one of the user's user-defined pages
$macros.showEditorNavBar()	Editor navigation bar, with links to the edit-bookmarks,edit-newsfeeds, edit-weblog, and edit-website pages
$macros.showBookmarks()	Entire bookmark collection in a multi-column table
$macros.showNewsfeeds()	Current headlines and story descriptions for the user's RSS newsfeeds
$macros.showWeblogEntries()	The most recent weblog entries
$macros.showWeblogCalendar()	A weblog calendar, with a link for each day on which there is a weblog entry

Conclusion

In this article, I have described four open source Java development tools and how these tools can be used together to develop a fairly sophisticated Web application. I hope I have given you a good idea of the power and flexibility of these tools.

Although I have not mentioned any problems with the open source tools that I have discussed, I did run into a number of bugs. I was able to find work-arounds and fixes for these bugs, but it was not always easy. I had to spend some time browsing mailing-lists, searching with Google, and, in one case, downloading the latest source for a product and building it myself. Formal technical support is not available for many open source tools, so keep in mind that you may have to solve your own problems.

In closing, I would like to thank the many developers and other contributors that made possible the open source Java development tools that I used in the development of Roller. The tools are great and they just keep getting better.

Resources

Weblogging

Blogging about Roller 6.1

2021-12-22T22:53:38+00:00

I barely even update this blog, but I do update the software that powers it and I'm happy to still have the help of an awesome team of volunteers who pitch in when they want to and always when needed. Today we released Apache Roller 6.1.0, a release we had been talking about, but that was prompted by the Log4J vulnerability. See the project's blog for details.

I'm not the one making the most code changes in Roller now days, but I do help with releases. I've been spending my spare cycles hacking on BlogQL, a Node/TypeScript-based blog server with a GraphQL API and a React front-end. It's really more of an example app to help me understand those technologies, kind of like Roller was. Maybe I'll write about it someday. That's all for now.

Powered by Digital Ocean Kubernetes

2019-02-10T22:42:05+00:00

Just a note to say that I've switched this site over to Digital Ocean Kubernetes service, which is in Limited Availability right now.

Digital Ocean's Kubernetes service is just as simple and well designed as the rest of Digital Ocean. I mentioned before that I rolled my own Kubernetes cluster via Ansible and Kubeadm. Now I can delete all those config files and that's a good thing. Plus, the price is right; I can get by with one $10/month node (1 CPU / 2 GB memory) and a $10/month load balancer.

To get this site up and running I had to deploy four things to my cluster. I installed the NGINX Ingress Controller, Cert-Manager for automatic creation of Let's Encrypt TLS certs, PostgreSQL and my custom build of Apache Roller. All of that went pretty smoothly and I didn't run into and problems that I could blame on Digital Ocean.

Powered by Kubernetes

2018-03-13T14:29:55+00:00

Just a quick note to say that I ditched Docker Swarm and now this rarely updated blog is powered by Kubernetes. Total overkill, I know. Like Roller itself, I did it as a learning exercise. I hope to blog more about what I learned by doing this. For now, here's a quick summary of what I've done so far.

Created a cluster

I created a 2-node Kubernetes cluster on Digital Ocean using some hand-crafted Ansible scripts that call apt-get to install and kubeadm to start Kubernetes. I considered using Typhoon to create the cluster, but I really wanted to learn how to install Kubernetes "from scratch".

Ran two Ingress Controllers

To avoid using Digital Ocean's $20/month load balancer I'm running an Nginx Ingress controller on each node, and pinning containers to nodes using labels and nodeSelectors. I had to borrow Nginx Controller setup files from the Typhoon project because I'm still kind of bewildered by Ingresses.

Deployed my containers

Next, I wrote Kubernetes YAML files for deploying my containers: a private Docker Registry, PostgreSQL and my custom Roller image. Getting the private registry working properly was the biggest challenge. I need private because I don't want to make my custom Roller image public. Next, I'll install Jenkins next for CI/CD of my custom Roller build via the Jenkins Kubernetes plugin.

Let me know if there are any aspects of this that you'd like to see covered in a blog entry, or suggestions for running the cluster without two Ingress Controllers. I've already got a post cooking about installing a TLS secured Docker Registry on Kubernetes.

New Bootstrap based theme

2014-01-19T21:10:01+00:00

I'm not motivated to write new blog entries but for some reason I was motivated to update my blog's theme. This time I decided to go with Twitter Bootstrap + jQuery. It's responsive, so to speak. What do you think? I think it takes a little too long for the banner image to load.

Latest Links - August 1, 2011

2011-07-31T15:00:01+00:00

Latest links, favorites and photos shared elsewhere:

snoopdave RT @mraible: Happy 9th Blogiversary to http://raibledesigns.com: 3045 entries, 13,269 comments. Thanks for keeping all my memories Apach ... 12:35:12 PM 01 Aug 2011

mgile First day at the new, new office. Obligatory empty startup office pic: http://t.co/7oVDQjk 10:29:17 AM 01 Aug 2011

snoopdave Shared: Million Persona March on Google, Labor Day? http://bit.ly/qmAR5y #fb 09:40:01 AM 01 Aug 2011

Welcome new Apache Roller committer Shelan Perera

2011-05-23T17:53:33+00:00

(cross-posted from the Roller project blog)

Here's some happy news. A new committer has joined the Apache Roller project. Shelan Perera has been helping out on the mailing lists, submitting fixes and recently won a Google Summer of Code (GSOC) project to add mobile blogging features to Roller. He was nominated for committer-ship and voted in on May 5, 2011.

Shelan's GSOC project is to add mobile theming capabilities to Roller. You can find the Mobile Theming for Roller proposal on the GSOC website. Shelan is seeking feedback on requirements and design for the project, and keeping the community in the loop by running a blog to journal his progress: Apache Roller Mobile Platform.

Welcome Shelan!

OAuth everywhere (continued)

2009-03-26T02:00:00+00:00

In my earlier OAuth everywhere post I explained at a high level "how I got a Roller Gadget working, one that uses OAuth to call Roller and enables Roller to use OAuth to call back to the social network." I ended with some unanswered questions:

How do I add my gadget to SocialSite so users can install and use it?
How does SocialSite get the Consumer Key and Secret needed for calling Roller?
How does Roller get the Consumer Key and Secret needed for calling SocialSite?
How does the user authorize Roller's access to his Profile information in SocialSite?
When is OAuth support coming to the Roller trunk and can you use it for AtomPub?

(that last question was answered in OAuth for AtomPub in Roller earlier this week)

Now that I've wrapped up my work on OAuth in SocialSite and OAuth in Roller, I'm prepared to answer those questions. I'll do it by reviewing how I developed my Social Roller gadget and set it up to work on http://rollerweblogger.org, my Roller and SocialSite powered site.

Along the way, I'll provide links to source code and screen-shots. I'll be referring to the diagram from first post, so I'll reproduce it here for the sake of convenience:

NOTE: this post is based on the current code in the Project SocialSite SVN trunk. The things described below WILL NOT work with the SocialSite M3 release.

Step 1 - Develop an OpenSocial Application#

My first step was to develop an OpenSocial application for Roller. This application is made up of the three parts listed below. These are the parts show in light-blue in the diagram above.

An OpenSocial Gadget for Roller that a user can install into his SocialSite profile. An OpenSocial Gadget is defined by Gadget Specification, an XML file with the metadata, HTML, CSS and JavaScript that render the gadget's user interface. I developed my gadget as a Roller page template and you can view it's source code here: gadget.xml
A gadget setup page, a new JSP page in Roller that is called by the gadget to enable and disable Activity posting. This JSP page is protected by OAuth and returns data in JSON format to the gadget. View the source code here setupgadget.jsp
A Roller Task that runs periodically, checks to see if any gadget users have created new blog posts and if they have, posts a Activity to SocialSite for each, by calling the OAuth-protected OpenSocial REST API provided by SocialSite. View the source code here SocialRollerTask.java

Step 2 - Register gadget with SocialSite#

This section answers the question "How do I add my gadget to SocialSite so users can install and use it?"

My next step was to register my application. Remember that SocialSite is intended to add social features to existing web sites and has very little user interface of its own, it's mostly made up of gadgets. So, the way you register a new application on a SocialSite-enabled site is to sign-up as a user of that site, go to your profile page, install the SocialSite Developer Gadget and then use that gadget to register your new application.

You can see a screenshot of the SocialSite Developer Gadget below. In the simplest case, you just enter the URL of your Gadget Specification, but I needed to take a couple of extra steps because my gadget needs to call an OAuth protected resource in Roller.

This next paragraph answers the question "How does SocialSite get the Consumer Key and Secret needed for calling Roller?"

I need my gadget to call back to the Roller setupgadget.jsp page (that's part #4 in the diagram above) to enable/disable activity posting. Because that page is protected by OAuth, I had to go into Roller and get Roller's site-wide OAuth key and secret (see also: OAuth for Roller) and then enter those it the Developer Gadget. SocialSite stores them and will use them to take care of the OAuth authentication process on each gadget call to Roller (in part #2 above).

Step 3 - Approve gadget registration#

Since I'm the administrator of my site, I approved my own gadget registration. I did this by logging into my site's SocialSite admin console, went to the Gadget Management tab, saw my new gadget registration request and approved it. Here's a screenshot of the Gadget Registration approval page:

Step 4 - Add OAuth consumer key and secret to Roller#

This next paragraph answers the question "How does Roller get the Consumer Key and Secret needed for calling SocialSite?"

After your gadget is approved for use on a SocialSite enabled site, you'll find the consumer key and secret that Roller needs to call the OpenSocial REST API (that's step #6 above) in the SocialSite Developer Gadget. Here's what you see in the Developer Gadget once you gadget is approved.

My OpenSocial Roller application needs to know about those keys, so I put them in its configuration. For simplicity's sake, I'm not going to go into the details of this step.

Step 5 - install the Social Roller gadget#

Finally, the OpenSocial Roller application is ready for use. To install it, I went to my profile page, clicked the Gadget Directory button, browsed through the gadgets until I found it and then clicked the install button. Here's a screenshot of the SocialSite Gadget Directory, which you can access from the SocialSite Profile Gadget:

The Social Roller Gadget is the last item in the list, the "Simple Roller Gadget."

Step 6 - authorize and enable the Social Roller gadget#

After I installed the gadget, it appeared in my Profile page as you can see in the screenshot below. It's installed and ready to run, but it's not yet authorized to access my Roller account so it tells me "Before you can use this gadget, you must authorize it to access your Roller account."

Finally, I can answer the question "How does the user authorize Roller's access to his Profile information in SocialSite?"

I want the gadget to access my Roller account so I clicked on the authorize link and saw this page popup, directly from Roller, which asks me to take the final step to authorize access.

After I clicked the authorize button, page disappeared and the Social Roller gadget redisplayed itself as you can see in the screenshot below. The gadget is now ready to access my Roller account and is asking me to enable activity posting:

I clicked the enable posting button and saw this:

And now, whenever I post a new blog entry, an activity is added to my profile. Here's proof in the form of a screenshot:

Conclusion#

I've done the work to enable OAuth in SocialSite and Roller, so now it's possible to develop OpenSocial gadgets for Roller that will work with SocialSite and other OpenSocial containers. The Roller side of this work is now available in Apache Roller (in the SVN trunk), but the future of the SocialSite is still uncertain.

I think SocialSite still has great potential. That's why I'm spending so much time promoting it and moving it forward, but I can't do it all myself. I'm joining IBM next week and as far as I know, SocialSite will NOT be part of my job. I'll wrap up this series of posts tomorrow with a post discussing the future of Project SocialSite.

Socialsite on rollerweblogger.org

2009-03-25T23:59:59+00:00

The value of Project SocialSite is that it allows you to add social networking features, including the ability to run OpenSocial gadgets, to existing web sites and have those sites all using the same "social graph" of data about people and relationships. To demonstrate this, I've deployed SocialSite to my site, http://rollerweblogger.org, and finally implemented those things I described in my August 2008 Social Roller post (except for protected entries).

My site includes a blog and a wiki, Roller and JSPWiki, so it's a pretty good candidate for demonstrating how SocialSite can work with multiple existing webapps. It's not perfect because it's got a very small number of users, less than a dozen, and because it's private; you have to login to see the social features, but it'll have to do. In this post, I'll explain the steps you have to take to add SocialSite to a multi-application web site and I'll illustrate the steps with examples, links to source code and screenshots from my work on this site.

NOTE: this post is based on the current code in the Project SocialSite SVN trunk. The things described below may or may not work with the SocialSite M3 release.

Step 1 - Setup an Authentication Delegate page in your site#

SocialSite doesn't do any user management, it leaves that to the sites that it enables. In my case, I've got Roller and JSPWiki setup to authenticate against the same database table of usernames and passwords, and I've got Tomcat's simple SSO setup so that logins work across both webapps. I want SocialSite to depend on Roller to verify that users are logged. SocialSite's Authentication Delegation mechanism makes this possible.

Here's how SocialSite Authentication works. You add a delegate page, a dynamic page (JSP, PHP, etc.) to the webapp that is to do the authentication, configure SocialSite to trust that webapp and then at runtime, SocialSite will call that delegate page to verify user logins. In my case, I want Roller to do the authentication so I added a delegate page to Roller called socialsite_context.jsp.

When a SocialSite gadget running inside of Roller needs to call back to the OpenSocial API provided by SocialSite it will pass Roller's login cookie with the call, an assertion about who the logged-in user is and the URL of Roller's authentication delegate page (socialsite_context.jsp). SocialSite will then call that delegate, pass the cookie and verify that assertion. SocialSite expects the delegate to return some JSON data like this:

Example: JSON data from socialsite_context.jsp


  {
    'timeout': 30,
    'assertions': {
      'containerId': 'rollerweblogger.org',
        'viewer': davej,
        'owner': davej,
      }
    }
  }

In the above example, Roller is confirming the assertion that the user is 'davej' and the owner of the page containing the gadget is also 'davej'. Knowing this, SocialSite can decide what data the caller is allowed to access.

Step 2 - configure SocialSite to trust your Authentication Delegate page#

SocialSite won't trust just any authentication delegate page. Once you have created your page, you must configure SocialSite to trust it. You do this by editing a SocialSite configuration file in WEB-INF/classes/socialsite_context.xml. Here's an example that sets up a trust relationship with Roller's socialsite_context.jsp page:

Example: socialsite_context.xml in SocialSite


  <rules>
    <rule>
      <sources>
        <indirect>*</indirect>
      </sources>
      <assertions>
        <reject>*</reject>
      </assertions>
    </rule>

    <rule>
      <sources>
        <direct>http://rollerwebogger.org/socialsite_context.jsp</direct>
        <direct>*</direct>
      </sources>
      <assertions>
        <accept>*</accept>
      </assertions>
    </rule>
  </rules>

Step 3 - Add SocialSite Context declarations to target pages#

Once the Authentication Delegate page is in place, you're just about ready to start adding gadgets to the pages of your web applications. Each page that includes gadgets will need to include a couple of SocialSite scripts and information about the SocialSite context, i.e. the URL of the authentication delegate. Here's an example of the the JavaScript that I include include in Roller pages that use SocialSite gadgets:

Example: SocialSite context declaration for a Roller page template


  #set($viewer = $utils.getAuthenticatedUser().getUserName())
  #set($userName = $model.getRequestParameter("user"))
  #if ($userName)
    #set($owner = $userName)
  #else
    #set($owner = $viewer)
  #end
  #set($contextURL = "${url.absoluteSite}/socialsite_context.jsp")
  <script type="text/javascript" 
    src="${url.absoluteSite}/social/js/consumer.jsp"></script>
  <script type="text/javascript">
    socialsite.setContext({
      'delegate': {
        'method': 'GET',
        'url': '$contextURL?owner=$owner&amp;viewer=$viewer',
        'headers': {
          'cookie': document.cookie
        }
      }
    });
  </script>

The above code pulls in some JavaScript from SocialSite and sets up the context necessary for gadgets to call back to SocialSite. It uses Roller's $utils.getAuthenticatedUser() to determine the logged-in user and a request parameter 'user' to determine who owns the page.

Step 4 - decide where to put key social networking pages#

Finally, you're ready to add gadgets to the pages of your site. First, you'll want to do some planning. You'll want to decide where to place some key pages. The SocialSite widgets are designed to support a dashboard page, which allows users to browse people, make friends and receive messages. They also support both personal and group profile pages.

For rollerweblogger.org, I decided to use one Roller page template 'people' to act as both the Dashboard and Profile page. If you access the page with a URL that specifies a user, then you'll see the profile page of that user. If you access the page with without specifying a user, then you'll see your dashboard page. Here's what I put in the socialsite.properties file to set all this up:

Example: SocialSite URL properties from socialsite.properties


  # People page shows your Dashboard
  socialsite.dashboard.url=\
    http://rollerweblogger.org/project/page/people

  # People page with user parameter shows profile of specified user
  socialsite.profile.url=\
    http://rollerweblogger.org/project/page/people?user=${userid}

  # Group profile page will be hosted in JSPWiki
  socialsite.group.url=\
    http://rollerweblogger.org/wiki/Wiki.psh?page=${groupid}

NOTE that in the above configuration, I'm using my wiki to host group profile pages; more about that later.

Step 5 - add OpenSocal Gadgets#

Once you've decided how to set things up, you're ready to start adding gadgets. Assuming that you've added the SocialSite context declarations in your pages, you can add a gagdet with a single line of JavaScript. For example, to add the SocialSite Owner Activities Gadget you'd add this code:

Example: add gadget code from a Roller page template


  <script type="text/javascript">
    socialsite.addGadget({'spec':'local_gadgets/owner_activities.xml', 
      'removable':false, 'height':75, 'includeChrome':true});
  </script><br/><br/>

NOTE that you can add any OpenSocial gadget by specifying its URL in the spec argument of the socialsite.addGadget() call.

Screenshots#

It's screenshot time. I've included small thumbnail images belo, which you can click for a closer view. If you're on my site, photos will display in a light-box. First up, is the new People page that you will see if you are logged into rollerweblogger.org. It uses the SocialSite Profile, Face, Status, Friends and Activities gadgets.

Next up, the dashboard page. It uses just one gadget, the SocialSite Dashboard, which provides a bunch of different features and was introduced in the SocialSite M2 release. In one tab you can see the most recent activities of your friends or any of your groups:

In the second tab of the Dashboard Gadget, you can search and filter the people in the social network. You can filter by friends or by your groups. You can also create new relationships and accept or ignore relationship requests from this view.

In the last tab of the Dashboard Gadget, you can view and manage incoming messages and friendships requests:

Want to see the source code? You can see the page template code for my People page in the Roller page templates people, which contains the SocialSite context declaration, and people, which contains the main body of the page.

Finally, let's take a look at an example group profile page, which is located in my wiki.

Hmm... I never explained how I got SocialSite gadgets working in JSPWiki. Better fix that now.

A note about SocialSite in JSPWiki#

To get SocialSite gadgets working in JSPWiki, I had to to a little extra work. In my instance of JSPWiki, I don't allow HTML so I couldn't just drop in the JavaScript code necessary to declare the SocialSite context and make the socialsite.addGadget() calls. What I had to do was to create a couple of JSPWiki plugins, one for the SocialSite context and one for the add-gadget call. Here the raw wiki text of the Atomic Group page pictured above:


  !!!SocialSite Group: Atomic

  [{SocialSiteGroupContext group='atomic' 
    consumerUri='http://rollerweblogger.org/social/js/consumer.jsp' 
    authUri='http://rollerweblogger.org/socialsite_context.jsp'}]

  Demonstrates the SocialSite Group gadgets, running in JSPWiki.

  !!Group Profile Gadget

  Below is the Group Profile for group __Atomic__. You can use the buttons at 
  the bottom to edit the group's profile properties, to send a message to 
  the group and to add OpenSocial gadgets to this page.

  [{SocialSiteAddGadget spec='/local_gadgets/group_profile.xml' removable='true'}]

  !!Installed Gadgets

  This is where the group's OpenSocial gadgets will appear.
  [{SocialSiteAddGadget collection='GROUP'}]

And here are links to the source code for the two plugins: SocialSiteContext.java and SocialSiteAddGadget.java.

Conclusion#

That should give you a pretty good idea of what you can do with SocialSite. Don't be dissappointed if the gadgets don't look like exactly what you want. The important thing is that SocialSite gives you a centralized social graph service and the infrastructure needed to add social networking features to your sites via OpenSocial gadgets. If you don't like the gadgets that come with SocialSite, you easily write your own using the standard OpenSocial APIs and the SocialSite extensions to those APIs.

OAuth for ROME Propono

2009-03-24T12:00:00+00:00

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.

OAuth for AtomPub in Roller

2009-03-23T12:00:00+00:00

Over the past month or so I've been adding OAuth support to just about every open source project that I can commit to. I added OAuth support to Roller so that you can now use OAuth to protect Roller's AtomPub server and other things. I also added OAuth support to ROME Propono's AtomPub client so you can now use Propono to post to Roller (more about that later). Here's a quick overview of how OAuth in Roller works.

NOTE that this post applies to Roller 5.0, which has not yet been officially released.

Setting up OAuth for AtomPub in Roller

If you want to use OAuth with AtomPub on your Roller site, go to the Server Admin page and find the Web Services section, enable AtomPub and specify 'oauth' as the authentication mechanism, like so:

Getting your OAuth key, secret and URLs

Once you've done the setup, you'll find an OAuth Credentials link on the Roller Main Menu page, which will lead you a page like the one below showing your OAuth consumer key & secret and, if you are a site admin user, the site-wide key & secret. Currently, there's only one set of site-wide credentials; I plan to fix that.

Of course, those aren't my real keys. You'll want to keep your OAuth keys secret as they can enable anybody to access your Roller account via AtomPub.

Want to try it yourself?

I mentioned that Roller 5.0 has not yet been released and that's true. There's still a lot of work to be done on 5.0, but that doesn't mean you can't get your hands on the code and binaries now. To make it easy, I've made an unofficial snapshot version of Roller 5.0-dev available for testing purposes only. It's what I'm running on my site. You can get it here in two flavors:

apache-roller-5.0-dev-20090321-SNAPSHPOT.tar.gz (31 mb)

apache-roller-5.0-dev-20090321-SNAPSHPOT.zip (31 mb)

The instructions in the old Roller 4.0 installation guide should work fine, so follow them to install and configure the 5.0-dev SNAPSHOT. Please send questions and feedback to either the Roller dev mail list and I'll do my best to respond there.

You'll also need an OAuth capable AtomPub client. More on that topic tomorrow...

ApacheCon EU 2009!

2009-03-22T14:19:16+00:00

I'm off to ApacheCon EU 2009> tomorrow in Amsterdam to speak on the topic of Shindig for Blogs and Wikis. I'm really looking forward to catching up with my Apache friends and colleagues. That's the conference venue in the photo on the right, the Movenpick hotel (in the background behind the music hall).

I'm staying a couple of extra days, so I hope to have time for bicycling around the city as I've done in the past (see also: Flickr photo sets for 2007 and 2008). Unfortunately, the weather forecast stinks. There's a 60% chance of rain every day that I'm in town. Oh well; guess I'll have plenty of time for blogging.

Speaking of blogging.This week, I'll be posting some blog entries to highlight the work that I've done in preparation for my talk. Here's what I plan to cover:

* Monday: OAuth for AtomPub in Roller
* Tuesday: OAuth for ROME Propono
* Wednesday: SocialSite on rollerweblogger.org
* Thursday: OAuth everywhere (continued)
* Friday: the future of Project SocialSite

If you plan to attend my talk, at 4:30PM on Friday March 27, then you should follow along. Pay special attention to the SocialSite on rollerweblogger.org and OAuth everywhere (continued) posts, which will include detailed background info. I'm looking forward to seeing you there.

Preparing for my Shindig talk next month

2009-02-06T12:58:34+00:00

The day before the layoff axe fell at Sun, I blogged about my upcoming Shindig for Blogs and Wikis talk at ApacheCon EU in March. Since then, I've been working almost non-stop on finding a new gig and have had little time to work on my presentation. That's not good, because I have fairly ambitious plans for this talk. I'll explain.

I want to be able to show how to add social features including OpenSocial support to a blog server and a wiki server by using plain old Shindig and then Project SocialSite. I'm targeting Roller and JSPWiki because they're the blog and wiki source code bases that I know best right now and they're both Apache efforts, but the same techniques should work with other systems like Wordpress or Drupal. If I have time I might be able to demo those too (but I wouldn't count on it).

I'm not sure how far I can go with plain old Shindig because, like most blog and wiki servers, neither Roller nor JSPWiki has detailed profile data, social relationships or activities. I should be able to get Google Gadgets working via Shindig, but OpenSocial Gadgets will take a lot more thought and effort.

I'm much more confident in the Project SocialSite approach. SocialSite provides for storage of detailed profile information, groups, activities and app data as well as the necessary UI. I'm confident enough that I'm going to deploy it on this site. So, stay tuned. I hope to have something to show by the end of next week.

Oh, and by the way. Today is the last day to register for ApacheCon EU with the early-bird discount. So sign-up already!

ApacheCon Europe 2009 (link)

23-27 March 2009 | MÃ¶venpick Hotel, Amsterdam
Pricing (register before Feb 6 for discount)

Leaving Sun...

2009-01-22T17:23:11+00:00

It was over four years ago when I discovered that Sun was using my software, Roller, to power blogs.sun.com. I was thrilled to go to work for the company back in 2004 and what an awesome cast of characters I've gotten to work with over the years. I really enjoyed the folks I worked with on the blogs.sun.com team, the open source folks and most recently, the Glassfish team -- some of the most talented and nicest folks I've ever worked with. It's been a great four and a half years but all good things must come to an end and today is the day.

I've been swept up in the latest round of Sun layoffs. Sun has decided to disinvest in Project SocialSite and as of today I'm free and available for employment. Though I do feel some urgency due to the bad economy, Sun's layoff package is pretty good and so I have some time to figure out what comes next and no need to make hasty decisions. Whatever I end up doing, I'll be blogging it here.

Oh, and about Apache Roller and Project SocialSite? I'm not ready to give up just yet. I'll be using a little of my time to do some mentoring and to move forward plans for Roller 5.0 this spring. And I see real value in the Project SocialSite "social-enable existing web sites" concept and I'm considering ways to move that forward as well, with or without Sun. I'm still giving my talk Shindig for Blogs & Wikis in March 2009 and, actually, I'm pretty happy I have some time right now to focus on those demos and slides.

Roller 4.0.1 bug fix release available

2009-01-14T11:30:00+00:00

Here's the announcement from the Roller project blog:

It's been over a year since our last Roller release and we've fixed a couple dozen bugs in that time including an XSS vulnerability reported recently by Secunia.com. Now those fixes are available as an official Roller release, 4.0.1

Bugs fixed are listed in the JIRA Issue Tracker Release Notes page.

Updated files and docs are available via the Apache download mirror network.

This is a bug-fix only release with no new features.

Wondering what's next for Roller? I'm going to push for a Roller 5.0 release in Spring 2009, as we've got good stuff in the trunk and more on the way, but I'm going to need your help to get there. More about that later.

OpenID support in Roller

2008-09-03T07:46:50+00:00

Thanks to one hard working student and the Google Summer of Code, we now have a patch for OpenID support in Roller and its ready to commit to trunk. Here's a teaser screenshot:

If you want to know more, the proposal for OpenID support is on our wiki and the patch is attached to issue ROL-1733 in our bug tracking system.

Roller and SocialSite at Open Source Days 2008

2008-08-18T18:36:38+00:00

I'm happy to report that I'll be traveling to Copenhagen, Denmark to talk about Roller and Project SocialSite at the Open Source Days 2008 conference on Oct. 3-4 this year. I'm going to tell the story of Roller and lessons learned along the way and then talk about blogging in the age of social networks and how to social-enable Roller with the SocialSite widgets. The session is called titled The once and future Roller.

Roller status

2008-08-18T18:27:40+00:00

If you want the lowdown on what's going on with Roller community health, ongoing work and upcoming releases then check out the Apache Roller August 2008 Board Report.

Happy 4th birthday to blogs.sun.com

2008-04-27T17:30:43+00:00

I remember how freaked-out I was to see the referrer hits start rolling in (pun fully intended) from http://blogs.sun.com/roller. I can't believe it's been four years already. Thanks to Linda for the reminder.

Latest Links: Roller, REST and more

2008-04-21T14:00:07+00:00

Skrocki's Blog: WOOHOO Sun Blogs sees its 100,000th blog post!!!
Pat Chanezon made the first post, not sure who made the 100,000th
Mark Fortner: how to publish to Roller via Google Docs
"Google Docs 'publish' feature allows you to publish a doc as a blog entry."
Chandra Chan: Using wbloggar 4 with JRoller version 3
"using the new version of w.bloggar version 4.03"

Jean-Francois Arcand: Jersey 0.7 released...with a tiny taste of Grizzly Comet Support
"gives us a couple weeks and we gonna have something really amazing"
Earthly Powers: Jersey 0.7 released
"many additions and clarifications to the API" plus Comet support
NetBeans 6.1 RC2: Let the IDE Do The Web Services Plumbing For You
"brings support for web services from Google, Amazon, Facebook and others"

ZDNet: Social networking will be biggest enterprise 2.0 priority by 2013
"smaller businesses arenâ€™t even considering, while the giants are diving in head first"
Move Over Lotus Notes, SharePoint is Filling Yer Shoes
"What Microsoft makes look easy â€” can quickly become a nightmare in the making"
Joshua Marinacci: know of any good forum software?
Comments suggest JForum, LifeRay message board and other Java options

colmmacc: AWS, AppEngine and the future of data
coping with the "fallout of using a planet instead of a hard-disk"
Search Guy: Minion open source search engine from Sun Labs
search "engine that ships with the Portal Server and Web Server"
Unit Structures: Introducing Freedom
"I find myself desperately searching out places where I can be network-free"

Google Summer of Code ideas for Roller

2008-03-16T13:55:31+00:00

I asked for Google Summer of Code (GSOC) ideas for Roller a couple of days ago. Below are links to the proposals I thought were good enough to volunteer as possible mentor for and to submit. The deadline is tomorrow, so you've still got time to suggest additions to the list.

Roller OpenID: Open ID support for Roller blog server, for user accounts and comments
Roller Mobile: Mobile interface for Roller blog server
Roller Activities: Simple Social Networking for Roller blog server, Twitter-like activities
Roller Abdera: Abdera-based AtomPub implementation for Roller blog server
AtomPub Export: AtomPub Export for Roller blog server, export all!
Roller Shindig: Google Gadget support in Roller blog server themes via Shindig
Roller Photo Gallery: Better photo and file upload features in Roller blog server

Here's the full list of Apache GSOC proposals.

ApacheCons 2008

2008-03-01T16:21:21+00:00

I've been busy as can be, working on launching a new project at work, lots of presentations and not enough code. March seems to have snuck up behind me, spun me around and punched me right in the stomach. Not good. I need more time. Slides for my Advanced Roller talk are due today, ApacheCon EU is a little over a month away and JavaOne is right around the corner (more about that later). That's enough whining. Now, it's my duty to remind you that there's still plenty of time to register for ApacheCon EU in beautiful city of Amsterdam, so here goes:

Click here to register for ApacheCon EU 2008.

And in other news, the ApacheCon US 2008 Call For Papers is now open. This year ApacheCon US will be November 3-7 in New Orleans, Louisiana.

Social Software for Glassfish screencast

2008-02-21T16:13:44+00:00

I mentioned the Social Software for Glassfish (SSG) EA2 release before the winter break, but I never got around to posting any details. Since then some documentation has appeared, Manveen Kaur blogged it, The Aquarium too and now screen-cast master Arun Gupta has created an excellent Social Software for Glassfish screencast that walks you through the features in this very early access release. Now I don't have to say nearly as much.

SpringSource and Covalent: good thing for Apache?

2008-01-30T09:27:34+00:00

SpringSource, the company behind the Spring Framework, has purchased Covalent, a company that provides support for Apache projects. This popped up on my radar because Covalent offers support contracts for Roller and in fact, SpringSource CEO Rod Johnson mentioned Roller specifically when talking about the deal (emphasis mine):

<a href= "http://www.informationweek.com/news/showArticle.jhtml?articleID=205920751">Rod Johnson: "We want to support the open source software that people want to use," including the Geronimo application server, the Axis Web Services Framework from Apache, and the Apache Roller Blog multi-user blogging software."

Sounds like a good thing and hopefully it will improve the support story for all Apache products. In fact, it could be a really good thing for Apache projects because Rod's philosophy is that you can't support software unless you are one of the software's creators.

<a href= "http://www.infoq.com/news/2007/06/open-source-models">Rod Johnson: "You can't divorce the process of maintaining software from the process of creating software...That's not the future of enterprise open source - unless open source has no future"

Based on that, we can assume that SpringSource will now be paying committers to do creative work on Roller and other Apache projects so that they can provide the best maintenance and support of those same projects. Right? Maybe I'm too naive -- after all, I figured having Roller in Lotus Connections meant IBM would be contributing.

The "all Dave" feed

2008-01-09T15:19:15+00:00

Another thing I worked on over the winter break was an all-Dave feed, a single page and feed that combines all of the various things that I post to the web: blog entries, Flickr photos, del.icio.us links and Twitter activity. So far, this is what I've got: http://rollerweblogger.org/roller/page/feeds.

Roller Strong #12

2008-01-04T15:27:04+00:00

I have just one item for Roller Strong today: the post below from James Snell of IBM, which lists some pretty impressive stats for IBM's internal blogging system. James doesn't mention it in the post, but I've been told that the site is powered by Apache Roller v3.1.

Growth: Quick note: IBM's internal blogging environment currently has 95k+ entries, 94k+ comments, 41k+ registered users, 11k+ Blogs (about 13% of which are considered active), 20k+ distinct tags, and 6k+ ratings on entries (entry rating has only been around since June of 2007). On average, there are just under 150 new entries posted to about 115 blogs per day. The number of comments per day fluctuate between 80-230 per day. A range of between 200-400 tags are used each day. Update: in the first three days of January, the server access logs show 109,439 unique visitors, 3,265,739 hits, and 61.37 GB of data transferred.

And that's internal boggers only. Just think what they could do with an external blog site. Roller works well outside the firewall too.

Holiday project: JMaki for Roller

2008-01-02T13:12:54+00:00

Over the holidays I avoided doing anything directly related to my current set of work tasks. Sun went quiet, which helped, and I ignored the messages that piled-up in the Roller user and dev lists. It was so quiet that I had time for a fun little project: a JMaki plugin for Roller.

JMaki makes it easy to use JavaScript widgets (Dojo, Google, YUI, etc.) from PHP, JSP, JSF and now Roller. To use a widget, all you have to do is call a method or include a tag and JMaki takes care of including the right JavaScript files and generating the right HTML for you. That's not all JMaki does, there's also a pub/sub facility to make it easy to wire widgets together via events, there's a proxy for fetching remote resources common table and tree data models. The theme is cool widgets with ease-of-development and that's what I'd like to see in Roller. You can read more about the JMaki value proposition on the Why Use JMaki page.

Here's an example. Below is a Roller page template that uses two JavaScript widgest, the Dojo Clock and the YUI Data Table. All it takes is a single line of template code to include each widget, and one widget is dynamic i.e. the table is populated via an RSS feed.


    <html>
    <head><title>JMaki test page</title></head>
    <body>

        <h1>JMaki test: dojo.clock</h1>
        $jmaki.addWidget("dojo.clock")

        <h1>JMaki test: yahoo.dataTable</h1>
        $jmaki.addWidget("yahoo.dataTable", "/roller/xhp?id=rss","","")

    </body>
    </html>

And here's what that page looks like when displayed by Roller:

I'll write more about the plugin once I install it on this site. If you want some details about how the plugin was developed, you can read the email that I sent to the JMaki dev list: JMaki for Roller issues and suggestions. It links to the Java source code for the plugin.

SSG EA2

2007-12-21T13:26:23+00:00

I'm supposed to be on vacation today and I'm doing my best, but I just wanted to point out that something interesting has quietly appeared in the Glassfish Update Center. Why so quiet? Well, it's an EA2 release and the emphasis is definitely on the E. I'll post some more details later, perhaps after winter break. I've still got shopping to do now and I'm supposed to be on vacation.

Interested? If you haven't done so already grab yourself a copy of the new Glassfish V2 UR1 release. Run the updatetool and install the latest EA2 release of Social Software for GlassFish.

Latest Links

2007-12-18T14:00:07+00:00

Today, I've got a couple of additions to my powered-by-Roller list:

GMJ Designs : Apache Roller 4.0 Released
"I love the interface and it works great."
Toast Technology Blogs : Weblog
SOA and business portal consultancy blogging with Roller
Limlom.com company blog
Business solutions and J2EE consultancy blogging with Roller
Biblical Recorder journals
Blogs and Baptist Planet all powered by Roller

More about the opening of the Social Networking platforms of the world:

Dare Obasanjo: Thoughts on the Opening of the Facebook Platform
"looks like Facebook plans to assert their Intellectual Property rights on anyone who clones their platform"
OpenSocial API Blog: Let's get this Shindig started
"We're thrilled to tell you the initial commit to the Shindig repository is in"
Ruminating on DiSo and the public domain
"Iâ€™m hopeful about projects like Shindig that call themselves â€œopen sourceâ€ and are able to be sponsored by stringent organizations like the Apache foundation. But..."

And some more about the intersection of corporate interests and community open source:

InfoWorld: Open source and the corporate elephant (FOSS.IN coverage)
Danese Cooper: "Having a well-read blog is the best defense you can have against any problems you may encounter"
eWeek: Sun Open-Source Support Questioned
"The only reason anyone should be surprised by anything Sun does with [the open-source projects] it controls is because that person has fundamentally created an expectation that access to source code meant more than just thatâ€”and that is a flawed assumption."
Reg Developer: Bruce Perens on the OpenDS spat
"In general open source is only going to work if you let it be a community led project. Sun has had a hard time learning this, and some of their open source projects have had a hard time getting outside contributors, because Sun has insisted on owning the [project]"

How to create a Roller 4.0 theme, part 2

2007-12-13T13:14:53+00:00

This is part two of a two part series:

How to create a Roller 4.0 theme, part 1: directory structure and required files
How to create a Roller 4.0 theme, part 2: the theme.xml file

In part one I explained how to create a theme directory and add the required template and resource files. Now I'll wrap things up by explaining what goes into a theme.xml theme definition file and how to deploy your new theme.

Create a theme.xml file

The example1 theme that I discussed in part one has a preview image, a Stylesheet Override file, a weblog template, a _day template, a custom template that displays an about page and a single image called aquadot.jpg. The theme.xml theme definition file below includes each of those items.

<?xml version="1.0" encoding="UTF-8"?>
<weblogtheme>    
  <id>example1</id> 
  <name>Example1: minimal theme</name>
  <author>Dave Johnson</author>     
  <preview-image path="preview.jpg" />

  <stylesheet>
    <name>Override</name>
    <description>Stylesheet override</description>
    <link>override.css</link>
    <templateLanguage>velocity</templateLanguage>
    <contentsFile>override.css</contentsFile>
  </stylesheet>

  <template action="weblog">
    <name>Weblog</name>
    <description>Main template of weblog</description>
    <link>weblog</link>
    <navbar>false</navbar>
    <hidden>true</hidden>
    <templateLanguage>velocity</templateLanguage>
    <contentType>text/html</contentType>
    <contentsFile>weblog.vm</contentsFile>
  </template>

  <template action="custom">
    <name>_day</name>
    <description>Displays one day of entries</description>
    <link>_day</link>
    <navbar>false</navbar>
    <hidden>true</hidden>
    <templateLanguage>velocity</templateLanguage>
    <contentType>text/html</contentType>
    <contentsFile>day.vm</contentsFile>
  </template>

  <template action="custom">
    <name>About</name>
    <description>About this weblog...</description>
    <link>about</link>
    <navbar>true</navbar>
    <hidden>false</hidden>
    <templateLanguage>velocity</templateLanguage>
    <contentType>text/html</contentType>
    <contentsFile>about.vm</contentsFile>
  </template>

  <resource path="images/aquadot.jpg" />   
</weblogtheme>

Now I'll break it down and explain each element.

Inside

The root element of the XML file contains some theme meta-data, an optional stylesheet, one or more templates and zero or more resources. Here's a run-down of the meta-data you must include in each theme:

- the unique ID, by convention this is the same as directory name
- name of the theme
- name of theme author
- path to image preview file, relative to theme directory

The override

Following the theme meta-data is the stylesheet declaration, including all of the required elements:

- name of stylesheet
- description of stylesheet
- value used in stylesheet URI (e.g. http://example.com/../page/styles.css)
- in 4.0, this must be 'velocity'
- path to theme file containing stylesheet, relative to theme directory

The elements

Next are the template elements, one for each page template. Each element must have an 'action' attribute that declares on which action the template will be invoked. Here are the possible values of the action attribute:

weblog: Each theme must have a weblog template, which displays the main page of the blog
permalink: (optional) template which will be used when displaying individual entries
searchIndex: (optional) template to be invoked to display search results
tagsIndex: (optional) template to be used when displaying entries by tag
custom: (optional) You can add as many custom templates as you want.

And here are the elements that must be included in a :

- name of the template
- description of template
- value used in stylesheet URI (e.g. http://example.com/../page/mypage)
- true if page should be include in navigation menus generated by standard macros
- true if page not to be called directly and only used as an include
- in 4.0, this must be 'velocity'
- the content-type to be generated by the template
- path to theme file containing template, relative to theme directory

Including resources

After the template elements, we include the one element we need for the one image that is included in the theme. The path is relative to the theme directory.

Deploying your theme to Roller

To make your theme available to Roller, copy the theme directory into the Roller themes directory. Restart Roller and watch the logs to see that your theme is deployed correctly. If there is an error in your theme.xml file you should see an XML parser error in your roller.log file. You can also turn on additional theme debugging by adding the following to your roller-custom.properties override file.


log4j.category.org.apache.roller.weblogger.business.themes=DEBUG

If you want to share your theme with an even wider audience, then consider contributing it to the Roller Support project, a site that hosts additional themes that are not included in the official Apache Roller release because Roller ships with only four core themes.

That's all

I think that covers all the bases. Let me know if it works for you or what parts of the doc could be improved. I hope to get this into the next rev of the Roller Template Guide (which you can get from the Roller download page in PDF form).

Here's the example1 theme that I discussed in this post:

How to create a Roller 4.0 theme, part 1

2007-12-10T16:58:46+00:00

This is part one of a two part series:

How to create a Roller 4.0 theme, part 1: directory structure and required files
How to create a Roller 4.0 theme, part 2: the theme.xml file

The Roller 4.0 Template Author Guide explains how to customize your Roller theme by editing the page templates that define it. It tells you how to use Roller's template language (Velocity), what objects are available to your template code and what macros you can use to generate HTML and other content. You can download it here in PDF form.

But the template guide does not tell you how to create a complete new Roller theme, one that you can share with other Roller site admins. That's a problem because I'd really like to see more themes, so I'm going to rough-out some docs right here on my blog. In part one I'll explain how to get started, what files you must provide and the new Roller 4.0 Stylesheet Override feature. In part two I'll explain how to create the new theme.xml theme definition file that you must include in your theme. Let's roll.

Getting started

Just as before, a Roller theme is a directory of files, some page templates and some "resource" files, which are typically images. So, your first step in creating a new theme is to create a directory to hold those files. Give it a simple one word alphanumeric name with no spaces.

In the next sections, I'll explain what files you need and I'll show some example templates from a minimal theme called "example1." This example theme is made up of seven files, including three Velocity templates (.vm files), a couple of images and a theme.xml file. Here's the directory layout of example1.

Add Weblog and _day templates

A theme must have at least a weblog template with the name "Weblog" and you'll find an example of one below. It's advisable to also have a _day template, which is responsble for displaying one day's worth of blog entries.

Here's the Weblog.vm file for the example1 theme, with

<html>
<head>
  <title>$model.weblog.name #if($model.permalink) 
     : $model.weblogEntry.title #end</title> 
  #showAutodiscoveryLinks($model.weblog)
  <style type="text/css">
  h1 { color:red; } 
  h2 { color:orange; }
  a { color:orange; text-decoration:none; font-weight: bold; }
  </style>
  <link rel="stylesheet" type="text/css" media="all" href="$model.weblog.stylesheet">
</head>
<body>
  <table width="80%" align="center">
    <tr>
      <td valign="top">
        <h1>$model.weblog.name</h1>
        #set($rootCategory = $model.weblog.getWeblogCategory("nil"))
        #showWeblogCategoryLinksList($rootCategory false false)
        #set($pager = $model.getWeblogEntriesPager()) 
        #showNextPrevEntriesControl($pager)
        #showWeblogEntriesPager($pager)
      </td>
      <td valign="top">
        #showPageMenu($model.weblog)
        #showAuthorMenu(true)
      </td>
    </tr>
  </table>
</body>
</html>

And here's the corresponding _day template:

<h2 class="dayheading">$utils.formatDate($day, "MMM dd, yyyy")</h2> 
#foreach($entry in $entries)
  <h2 class="entryheading">
    <img src=$url.resource("images/aquadot.jpg") />&nbsp;
    <a href="$url.entry($entry.anchor)">$entry.title</a>
  </h2>
  <p>$utils.formatDate($entry.pubTime, "HH:MMa z") by $entry.creator.fullName</p>  
  <p>
  #if($model.permalink)
    $entry.displayContent
  #else
    $entry.displayContent($url.entry($entry.anchor))
  #end
  </p>
#end

You can read more about the Weblog and _day templates in the Roller Template Guide, what I'd like to highlight now is a new 4.0 feature called the Stylesheet Override. Notice that the Weblog.vm file above includes some CSS styles, followed by a to a CSS file with URL $model.weblog.stylesheet, that's the Stylesheet Override file. Let me explain.

Add a Stylesheet Override file

Roller 4.0's new Stylesheet Override feature makes it possible for users of your theme to to change font, colors and other things without having to edit any of the templates that define the blog. Instead, they edit a CSS file known as the override file and that file is included in the right places when the blog is displayed.

To support Stylesheet Override your theme must provide an 1) override file, 2) an entry its theme.xml file and 3) must reference the override file in the right place as shown above in the example Weblog.vm file.

When you create your override file, keep in mind that your theme should stand-alone without the override file. The override file is for specifying additional styles above and beyond what your theme already provides. It's perfectly OK and even a good idea for your theme's override file to be empty, or containing a comment like this:


  /* add your own custom CSS here */

Add other resources required by your theme

If your theme requires any static resources, i.e. images for the banner or for the background, then include them in the theme directory or its sub-directories. You must reference each one in your theme.xml definition file.

Your theme must also provide a Preview Image, an image (recommended size ~350x400) that will be shown to users as they browse possible themes within Roller. To satisfy this requirement, you include a preview image file in your theme directory and reference it from your theme.xml file.

In part 2, I'll explain how to create that theme.xml file with references to all the tempate files and images that make up a theme.

Roller 4.0 released

2007-12-05T13:16:32+00:00

Finally!

Apache Roller 4.0 has been released and is now available for download.

This is a major new Roller release which includes easier blog theme customization, a much more simple installation/upgrade process, infrastructure improvements and numerous other small fixes. You can get the release files and the official documentation via the Apache mirrors at this page:

http://roller.apache.org/download.cgi

And you can read about the new features on the What's New in Roller 4.0 page of the Roller wiki.

Project releases are approved by vote of the Apache Roller Project Management Committee (PMC). Support for a release is provided by project volunteers on the project mailing lists. Additional free support is provided by many other volunteer subscribers to the list. Bugs found in a release may be discussed on the list and reported through the issue tracker.

Roller is a Project of the Apache Software Foundation (ASF), formed by a resolution of the ASF Board of Directors. As an ASF Project, Roller is subject to the ASF Bylaws and the direction of the ASF Board. The user mailing list and issue tracker are the only support options hosted by the Apache Roller project.

Cross posted from the Roller project blog.

OpenQabal: a social software platform w/Roller

2007-12-04T13:56:55+00:00

I'm always happy to see Roller used in new sites, projects and products. Here's an interesting new example that I've been meaning to blog for a while now. Phillip Rhodes is working on building what he calls OpenQabal a "social software operating system." The project integrates a set of social software applications, including Roller and JavaBB, via Single Sign-On (SSO), a common look-and-feel and Semantically-Interlinked Online Communities (SIOC). He explains it all in an lengthy and informative blog post on the project's JRoller.com blog.

I'd never heard of SIOC before. Here's the executive summary:

Semantically-Interlinked Online Communities SIOC or is a framework aimed at connecting online community sites and internet-based discussions. Currently, online communities (boards, blogs, etc.) are like islands - they contain valuable information but are not well connected. SIOC allows us to interlink these sites, and enables the extraction of richer information from various discussion services.

Sounds like it could be pretty darn useful. But then again, I spent a little time exploring the list of SIOC enabled sites with the SIOC Firefox plugin and didn't really find any examples of interlinked communities or conversations. Am I missing something?

RC10 is 4.0

2007-12-03T13:35:41+00:00

We've got the votes to release our tenth release candidate as Apache Roller 4.0. I'll make formal announcements after I've put files in place and updated the various release and docs pages.

Advanced Roller at ApacheCon EU, April 2008

2007-12-03T13:33:13+00:00

One of my five ApacheCon EU 2008 proposals was accepted. I submitted a couple of proposals for customizing Roller, one for advanced Roller and one on RSS/Atom. The advanced Roller talk was accepted. Here's the abstract:

Apache Roller is a popular open source blog server designed to serve the needs of large multi-user blogging sites and typically used by large corporations, universities and government organizations. This session for managers, sysadmins and developers will goes beyond the Roller installation guide and explores the advanced issues of planning and executing a Roller deployment, including deployment architecture and configuration options as well as options for customization and automation.

Roller Strong #11

2007-11-27T21:04:43+00:00

I've got a couple of Roller related items to blog about, so why not just call it Roller Strong #11.

First, Lars Trieloff responds to some of the questions I raised about JCR and Roller in my ApacheCon wrap-up post. I left a comment on his blog in response. Personally, I think a JCR back-end is a very interesting idea and I wish I had some more time to explore it.

Manchi Leung AKA Thinkboy posted the code for a new Textile plugin to the Roller dev list, using Textile-J. Thinkboy says "it supports almost all of the Textile syntax. very much the same as Confluence wiki. Now I can easily sync or copy working notes from Confluence wiki to my personal Roller blog." Nice. Note to self: I need to fix up some of our existing entry plugins -- I think some of them (e.g. Ekit) still haven't been updated for Roller 3.1.

Arun Gupta blogged recently about Backing up your Roller entries and explained how to use the Grabber example (now known as BlogBackup in Blogapps 2) from the Blogapps project to backup your Roller blog. Backing-up your entries, but backing up your uploads is not. Hopefully, blogs.sun,com will turn on Atom protocol someday and that'll will make it easy for a tool like Grabber backup both entries and uploads.

We're still waiting on Roller 4.0, but I sense our wait is soon over. Roller 4.0 RC10 was released one week ago with just a couple of bug fixes. And so far, no critical issues have been found. We've got only one +1 vote (thanks Anil!) so far so committers please test and vote.

And finally, I have to mention MarkMail because I've been using it throughout this blog post. MarkMail provides a slick interface and excellent facilities for mailing lists of all kinds. They're indexing all of the Apache mailing lists and providing statis and charts for each. Check the Roller page at MarkMail for example.

That's all I've got for this go-round. Keep on rollin'

Roller Strong #10

2007-10-29T20:34:46+00:00

It's been over a month since the last Roller Strong, so now I'm really glad I didn't call this thing Roller Week. Anyhow, in this installment I've got news about including new releases, a big new Roller customer and upcoming Roller-related events. I'll start with the release news.

Apache Roller 4.0 RC9 available for testing

In addition to the internal testing done by Sun's blogs.sun.com and App Platform teams, the Apache Roller community has also tested eight release candidates of Roller 4.0. That's a lot of testing and fixing, but we're still not quite done. We found enough issues in RC8 to justify yet another build, so today I spun a new one, made it available for testing and called for another release vote. Here are the files:

RC9 file are available for testing purposes here:
http://people.apache.org/~snoopdave/apache-roller-4.0-rc

Ten new 4.0 themes (from rollerthemes.com) are now available here:
https://roller.dev.java.net/servlets/ProjectDocumentList

"Your US government blog" powered by Roller

The US Government recently launched a blog called GovGab (http://govgab.com). It's powered by five employees of the Office of Citizen Services and Communications and Apache Roller 3.1.

The GovGab folks have been helping out with the (still ongoing) Roller 3.1.1 release by reporting bugs and suggesting fixes. I hope we'll be seeing more from them as they role out more blogs and more Roller-powered blog sites.

Roller at ApacheCon US and EU

ApacheCon US 2007 is only a couple of weeks away but there's still enough time for you to sign up and make travel arrangements for Atlanta, GA. So get on it! You don't want to miss my talk again now, do you? I'll be presenting my Roller and blogs as a web development platform, the same one I gave earlier this year at ApacheCon EU. I'll also be at the Struts/Roller BOF on Wednesday night to talk about Roller's recent migration to Struts2. BTW, Raible says there will be FREE BEER at the BOF.

In related news, I just proposed five Roller related talks for ApacheCon EU 2008. While I was submitting my proposals, I saw that Matt Raible submitted one too (on Roller w/LDAP and SSO), so it's pretty likely that somebody will be talking Roller in Amsterdam in April 2008 too.

That's all I've got for you today. See ya next time...

- Dave

Instructions for Roller w/LDAP and CAS plus Roller on Geronimo

2007-10-23T19:04:15+00:00

Matt Raible gave a talk today at the Colorado Software Summit on integrating Roller with LDAP and CAS. He also has provided some nice notes on that and running Roller on Geronimo:

Matt had to make a couple of tweaks to get thing going with Roller 4.0 RC8 and a couple other problems have been found, so you can expect RC9 shortly.

Ten types of plugins supported by Roller 4.0

2007-10-17T10:12:31+00:00

<a href="http://cwiki.apache.org/confluence/display/ROLLER/What%27s+New+in+Roller+4.0 "> I'm working on documenting the Roller plugin system, comparing it to similar systems (e.g. Wordpress and Confluence) and coming up with some proposals for improvements. As part of that work, I've come up with a list of the plugin types supported by Roller 4.0:

Page Model Plugin (Interface: PageModel)
Allows you to make new objects available to Roller page templates, providing a way to display external data in the blog pages and feeds generated by Roller.
Weblog Editor UI Plugin (Interface: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-web/src/main/java/org/apache/roller/weblogger/ui/core/plugins/WeblogEntryEditor.java?view=markup"> WeblogEntryEditor)
Plugin your own Rich Text or other type of editor into the New/Edit Entry page in the Roller web UI. Roller comes with two such plugins: a plain-text editor and a rich-text editor based on Xinha.
Weblog Entry Plugin (Interface: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-business/src/main/java/org/apache/roller/weblogger/business/plugins/entry/WeblogEntryPlugin.java?view=markup"> WeblogEntryPlugin)
Allows you to transform weblog entry content at the time it is displayed in a weblog page or a feed. Once you've installed your entry plugin, blog authors can enable and disable it on a per entry basis. For example, if you've got the Wiki Plugin installed then bloggers can choose to blog using wiki syntax and the plugin will transform the wiki syntax to HTML on display.
Weblog Entry Comment Plugin (Interface: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-web/src/main/java/org/apache/roller/weblogger/business/plugins/comment/WeblogEntryCommentPlugin.java?view=markup"> WeblogEntryCommentPlugin)
Allows you to transform comment content at the time it is displayed in a weblog page or feed. By default, Roller uses a link-markup plugin to turn URLs into clickable links, an auto-format plugin to add paragraph breaks and a safe-subset plugin to strip out all but the safest HTML tags. You can add new comment formatter plugins or replace the existing ones.
Comment Authenticator Plugin (Interface: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-web/src/main/java/org/apache/roller/weblogger/ui/rendering/plugins/comments/CommentAuthenticator.java?view=markup"> CommentAuthenticator)
Plugin your own comment authenticator to replace the math-question test used in most Roller blogs. Allows you to add some additional HTML to the comment form and some server-side logic for authenticating comment posts. You could add a CAPTCHA test this way, but I'm not sure there's enough pluggability to support OpenID authentication.
Comment Validator Plugin (Interface: <a href= "http://svn.apache.org/viewvc/roller/trunk/apps/weblogger/src/java/org/apache/roller/weblogger/ui/rendering/plugins/comments/CommentValidator.java?view=markup"> CommentValidator)
Allows you to add additional comment spam filters to Roller. Your filter can examine each comment posted and report to Roller whether it appears to be spam or not. Roller includes an Akismet validator, a too-many-links validator and a trackback validator.
Renderer Plugin (Interfaces: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-web/src/main/java/org/apache/roller/weblogger/ui/rendering/RendererFactory.java?view=markup"> RendererFactory and <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-web/src/main/java/org/apache/roller/weblogger/ui/rendering/Renderer.java?view=markup"> Renderer)
Allow you to plugin a renderer for a specific template language name. Roller's stock templates and theme all use the Velocity template language, but by plugging in your own renderer you can author templates in whatever JVM based language you wish. For example, plugins exist for authoring Roller templates in JavaScript, JRuby and Groovy Server Pages (GSP) languages.
Request Mapper Plugin (Interface: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-web/src/main/java/org/apache/roller/weblogger/ui/rendering/RequestMapper.java?view=markup"> RequestMapper)
Allows you to plugin to Roller's URL structure and request handling system, like adding a Servlet but not requiring you to edit web.xml.
Cache system Plugin (Interfaces: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-business/src/main/java/org/apache/roller/weblogger/util/cache/CacheFactory.java?view=markup"> CacheFactory and <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-business/src/main/java/org/apache/roller/weblogger/util/cache/Cache.java?view=markup"> Cache)
Plugin your own cache system to replace or augment Roller's in-memory cache system. For example, you might want to plugin memcached as your distributed page/feed cache as Sun does for blogs.sun.com.
Repeatable Task (Classes to extend: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-business/src/main/java/org/apache/roller/weblogger/business/runnable/RollerTask.java?revision=559911&view=markup"> RollerTask or <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-business/src/main/java/org/apache/roller/weblogger/business/runnable/RollerTaskWithLeasing.java?revision=559911&view=markup"> RollerTaskWithLeasing)
Roller runs a number of tasks behind the scenes and you can add your own tasks and configure when they start and how often they run. There's also a lease-system for working in a distributed environment.

UPDATE: The Advanced Roller presentation from ApacheCon EU 2008 covers many of the different types of plugins above and gives examples, configuration tips, etc.

Latest links: AtomPub news round-up edition

2007-10-12T12:31:13+00:00

I've been in crunch-mode working on a new project, but I've been trying to keep an eye on what's going on the world of Atom Publishing Protocol or AtomPub as the cool kids call it. Here's a wrap-up of some of the AtomPub news I've picked up on the past month or so.

Specifications

The big news is, of course, that AtomPub has been granted an RFC number RFC-5023 and is now an IETF "proposed standard" like Atom format (RFC-4287). The folks at Ricoh have provided a Japanese translation.

Extensions to AtomPub are under development and you can find a good list of them at the XML Cover Pages page for Atom. One I find interesting is James Snell's AtomPub Feature Discovery spec, which is designed to help AtomPub clients determine what features are supported and required by servers. The features spec is controversial and has sparked a lot of good discussion including, Brian Smith's email Atom Weblog Publishers Guide and Sergey Beryozkin and Dan Diephouse's discussion of AtomPub and WS-Policy

Server implementations

More big news to report here: the new Wordpress 2.3 release provides full support for AtomPub. Sam Ruby blogged about it in Wordpress 2.3 loves AtomPub and the Wordpress 2.3 AtomPub docs provide a good summary and cover some limitations. Yesterday, Sam posted Wordpress vigilance and plans. He wants to get Wordpress to score a perfect 0 errors and 0 warnings on the APE tests, which means among other things preserving foreign markup.

New releases of Apache Roller have also been updated for the final AtomPub spec. The upcoming Roller 3.1.1 and Roller 4.0 releases include AtomPub support. Both releases are up for vote now, so they should be out Real Soon Now. And I'm working on adding AtomPub support for comments for Roller 4.1, building on top of the Atom Threading Extension (RFC-4685).

I've been googling and browsing the SixApart site, but I can't figure out if Movable Type 4.0 supports the final AtomPub spec. Anybody know?

And Google has added another AtomPub based API. Read about it on Bill de hÃ“ra's blog YouTube via GData and on the YouTube Developer API blog: New YouTube API Released into the Wild.

Client implementations

In Stick a fork in it Joe Cheng writes "The Windows Live Writer team is still on track to deliver AtomPub support in the next version, which I am looking forward to immensely. Itâ€™s definitely an exciting time to be in the blogging tools space!" Based on what I saw at the last face-to-face AtomPub interop, it looks like Microsoft may have the best AtomPub-based blog client around. I wonder when MarsEdit and Ecto will get on board with AtomPub.

Toolkits and programming libraries

I already blogged about the Propono 0.6, a Java-based client and server library for AtomPub, which has been updated for final spec. Since then the Apace Abdera project has released Apache Abdera (incubating) 0.3 release is available with a long list of improvements and new features. There are also a couple of usage notes from James Snell. Also on the topic of Abdera, Dan Diephouse has done some work to make Spring and Abdera work well together.

The Perl AtomPub::Client at CPAN has updated for final AtomPub too.

That's all I've got for now. Did I miss any important AtomPub news?

Blogapps 2.1 released

2007-10-02T21:49:40+00:00

<a href= "http://www.amazon.com/dp/1932394494?tag=bloggingrolle-20&link_code=as3&creativeASIN=1932394494&creative=373489&camp=211189"> The next releases that I'd like to announce are the Blogapps 2.1 Examples and the Blogapps 2.1 Server.

If you'd like to learn more about the Blogapps examples and server then read The Blogapps Project article at Java.net. Here's a quick summary:

The Blogapps project hosts a collection of useful RSS and Atom utilities and examples from RSS and Atom In Action by Dave Johnson. They're designed to be useful even if you haven't read the book and they're available under the Apache License 2.0 so you can use the code in your applications and you can modify and redistribute them as you wish.

What's changed since 2.0? The examples have been updated to include the latest version of ROME Propono, which means that most of them now support the final Atom protcol spec. The server has been updated to include Roller 4.0 RC5, which also includes Atom protocol support and JSPWiki 2.4. And of course, various bugs have been fixed. Here are the release files, installation instructions and release notes.

This blog entry was posted via Atom protocol and the MatisseBlogger blog-client, which you can see in the screen-shot below (which was also posted via Atom.

What's next? Not sure at this point, but I will do another Blogapps release once ROME 1.0 is released.

ApacheCon US 2007 - still time to be an early bird

2007-09-07T18:48:10+00:00

ApacheCon is coming up fast. I just faxed in my speaker's agreement and I'm starting to update my talk to cover the latest changes in the upcoming Apache Roller 4.0 and 4.1 releases.

I've been four times now and ApacheCon is always a great conference. It's small and cozy enough, but almost all of the Apache projects are represented. So it's easy to find the experts, make new friends and get all of your questions answered. The session line-up looks great this year; here are ones that caught my eye:

Hacking Atom with Apache Abdera - Garret Rooney
A little REST and Relaxation - Roy Fielding
WS-* vs. REST: Facts, Myths and Lies - Sanjiva Weerawarana
Go Light with Apache Struts 2 and REST - Don Brown
How to Run a Business Around The ASF - Sanjiva Weerawarana
Open Source Community Anti-Patterns - Ted Leung
RIAs using Apache Derby and Comet - Jeanfrancois Arcand & Francois Orsini
Apache Derby - Saucer Separation - Rick Hillegas
JCR in Action - Content-based Applications with Apache Jackrabbit - Carsten Ziegeler

Want to go? There's still time to shave a couple of hundred dollars off the conference fees by registering early. Early bird pricing has been extended to Sept. 22, 2007.

And the Weston looks like a pretty nice place for a conference:

ApacheCon US 2007 | Register here
November 12-16, 2007
Westin Peachtree Plaza
Atlanta, Georgia

Roller Strong #8

2007-08-14T10:20:17+00:00

It's been a couple of weeks since the last Roller Strong because I've been very busy with 4.0 and some other new projects. Plus, I was getting a little tired of saying "we're still working on 4.0." So now I'm happy to report that release candidates have been made available for upcoming Apache Roller 4.0 release.

It should be very easy to try out the new release because we spent a lot of time focusing on a new easy-install process, plus there is no need to download a separate bundle of Hibernate files as Roller no longer uses Hibernate. With the new easy-install, installation should be as easy as editing four settings in a small configuration file and dropping the WAR into Tomcat or Glassfish.

Below are some links to the 4.0 RC1 release files.

<a href= "http://people.apache.org/~snoopdave/apache-roller-4.0/apache-roller-4.0-rc1.tar.gz">apache-roller-4.0-rc1.tar.gz (key)
<a href= "http://people.apache.org/~snoopdave/apache-roller-4.0/apache-roller-4.0-rc1.zip">apache-roller-4.0-rc1.zip (key)
What's new in Roller 4.0
<a href= "http://opensource.atlassian.com/projects/roller/secure/ReleaseNote.jspa?projectId=10000&styleName=Html&version=10270">Roller 4.0 Change list in JIRA
<a href= "http://people.apache.org/~snoopdave/apache-roller-4.0/roller-install-guide.pdf">Roller 4.0 Installation Guide (PDF)
<a href= "http://people.apache.org/~snoopdave/apache-roller-4.0/roller-user-guide.pdf">Roller 4.0 User Guide (PDF)
<a href= "http://people.apache.org/~snoopdave/apache-roller-4.0/roller-template-guide.pdf">Roller 4.0 Template Guide (PDF)

Keep in mind that 4.0 RC1 is not an official Apache release and is meant for testing only. Even so, this is probably a pretty solid release. The .Sun Engineering team put the code into production at at blogs.sun.com over a month ago and my coworkers on the Sun App Platform team just put the code through a couple weeks of testing.

rollerthemes.com

<img src="http://rollerweblogger.org/roller/resource/roller-themes.png" alt="screenshot of rollerthemes.com" align="right" /> Big thanks to Gene Strokine! As seen on raibledesigns.com, Gene has been busy with Roller theme development and has started a new site rollerthemes.com to promote his work. Gene is also the newest committer on the Roller Support project at Java.net and has committed many of his themes there (they still need to be upgraded to work with 4.0 though).

Notes on Roller and JA-SIG CAS SSO

And Phillip Rhodes reports success integrating Roller and JavaBB with single-sign on via JA-SIG CAS and has plans for additional identity related work. He has posted his notes on Roller and CAS/SSO to the Roller dev list.

JRoller.com troubles

In the "OK, so maybe Roller ain't so strong" department, JRoller.com has been having problems with Roller 3.1. Matt Schmidt upgraded JRoller.com from Roller 2.0 to Roller 3.1 a couple of weeks back and ran into database connection pool problems, which were resolved by switching back from Tomcat to Resin. Now he's dealing with some explosive memory usage and <a href= "http://www.javalobby.org/java/forums/t99490.html">asking for help from the Javalobby community.

Coming soon: a Geronimo plugin for Roller

Our Geronimo friends David Jencks and Peter Peterssen stopped by the Roller-dev list this month to contribute some code to make it easier for Roller to work in Apache Geronimo. They're cookin' up a Geronimo plugin for Roller and I'm looking forward to seeing it in action.

In other news...

One final note. We've made a bunch of fixes to 3.1 so we also have a new RC available for the upcoming Apache Roller 3.1.1 fix release. You can find the RC files for 3.1.1 in my Apache site and the change list in JIRA.

Atom protocol has been finalized

2007-07-24T17:21:09+00:00

Good news today from Tim Bray: Atom protocol has been finalized. The final version of the spec is going to be Atom protocol draft #17.

Instead of staying up until the dawn hours (not naming names) reading the final Harry Potter book, I spent most of the weekend working on bringing Propono in-line with the draft #17 and in particular adding support for out-of-line categories and relative URIs. I've got code ready to commit that passes Tim's Ape tests, so hopefully we'll have a new Propono 0.6 release ready very soon that supports the final spec.

Roller's Atom protocol implementation is already up to date and passing Ape tests, so Roller 4.0 will be Atom protocol ready. I still need to do a little work to document the setup.

Roller Strong #4

2007-06-23T12:19:13+00:00

Lilac-breasted Roller by David Meeker

Not too much to report this week...

Matt Raible gave his Introduction to Apache Roller webinar on Wednesday. Most unforunately, I was unable to break out of my Wednesday meeting marathon to attend. At some point Matt says he'll post his slides to the Roller wiki.

In Roller development we wrapped up work on the new Roller EZ install, which makes it really easy to install Roller -- just set four properties, deploy roller.war and Roller will start up, creating or upgrading tables as needed.

Also, my Guice proposal gained consensus and I merged the work into the Roller trunk just this morning. As of now, I believe we're feature complete for Roller 4.0.

Tune in next week and perhaps I'll have something to say about release. It's about time to start getting 3.1.1 and 4.0 release candidates ready.

Reminder: Covalent's Roller webinar is tomorrow

2007-06-19T17:25:27+00:00

Roller fans don't forget, Covalent's Introduction to Apache Roller webinar is tomorrow, Wednesday June 20 at 2PM ET. Raible has the details.

Powered by Struts2 and OpenJPA

2007-06-18T13:06:25+00:00

I stayed up a little too late last night upgrading this site (rollerweblogger.org) to the latest Roller 4.0 code base, which includes the new Struts2 based Admin UI and a new OpenJPA based back-end. No more Hibernate for me. The upgrade was a bit of a rocky road, but the site seems to be working OK now.

Roller Strong #3

2007-06-15T23:07:30+00:00

This week was a big week for Roller, development and deployment-wise. As you may already know from Linda Skrocki's blog, Roller 4.0 went live this week at the premier corporate blogging site blogs.sun.com (BSC) with some nice new themes, easier blog customization and a UI that has been completely rewritten to do use Struts2. Check the What's New in Roller 4.0 page to learn more about the upcoming release.

But don't get too excited, you can't download Roller 4.0 just yet. Sun deployed a pre-release version of Roller and if you want to do the same, you'll either have to build it yourself or wait for the official Apache Roller 4.0 release coming out this summer. And don't be too disappointed, that's one of the nice things about Roller: before we make a release, the code is battle tested on blogs.sun.com. Big thanks to .Sun Engineering for that.

A couple folks wrote into to tell me that GIS software developer ESRI is blogging with Roller, something I've been meaning to mention for quite some time. In fact, I've been meaning to mention it for over a year and now it's time to wish ESRI a happy 1st blogaversary. Man, how time flies.

That's it for this weeks installment of Roller Strong. Y'all come back now.

Roller Strong #2

2007-06-08T17:43:30+00:00

Welcome to the second edition of Roller Strong. This has been a busy week for me with a silly number of telecons, but I've still managed to keep up with Roller events and even get a little development done so here's the Roller news round-up.

First, an announcement from Covalent. They've rescheduled their Apache Roller webinar with Matt Raible to June 20.

A couple of new users showed up on the Roller mailing-list this week. One was Ryan Delaplante who wrote about his Roller installation experience and the nice new theme he developed on his blog ryandelaplante.com. Jason Johnson stopped by to tell us about the new Roller-based blogging system at the University of South Dakota blogs.usd.edu. They've got some looking themes there too, check out Astra blue and red.

In the blogs, here's a post for Sun bloggers only from Rich Sharples: OpenID Delegation with Roller (take 2). Rich explains how to setup your Roller-based blog as a proxy for your Sun OpenID account.

In development, we're still finishing up the Roller 4.0 release. Most commits this week are coming from Allen who is working on bug fixes across the board. I've been making slow and steady progress on the Roller easy install work. Also, if you look at the Subversion logs you'll see that I'm working in a separate branch to implement Dependency Injection (DI) in Roller via Google's Guice. I'm almost ready to show-and-tell with a proposal. Denis Balazuc has also created a DI implementation using Spring, so we may have some interesting discussions next week.

No significant news about releases this week. We've probably got enough fixes to justify a Roller 3.1.1 release, but nobody has prepared a release candidate yet. I might be able to do one next week.

That's it for this edition. Have a great weekend.

Roller Strong Disclaimer: this is a personal blog and I do not speak on behalf of Sun Microsystems or the Apache Software Foundation.

Apache Roller webinar from Covalent

2007-05-23T23:12:43+00:00

Covalent is presenting a web presentation titled "Introduction to Apache Roller" that will cover Roller architecture, features, installation, customization and road-map with Roller committer and blogger Matt Raible. The presentation is on June 6 at 11AM Pacific Time. You can sign up at raindance.com.