Planet Hippo

Arje Cahn (Hippo): What's wrong with portals?

Thu, 11 Mar 2010 08:50:36 +0000

This post clearly describes the problem that I see with all current portal implementations: they treat content as “just another application running

Vijay Kiran (Hippo): Updated: Related Documents Plugin for Hippo CMS 7.3

Vijay Kiran — Mon, 08 Mar 2010 15:28:43 +0000

The Related Documents plugin for Hippo CMS allows the editors of the documents to select “related” documents of the current document. The plugin provides automatic suggestions using Similarity Search and Referring documents. Also, the document editors/authors can hand-pick the related documents.

The plugin is now updated for CMS 7.3(released last week). You can get the plugin from the Hippo Forge, the demo project is also now updated to 7.3. If you are already using the plugin, then there are no changes required in the plugin configuration to make it work with 7.3. Just update the plugin version in your pom.xml to 2.05.00 and you’ll be good to go.

Vijay Kiran (Hippo): Smart Console now on Hippo Forge

Vijay Kiran — Mon, 01 Mar 2010 21:52:06 +0000

Finally I got sometime to move the Smart Console project out of sandbox. The project is now hosted at Hippo Forge. There are two things that are aimed with this project . One – to provide a simple, user friendly JCR Explorer and Console for any repository. Obviously, I’ll add Hippo Repository specific features to the project soon. The second is experimenting with REST interface for the Repository. I’m using JBoss RESTEasy for providing the REST service implementation and ExtJS as the front end.

Currenlty the project is in pre-alpha, and during the next couple of weekends I’ll try to add more features – most , if not all – buttons in the UI do nothing at the moment. But the application in its current state can connect to the repository and display the node tree, and node properties (in a tab) when clicked.

Stay tuned for updates, or if you want to help, just join the project at Forge. Though the project is still in cowboy-coding phase, contributions are welcome, as always.

To see it action, check out the code and run mvn jetty:run. Make sure that your Hippo CMS/Repository is running on localhost.

Vijay Kiran (Hippo): The First Golden Hippo

Vijay Kiran — Sat, 27 Feb 2010 12:11:28 +0000

Yesterday I joined the hippo professional services team for a fun filled team event with go karting evening and the first ever Golden Hippo Award event. The evening started with go karting fun, we were competing with each other. This was the first time I ever did this, I failed miserably in the

Tjeerd D. Brenninkmeijer (Hippo): Five golden rings, four golden Hippos and one platinum Hippo

Fri, 26 Feb 2010 14:18:51 +0000

Today we will leave the office by taxi to a secret 'kart' location where we will be treated to some (non alcoholic) drinks, some "bittergarnituur" and a presentation by Stefan. Later on we will get a short introduction in how a kart works (probably only useful for myself) and do a training lap. Thr

Jeroen Reijn (Hippo): Jboss ModeShape: A federating JCR repository

noreply@blogger.com (Jeroen Reijn) — Thu, 04 Feb 2010 15:27:00 +0000

Some interesting stuff is happing in the JCR community. With Apache Jackrabbit 2.0.0 out (with JCR 2.0) and an interesting project called Jboss ModeShape almost reaching it's final 1.0 release. ModeShape recently came to my attention and it seems an interesting project. In this post I will give a short introduction of ModeShape and it's features.

What's ModeShape?

ModeShape is a Java Content Repository implementation which will support both JSR-170 and JSR-283. It's not trying to be just another isolated content repository, but a repository with a strong focus on content federation. In other words: ModeShape's main goal is to provide a single JCR interface for accessing and searching content coming from different back-end systems. These systems can even be of different sorts. You might think of a ModeShape repository containing information from a relation database, a file system and perhaps even another Java content repository like for instance Hippo CMS 7's content repository. You can configure these sources of information with the help of ModeShapes connector framework.

Connectors

One of ModeShape's key concepts is the concept of connectors. A connector will allow you to connect to a certain type of back-end system and transparently expose the information inside the ModeShape repository. In the current 1.0.0 beta release there are already a couple of out of the box connectors available:

In-Memory Connector
File System Connector
JPA Connector
Federation Connector
Subversion Connector
JBoss Cache Connector
Infinispan Connector
JDBC Metadata Connector

That's already quite a few, but for the upcoming release they also have plans for expanding the set of connectors with for instance a JCR connector, which I find quite interesting myself, because that would allow you to expose other JCR implementations like Hippo CMS 7 (Apache JackRabbit) in combination with other systems through one JCR interface.

There are many other content solutions out there, so if you can't find a connector that suits your need, you can of course write one yourself and perhaps donate it to the ModeShape project.

Sequencers

One of ModeShapes other interesting features is the concept of sequencers. With sequencers you can gather additional information from a certain item inside the repository and store that extracted information in the repository. ModeShape has quite a few sequencers out of the box:

Compact Node Type (CND) Sequencer
XML Document Sequencer
ZIP File Sequencer
Microsoft Office Document Sequencer
Java Source File Sequencer
Java Class File Sequencer
Image Sequencer
MP3 Sequencer
DDL File Sequencer
Text Sequencers

The example below is of the ImageSequencer, which can gather information from certain types of images stored inside the repository. The ImageMetaDataSequencer is used here to extract metadata like size, dimensions and so on from the image if they have one of the specified extensions and the extracted information is stored somewhere else inside the repository.

JcrConfiguration config = ...
config.sequencer("Image Sequencer")
.usingClass("org.modeshape.sequencer.image.ImageMetadataSequencer")
.loadedFromClasspath()
.setDescription("Sequences image files to extract the characteristics of the image")
.sequencingFrom("//(*.(jpg|jpeg|gif|bmp|psd)[*])/jcr:content[@jcr:data]")
.andOutputtingTo("/images/$1");

Conclusion

With other mature JCR implementations out there I think ModeShapes strongest point is it's focus on content federation. Providing a single JCR interface for content stored in different systems is a great initiative, because the JCR API is quite easy to learn and to use. I see a bright future for ModeShape, since companies are sharing more and more in-house information on the web these days. I myself will try to keep a close eye on ModeShape and see how it evolves.

Lars Peters (Hippo): Why WCM/Portal convergence is a good thing

noreply@blogger.com (Lars Peters) — Wed, 27 Jan 2010 01:01:11 +0000

Stephen Powers' blogpost on convergence between WCM and Portal sparked a nice little controversy about the alleged trade-off between integration and separation of concerns. It ain't necessarily so: If integration is done right, the trade-off does not need to be there at all.

Convergence is a two way street. From the WCM perspective we like to think of Portals as a way to offer 'self service', personalization, security and integration with other applications / widgets / iframes and the like. From the Portal perspective we need WCM to provide tools to work with our portal content that does not reside in other applications.

Both are, of course, nothing new. Neither is the fact that vendors (Hippo with Hippo CMS and Apache Jetspeed Portal is the open source example) have been offering integrated portal offerings for a number of years. Given the challenges and costs involved in true integration, it clearly makes sense to offer integrated solutions as to keep such projects manageable. And who can better ensure integration is done right than the vendor itself?

New in Stephen's post is the fact that he, or rather IBM, sees the package of WCM & Portal becoming such a common combination that distinguishing the two markets would no longer be meaningful. This does not mean that WCM and Portals will become an undistinguishable mesh (or mess?) with the risk of losing all we gained from separating content from the presentation layer in the first place.

It does mean, just like before, that buyers should be careful not to select a package that restricts their choice in where and how to manage and publish their content. It also means that buyers should be critical when making decisions about such things as collaboration platforms. Collaboration systems put in place today, may be with us for many years to come. Where does the content reside? Can it be accessed, altered, integrated in other applications? What about the source code? Remember Lotus Notes?

For maximum flexibility and future readiness in purchasing an integrated WCM & Portal, there are four basic questions to ask:

1. Can the WCM system stand on its own? Would you buy it for its WCM functionality?

2. Can the Portal stand on its own? Would you buy it for its Portal functionality?

3. Are the two really integrated? Integrated user management, security, administration, URL mapping, ease of development etc.

4. Is it Open Source (eg, are you free to use and change the software as you wish)?

David Taylor (Hippo): Jetspeed UI in 2.2.1

noreply@blogger.com (DST) — Thu, 14 Jan 2010 04:01:16 +0000

With this blog post, I introduce the new Jetspeed portal user interface we are developing for the upcoming release of version 2.2.1. For the past several years, the Apache Jetspeed Portal has had two user interfaces:

1. The Portal Pipeline, a server-side, servlet based aggregation engine. The server-side rendering engine was and still is the most common user interface for Jetspeed portals. It has progressed over the years, including the addition of nice features like a multi-threaded aggregation engine, rendering each portlet in parallel on its own thread.

2. The Desktop Pipeline, a client-side, Javascript based aggregation engine. The client-side rendering engine was not the default, and didn't get as much attention as the server-side. That said, I think the desktop pipeline had much more interesting features, with Ajax rendering pipelines serving portlet content to handle parallel rendering requests from within the browser. The desktop pipeline, even though it ran in the browser, still supported the Java Portlet API, adhering to the requirements of action and render phases. It also had some interesting features including drag and drop moving of portlets in either grid or detached mode, and resizing the portlets and layouts.

With version 2.2.1 (still unreleased), we are working on a single rendering engine sharing the same pipeline and code base. This engine can be configured to render portlets on the server-side or client-side. We call this new rendering engine "Jetui", since the client-side code is based on the YUI Javascript library. Jetui already supports many of the drag and drop customization features of the Desktop pipeline, with the addition of several new features. Two interesting new additions are the toolbars: a Page and Space Navigator and a Toolbox.

In this blog I will introduce the Jetspeed Toolbox. The Toolbox is designed to make user customizations very easy in just one click. The toolbox contains three panels:

- Portlet Selector
- Layouts
- Themes

The Portlet Selector can be docked to the left or right side of the page, or it can float freely on top of the page. Portlets can be searched for using this tool, as all portlet metadata is automatically indexed in the portlet registry. Additionally, portlets can be categorized and filtered based on categories (see the drop down list). One click addition of portlets is now possible without ever leaving the page being customized. Portlets are also filtered by secure access. Only portlets that are configured to be viewable to the current user are displayed in the Jetspeed Toolbox.

An interesting new feature is portlet preview mode:

Selecting the theme for the current page or space is as easy as selecting the theme tab and then clicking on the theme. Jetspeed introduces several new themes in 2.2.1:

Page layouts, selected from the Layout tab, provide several default layouts (with more coming).

We are working on integrating the W3C Widgets alongside Java Portlets. Like portlets, widgets will be available for searching and adding from the Jetspeed Toolbar. I will discuss Widgets more in an upcoming blog.

In an upcoming blog, I will talk more about how to use templates to configure tools across pages...

Arje Cahn (Hippo): 2010: the year the E-Reader will become the content managers’ favorite productivity tool

Thu, 31 Dec 2009 11:43:41 +0000

Flipping through my usability notes, I noticed one of our Hippo CMS users mentioned the following about proof-reading:

“There is no printing facility for content in Hippo CMS so everything has to be done on screen. Even if we could print, we can only see a single field, not the whole article, so it's a bit pointless trying to proofread this way. This leads to long periods of time staring at a screen. It's also very difficult to spot typos on screen, leading to potential loss of quality in copy.”

Exactly. Often enough, also I spot typing errors only after having printed out my text (like this blog post), and walking through it again while commuting on the train. The letters start to dance before my eyes when I’m behind a monitor for too long. Sometimes it helps a lot to just put your text aside, do something else for a while, and then return to it on a quiet moment to walk through what you’ve written. So, why not implement a printing functionality in Hippo CMS, to allow authors to take their text with them? Everybody got so used to printing out Word documents anyway, that it baffles me that this idea had never appeared to me before.

So I put the print function on our roadmap.

But somehow, it feels wrong. What happened to the paperless office? It’s almost 2010 (it’s the 31st of December, 11:45 in the morning, as I write this), Kopenhagen happened only a few weeks ago, I’ve been driving the most economical car on earth for years, and I use the printer as little as possible. I don’t want to have a tree cut down for me to be able to proof-read my blog post!

Enter the e-reader. 2009 was the year of the e-reader. A number of those devices already boost a keyboard and the possibility to add annotations to texts, to store them and synchronize them with your PC. And every modern writer nowadays carries an e-reader to read their books anyway, right?

So here’s the thought: let’s make a tool that allows you, after a long day of writing, to take all the texts you’ve worked on with you on your e-reader. You grab your reader again when you sit on the train, where you walk through all passages for typos and make annotations. The following day, you import all those changes back into Hippo, or maybe you’ve already sent them to the content repository over wireless email.

I don’t know whether the latest generation of e-readers are already open enough to share annotations with a content management system. Maybe we’ll have to wait for that to happen in 2010. But at least I found a very good excuse to rush downtown and treat myself with another gadget to go try it out!

Vijay Kiran (Hippo): → What’s Coming from Hippo in 2010

Vijay Kiran — Tue, 22 Dec 2009 11:08:52 +0000

The Hippo CMS team has big plans for 2010. Early in the year they intend to launch a new web 2.0 platform. This open source product is aimed at the enterprise, to ensure “improved communication, collaboration and knowledge retention while lowering the burden on IT resources.”

