Why Look at Portals?
Along with our recent effort to build a collection of common/shared Identity and Security Services for our products leveraging an LDAP / Directory server (see posts on LDAP comparison) and a security framework (more on this in another post), we are also working to carry the service paradigm forward into the user interface. I don’t feel like portals really get as much attention as they deserve in the service oriented architecture (SOA) world, while other things that aren’t really service oriented at all end up being associated with the SOA buzz (see my thoughts on Service Oriented Architecture). Having said that, it seems to me that portals can provide an especially good representation of services and allow for aggregate applications in a way that most other presentation options don’t. You can really gain quite a bit of flexibility by creating portlets that leverage either one or many services.
The rest of this post will talk about some of our high level requirements for choosing a portal and what we evaluated. I’ll tell you what made the short list, what didn’t and why, and then followup with another post that discusses our short list candidates and how we picked a winner.
Our overall goal is to be able to use the portal to create a flexible product that we then deliver over the internet. We don’t sell the product itself – we only sell the services that our products deliver, and then the ability to get to our data using our flexible front end (soon to be available in a portal). Some of our requirements should be things that all people consider, while others, such as the fit to our particular architecture and technology stack, will be more specific to us. Keeping that in mind, here were some of our high level requirements:
- Standards are important, so we want JSR-168 / JSR 286 and WSRP support. WSRP support, in my opinion, is better even than the JSR support, because it allows for a better dispersal of portlets and services. Each JSR portlet needs to reside on the portal server, whereas only one WSRP implementation need be resident on the portal – all the WSRP portlet “guts” can be anywhere else. Having said that, the WSRP and WSRP2 portlet implementation are normally JSR compliant porlets themselves.
- Support for LDAP directly or through a security framework, with as little duplication of storage as possible. Plus, the LDAP server should be the source of as much of the identity data as possible.
- Customization and configurability are key. The end user need not even know they are really using a portal … at the very least, the portal should be branded and have a look and feel that says it is a Lotame product and not look like someone else’s. We may also need to change the layouts, the login, and remove components that we don’t need.
- Ease of use. This falls into two categories – end users and developers.
- End users need to be able to use whatever we create. While much of that falls to us, the portal framework also plays a significant role.
- Developers should be able to figure out how to use the portal, how to configure it, how to customize, add new pages, content and portlets without having to spend days and days just to get started. While it may take a while to become a portal “expert”, you should be able to get up and running in a couple of hours.
- It should fit nicely into our technology stack. We run a Linux and MySQL environment here. Anything that doesn’t run on those is out! The bulk of our development is done in Java and PHP and we prefer not to add any new languages if it can be avoided. You can begin to see a trend here, we also prefer open source products so we will be sticking with products that are either open source or otherwise very affordable.
- It should also fit into architectural roadmap. At a high level we are choosing a portal because conceptually it does fit with our vision of creating aggregate applications through use and reuse of services, but the specific portal we choose needs to be a good long term choice based on where we are taking our entire product line.
- Some document management or CMS ability would also be nice to have.
- Good documentation and community support.
We investigated or otherwise considered the products below. For those of you who read this and think … “but there is a more recent version out now”, I recognize that, but this evaluation was done essentially in November of 2008. There are also many other portals and portal frameworks out there, including ones for pay such as Vignette, BEA, IBM, Oracle and others. The portals below were chosen because 1) they met our requirements above and 2) we were aware of them.
|Product||Version||Link to Site|
|Jahia Community Edition||5||http://www.jahia.com/jahia/Jahia|
|JBoss Portal (Community Edition)||4.7||http://www.jboss.org/jbossportal/|
|eXo Portal Community Edition||2.2||http://www.exoplatform.com/portal/public/en/|
|Light Portal||? Pre-1.0||https://light.dev.java.net/|
|Liferay Portal Standard Edition||5.1.2||http://www.liferay.com|
The First Pass
Coming into the evaluation I was the most excited about 3 portals – Jetspeed, eXo, and Liferay. This was primarily due to some previous experiences as well as just a general respect for each of these communities. I really didn’t know enough about the others to render much of an opinion one way or another with the possible exception of JBoss since we run the JBoss App Server and I knew that there was (at some point at least) some involvement work done by Novell on the JBoss Portal. In any case, I went and downloaded each of the portals and gave them a try. In many cases I also encouraged some of our developers to do the same so I could also learn from their experiences.
Jahia Community Edition
Jahia is a very nice product that meets most of the requirements that we have, incuding very good support for content management, JSR-168 portlets, good administrative tools, and good support for developers including support for Maven and Ant. Jahia has a very strong offering, with only one problem for us … no support for LDAP in the Community version. Seeing as how LDAP integration was one of our stated high level requirements, this was a problem. Also, since we did not find any infromation readily available about integrating a security framework such as Acegi / Spring Security with Jahia (which would allow for LDAP integration via one level of indirection), this pretty much sealed Jahia’s fate.
Regardless of our decision, Jahia is a very good product. You can find more information about its features here.
Per the website:
Light is an Ajax and Java based Open Source Portal framework which can be seamless plugged in to any Java Web Application or as an independent Portal server. One of its unique features is that it can be turned on when users need to access their personalized portal and turned off when users want to do regular business processes.
This is in fact true, it is a framework that shows some promise, but it was in fact a little too light for us. In other words, it left us with a lot to do and it didn’t have any CMS capabilities, LDAP integration, etc. It would seem that a lot of new work is going on and I just read a message here at the end of December that said 1.0 is on its way. Not right for us, but I am interested in what happens with Light and I’ll keep watching.
I ended up not spending too much time looking at Gridsphere. It seems pretty straight forward to set up and use, but the feature base didn’t have everything I wanted (again LDAP, CMS). There is some documentation out there that seems to be accurate, but honestly, there isn’t that much of it. Gridsphere also was not right for us.
eXo Portal Community Edition
I was pretty excited about eXo. When I was doing my first portal implementation in 2003 or so eXo wasn’t quite what we needed, but it was really coming along and I went into this evaluation looking forward to using it. I downloaded both the All in One bundle as well as the 2.2 Portal Tomcat binary (both from here). getting things up and running with these packages was very straight forward, and eXo looked really great right out of the box. We even took a look at the WebOS / desktop portion of the product in the All in One package, and it looks really cool (no something we need right now, but it works). From a feature standpoint eXo looks really strong, particularly in their ability to deal in a flexible manner with LDAP models. If you don’t have a directory tree already set up, then it will create a tree that supports what it needs to do. If you have a tree already, eXo can be configured to work with it (see the LDAP config info). eXo also has great standards support, including JSR-168 / JSR-286, WSRP 2, JSR-170 (for content), and supports the JAAS security framework. On top of that it support AJAX, a REST API, drag and drop, customization, and bunches of flexibility.
eXo looked great and looked like it would make our short list for sure … until we tried to really use it. I was continuously stumped by the interface when I was trying to create new pages, new portlet instances, and basically place our applications into the portal. The interface was not working in any way that I expected and I could not seem to create a new instance of a porlet. Assuming it was just me being thick, I had several other developers install it and take an independent look before I made any significant comments. Each one had the same issue – they thought it was easy to install and looked great, but couldn’t figure out how to create new portlet instances. I was sure that we were missing something in the setup, or missing something very simple right in front of our faces. The documentation we were looking at was not able to help us along any.
Unfortunately, that led to eXo not making our short list. I know there are bunches of people out there using eXo, and I am sure it is a fantastic platform and I can see all the work that has gone into it. The problem is that our experience violated one of our high level requirements – that it be easy for developers to get up and get started without being a portal expert. I am willing to chalk our experience up to some lack of understanding or missing of the obvious on our part, and certainly look forward to any info that we might get from eXo or eXo users. While ultimately our choice has already been made, I want to understand what went wrong with our look at eXo and would be willing to consider it in the future.
My personal experiences with portal have been very heavy in Jetspeed (and the implementation from Gluecode, which is now part of IBM – the Gluecode portal product no longer exists to the best of my knowledge) and Vignette, so I was also excited about Jetspeed. If you want standards compliant software that is working to make sure to support integration with other Apache based software, then Jetspeed is it. Jetspeed has support for most of the standards and supports LDAP quite nicely (they work well with ApacheDS). I did have some questions about how flexible the support for LDAP is if I have a schema that differs significantly from the default LDAP schema. It looks like there were custom objectclasses and attributes, which is something we were looking to stay away from.
In the end, Jetspeed 2 did not make our short list for a couple of reasons.
- I found the existing workflow for creating portlets and pages to be a little more cumbersome than I had expected. I worked extensively with Jetspeed 1, and a little with Jetspeed 2 when work on it was just starting. I found the placement and workflow of the administrative functions to be cumbersome and not intuitive to any of the developers that looked at it. I knew what to do based on previous experiences, but the other folks struggled a bit. I realize we could customize it to make it better, but I want to focus on working on the look and feel and our own apps, which is what our users are going to see. I don’t want to spend a ton of time working on the administrative interfaces above some limited identity type of work we will have to do in any portal.
- The documentation is OK, but not great.
I love Apache, and have used many Apache products, but two areas the I personally feel many Apache products come up short is in presentation / UI (the first point above) and in documentation (second point). This isn’t true for all Apache products, and it has gotten somewhat better, but documentation and UI are just not major strength of some of these folks. That is one reason why I liked when Gluecode implemented a commercial version of Jetspeed – they cleaned it up a bit. I also had some concerns about the flexibility of the LDAP model, but I didn’t dig deep enough to be able to address those concerns.
Apache is great, Jetspeed is great, but Jetspeed 2 did not make our short list based on our high level criteria.
The Short List
So, what did make our short list and why? Well, the short answer is that Liferay and the JBoss Portal (Community Edition) were our short list candidates. Liferay had always been a contender, but JBoss Portal made the short list toward the very end of the evaluation. Both of these products have good documentation, good support for standards, support for LDAP and security frameworks, and strong community support.
I will be providing some more detailed information on why the made the short list and what portal we eventually chose, but this post has gotten quite long, so I will be providing that information in a followup post in the next couple of days (probably after the new year)