Features include an integrated approach to user-generated content, an “enterprise mash-up” functionality that focuses on matching content and applications with the needs of individual employees. Each user will get a personalized window to “content and applications inside and (cl)outside the organization, while IT keeps (or regains?) central control over security & access rights.”

Instead of aiming to reinvent popular applications such as Gmail, Zoho, Twitter and Evernote, this new product aims to let companies integrate such tools within their enterprise security umbrella.

via Alert: What’s Coming In Open Source CMS In 2010.

Jeroen Reijn (Hippo): Content mangement and the semantic web

noreply@blogger.com (Jeroen Reijn) — Thu, 17 Dec 2009 10:43:00 +0000

I came across the term 'semantic web' a couple of years ago, when one of the original creators of Apache Cocoon went of to work on the SIMILE Project at MIT. I didn't pay much attention to the concept of 'semantic web' back then, because I just started learning Apache Cocoon and still had a lot to learn.
But over the last couple of months I've been doing some research on the currently available standards for providing semantic data on the web with a strong focus on RDFa.

Content management

Working at Hippo, a CMS vendor based in the Netherlands & USA, makes me think in content and publishing strategies. Publishing information to the web is one of our core businesses, but I've learned over the last couple of month we can enrich our publishing platform even more by providing semantic data. I started my journey by looking around if other CMS vendors are paying attention to semantic web standards. I noticed that only a few of the enormous amount of content management vendors actually put effort in providing semantic web functionalities for their end-users. I think that's a shame, because enrich your pages a lot.
This post should give you an insight on how you could create a website with embedded meta data (with Hippo), but let's first start with some basics.

What's the idea behind the semantic web?

The current web is very well suited for being read by people like you and me. Computers however can only analyze the words on a page, but can not see the semantics of a piece of information on that specific page, that we as people do see.
If you would allow the information on you page to be machine-readable, the computer would be able to analyze your page and extract much more information from it then just being a piece of text. That's where semantic web standards can help out.
Standards for providing semantic data on the web are not new and some of them have already been available for quite some time. Probably the two most well known are: RDF and Microformats. However recently RDFa has been getting a lot of attention by Google, Yahoo and now also the UK government.

What is RDFa?

RDFa is short for “Resource Description Framework in attributes”. This sounds a bit descriptive, but it means that RDFa provides a set of XHTML attributes, which in their turn provide a way of translating visual data on a page into machine-readable hints. So let's take a look at an example of how a simple web page is currently structured.

<html>
  <body>
    <h1>Content management and the semantic web</h1>
    <h2>Jeroen Reijn</h2>
    <p>some information</p>
  </body>
</html>

As you can see in the above XHTML fragment, we have a page with a title, a subtitle and a small snippet of text inside the body of the page. By rendering this HTML fragment in the browser the visitor of this page will recognize this piece of text as being the title and author of the current article on the page. A machine however would need a bit more information to be sure the content can be identified as a title and author. That's where RDFa can help out. By using vocabularies, you can give meaning to specific pieces of content on a page.
Let's see what the above XHTML fragment would look like if we would use RDFa.

<html>
  <body xmlns:dc="http://purl.org/dc/elements/1.1/"> 
    <h1 property="dc:title">Content management and the semantic web</h1>
    <h2 property="dc:creator">Jeroen Reijn</h2>
    <p>some information</p>
  </body>
</html>

As shown in the example, the Dublin Core vocabulary is added to the page first. This is important to be able to use the properties inside the vocabulary later on. Once the vocabulary is in place, we can give meaning to fragments on the page. In the HTML fragment above the h1 is marked as the Dublin Core title attribute and the h2 as the Dublin Core creator attribute. With these properties in place a machine, like a search engine crawler, can now also store this as additional meta data of the page.
One of the main advantages of RDFa is that your content can processed in a more efficient way, which in turn can make your page rank higher then it might have been before.
Big search engines like Google and Yahoo already scan your website for RDFa embedded information, so why not use it?

How to use RDFa in your (hippo) website?

Hippo CMS is a content (centered) management system and it differs from other CMS's in such a way that the information inside the Hippo CMS content repository is not stored or identified as pages, but rather as content. In most cases even reusable content. To be more precise: information stored inside the content repository is stored as JCR nodes and/or properties.
Since the data is just content and not bound to any front-end technology, you can either publish it as XML, (X)HTML with some help from the Hippo Site Toolkit (HST) or any other format you might like.
Now let's take the above HTML fragment as an example and let's see what this would look like on a content level. One of the most important things to mention here is that a JCR repository has the concept of nodetype definitions in which you can configure what your data model looks like. You could compare it with for instance a XML Schema or DTD for a piece of XML, but then for the nodes and properties available in a JCR repository.

Let's first start with our content definition or in content management terms the document type. We will need three fields:

Title
Author
Body (rich-text field)

If you would create a document type with the Hippo CMS template editor, the resulting nodetype definition will end up looking like this:


<'myproject'='http://www.myproject.org/nt/myproject/1.0'>
<'hippostd'='http://www.onehippo.org/jcr/hippostd/nt/2.0'>
<'hippo'='http://www.onehippo.org/jcr/hippo/nt/2.0'>

[myproject:text] > hippostd:publishable, hippostd:publishableSummary, hippo:document
- myproject:title (string)
- myproject:author (string)
+ myproject:body (hippostd:html)

As you can see all three fields are available and can be used later on by any client that can read from the Java content repository. To be able to render this type of information as XHTML, we will be using the Hippo Site Toolkit. The Hippo Site Toolkit uses the concept of mapping JCR nodes to simple Java beans, to be able to have an easier development cycle without having to learn the entire JCR API.

A Java bean representation of the JCR 'myproject:text' nodetype will look like this:

import org.hippoecm.hst.content.beans.Node; 

import org.hippoecm.hst.content.beans.standard.HippoDocument;
import org.hippoecm.hst.content.beans.standard.HippoHtml;


@Node(jcrType="myproject:text")
public class TextBean extends HippoDocument{

    public String getTitle() {
        return getProperty("myproject:title");
    }
    
    public String getAuthor() {
        return getProperty("myproject:author");
    }

    public HippoHtml getBody(){
        return getHippoHtml("myproject:body");
    }

}

As you can see the Java bean is quite straight forward and easy to read.
Now if we want to render the information on a webpage, we can use for instance JSP's with expression language to get the information from the Java bean. The JSP needed for outputting the RDFa enabled webpage can be as simple as this:

<%@ page language="java" %>
<%@ taglib uri="http://www.hippoecm.org/jsp/hst/core" prefix='hst'%>
<html>
  <body xmlns:dc="http://purl.org/dc/elements/1.1/"> 
    <h1 property="dc:title">${document.title}</h1>
    <h2 property="dc:creator">${document.author}</h2>
    <hst:html hippohtml="${document.body}"/>
  </body>
</html>

As you can see it's that easy to use RDFa inside your website if you have a template independent CMS like Hippo.

It gets even better

Using RDFa for simple text can already be a great improvement for you website, but support for other RDFa vocabularies is added on a regular basis. Google recently announced support for RDFa enabled pages with videos (or media) on them. You can provide extra information for your media files to the Google crawler, like the url to the thumbnail that belongs to your video, which can be presented when your video is found as one of the results in a search performed at Google. The possibilities are enormous, so I can see a lot of good things coming from using RDFa in the near future.

I think the role that content management systems can have for RDFa should not be underestimated, since most website these days are backed by some sort of content management system.

For more information on RDFa see:

RDFa for HTML authors, by Steven Pemberton
RDFa.info - A site containing news about RDFa
Google supporting FaceBook Share and RDFa for videos

Jasha Joachimsthal (Hippo): Generate RSS in JSP? Set the locale!

noreply@blogger.com (Jasha Joachimsthal) — Thu, 10 Dec 2009 08:55:00 +0000

The RSS pubDate fields contain dates in a format that may be human readable, but not very handy in a programmer's point of view. According to the RSS specification the date must conform to the RFC822 specification. A typical RSS snippet looks like:

<item>
  <title>Generate RSS in JSP? Set the locale!</title>
  <description><p>Description of the feed item</description>
  <link>http://blog.jasha.eu/2009/12/generate-rss-in-jsp-set-locale.html</link>
  <guid>http://blog.jasha.eu/2009/12/generate-rss-in-jsp-set-locale.html</guid>
  <pubDate>Wed, 10 Dec 2009 09:55:00 +0100</pubDate>
</item>

An easy way to generate this from JSP is using the fmt library from JSTL.

 <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

 <item>
  <title>${item.title}</title>
  <description>
    <![CDATA[<hst:html hippohtml="${item.html}"/>]]>
  </description>
  <link>${link}</link>
  <guid>${link}</guid>
  <pubDate>
    <fmt:formatDate value="${item.date.time}" 
      pattern="EE, dd MMM yyyy HH:mm:ss Z"/>
  </pubDate>
</item>

This seems to look good when you request the RSS feed from your browser. However when you request the same feed from a Java (ROME), a request generator (Fiddler) or just use wget the format of the pubDate field is invalid. It returns "Wed Dec 10 09:55:00 CET 2009" instead of "Wed, 10 Dec 2009 09:55:00 +0100" as value of pubDate. What happened?

Your browser sends a header "Accept-Language" with, hopefully, "en-US" as first value. The JSTL library uses the en-US locale to format the date and the feed gets parsed correctly. The other tools don't send this header and the programmer did not specify a locale for fmt. fmt does not know how to format the date and returns a "Date.getString();".

A workaround for you as requester of the feed is to manually add the "Accept-Language" header to the request with value "en-US". For the JSP developer: the date format for RSS should always be "en_US". Just add this line to your JSP:

<fmt:setLocale value="en_US"/>

Vijay Kiran (Hippo): Easy Forms ß1 for Hippo CMS (Video)

Vijay Kiran — Fri, 04 Dec 2009 04:07:42 +0000

Vijay Kiran (Hippo): EasyForms for Hippo CMS 7 – Some progress

Vijay Kiran — Mon, 30 Nov 2009 17:56:38 +0000

Vijay Kiran (Hippo): EasyForms Plugin for Hippo CMS

Vijay Kiran — Fri, 27 Nov 2009 22:01:11 +0000

Now onto adding more field types and other whizzbang fields and stuff.

Tjeerd D. Brenninkmeijer (Hippo): A short recap of Forge Friday: October 30th

Mon, 16 Nov 2009 11:25:08 +0000

Everyone was invited at the Hippo office's in Amsterdam or San Francisco to participate in the creation of cool projects. Any idea was welcome, as long as it was Hippo related (and could therefore be posted on the Hippo Forge). Last time it was a big success, with the entire Hippo staff coding and having fun. This time they were reinforced with external developers who enthusiastically entered the friendly competition for a wide variety of reasons. Everyone, from consultants taking their first Hippo step to experienced Hippo partners, joined with Hippo colleagues and teamed up to speed-build their forge project. While some teams had some start up problems there were quite a few wonderful Forge projects, sure they could use some polishing and sure it might only work for one corner case, but still, in half a day people created something tangible and -more importantly- something demo-able. And even if people didn't learn anything, they at least had some good food ;-). As a Forge Friday would not be complete without abundant snacks, beer and pizza. Hippo Rijkshuisstijl Archetype The Sourcesense team was the first team to enter the stage. With their plugin (Maven Archetype) it becomes very easy to set up a website which is compliant with the current Rijkshuisstijl, the style guide of the dutch national government. Simple Slide Show Another interesting plugin used the Hippo repository and used its content to present a slide show. Simple, yet elegant and a good example of a new innovative plugin. iPhone While hard to demo on a beamer, the iPhone app which read content from the repository through a REST interface did WOW the audience, the slick interface and the iPhone-factor proved enough to win a second place! Never Gonna Give You Up A newbie team showed their love for Hippo CMS combined it with their other love: Rick Astley. Which resulted in their "Never Gonna Give You Up" project.... Google maps in CMS The search engine, Google, with its seemingly endless amount of tools is a obvious project focus and two teams based their Forge project on a Google component. One allows the user to select an address based on Google Maps (yes, the other way around) which is then stored in the repository. Google Translate The other Google user was the eventual winner of the evening, it used Google translate to automatically present content in various languages, the user could then edit the results and store this in the CMS. This could allow for rapid creation of multiple language sites, while Google Translate is not infallible, it will do the bulk of the work for you (the good old 80-20 rule comes to mind). Here you can find the project on the forge. Tripolis Developers from Tripolis also came to work on a Hippo Forge project. They implemented a connection between the Tripolis Dialogue connector and the Hippo repository. While it did not work to their complete satisfaction, it was shown that the basic concept worked (this time only titles where synchronized, but if you can do a title, you can do the rest ;-). Sysadmin work Our very own infrastructure guys made a plugin which protects your preview website with a password and the access management is done from within Hippo CMS. They earned extra credits by placing their project on the Forge before their demo started. PDF Export What better way to show the versatility of Hippo and the repository then by automatically creating printable .pdf documents? While the result is basic, it is clear that the flexibility of open standards creates an environment in which everything is possible. I hope to see you all next time!

David Taylor (Hippo): Apachecon, Oakland

noreply@blogger.com (DST) — Thu, 05 Nov 2009 02:01:00 +0000

I will be presenting at Apachecon in Oakland tomorrow at 9 AM.

http://www.eu.apachecon.com/c/acus2009/sessions/282

The presentation is less than an hour, introducing new direction in the Jetspeed open source portal, integrating with the Apache Jackrabbit project

Arje Cahn (Hippo): ApacheCon US 09 Evening Meet-ups - Free for all

Mon, 26 Oct 2009 13:01:18 +0000

Monday 2nd, Tuesday 3rd and Thursday 5th of November
Oakland, CA
Content Tech, Hadoop, Lucene, NoSql, OSGi/Felix, SocialAndWidgets, Subversion, Tomcat, Traffic Server Podling, WebCrawlers, WebServices

Join us for a third year of Apache Meetups! Users, committers, managers and developers will come together on the evenings of Monday 2nd, Tuesday 3rd, Thursday 5th of November .

Registration is free of charge, and everyone is invited. Register on the meetup wiki pages:

Monday 2nd (BarCamp Apache during the day)

20:00 - 22:00 NoSqlMeetup Room 1&2
20:00 - 22:00 Tomcat Room 6

Tuesday 3rd (BarCamp Apache during the day)

20:00 - 22:00 Lucene Room 1&2
20:00 - 22:00 OSGi/Felix Room 3
20:00 - 22:00 Traffic Server Podling Room 4

Thursday 5th

20:00 - 22:00 Content Tech 1&2
20:00 - 22:00 Web Services 3
20:00 - 22:00 SocialAndWidgetsMeetup
20:00 - 22:00 Web Crawlers Room 5
20:00 - 22:00 Hadoop Room 6
20:00 - 22:00 Subversion Room 7

If you're interested in any of these popular open source projects, come join us for an evening of presentations and discussion with the creators and committers working on the projects themselves.

Hosted by and located at the ApacheCon, these five special community meetings are taking taking place on the days before the ApacheCon conference in Amsterdam. Entrance is FREE for everyone, so sign up quick!

Location
Marriott Oakland City Center
1001 Broadway | Oakland, CA 94607 | +1 510 451-4000

What is a Meetup?

A MeetUp has a number of key attributes:

Focused on a single Apache project
Organized by the members of the project community itself
Open agenda, anyone can propose a talk, covering a wide range of subjects related to the core project
An opportunity for users, interested people and committers to get together

MeetUps generally happen during the evening, and, most importantly, are supposed to be fun (as well as useful).

ApacheCon is the official conference of the Apache Software Foundation (ASF), drawing ASF Members, innovators, developers, vendors, and users to experience the future of Open Source development. Drawing internationally-renowned thought-leaders, contributors, influencers, and organizations in the Open Source community, ApacheCon offers insight into the culture and community that develops and shepherds industry-leading Open Source projects, including Apache HTTP Server - the world's most popular Web server software for ten years running.

About ApacheCon US 2009

These special Apache Meetups are organized as free side events next to their bigger sister conference, the ApacheCon US 2009.

ApacheCon is the official user conference, trainings, and expo of the Apache Software Foundation (ASF). Celebrating its landmark 10th Anniversary, ApacheCon US takes place November 2 - 6 at the Marriott Oakland City Center, California.

The global conference series gives attendees a 360-degree view into the highly lauded community that develops and shepherds industry-leading Open Source projects, including Apache HTTP Server - the world's most popular Web server software. ApacheCon offers participants the opportunity to deepen their understanding of Open Source methodologies and further advance their participation with like-minded peers in a relaxed, community-focused environment. More than 500 users, developers, and thought leaders are expected to attend.

With engaging keynote addresses, technical presentations, informal networking, Birds-of-a-Feather discussions, and entertaining social events, ApacheCon US 2009 gives participants the opportunity to choose from more than 60 sessions at the beginner, intermediate, and expert level. From mission-critical implementations to groundbreaking technologies, incubating projects, and collaborative development, ApacheCon presenters and faculty are passionate about some of the hottest issues at the heart of the industry.

Jasha Joachimsthal (Hippo): Generate the robots.txt from Hippo CMS

noreply@blogger.com (Jasha Joachimsthal) — Sun, 25 Oct 2009 14:01:10 +0000

The robots.txt is a response from your website that is unimportant for your human visitors but very important for search engine crawlers. That's why we created a Hippo CMS / Hippo Site Toolkit (HST) plugin to manage the robots.txt in the CMS and return the proper output.

The plugin comes with an out of the box document type to manage the parts of the site that are disallowed to crawl for search robots. There's usually one configuration for all crawlers but if you want, you can add multiple configurations per crawler.

In the first screenshot all crawlers should skip "/donotindex/" and "/search/", only "Googlebot" should ignore /hide/for/googlebot and the non existing "EvilBot" is kindly requested not to index the site at all.

Generating the response is mostly configuring the HST response for the request for "robots.txt". The plugin comes with a demo project and documentation how to configure the plugin for your existing project.

In the second screenshot you see the response by the HST for the "robots.txt" request. The HST returns a plain text response with all the fields we've configured in the CMS.

Vijay Kiran (Hippo): Hippo Forge Friday

Vijay Kiran — Fri, 23 Oct 2009 04:38:16 +0000

On October 30th, we at Hippo are organizing the free Forge Friday hacking event. If you are using any software from Hippo or interested in implementing it in the future or even just wanted to know more about Hippo Software, this is a great time to come and join us during the Friday Forge event.

You don’t need to have any prior experience with Hippo software or codebase. The focus of this event is to hack some cool plug-ins for Hippo CMS or Hippo Site Toolkit Components and in the process learn more about hacking Hippo Stack in general. You can walk into either one of Hippo Offices across the pond (Amsterdam or San Francisco).

So join us and learn more about Hippo CMS, HST2, Portal, Repoisotory. We’ll help you with building your own plugins, portlets, components, extensions. You can use our very own Hippo Forge to publish your project and earn eternal fame!

Here’s the Signup Page for the event. If you want to more information about the event.

Here are some links about the event:
→ Forge Friday Announcement - Tjeerd’s Blog
→ Forge Friday - Arjé’s blog.
→ Forge Friday Wiki Page
→ Forge Friday Signup Page

Arje Cahn (Hippo): Hippo Forge Friday: October 30

Thu, 22 Oct 2009 10:08:02 +0000

Get your hands dirty with Hippo, the open source Java CMS and Portal framework that everybody talks about. Join us for this free Hippo Forge Friday plugfest! We've scheduled an afternoon of free flow Hippo coding on Friday, October 30 in

Tjeerd D. Brenninkmeijer (Hippo): The Hippo hunting season has been opened!

Wed, 07 Oct 2009 16:23:13 +0000

Last week I was in Paris for the Open Source World Forum. And looking at my travel plans for the upcoming months I noticed that the conference season has started again. For us this means driving around with big boxes of orange-anti-stress-hippos, lots of demos, contacts with new people, meeting old acquaintances and off course free beers ;-) s So if you always wanted to meet a Hippo in real life? Now you have the chance... Hippo's will be all around the globe to visit, sponsor, speak and organize conferences and meet ups. If you want to join us this year in our quest, please have a look below and see where we will be hanging around the upcoming months: Financial crisis? Get more value out of your information! The Hartman Event will teach you everything about strategies, methodologies, techniques and tools that create a perfect marriage between information and your customer. On October 8, you can meet national and international gurus and peers who will combine theory and best practices in an educating and interactive style. Block your agenda for the first international Hippo Forge Friday on the 30th of October! Spend an afternoon together with the core Hippo developers to build the Hippo component you always dreamed of! A Google Analytics plugin, an image resizer, a Jira portlet, a Lightbox HST Component - as long as you think it's cool enough to turn into a Hippo Forge project, you're in! Whether you're an experienced Hippo hacker or a complete newbie, come join us for some proper coding fun, beers and food. If you don't know where to start - we'll help you get on track :) Apache celebrates its 10th anniversary of the Apache Software Foundation in Oakland, California from 2-6 November and the other 10 year old, Hippo, will be there to join in the celebrations. We can't give away too much about the program just yet, but expect a lot of Hippo folk to be there. If you want to register or find more info, please click here. Hippo will be business partner at the Jfall congress for the members of the Dutch Java User Groep (NLJUG) again in 2009. An interesting program guarantees a fully packed day with Dutch and international speakers who will share their vision on divers JAVA topics. Visitors can attend lots of sessions around the different techniques and methods. JBoye09 is a conference born out of a desire to let people share and learn in an open environment all about content management. It is an intense event with discussions, demos, and interaction from attendees. The main objective is (as it has been from the beginning) to create an open minded conference with a campus like atmosphere for online professionals. Here our global audience can meet and exchange experiences and knowledge in a professional, yet informal atmosphere. Moreover, our social events during the conference offer unrivalled networking opportunities. Jboye09 Join us at the 6th Annual Gilbane Conference in Boston about "Content, Collaboration & Customers". As the lines between content technologies continue to blur, the business implications of your content strategies need to be crystal clear. You need to make your web content part of an integrated platform for customers, partners, and employees. You need to understand which social media outlets fit into your overall content and communication channels. And you have to hold down costs for content management and delivery in ways that don't slow down your company's ability to innovate and grow. If you can't make it to one of these places, just sign up for the events RSS on our website.

Lars Peters (Hippo): Do it yourself software

noreply@blogger.com (Lars Peters) — Tue, 22 Sep 2009 03:54:00 +0000

Recently I refreshed my memory on a company my friend Alef Arendsen, then at SpringSource, pointed out to me. Charles Simonyi of Intentional writes that “all too often the knowledge and insights gained during the development disappear into the details of the code”.

Although Intentional as a company has been around since 2002, and its ideas date back to the 90’s, this is still very much where business software is at today. The need for specialized engineers to get involved to build applications or websites, comes at a loss of direct influence and knowledge about the things that you need to build. Companies that are able to successfully bridge this gap, can produce stunningly usable software that others just don’t seem to get right: Google and Apple are the obvious examples.

In this light Content Management Systems have always been about putting direct control back into the hands of business. When trying to create web pages, back in the early/mid ‘90s, I had to teach myself a bit of HTML for even the simplest piece of green text on a black background. With business software this is no different. While years back for every 1 or 0 you needed a team of programmers, now many of us with simple development skills can create very complex and powerful applications.

Most of these developments stop short of one final step: new technology has empowered the developer, but you still need programming skills to get sophisticated enterprise applications up and running. The business users or ‘lay programmers’ as Martin Fowler calls them here, remain dependent on the IT community to realize their ideas. Hence business users stretch the boundaries of the tools they control: multi billion dollar projects with 1000s of people are entirely managed with cleverly designed spreadsheets.

The first step in CMS development was to take the developers out of the loop in changing content on the website. With this 'Do-it-yourself' software a company did not only dramatically reduce the cost of maintenance, it also enabled business users to control the content directly. This in turn solved many of the translation problems on early websites. With a CMS it was immediately clear what a text would look like online. Text could be correctly fitted and the author could place pictures exactly where he wanted.

Today even the simplest CMS has solved this problem and it is time to push the bar a bit higher: giving business the power to change and build complex websites integrating existing applications without IT support: so it does not require a project proposal and 4 months queuing time to get a new site live. And yes, it would be nice if it could all run on an invisible internal or external cloud infrastructure, so you would not have to worry about plugging in an extra server or getting the backup hooked up.

The benefits are clear: No more ridiculously detailed requirement sheets, no more blame game when the results don’t meet expectations in spite of this effort, and much, much shorter cycles – removing an entire layer of ‘friction’ between customer and producer.

None of this is new – but in practice many challenges remain. While those in the know seem to be able to develop great looking, complex integrated sites in a matter of days or weeks; the average business user still fumbles with his Excel spreadsheet. And while the developer community has largely embraced the open source development model, participation of business users is notably low. With business users largely sidelined, there is a permanent danger for open source projects to lose track of the ‘business intent’ of a project. In projects where the engineers and business end users are one and the same, this danger is relatively low, but with any software that moves up the enterprise ladder, the dangers of a disconnect grow. On the bright side: if successfully tackled there seems to be a terrific opportunity for open source companies to involve more business users in their projects.

Ideally the end result of such a project is not only a CMS driven website or a content driven portal, but a system that allows users to use this as a starting point, with easy to use interfaces for creating additional websites and/or portals.

Here are a few things we do at Hippo make it easier for our partners and customers to build such environments:

Provide direct and user friendly access to administrative interfaces; eg, drag and drop Portlet selector for Jetspeed Portal 2
Give access to functionality previously only available to programmers through a user friendly UI: eg, Nested Template Picker, Site control functions in CMS 7 or space creation in Jetspeed Portal 2.
Involve end-users in ongoing road map meetings, not just during the requirement / delivery phase
And of-course: Develop products with a keen eye on keeping things clean and nimble for the daily user

So we're not quite at the full realization of Simonyi’s lofty goals yet, but rapid development environments and the rise of cloud infrastructures provide an opportunity to involve business users in different ways than before. Companies definitely seem eager to embrace it.

Jeroen Reijn (Hippo): Apache Cocoon and Javascript minification

noreply@blogger.com (Jeroen Reijn) — Tue, 15 Sep 2009 20:01:17 +0000

A couple of days ago somebody on the Apache Cocoon user list send a message to the mailing-list about on the fly minification of for instance Javascript files. This topic has been quite popular over the past years, since web application have become richer and Javascript files have become larger.

The ideal situation would be to compres your static files (CSS or Javascript) at build time, so this will not cost you any processing power, when your application is already running. I myself quite often use the Maven 2 YUI compressor plugin while building my projects, but in case you can't use this plugin you could think about a different solution. Since I've been using Cocoon for over more then 5 years, I thought I gave it another try and write a nice Cocoon reader that does this minification for you.

There are multiple minification and obfuscation frameworks out there. One has a greater compression ratio then the other, but for me the most well know ones are probably:

Dojo Shrinksafe - Rhino based compressor from the Dojo Toolkit
YUI Compressor - Rhino based compressor by Yahoo
JSMin - a whitespace compressor by Douglas Crockford

Since Apache Cocoon comes with a version of Rhino and both #1 and #2 have their own version of Rhino included, this could end up having nasty conflicts because of two different versions of the library on the same classpath. Therefore I chose to write a reader based on JSMin, which does a lot of whitespace compression for you.

The implementation of this reader was quite simple and if you're interested, you can get the source here. Do keep in mind that you will have to have the JSMin.java file also on the classpath, otherwise it wil not work.

Tjeerd D. Brenninkmeijer (Hippo): Block your agenda for the international Hippo Forge Friday on the 30th of October

Wed, 26 Aug 2009 14:18:36 +0000

Forge Friday sounds cool, but what is it? The goal for everyone, so all developers, technical support engineers, architects, sys admins, hackers etc. is to build a CMS plugin, a portlet, a repository addon, a HST component, or something else that you think is cool enough to turn into a Hippo Forge project (and win the big prize(s)! ;-). On Friday the 14th of August Hippo had its first international Forge Friday, a joint effort between the offices in San Francisco and Amsterdam. We had a full afternoon and evening of pure hacking, a big BBQ, beers, and of course: geeky prizes. Besides building forge projects the overall goal is also to share knowledge between all the different people in our offices in Amsterdam and San Francisco and do something different for a day. So build a portlet when you've been building HST components all of your life, or build a CMS plugin when you've been building portlets since the Americans set foot on the moon. For this special occasion we built a brand new Forge Portal (a mashup of Hippo CMS, Jetspeed & Google ideas). On this Portal employees could submit ideas of what they think would be useful to create or (also important) fun to work on. During an intensive and fairly warm afternoon in our brand new office space you could feel the creativity and energy flowing. Groups were formed in such a way that teams were mixed as much as possible to get a maximum cross-over of knowledge and skills. And the results were amazing. Not only did it seem possible to create a forge project in less then a day, it was even possible to make it work and demonstrate it to the rest of the colleagues. There were no restrictions to the projects chosen, but there were some for the presentations: - Whatever you build has to be targeted towards the latest stable or Trunk versions of Hippo CMS 7, Jetspeed 2.2, HST 2, Hippo Repository 2, or a combination; - Your code has to be ready at 20:00, and demoed live, in a 2 minute elevator pitch; - Your demo has to be accessible over HTTP from within a web browser (ie - from the jury laptop); - You have to submit your demo by adding a URL to the submission page, after which the jury will randomly pick demos from the list; - You have to assign a presenter for your demo. Only one person is allowed to touch the keyboard and mouse. And make sure to test your demo remotely :-); - No slides or code is allowed; the only thing that you'll be judged upon is the running demo; Results of the day: 9 forge projects presented. Interesting components were built that are more or less usable for clients right away. Good integration between the different technologies, lots of interaction between departments / developers, 20 kilo of meat, 60 liter of beer, 1 bottle of cola... This was just the first day in a hopefully long series of Hippo Forge Fridays. We think there are lots of you out there who would like to dive deeper into the Hippo products and built new components together with the experts in the specific Hippo / open source fields. Therefore we decided to organize the first Hippo Forge Friday for everyone who would like to participate in or contribute to the Hippo community. So here we go: What: First international Hippo Forge Friday with friends When: October 30th from 14.00 until 21.00 (CET) Where: Hippo Office Amsterdam, Hippo Office San Francisco or join us through skype/ internet etc Why: To learn all about the Hippo products, create new or expand the current plug-ins, HST components, portlets etc. And to win eternal fame by earning one of the prestigious prizes in the following categories ( The Wow! Factor award, Most customer friendly, Most promising, And of course.. The Nice Try Award (too bad it didn't work out)) Cost: Free (as in free beer ;-) Who: Everyone who has a Hippo heart. If you are interested in joining or want more information, drop an email at "forgefriday at onehippo dot com".

Shane Smith (Hippo): Looking for parameters settings on a hst component

noreply@blogger.com (shane smith) — Thu, 20 Aug 2009 08:48:00 +0000

Finding all components with a certain parameter setting,
You can use in cms/repository:
//*[@hst:parametervalues='value']

Shane Smith (Hippo): Removing meta files

noreply@blogger.com (shane smith) — Wed, 19 Aug 2009 15:01:12 +0000

Note:
Removing meta.xml files for a gallery import from a dav export:
find . -iname '*.meta.xml' -exec rm '{}' \;

Jeroen Reijn (Hippo): Japanese and Java resource bundles

noreply@blogger.com (Jeroen Reijn) — Fri, 07 Aug 2009 16:01:17 +0000

At Hippo we have a project, which is build with Java Server Faces, for which I occasionally do some maintenance. A while ago I had an issue in our JIRA bug tracker that reported an error for the Japanese version of the website. The error came from a component that reads information from a resource bundle properties file, which is stored on the local filesystem. In this case from the Japanese version of the resource bundle (ApplicationResource_jp.properties), which is used by the web application to display some Japanese labels.

The error wasn't very clear since it only gave the following exception:

java.util.MissingResourceException:
Can't find resource for bundle java.util.PropertyResourceBundle, key 'somekey'

Looking in my project, I could clearly see that the resource bundle was there and after a quick peek at the resource bundle file itself, I could see that the requested key was also present.

After trying some different options I came to the conclusion that my web application was unable to read the actual .properties file from the classpath. By searching some more, I found out that the Java compiler and other Java tools can only process files which contain Latin-1 and/or Unicode-encoded (\udddd notation) characters. Since I was seeing Japanese characters when opening the properties file, it was clearly the case that this file did not meet those requirements.

Solving this issue was quite simple in the end, since the Sun JDK comes with a utility to help you out with files that contain characters, which are not Latin1. The utility is called: 'native2ascii' and can be run from the command-line quite easily by typing:

$ native2ascii [inputfile] [outputfile]

Once I did that the application was working like a charm again!

Vijay Kiran (Hippo): Video: How to add a workflow step to Hippo CMS 7

Vijay Kiran — Fri, 07 Aug 2009 10:54:44 +0000

Berry explains how to add a workflow step to Hippo CMS. This video tutorial takes you through the process of adding a button to the CMS that calls a workflow action on the repository.
You can find the discussed code on the Hippo Forge: forge.onehippo.org/projects/workflow-action/

via: Arjé Cahn

Shane Smith (Hippo): HippoOnRails: Experiment 2

noreply@blogger.com (shane smith) — Wed, 05 Aug 2009 20:40:00 +0000

Introduction

In this experiment I'll show you how you can set up your own application within 15 minutes, with Hippo on Rails.

Prerequisite

For this to work you will need to have set up a working HippoOnRails example project.

Start up

Start the cms: mvn jetty:run-war

Open up the console and add another node to the root node, call it ToDos

Start the ruby server: jruby script/server

Next open up a console and generate the code with the normal ruby scaffold:
jruby -S script/generate scaffold todo deadline:date title:string description:text

Open up the model and extend the todo model from the jcr, add the columns (plus id column) and the table name, it should end up looking link this:
The set_new_record method is necessary to edit the node values, instead of creating new values each time. This is a result of the hack were using to set up this experiment.

Don't forget to ad an id column, rails needs this to create the urls for your model.

Now fire up your webbrowser once again, point it to http://localhost:3000/todos, and see your results.

This is it, it's this easy to set up a very basic application in HippoOnRails.

If you have any problems setting this up, don't hesitate to ask for help with your HippoOnRails experiment on our forum.

Shane Smith (Hippo): Hippo on rails

noreply@blogger.com (shane smith) — Tue, 28 Jul 2009 05:00:00 +0000

an experiment

Intro

My employer, onehippo, challenged me to create a Ruby on Rails demo connecting to the Hippo JCR repository. So I took the two examples from day.com and tweaked them into one file until I had a working example.

Preparation

To run the example application you will need to install jruby and some java library files, the onehippo cms and the hippoonrails example application.

To download and install jruby and rubyonrails, follow this tutorial.
You will also need some of these jars in your jruby/lib dir.

If you don't have a hippo repository, then download the hippo quickstart war file.

svn checkout http://forge.onehippo.org/svn/hippoonrails/tags/phonebook_1_0_1/

Getting everything to work probably took some time. If you have any questions or need some help, don't hesitate to ask them on the hippoonrails forum

If you are still here, then the next few steps should be a breeze. :-)

The example hippoonrails application

First go to your cms (quickstart) directory and run it with: mvn jetty:run-war

Go to your cms console (http://localhost:8080/cms/console) select the root node and add the node people (nt:unstructured) needed for the example application

Next go to your hippoonrails example application and start the webbrick server: jruby -S script/server
Then fire up your webbrowser and go to http://localhost:3000/people

You should be able to create a new person, edit and delete it.

That was easy now, wasn't it?
Next stop, set up your experiment with scaffold and the basewithouttables/jcr connector hack.

Niels van Kampenhout (Hippo): Creating a new document through the Hippo Repository Workflow API

noreply@blogger.com (Niels) — Tue, 23 Jun 2009 21:33:00 +0000

It's already a couple of months ago that I wrote about using the Hippo Repository Workflow API. Back then, I explained how to modify an existing document, and request publication. Ever since that blog post I have been getting the same question over and over again: how to create a new document through the repository API?

If you read the previous blog post, and looked at the worklfow API, it might not be directly obvious how to create a new document through the workflow. Think about how a document is created though: it is always created as a child node of an existing node: the parent folder. Creating a new document is actually part of the Folder Workflow!

Knowing this, it all becomes very easy. Let's step through the code:

Let's hardcode some values for simplicity's sake:


String folderPath = "/content/documents/news";
String newDocumentName = "Hippo CMS 7.1 released!";
String newDocumentType = "defaultcontent:news";

We will be creating a new document inside the folder /content/documents/news. This is actually a node of type hippostd:folder, which means a FolderWorkflow applies to this node. We will be creating a new document of type "defaultcontent:news", as provided with the Hippo CMS Quickstart WAR. We will call the new document "Hippo CMS 7.1 released!".

Next, we get the folder node from the repository session:


// get the folder node
HippoNode folderNode = (HippoNode) session.getItem(folderPath);

We also need the workflow manager:


// get the workflow manager
HippoWorkspace workspace = (HippoWorkspace) folderNode.getSession().getWorkspace();
WorkflowManager workflowMgr = workspace.getWorkflowManager();

Using the workflow manager, get the folder node's workflow:


// get the folder node's workflow
Workflow workflow = workflowMgr.getWorkflow("internal", folderNode);

Check if the workflow is a folder workflow, and cast it to a FolderWorkflow object:


if (workflow instanceof FolderWorkflow) {
    FolderWorkflow fw = (FolderWorkflow) workflow;

Now that we have the folder workflow, we can simply call the add method. It takes three String parameters: the category ("new-document"), the node type, and the node name:


// create the new document
fw.add("new-document", newDocumentType, newDocumentName);

That's it! Run the program, and check your CMS. There should be a new document "Hippo CMS 7.1 Released!" visible under the "news" folder. You can edit and publish this document just like any other. To modify the document through the API, see my previous post on this subject.

For your convenience, here is the complete class:


package org.example;

import java.rmi.RemoteException;

import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.hippoecm.repository.HippoRepository;
import org.hippoecm.repository.HippoRepositoryFactory;
import org.hippoecm.repository.api.HippoNode;
import org.hippoecm.repository.api.HippoWorkspace;
import org.hippoecm.repository.api.Workflow;
import org.hippoecm.repository.api.WorkflowException;
import org.hippoecm.repository.api.WorkflowManager;
import org.hippoecm.repository.standardworkflow.FolderWorkflow;

public class CreateDocument {

    public static void main(String[] args) {
        Session session;
        HippoRepository repository;
        try {
            repository = HippoRepositoryFactory.getHippoRepository("rmi://localhost:1099/hipporepository");
            session = repository.login("author", "author".toCharArray());
            
            String folderPath = "/content/documents/news";
            String newDocumentName = "Hippo CMS 7.1 released!";
            String newDocumentType = "defaultcontent:news";

            // get the folder node
            HippoNode folderNode = (HippoNode) session.getItem(folderPath);
            
            // get the workflow manager
            HippoWorkspace workspace = (HippoWorkspace) folderNode.getSession().getWorkspace();
            WorkflowManager workflowMgr = workspace.getWorkflowManager();
            
            // get the folder node's workflow
            Workflow workflow = workflowMgr.getWorkflow("internal", folderNode);
            
            if (workflow instanceof FolderWorkflow) {
                FolderWorkflow fw = (FolderWorkflow) workflow;
                
                // create the new document
                fw.add("new-document", newDocumentType, newDocumentName);
                
                System.out.println("New document '" + newDocumentName + "' of type '" + newDocumentType + "' created");
            }
            else {
                System.out.println("Workflow is not an instance of FolderWorkflow");
                return;
            }
            
        } catch (RepositoryException e) {
            System.out.println(e.getMessage());
        } catch (RemoteException e) {
            System.out.println(e.getMessage());
        } catch (WorkflowException e) {
            System.out.println(e.getMessage());
        }
    }
}

David Taylor (Hippo): Roadmap Jetspeed 2.2.1

noreply@blogger.com (DST) — Fri, 19 Jun 2009 21:31:00 +0000

I am sketching out a Roadmap for the next Jetspeed release, version 2.2.1. Here was my original plan for 2.2.1, to be based on maintenance and improvements to 2.2.0:

Old Roadmap for 2.2.1

Advanced Portlet API 2.0 Support
Data Migration from 2.1.x to 2.2.x
Bug and Performance fixes to initial 2.2.0 release
Complete implementation of optional JSR-286 Cache features
Improved User and Site Browsing in Admin Portlets
Registry Export

As time passes, priorities change. I have been working with the Hippo Enterprise Content Management suite quite a bit lately, and I realized Content Management goes hand and hand with portals. It is about time Jetspeed gets content management features too. We were originally planning on implementing JCR features in version 2.2.2. After discussions with other team members, we are now looking at the following feature sets for JCR as the top priority for the 2.2.1 Roadmap:

Site and PSML persisted in JCR (Jackrabbit) Repository
Navigation integration with repository: portal can navigate directly to bookmarked content
Automatic publishing of content from repository, immediately accessible in portal
Security synchronized with JCR security

We will still need to provide Data Migration for 2.1.x users, thus the new high level Roadmap for 2.2.1 is as follows:

New High Level Roadmap for 2.2.1

Site and PSML persisted in JCR (Jackrabbit) Repository
Navigation integration with repository: portal can navigate directly to bookmarked content
Automatic publishing of content from repository, immediately accessible in portal
Security synchronized with JCR security
Data Migration from 2.1.x to 2.2.x
Bug and Performance fixes to initial 2.2.0 release
Registry Export

With full Portlet API 2.0 support from version 2.2.0, and JCR support coming in version 2.2.1, we are planting the foundation for developing Java enterprise applications mixed with content.

Vijay Kiran (Hippo): Customizing Hippo CMS – Getting Started

Vijay Kiran — Fri, 19 Jun 2009 13:59:41 +0000

This post is part of a series which will be focusing mainly on Hippo CMS’s extensibility. These posts are more targeted towards the developers who want to customize and enhance the core CMS functionality.

Introduction

Hippo CMS is part of the Hippo’s Open Source Enterprise Content Management System. It provides a browser based user interface for managing the content in the Hippo Repository. Hippo CMS is fully customizable and developer friendly CMS that provides various ways to extend its functionality.

Hippo CMS application is built using Apache Wicket, one the best frameworks available today for building web applications using Java. Wicket is known for its simplicity, and its component-oriented programming, thus providing solid base for the Hippo CMS.

Hippo CMS has pluggable architecture which boasts of first class plug-in mechanism. Depending on your needs, you can create complex document types, extend and enhance the user interface and even create a combined add-on that can change the Core CMS and even replace. All you need to know to build the GUI add-ons is Java and Wicket.

I’ll try to explain each of these extensibility in detailed examples in this series of blog posts. So let us get started.

Yesterday we have announced a new version of Hippo CMS (version 7.1) and Hippo Site Toolkit 2(Version 2.03.09).

Getting and Building Hippo CMS
I’m assuming you are using a Unixy Operating system (Linux/Mac OS X). If you use windows replace the commands appropriately.

Before starting to checkout the source and building please make sure you have the following installed on your computer.

Open a command line and check out the code for Hippo ECM using following command. Please note that if you are using an graphical client such as Tortose SVN, then you can checkout using the appropriate menu option.

svn co http://svn.onehippo.org/repos/hippo/hippo-ecm/tags/Tag-HREPTWO-v2_06_06 cms-7.1

Now change to the cms-7.1 directory and build the Hippo ECM using maven.

cd cms-7.1
mvn clean install [-DskipTests]

If you are getting out of heap space error, set the MAVEN_OPTS using the following command:

export MAVEN_OPTS="-Xms256m -Xmx700m -XX:MaxPermSize=1024m"

If you are building for the first time, please note that it may take some time since maven needs to download all the dependencies. Once you are done with building Hippo ECM and you can run the provided Quick-start WAR file to get a feel of the user interface and the CMS application.

Change to the quickstart/war directory and run the hippo-cms web application using embedded jetty.

cd quickstart/war
mvn jetty:run-war

After jetty has been started, goto http://localhost:8080/cms to check the version of the CMS that you’ve just built. You can login using default username/password combination of admin/admin.

Hippo CMS Login Screen

Note that you can even deploy the generated war file in Tomcat or an Application Server. Check the documentation for more information.

This concludes the first part of Hippo CMS Customization Part 1- Getting Started . In the next post of this series we will see how to create a simple backend templates (a.k.a Document Types) using Document Type Editor provided within Hippo CMS.

Mathijs Brand (Hippo): Limited choices

Mon, 15 Jun 2009 15:55:36 +0000

I don't like to make choices. For me the best choice in life is - no choice at all. For example: I like to drink coffee. Any kind

Jeroen Reijn (Hippo): JCR: Sorting on child node properties

noreply@blogger.com (Jeroen Reijn) — Sat, 13 Jun 2009 17:01:11 +0000

A JCR repository, like Apache Jackrabbit (basis for Hippo CMS 7's content repository), mainly consists of nodes and properties.
As described in the JCR specification, a Java Content Repository should support 2 different query syntaxes: XPath and SQL. Once you get the hang of the syntax, performing a search on a JCR repository is quite easy, but today I came into a situation where I was not able perform the query I wanted. In this post I'll try to describe what my problem was and how the same result can still be achieved.

The content model

Let's first start with my content model. The actual node definition for my project looks something like the below:


[myproject:metadata]
- myproject:creator (string)
- myproject:language (string)
- myproject:publicationDate (date)
- myproject:availableUntil (date)
- myproject:lastModified (date)
- myproject:keywords (string)
- myproject:contributor (string)

[myproject:news] > hippostd:publishable, hippostd:publishableSummary, hippo:document
- myproject:title (string)
+ myproject:introduction (hippostd:html)
+ myproject:body (hippostd:html)
+ myproject:metadata (myproject:metadata)

I came into a situation where I wanted to search for nodes of type 'myproject:news', but sorted on the 'myproject:publicationDate' property of the 'myproject:metadata' subnode. Writing an XPath for such a query is quite easy if you're familiar with the XPath syntax.

Let's start out with a very simple search and just search for nodes of the type 'myproject:news' , which in XPath looks like:


//element( *, myproject:news)

Now if we would want to order these node types based on for instance the myproject:title property the same XPath query looks like:


//element( *, myproject:news) order by @myproject:title descending

Now if we would want to sort on the 'myproject:publicationDate' property of the myproject:metadata subnode, I would expect the same XPath to be:


//element( *, myproject:news) order by myproject:metadata/@myproject:publicationDate descending

Unfortunately this query did not seem to actually sort the result on the publicatenDate property as I would have expected. I was searching for typos first, but it appeared that the syntax of my query was ok, but it appeared that support for child axis in order by clauses was not yet supported by Jackrabbit itself.

Then I found this JIRA issue[1] in the Jackrabbit bugtracker describing this problem and there appears to be a patch available. I'm still wondering how much of a performance impact this might have for large repositories, where you might want to sort on a property of a child node 'n'-levels deep underneath the actual node.

If you want to sort on properties of a specific nodetype, you will have to add the sortable properties to the actual nodetype, which you are searching for and can't put them on a subnode.
It seems that the patch, which should fix this problem, has already been comitted to the Jackrabbit trunk and should be available from Jackrabbit 1.6.0 as marked in the JackRabbit JIRA.

Woonsan Ko (Hippo): Spring Web MVC framework support in HST-2

Fri, 05 Jun 2009 16:28:37 +0000

Spring Web MVC framework support in HST-2

HST-2 has provided a basic support to enable developers to utilize Spring Framework IoC container for HST components. [1]
Now, HST-2 provides even more. It supports Spring Web MVC Framework based applications under HST-2 environment! Using

Jasha Joachimsthal (Hippo): Hippo Site Toolkit Query interface and pagination

noreply@blogger.com (Jasha Joachimsthal) — Thu, 04 Jun 2009 18:01:43 +0000

Today an interesting question came from a developer of one of our implementation partners. He wanted to list items from our JCR repository and use pagination. In this post I tried to make a summary out of the conversation.

The query was:

HstQuery query = getQueryManager().createQuery(requestContext, scope, filterBean);
Filter filter = query.createFilter();
filter.addContains(".", "my keywords");
query.setFilter(filter);
HstQuery queryResult = query.execute();

The developer tried to get a paged result and the total number of items with:

query.setOffset(0);
query.setLimit(10);

HippoBeanIterator hits = queryResult.getHippoBeans();        
hits.getSize();

The result contained indeed 10 items but hits.getSize(); also returned 10. What's going wrong? Ard Schrijvers explained:

If you use setLimit(3), you will get at most 3 hits, but never more. getSize() from the queryResult returns at most 3. Even if the search criteria matched hundreds of documents. If you use offset(10) and no limit, getSize() returns just 10 hits less then without the offset.

This limit is there to be used for performance, and suits for example very well "show last 3 agenda items on homepage".

If you need paging and only want 10 results, do not use setLimit(int limit).

What you do use, is just the query without setLimit(). Then you'll get back a queryResult, from which you get a HippoBeanIterator. This is a normal Iterator, with some extensions. A very important one is the method skip(int skipNum).

From the HippoBeanIterator, you can simply iterate the beans you need. Make sure you use skip(int skipNum) to jump to the correct place. If the current page is 11 and pagesize is 20, set skipNum to 220.

Then fill your List in a for loop from skipNum - skipNum + pageSize.

What about performance?

The skip is propagated to the JCR NodeIterator. If you want to display item 100-110, and you use skip(100), still only 10 Beans will be created. JCR nodes for Beans 0-99 are not fetched.

What if you need the total number of hits?

Use getSize(). The getSize() on the the HstQueryResultImpl or on the HippoBeanIteratorImpl does not actually populate the entire iterator with HippoBeans. It is a call through the JCR NodeIterator, which in JackRabbit is some lazy loading iterator, and, where the getSize is propagated to the executed query, without fetching actual nodes.

Niels van Kampenhout (Hippo): HST Components at Hippo Forge

noreply@blogger.com (Niels) — Thu, 21 May 2009 18:01:42 +0000

In the past couple of days I slapped together two simple components for use with the Hippo Site Toolkit 2: RSS Feed Creator and List Builder. At this moment, their names are more fancy than their actual functionalities ;-) but the idea is to provide some basic building blocks that people can take and extend. Both components are hosted at Hippo Forge, so the source code is available and you can do with them whatever you want. Go ahead and take them for a test drive. If you think you can improve them (not that hard), feel free to contribute your work. I am happy to apply your patches. I might even consider giving you commit rights! ;-)

The Forge is actually starting to become a well stocked library of CMS and HST components. Check out the Related Items Plugin; It helps you creating a list of documents related to the one you are editing, by making suggestions. Just one example of reusable functionality that you can add to your CMS project. Doesn't match your exact requirements? Adapt it, it's open source! Made a component for your project that is useful for others? Add it to the Forge!

Jasha Joachimsthal (Hippo): I don't want to register before downloading

noreply@blogger.com (Jasha Joachimsthal) — Sat, 16 May 2009 12:01:19 +0000

Okay I just wanted to try the "community edition" of some software. So I clicked on the big download button and then... I had to login. Because I don't have an account yet I had to register first. So I filled in all required field like my email address and a free to choose password without any help message about it's strength and then I got this error message:

Password not strong enough. Please use at least 3 of the following prerequisites:lowercase (a-z), uppercase (A-Z), numbers (0-9), and special characters (!^%#$@*.,)

Come on, I just want to try some software. Just let me download it without creating an account I will probably never use again. When I want to post on your support forum that's the right moment to create an account. I wonder if these companies have ever looked into their website statistics to see at which point people quit.

Vijay Kiran (Hippo): Debugging maven-jetty web application in NetBeans

Vijay Kiran — Tue, 12 May 2009 14:56:00 +0000

Setup Jetty to run with Debugging enabled on port 8000

export MAVEN_OPTS="

Jasha Joachimsthal (Hippo): Hippo developer training

noreply@blogger.com (Jasha Joachimsthal) — Mon, 27 Apr 2009 06:20:00 +0000

Hippo let me follow the three day developer training for CMS 7 and Hippo Site Toolkit 2 (HST2) by Jeroen Reijn. I don't live inside a cocoon so I knew already which new products had been developed. Until now I hadn't done any implementation yet with Hippo CMS 7 and the HST2 because I was too occupied with Hippo CMS 6 projects. Since I'm also a Hippo trainer it was a good chance to get to know our new training programmes.

Day 1: introduction

After we received the handouts of the training we introduced ourselves. It was a pretty mixed group with developers from partner implementation companies, an independent consultant, developers from a customer and me. Jeroen explained the Hippo architecture which is basically still the same as with version 6 but based on different technologies. The WebDAV repository has been replaced with our JCR Repository (based on Apache Jackrabbit) which also uses Apache Lucene for fast indexing & searching. Hippo CMS 7 is still an application that runs separate from the repository and has been written in Apache Wicket. For front end applications you're free to choose a technology but Java is recommended because of the J in JCR ;)

Jeroen showed us the CMS and the Console to show what's happening inside the repository. The trainees all got a laptop from Hippo with a VirtualBox image for the training to "play" with the CMS and the console. No need to bring your own laptop for the first two days!

Day 2: changing templates and HST2 introduction

After some explanation we started to create our own document type. We used version 2.03.00 (later versions have some issues with the graphical template editor which are being solved soon). With just a few mouse clicks I had a "blogpost" template with a date, title, WYSIWYG field and a checkbox for "allowing" comments. Because this template isn't very difficult, it's nice to create it by the GUI editor instead of creating XML configuration by hand (which is still possible if you like to).

After lunch Jeroen started explaining the Hippo Site Toolkit version 2.03.02. The HST is not a framework but a toolkit to create your own website using Hippo CMS and Hippo Repository. At this moment there's an HST for JSP sites but other (Java) technologies may follow in the coming years. On the VirtualBox image there is a sample site with a navigation structure, a news listing and a view for detail pages. All configuration for the menu structure, sitemap (mapping between URLs and repository paths), pages and templates is done in the repository. Now you have to do it by hand but in the near future there will be a configuration editor in the CMS. That would make it easy for the webmaster to change the URL structure or the way pages look.

The URL mapping is easy to understand if you know how matching works in Apache Cocoon. _default_ is the equivalent of * in a Cocoon sitemap and _any_ is equal to ** in the WildCardMatcher. A navigation structure like

News
|- _default_
  |- _default_
    |- _any_.html

would match a URL like /News/2009/04/My_blogpost.html. The "wildcards" _default_ and _any_ can be added as parameters to the rendering class that can pass it to the JSP so you can display "April 2009" in the title of your news overview if a visitor goes to /News/2009/04. As last exercise we added a new document type for events in the CMS, created some events and added a new event listing to the existing example site.

Day 3: create your own site from the Maven archetype

For this day we were asked to bring our own laptop so we could leave with a functional website at the end of the day and have all the necessary software installed to create another. Jeroen explained about Maven en let us create a project using the Maven archetype:

$ mvn archetype:generate \
   -DarchetypeRepository=http://repository.onehippo.org/maven2 \
   -DarchetypeGroupId=org.onehippo.ecm.hst \
   -DarchetypeArtifactId=hst-archetype \
   -DarchetypeVersion=2.03.02 \
   -Dversion=1.01.00 \
   -DgroupId=org.example \
   -DartifactId=myproject

It creates a project on the file system in three parts: the content, CMS and the site. After lunch we started to build our own website. I took the Urban-net website as example because it has an easy layout (1 header and 3 columns: left hand navigation, dynamic content in the centre and some downloads on the right hand site).

First I created two document types, one for normal text and one for "research programmes" (leaving away some fields compared to the original site). Then there was the time consuming part: copy-pasting enough content for a decent paging in the site. For real projects there are migration tools available to convert the XML content from the WebDAV repository to JCR nodes and properties. For the themes I used an ordinary repeating text field but the Hippo ECM Tagging add-on would be more user friendly in a real life implementation.

After defining the several sitemenu parts, components, pages and templates it was time to add the design and copy-paste the HTML into the JSP's. I couldn't implement everything I wanted (helped others as well and the time was limited). However in just a few hours I managed to implement a subset of the normal site. It does not contain search, no faceted navigation, the links on the right hand site are fake but it does show the basics.

After the training it was time to enjoy the beautiful weather on our balcony with some drinks and chips.

Woonsan Ko (Hippo): Spring framework support in HST-2

Mon, 20 Apr 2009 10:04:55 +0000

I'd like to explain the current status to support Spring Framework-based developer community. HST-2 (Hippo Site Toolkit - 2) now supports Spring Framework more than the earlier versions because there are a lot of developers utilizing the framework. 1. Introduction It is very desirable to use spring web framework if the development team is familiar with Spring and they could make better productivity with that. HST-2 now provides a bridge HstComponent to HstComponent beans which are managed by spring web application context. So, you can define your HstComponent beans in your spring context configuration and inject your existing component to them. You can see an example in the HST-2 source already if you download the source from the trunk for now. In the /applications/site/, 'contact-spring' menu will show the example which uses the bridge component. The actual bean is defined in /WEB-INF/applicationContext.xml like the following:

  <!-- HST Component Beans -->
  <bean id="contactBean" class="org.hippoecm.hst.components.ContactSpring">
    <property name="mailSender" ref="mailSender" />
    <property name="templateMessage" ref="templateMessage" />
  </bean>

  <!-- The existing components as an example -->
  <bean id="templateMessage" class="org.springframework.mail.SimpleMailMessage">
    <property name="to" value="contact@mycompany.com" >
    <property name="subject" value="My opinion" >
  </bean>
  <bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
    <property name="host" value="mail.mycompany.com"/>
  </bean>

2. How it integrates with HST 2.3? HST container manages, invokes and aggregates only components based on HstComponent interface for some reasons: to support transparent page aggregation, seamless portal integration, etc. A generic HstComponent was developed to play a role as a bridge to a bean managed by spring framework. So, the generic bridge HstComponent will delegate all invocation to the actual HstComponent bean managed by spring framework. 3. What the benefits are? What the drawbacks are? Spring-based developers can use full cool functionalities of spring framework like Dependency Injection, out-of-box spring components to support enterprise computing like JDBC template, transaction management and enterprise messaging, AOP techniques, Web Service support, Various view technologies, etc. HstComponent can be fully integrated with these rich spring supports. The Spring bridge HstComponent invokes directly the actual bean, so there's no performance degrade and functional shortage here. Of course, it looks a little bit different from the original spring web mvc pattern. The differences you can think of are originally from the differences of goals: HST-2 is to support transparent page aggregation and seamless portal integration, etc. Because HST-2 container aggregates multiple components in one page, the action phase should be separated from the rendering phase of all components. This means that HST container's aggregation should imply the PRG pattern internally. [1] Therefore, in a HST component, the *controlling* logic should be separated in doAction() and in doBeforeRender(). Also, those two separate phase should have separate request life cycles. Anyway, once you get accustomed to HstComponent request l

Niels van Kampenhout (Hippo): Coming soon to a computer near you: Hippo Site Toolkit 2!

noreply@blogger.com (Niels) — Mon, 13 Apr 2009 23:01:32 +0000

It's almost finished! Hippo Site Toolkit 2 will be released really soon now. I am working on the documentation right now and I have to say I am impressed by the work of our development team.

Hippo Site Toolkit 2 is a very versatile and lightweight component based framework for building websites on the Hippo CMS stack. Very much in Hippo tradition, we do not enforce you to use any particular technology or framework, but rather give you freedom of choice and the building blocks you need.

Some highlights among the many features of Hippo Site Toolkit 2 are:

Component based
HST2 lets you create reusable components and assemble webpages from those components.

Transparent support for portlets
HST2 components can be used out of the box as portlets in a portal environment.

Framework independent
Although our primary focus is JSP, any Java web framework can make use of HST2 functionalities. A Spring MVC example is included.

Plain Java
HST2 does not enforce any "dominating technology" that has been built on top of Java, such as Cocoon or Sling. It's all plain old Java.

Rapid website development
HST2 includes a web based configuration GUI embedded in Hippo CMS, and many reusable out of the box components.

There is no official release yet, and it's still a little rough around the edges here and there (you need to use the CMS Console for some configuration), but it is already usable. If you want to live on the edge, check out the trunk and give it a go (see the README). If not, stay tuned while we finish up the release and the documentation!

Niels van Kampenhout (Hippo): Publishing Maven artifacts for your Hippo Forge project

noreply@blogger.com (Niels) — Tue, 31 Mar 2009 16:06:00 +0000

Do you have a project on Hippo Forge? Then you might want to deploy artifacts in a Maven repository, so your projects can be added as a dependency to other Maven projects. Hippo Forge has no central Maven repository, but you can use your project's SVN repository to publish the artifacts. To do this, you can use wagon-svn, a Maven Wagon provider for Subversion.

The first thing you need to do is create a space in your SVN repository to deploy the artifacts in. If your project's SVN repository is at http://forge.hippo-ecm.org/svn/myproject/, create a folder maven2 in the root of the repository, i.e. http://forge.hippo-ecm.org/svn/myproject/maven2/.

In your project's POM, add the wagon-svn extension to the build section:


  <build>
    ...
    <extensions>
      <extension>
        <groupId>org.jvnet.wagon-svn</groupId>
        <artifactId>wagon-svn</artifactId>
        <version>1.8</version>
      </extension>
    </extensions>
  </build>

Then add a distributionManagement section to your project's POM, and specify the SVN location you created as the Maven repository to deploy artifacts to. For the id you can use any string you like.


  <distributionManagement>
    <repository>
      <uniqueVersion>false</uniqueVersion>
      <id>myproject-maven-repo</id>
      <url>svn:http://forge.hippo-ecm.org/svn/myproject/maven2/</url>
    </repository>
  </distributionManagement>

Finally, add credentials for the Maven/SVN repository to your Maven settings.xml, located in the .m2 directory in your home directory (e.g. /home/username/.m2/settings.xml on Unix). Right under the settings element, add a servers element:


  <servers>
    <server>
      <id>docselector-maven-repo</id>
      <username>myname</username>
      <password>secret</password>
    </server>
  </servers>

You should now be able to deploy artifacts to the SVN repository using the following command:


mvn deploy

Don't forget to add the location of the Maven repository to your project documentation! People need to add that repository location to their project POM or settings.xml in order to download dependencies from it.

Jeroen Reijn (Hippo): Apache Camel: open source integration framework

noreply@blogger.com (Jeroen Reijn) — Tue, 31 Mar 2009 13:01:22 +0000

I'm currently working on a project where we are looking at creating an integration layer for external applications to connect to our back-end applications. In our case, one of the back-end applications is Hippo CMS 7's repository.

I've been reading up on ESB's like Apache ServiceMix and Synapse, but even though both projects look very interesting, they actually are a bit too much for what I want to do. There was one project though that seems to be exactly what I want: Apache Camel.

About Apache Camel

Apache Camel is an open source Java framework that focuses on making integration easier. One of the great things is that Camel comes with a lot of default components and connectors.
Even though I was quite new to the integration concept, I was able to get my first Camel project up and running within 30 minutes or so, which I think is quite fast. You only need is a bit of Java/Spring knowledge to get going.

The basic concepts

While using an integration framework like Camel, you will have to keep four key terms in mind:

Endpoint: where the message comes in or leaves the integration layer
Route: how a message goes from endpoint A to endpoint B
Filter: the chained components that are involved in the process of handling a message that comes from endpoint A and goes to endpoint B. It could be that the content of the message needs to be transformed from SOAP to for instance ATOM.
Pipe: the way the message travels from endpoint A through filters to endpoint B

One of the things I'm looking at Camel for is using it to convert RSS feed entries into JCR nodes. If I would create an endpoint diagram, which would describe my route, it would look something like the image below.

With Camel, the endpoints and routes can be configured in a few lines of Java code or with Spring XML configuration. I started out with the Spring XML configuration and it was actually quite easy to get going. Here is an example where I poll my own RSS feed and store the items into a mock 'feeds' object.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://camel.apache.org/schema/spring
http://camel.apache.org/schema/spring/camel-spring.xsd">

  <camelContext xmlns="http://camel.apache.org/schema/spring">
    <route>
      <from uri="rss://http://blog.jeroenreijn.com/feeds/posts/default?alt=rss" />
      <to uri="mock:feeds"/>
    </route>
  </camelContext>

</beans>

As you can see that's just a couple of lines of code. It's really that simple to do things in Camel. Of course this configuration does not end up in a JCR repository, but as an example I think it's quite easy to grasp. For those of you, that want to play around with Camel as well, I'll try to explain all the step I took to get a working web application example from here on. As I'm using Maven2 for building my projects, you should be able to reproduce my setup quite easily.

Setting up your maven project

First off we'll start with adding the camel dependencies to our maven project descriptor( pom.xml).

<dependencies>
  <dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-core</artifactId>
    <version>${camel-version}</version>
  </dependency>
  <dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-spring</artifactId>
    <version>${camel-version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring-version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>${spring-version}</version>
  </dependency>
  <dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-rss</artifactId>
    <version>${camel-version}</version>
  </dependency>
</dependencies>

As you can see I explicitly added the camel-rss component, so that my camel application knows how to handle rss feeds. Camel does not have it's own RSS parser, but is using Rome in the background for handling the RSS feeds. The Camel project is setup in such a way that you can include any component you want, by adding the needed component dependency to your pom.xml. If you're thinking about using Camel, make sure you checkout the components page, which shows you all of the currently available components.

Camel uses Spring, so we need to add the Spring ContextLoaderListener to the local web.xml in src/main/webapp/WEB-INF/.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
version="2.4">

  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

The last step in our process is defining our endpoints. In my case I chose to use the Spring XML configuration for defining my endpoints.

Add a file called applicationContext.xml to your src/main/webapp/WEB-INF/ folder.
Once the file is created you should be able to define your routes like this:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://camel.apache.org/schema/spring
http://camel.apache.org/schema/spring/camel-spring.xsd">

  <camelContext xmlns="http://camel.apache.org/schema/spring">
   <route>
     <from uri="rss://http://blog.jeroenreijn.com/feeds/posts/default?alt=rss" />
     <to uri="mock:feeds"/>
  </route>
</camelContext>

</beans>

In this example I'm using my own RSS feed, but you can of course use any feed url you like.
For testing purposes you can add a log4j.properties file in src/main/resources/, so you can see the output of the Camel RSS component in your console. Here is the configuration I used writing this blogpost.


# The logging properties used for eclipse testing, We want to see debug output on the console.
log4j.rootLogger=INFO, out

log4j.logger.org.apache.camel=DEBUG

# uncomment the following line to turn on ActiveMQ debugging
# log4j.logger.org.springframework=INFO

# CONSOLE appender not used by default
log4j.appender.out=org.apache.log4j.ConsoleAppender
log4j.appender.out.layout=org.apache.log4j.PatternLayout
log4j.appender.out.layout.ConversionPattern=[%30.30t] %-30.30c{1} %-5p %m%n

Well that's it. Now the only thing you will need to do is fire up an application container, like Jetty and see what's going on in the console.

$ mvn jetty:run

If Jetty is running and everything is setup correctly you should be able to see some debug information come by that looks like:


  SyndFeedImpl.author=noreply@blogger.com (Jeroen Reijn)
  SyndFeedImpl.authors=[]
  SyndFeedImpl.title=Jeroen Reijn
  SyndFeedImpl.description=
  SyndFeedImpl.feedType=rss_2.0
  SyndFeedImpl.encoding=null
  SyndFeedImpl.entries[0].contributors=[]

As you will see the RSS feed is parsed and converted into a SyndFeed object.
From there on you can make use of this object and perform any operation on it.

I must admit that while playing around with Camel and RSS feeds,
I noticed that the RSS (and Atom) component did not handle extra request parameters correctly, so I added a patch in the Camel JIRA, hoping it wil be included in the next release of Camel.
If you have issues with the RSS component and request parameters, you might want to try to build the Camel SVN trunk and apply my patch (CAMEL-1496).
This is only necessary if you want to parse a feed that has for instance a unique id as request parameter added to the feed URL.

We'll that's it! This post will get a follow-up, where I will show you have to use Camel to actually store the RSS feed entries into a JCR repository.

Here are a couple of good articles too read before starting with Camel:

This blogpost was inspired by an article over at Gridshore, where Jettro wrote a post on using Spring Integrations as integration framework. Since I'm pretty much Apache minded, I have been looking around for other open source integration frameworks within the ASF, which brought me to Apache Camel.

Niels van Kampenhout (Hippo): ApacheCon Europe 2009

noreply@blogger.com (Niels) — Mon, 30 Mar 2009 22:01:20 +0000

I'm just back from a trip to Amsterdam for the ApacheCon Europe. It was a very short trip (too short!) and it all went by too fast. Some hightlights:

I attended the Portals and Wicket Meetups. For some reason I find these low key meetups always much more interesting than the "real" conference. The talks are usually shorter and more spontaneous, and there is more interaction with the audience. Unfortunately the meetups were in the evening, and with a fresh jet lag I had a hard time staying focused, and I didn't make it all the way to the end of the Wicket meetup (I heard it only ended after 11 PM!).

My talk about documentation on Thursday went exceptionally well. Documentation is usually not the most popular subject at ApacheCons, so I was happy to see about 25 people turn up - about the average for the talks I attended, so not bad at all! There were a lot of questions and quite a bit of discussion afterwards, and I got some good feedback to improve my talk. I heard some cool ideas - more on this in another blog post later!

I have to admit that I did not attend that many talks at the conference. I tried to get at least some of the Hadoop hype on Wednesday, and saw some interesting talks on continuous integration ("in the cloud!") on Friday. Most of my time was taken however by preparing my talk and getting updated by my Hippo colleagues on their latest work (the new Hippo Site Toolkit is really cool!).

Of course visiting Amsterdam was also an opportunity to see my friends and family. Instead of staying at the conference hotel I chose to crash at my cousin Martin's place, in the same neighborhood I lived in for 3 years. Despite both having a very busy schedule, we managed to have a delicious dinner at student-run restaurant Studio K, and see the exhibition of Richard Avedon's intriguing photographs at Foam (Amsterdam's Photography Museum). The weather was very Dutch the whole week - cold, rainy, and windy. But this did not keep me from enjoying riding my bike through the city. It was good the be back in Amsterdam!

The week was finished in style with drinks and bitterballen with my Hippo colleagues in the Muziekgebouw - a fabulous location with a grand view over the river. My friend Andre (for those who attended my talk, yes, the Microsoft guy) joined us and we had a great evening.

Unfortunately my busy schedule never really let me catch up with the jet lag, and boarding the plane back to San Francisco on Sunday, I felt completely wrecked. Nevertheless it was an inspiring trip, and the Californian sun is already recharging my batteries ;-)

Jasha Joachimsthal (Hippo): My Friday at ApacheCon Europe 2009

noreply@blogger.com (Jasha Joachimsthal) — Sun, 29 Mar 2009 08:01:30 +0000

Last Friday I went to the 3rd conference day of ApacheCon Europe 2009.

Becoming a Tomcat superuser - In this "Geeks for geeks" session Mark Thomas explained about the Subversion structure of the Apache Tomcat project and how to build the several versions. He demonstrated how you could debug Tomcat in Eclipse and create or apply a patch. His explanations were very clear so if I'm ever going to patch my own Tomcat, I know how to do it now.

Scripting your Java application with BSF - The rest of the day I went to the "Java development" sessions. With all Rhino code in Hippo CMS 6 in mind I chose to go to this session. Using a scripting language may seem an easy way to develop you application but in the end it's hard to debug and maintain. Felix Meschberger demonstrated using several scripting languages (Rhino, Groovy) in a Java application. It looked easy to use.

Apache Pioneer's Panel - 10 years of The Apache Software Foundation. The history of the ASF with stories of the past 10 years. Very funny if you were actually at the events they were talking about.

What's new with Apache POI - I used POI once for my ApacheCon Europe 2007 talk with Jeroen Reijn about Cocoon to generate a MS Excel file. I didn't know Apache POI supported that many MS Office formats (Word, Excel, PowerPoint, Outlook, Visio and Publisher). Nick Burch ran through the several formats and pointed out the most frequently made errors while using POI.

Apache DS 2.0 : What's new ? Apache DS is one of the projects I've never used. I went to this session with my colleague Dennis who has much more to do with LDAP, authentication and user management. For his work (portals) it was way more interesting than for me (public websites) but it was very interesting to hear the possibilities of Apache DS. I should install Apache Directory Studio for browsing our internal LDAP development environment.

Shindig for Blogs and Wikis - This was a perfect talk for the end of the day. Cool product and a hot subject so people are paying attention and they're not leaving although it's getting late.

Closing event & raffle - First a "thank you all and see you at the next event". At the raffle I got the lucky lot. By pure randomness and luck I won a 15" digital picture frame that also plays video! :D So don't leave early, there's something to win after the talks.

Jeroen Reijn (Hippo): Using Daemon modules with Hippo CMS 7

noreply@blogger.com (Jeroen Reijn) — Sun, 22 Mar 2009 12:44:00 +0000

Recently I was working on a new Hippo CMS 7 based project, where I was in need of a repository component that could run in the background and perform some scheduled tasks.

While talking to some colleagues about what I had to do, they pointed me to a build-in solution for adding repository components, which are initiated at startup.

It was actually very simple to implement this feature, so I'll try to describe how you can achieve the same solution in some very small steps.

The first thing you will need to do is create a Java class that implements the DaemonModule interface. As an example I've created the BackgroundModule as shown below.

package com.onehippo.repository;

import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.hippoecm.repository.ext.DaemonModule;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class BackgroundModule implements DaemonModule{

  static final Logger log = LoggerFactory.getLogger(BackgroundModule.class);
  static Session session = null;

  public void initialize(Session session) throws RepositoryException {
    this.session = session; 
    log.info("BackgroundModule started"); 
  }

  public void shutdown() {
    session.logout();
  }

}

You might wonder how the repository knows about these daemon modules? Well the trick is that the repository goes through all 'MANIFEST.MF' files, which it can find on the classpath. If the MANIFEST.MF file contains an entry for the property 'Hippo-Modules', it will be added to the list of available modules. Once finished finding all modules it will start to initialize each of them and pass on an authorized JCR session, so you will be able to work with all information inside the repository.

I'm always using Maven 2 while working with CMS 7. Maven 2 has some usefull utilities and it can help you you out with adding the correct manifest entry. In my pom.xml I added some configuration for the maven-jar-plugin that adds my module to the manifest.

<plugin>
  <groupid>org.apache.maven.plugins</groupid>
  <artifactid>maven-jar-plugin</artifactid>
  <configuration>
    <archive>
      <manifest>
        <adddefaultimplementationentries>true</adddefaultimplementationentries>
      </manifest>
      <manifestentries>
        <hippo-modules>com.onehippo.repository.BackgroundModule</hippo-modules>
      </manifestentries>
    </archive>
  </configuration>
</plugin>

If you need to add more then one module, you can do so by adding a space in between modules.

For the project I was doing, I also made use of Quartz triggers, so my module would execute once in a while instead of just after initialization of the repository.

The concept of these modules is quite powerful, so I hope this can help you to get started with writing your own Daemon modules.

Arthur Bogaart (Hippo): HippoCMS 7 integration testing with Selenium

Mon, 16 Feb 2009 12:40:18 +0000

Integration tests are designed to check the functionality of an application as a whole, rather than focussing on the internal workings of individual software modules, which is the domain of normal unit testing.

Selenium

Jasha Joachimsthal (Hippo): How to add the YouTube plugin in Hippo CMS 7

noreply@blogger.com (Jasha Joachimsthal) — Fri, 13 Feb 2009 16:35:00 +0000

The YouTube Template Plug-in is a very simple, but cool project in the Hippo ECM forge. The plugin was created by our former intern Jeroen Tietema. With this plug-in you can easily add YouTube videos to your documents. In this blog I'll explain how to add this plug-in into your Hippo ECM project. I assume you have already checked out and built Hippo ECM from source.

Check out the YouTube plug-in from SVN and build it using Maven with the following command:

mvn install

Then add the dependency to the pom.xml of quickstart/war

<!-- YouTube Template plugin for Hippo ECM 2.03.00 -->
<dependency>
    <groupId>org.onehippo.addon.frontend.youtube</groupId>
    <artifactId>youtube-plugins</artifactId>
    <version>1.01.00-SNAPSHOT</version>
    <type>jar</type>
</dependency>

Configuration in the console

(Re)start the Hippo ECM war and go to the console on http://localhost:8080/cms/console. Navigate to the following location:

/hippo:namespaces/hippo/templatetype/hippo:template/hippo:template/list

Now add the value Youtube to the templates property and save the changes. Make sure you log out of the CMS and back in (the list is cached in your session).

CMS template editor

Go to the template editor in the CMS. You can either create a new document type or add the new YouTube field to an existing template. Save the template and choose "Update all content" from the drop down menu in the top bar.

Editor

Now the plug-in has been configured and added to the template, the CMS users can add YouTube videos to their documents. Just paste the ID of the video into the YouTube field.

If you are not editing the document you get a preview of the selected video:

Niels van Kampenhout (Hippo): Using the Hippo Repository Workflow API

noreply@blogger.com (Niels) — Fri, 13 Feb 2009 01:02:09 +0000

Hippo CMS 7 provides workflow functionality not only through its GUI, but also through its Repository API. Without ever logging in to the CMS, you can create, edit and publish documents from your own Java application. I would like to give you a simple example of editing a document, and requesting publication. The complete example is downloadable as a zipped Maven project that works out of the box with the Hippo CMS 7 Quickstart package version 2.03.00.

Before we start, I suggest you read the JCR basics and examples in the Hippo CMS documentation. These will give you a general idea of how to connect to and work with the repository through the API.

Connecting to Hippo Repository is pretty straightforward:


HippoRepository repository = HippoRepositoryFactory.getHippoRepository("rmi://localhost:1099/hipporepository");
Session session =  repository.login("author", "author".toCharArray());

For simplicity, let's just use some hardcoded values for the document location, the name of the field we are going to edit, and the new value we are going to give the field:


String path = "/preview/content/articles/myarticle1";
String field = "defaultcontent:title";
String content = "Hello World!!!";

First we retrieve the document node from the repository:


HippoNode documentNode = (HippoNode) session.getItem(path);

This node is a so-called handle: an umbrella under which each variant of the document is stored. These variants can be different languages, different versions, different workflow states, you name it. Each variant is represented as a child node of the handle node, and has the exact same name as the handle node. In the quickstart application you will only find variants with different workflow states. Let's get one of the variants:


documentNode = (HippoNode) documentNode.getNode(documentNode.getName());

Which variant we get is actually not really important, as we only use it to get to the documents workflow.

First however, we need to make sure we are using a physical node. Nodes inside Hippo Repository can be virtual. That means that they do not exist at that location, but rather they represent a node in a different physical location. This allows different organizations of your content without duplicating any data. The virtual nodes are generated on the fly. Since they do not exist in that particular physical location, we need to retrieve the original node and save our changes there. This is done through the getCanonicalNode() method:


documentNode = (HippoNode) documentNode.getCanonicalNode();

Now that we finally have the node we want to work with, we can obtain the document's workflow, through the workspace and workflow manager:


HippoWorkspace workspace = (HippoWorkspace) documentNode.getSession().getWorkspace();
WorkflowManager workflowMgr = workspace.getWorkflowManager();
Workflow workflow = workflowMgr.getWorkflow("default", documentNode);

If the workflow is of the type BasicReviewedActionsWorkflow (it should be in the quickstart application), we can obtain an editable instance of the document. Regardless of the state the document's workflow is in, this will give us a draft version to work with.


if (workflow instanceof BasicReviewedActionsWorkflow) {
  BasicReviewedActionsWorkflow braw = (BasicReviewedActionsWorkflow) workflow;
  Document doc = braw.obtainEditableInstance();
  String uuid = doc.getIdentity();
  documentNode = (HippoNode) session.getNodeByUUID(uuid);
}

With the editable instance, we can start making our changes. First we need to find out where the field we want to edit is stored. Fields can be stored either as a property, or as a child node. Hence we check for a child node and for a property matching the name of our field:


Property contentProperty;
if (documentNode.hasNode(field)) {
  HippoNode fieldNode = (HippoNode) documentNode.getNode(field);
  if (fieldNode.hasProperty("hippostd:content")) {
      contentProperty = fieldNode.getProperty("hippostd:content");
  }
} else if (documentNode.hasProperty(field)) {
  contentProperty = documentNode.getProperty(field);
}

We now have all the information we need, and can make our change on the node property using the setValue() method. Through the workflow we can then request publication, and commit our editable instance. Finally, we save the JCR session so our changes (including the request for publication) are persisted:


if (contentProperty != null) {
  contentProperty.setValue(content);
  BasicReviewedActionsWorkflow wf = (BasicReviewedActionsWorkflow) workflow;
  wf.requestPublication();
  wf.commitEditableInstance();
  session.save();
}

If you now log in to Hippo CMS, you should see the document listed in the Workflow To Do list on the dashboard.

Download the complete example.

Niels van Kampenhout (Hippo): Let's talk about documentation

noreply@blogger.com (Niels) — Wed, 14 Jan 2009 21:31:00 +0000

I noticed the schedule for ApacheCon EU 2009 is up on their website, and it looks like my talk on documentation has been accepted! Documentation is traditionally not the strongest selling point of open source software. I am full of ideas on why this is, and how it can be improved. I even think it is not that hard, and that open source projects have a benefit over closed source software vendors in this area. We just need to see this benefit and make use of it!

If you are curious about my ideas, the session is scheduled for Thursday, March 26, at 2 pm. I hope to see you all in Amsterdam!

For completeness, here are all the details:

Documentation: get it right!
Niels van Kampenhout
Thu, 26 March 2009 14:00

Good documentation is vital for the health of any open source project, yet the challenges that this fact presents are not always overcome. Let's face it: open source software has a reputation for poorly written and organized documentation. What causes this reputation? Is it really that bad? Is it really that difficult? How can we do better? And why do we need documentation anyway, can't you just look at the code?! This talk explores an often overlooked aspect of open source software development. It explains what makes documentation good documentation, and how it can benefit a project. It shows that, with a bit of common sense and clever use of resources, it's actually not that hard to produce useful documentation. A rough guide to getting your documentation right, while strengthening your community at the same time.

Niels van Kampenhout (Hippo): Using JCR-Explorer with Hippo CMS 7

noreply@blogger.com (Niels) — Thu, 08 Jan 2009 18:49:00 +0000

Following Bertrand's useful blog post, here's how to configure JCR-Explorer in Tomcat, for use with Hippo Repository.

I used Tomcat 6.0.18, Hippo CMS 7 v2.02.01, and JCR-Explorer 0.9.5.

Start with a clean Tomcat installation, and add the following jars to the lib directory:

Download the Hippo CMS 7 WAR, rename it cms.war, and copy it to Tomcat's webapp dir.

Add to Tomcat's conf/server.xml, inside <GlobalNamingResources>:


<Resource name="jcr/globalRepository"
auth="Container"
type="javax.jcr.Repository"
factory="org.apache.jackrabbit.rmi.client.ClientRepositoryFactory"
url="rmi://127.0.0.1:1099/hipporepository"/>

Add to conf/context.xml, inside <Context>>:

<ResourceLink name="jcr/repository"
global="jcr/globalRepository"
type="javax.jcr.Repository"/>

Download JCR-Explorer and copy the jcr-explorer.war file to the Tomcat webapps folder. Start Tomcat, stop it (so that the webapp is expanded) and add this at the end of

webapps/jcr-explorer/WEB-INF/web.xml, inside <web-app>:

<ResourceLink name="jcr/repository"
global="jcr/globalRepository"
type="javax.jcr.Repository"/>

Now start up Tomcat and load the JCR-Explorer login page at http://localhost:8080/jcr-explorer/login.jsf. Use java:comp/env/jcr/repository as JNDI name, and login using username admin and password admin. You will now see a JCR-Explorer screen showing the contents of Hippo Repository!

Credits go mostly to Betrand of course.

Jeroen Verberg (Hippo): Clinton and me

Mon, 22 Dec 2008 15:11:00 +0000

Today BNR (Business News Radio) had exclusive interview with former US president Bill Clinton. Clinton had interesting story about a recent small scale project in Ethiopia bringing light with solar power

Jasha Joachimsthal (Hippo): Hippo CMS v6.05.05 released!

noreply@blogger.com (Jasha Joachimsthal) — Thu, 18 Dec 2008 10:07:00 +0000

Hippo is proud to announce the latest release of Hippo CMS 6. This release contains many small improvements and fixes. Some highlights of this release:

Faster loading of the configuration
Search on document types
Publish properties of folders

For the full news item see the Hippo CMS 6.05.05 released! on www.hippocms.org.

Jeroen Verberg (Hippo): Government support

Thu, 09 Oct 2008 15:21:17 +0000

Regarding SPAM I thought nothing could really surprise me anymore. According to our filter statistics it blocks about 100 messages a day for me. But yesterday one slipped through from the European Commission.

Jeroen Reijn (Hippo): 5 years at Hippo and 5 years of open source

noreply@blogger.com (Jeroen Reijn) — Thu, 09 Oct 2008 09:45:00 +0000

I've been thinking about this post for a while, because I wasn't really sure what to write about my past 5 years. So much has happened and there is so much to mention, but that would mean this would be a longggggg post. I'll just create a (short) summary of my entire story for now.
>

My main reason to start at Hippo 5 years ago was because I wanted to do something with Java and the web. Hippo provided both and offered a great learning environment at the same time with all the open source products they used in their software.
>

While doing my daily work at Hippo, I learned a lot about Apache Cocoon, an open source framework, which was one of the core open source products used within Hippo driven websites. Before that, I wasn't really aware that Apache was a lot more then Tomcat and the HTTP server. While getting more involved within the Cocoon community I was up for my first real open source experience.
>

The Cocoon GetTogether 2003 was a place were I met all the people behind the names that I had seen on the Cocoon mailinglist. The GT2003 was held in Ghent (Belgium) and it was my first of the many to come trips related to working with open source projects at Hippo. Later on, I was able to travel to Dublin and Rome for Cocoon/Apache related conferences with the ApacheCon in Amsterdam 2007 as a highlight. In Amsterdam Jasha and I gave a presentation about Cocoon. I was just elected as an official Cocoon committer a month or so before that and tried to give my share of support to the Cocoon community that had given me so much those past years.
>

Cocoon wasn't the only Apache open source project I was going to end up using. So far Lucene, MyFaces, Slide, Jackrabbit and Wicket have also been part of my daily work. Then of course we also have our own open source projects, like Hippo CMS and Hippo Repository. I think it was a great move to make both products open source, because it helped the products to become more mature and it allowed other developers to learn much more about the product then if it would be a closed source project.
>

From the company point of view, it was great to see Hippo grow from the small (only 6 people when I started) to the +/- 40 people that I'm working with now. I think Arje, Tjeerd and Jeroen are doing a great job with this. I've learned so much from them and the other Hippos around me that the current environment is very inspiring. Also the projects that we're doing now with Hippo are getting bigger and bigger. That's one of the reasons why we're currently working very hard on a first final release of Hippo ECM platform, which is coming up very soon.
>

Looking at my self, I can say I also grew from being a developer working on small websites to developing large applications/websites, guiding partners with their Hippo implementations, doing some consultancy and giving training sessions about open source Hippo software or on the use of Apache Cocoon.
>

I'm looking forward to what the future will bring us with Hippo ECM coming up and our goal to become one of the bigger players in the ECM market. I guess in 5 more years I can tell you the answer to that question.
>

Ard Schrijvers (Hippo): Cocoon is easy

Mon, 04 Dec 2006 15:31:20 +0000

I just disagree with people telling that cocoon is hard to learn. If you get it explained by somebody who knows how it works, then it simply can't be hard. Perhaps it is hard for people because nobody takes their hand, and help them through the first few steps. After all, what is hard about it? You need to know some sitemap matching things, and you need to know how to write some xsls. Only knowing xsl, which you learn in twice the time you learned html, so about 2 days, and knowing sitemaps, you can make yourself valuable for a project. Not only valuable, but already productive. And after some time, you will be able to build sites yourself very fast. I am convinced that development in cocoon outruns any other framework, and when starting with the right patterns and maintain them, maintainance will be easy as well.

So, what is the problem. Why is not the entire world using cocoon? Were the founders too superior for other people to be able to understand cocoon? Did they have a brilliant vision, but forgot about (average) users?

Lately, I have seen many other projects developed in cocoon, and some things frustrated me extremely. The things the sites all had in common were:

1) The content repository was hippo repository, a repository implementing the WebDaV protocol
2) The customer was in control of maintaining their own sitemenu (all in the repository).
3) Standard cocoon components, either standard in cocoon, or standard added by Hippo

As you can see, 1 and 2 are part of the repository, which is the same for every customer (except for custom backend templates), and 3 is part of a jar we include in our cocoon build.

So, that should give a strong enough base, to implement sites through some sort of best practice patterns. But, and that is the weakness of cocoon: it is just to flexible. People do not know how to start. I did not look at blueprint yet, but it is an attempt to help people getting started with cocoon.

Now, for building websites with hippo repository and with using a sitemenu, we discussed about the best way to get started, and how to structure your pipelines. The result is something incredibly easy to use. It assumes one thing: you have a repository with some data and a genuine sitemenu. When you do have this, you have your site with a best practice pattern up and running (including paging through archives) within minutes.

All you need to do is check out a project.xml and a properties file and install the latest hippo cocoon plugin. You just deploy your site, and start it. After starting, you open your browser on the right domain and port, and start configuring cocoon from there (like which sitemenu's to use, if your urls do have a prefix, if you have cforms, etc). when ready, you have to redeploy, and start your site again. Then, you have the option to auto-generate a site, which is based on the sitemenu(s) structure found in the repository. All configuration is done for you. We use 5 different stores for cocoon, to optimize performance. All is configured and arranged in the default auto created site.

And more important, it is an incredible simple sitemap pattern and, evenly important, a strong and correct xsl pattern, build on import precedence concept. With this functionality, you help everybody starting with cocoon to learn the patterns, enable incredible fast development, and enable everybody to understand each others sites.

I hope to have a demo online on short notice.

Arthur Bogaart (Hippo): Back to Basic, or flowscript actually

Tue, 18 Apr 2006 11:32:52 +0000

Doing (complex) eventcached DASL queries without the HippoJX generator can be a tedious task.
Clearly, the Cocoon Jxtemplate generator is a nice mechanism for a) passing sitemap parameters into the query and/or b) cha