Planet Hippo

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());
        }
    }
}

Tjeerd D. Brenninkmeijer (Hippo): Walking the open source road

Tue, 23 Jun 2009 11:46:37 +0000

At a recent conference, I was approached by an executive from a software company who wanted advice on how they could open their code. I’ve been in open source for many years; early open source developments simply evolved organically as collaborative projects, and there was no ‘right or wrong’

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

# uncomment the following line to turn on Camel debugging
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.

Tjeerd D. Brenninkmeijer (Hippo): The Hippo CMS Vendor meme

Wed, 18 Mar 2009 16:25:38 +0000

We have been challenged by Magnolia to participate in the CMS Vendor Meme. Thanks, guys ;) First off, I think you can only get something like an independent answer when you stick to open source system 'vendors'. You can validate whatever they say by asking the community. You can download the system and see for yourself. But whatever you do - don't ask a closed source vendor :). Or let analysts like Seth Gottlieb, or the people at CMS watch and CMS Wire decide whether or not "you get it". But since it was CMS Watch's Kas Thomas, we'll gladly help him with the first shifting :) So here we go: 1. Our software comes with an installer program - Sort of We understand that for someone reviewing a CMS an installer is nice. So go ahead: download the ZIP file, unzip it, doubleclick the starter and you're done. But in all honesty, our customers run Hippo in environments with one, two, eleven, or - if they want - a gazillion installations across a clustered environment. They are not interested in clicking through an installer on every single installation. They want to roll out quickly and securely, in a controlled fashion. That's why we have WAR and EAR builds. They're the standard in the Enterprise world, and not for nothing. 2. Installing or uninstalling our software does not require a reboot of your machine - Yes No restart required. Can't agree more with the Magnolia guys: why are you asking? Because other CMS systems only have a Windows installer that requires a reboot? :-P 3. You can choose your locale and language at install time, and never have to see English again after that - Sort of We (Europeans) like to give the editor the option to change and work with different languages. We'll have to! :-) 4. Eval versions of the latest edition(s) of our software are always available for download from the company website - Yes, well, no. We don't have an evaluation version. Instead, we give you the whole shebang, freely available online at www.onehippo.org. We don't believe in baitware. We are 100% open source. 5. Our WCM software comes with a fully templated "sample web site" and sample workflows, which work

Arje Cahn (Hippo): Apache Meetups: next week!

Mon, 16 Mar 2009 14:59:51 +0000

Wicket, Maven, Lucene, Jackrabbit and Portals Evening Meetups

Join us for a third year of Apache Meetups! Users, committers, managers and developers will come together on the evenings of Monday 23rd and Tuesday 24th of March.

Registration is free of charge, and

Arje Cahn (Hippo): Wicket use case testing with Selenium

Tue, 17 Feb 2009 07:49:27 +0000

Our very own mr AJAX, Arthur, blogs about how we perform automated Selenium tests on Wicket components for Hippo CMS 7.

Although he credits me for the video, I was merely playing the annoying voice-over and shaky-cam-operator role :-). Arthur does all the talking. So here's credit back, 'Thuur.

In his blog, he explains how we had to tweak the Wicket markup ids to get Selenium to work.

"Use case testing" is my term for what Arthur (and with him probably the rest of the world) calls "integration testing". This is where we bring together two very important stakeholders into our development project: on one hand, the developers want to know whether integration doesn't break functionality, and on the other hand, users and testers want to know whether the new version of the system has at least the same level of functionality and stability as the last time they tested it. That's why, at the end of each development Sprint, we have a round of user testing. During that phase we record the use cases that the testers perform and add that to our set of automated Selenium tests.

Go ahead and enjoy Arthur's blog and the demonstration video (and my shaky camera moves).

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.

Arje Cahn (Hippo): Introduction to imagesets

Tue, 03 Feb 2009 11:56:19 +0000

An image is not just *one* image to us. It can come in a wide variety of representations. The image that the user uploads, can be (automatically) scaled to different sizes, translated into different languages, or have different versions for different target audiences. All of these different insta

Arje Cahn (Hippo): Hippo CMS 7 is live!

Fri, 30 Jan 2009 12:23:29 +0000

Go get Hippo CMS 7 at http://www.onehippo.org, try out the distro and knock yourself out.

I need to thank so many people, that I wouldn't know where to start. Most of all, I need to thank "The Guys Upstairs" for all their hard coding in the last couple of months. Berry, Frank, Bart, Arthur, Ard and Auke, thank you. It's been a rocky ride but it was worth it. I also need to thank Niels, Rita, Jeroen, Jeroen, another Jeroen, Dennis, Jettro, Jasha, Ate, David, Woonsan, Vivek, Anton, Mathijs, Wouter, Tjeerd, Jeff&Jody;, Ruben, Johan, Wander and Mike for their contributions. The "Guys Downstairs" (you know who you are!), folks in the US, the marketing people, our customers, everyone from Jackrabbit, Wicket, Maven, Lucene and everyone else who influenced this incredible new version of Hippo CMS.. Thanks.

Hippo CMS 7 was built on Apache Jackrabbit, Lucene, Wicket and many other Apache projects. Combine these really powerful components, add a little faceted navigation, a touch of plugin framework and 36 person years of development [1] and you have Hippo CMS 7 :-)

Oh, and it's open source. Go get our code from http://svn.onehippo.org/repos/hippo/hippo-ecm/, check out the Hello World example, and start your own plugin project at the Hippo Forge. The first 25 people to build a really neat plugin on the forge will receive one of those funky Hippo T-shirts. What's neat? A Google Maps location picker is neat, and maybe a Flickr image plugin is neat, too :)

If you have questions, or would like to share some feedback, feel free to sign up to our CMS 7 User list. Your comments are very well appreciated! :)

[1] Stats from Ohloh http://www.ohloh.net/p/hippoecm

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.
>

Arje Cahn (Hippo): Announcing Hippo ECM and Hippo CMS 7

Mon, 22 Sep 2008 22:38:50 +0000

Lots has happened.

And we're nearly there. It took us more than a year of heavy development, but it feels *so good* to play around with this cute little gem! It just feels right. Here's a bit of a sneak preview:

In the meantime, Dennis Byron of IT Business Edge wrote a really nice blogpost about how Hippo "Helps Get Portal Enterprise Software Right". As he says, "the characteristic of using CMS to do multiple things multiple ways is the key to the Hippo approach" - and he's so spot on. Hold your breath for v7.

This came in just days after something else that I think I'll simply interpret as a big compliment.

As they say, imitation is the greatest form of flattery. Draw your own conclusions. Apparently, there are more people in the world that really like Hippo :-).

Expect more from me in the blogosphere the upcoming weeks as we reveal the new kid on the block in open source ECM.

Arje Cahn (Hippo): Congratulations, XML

Fri, 15 Feb 2008 10:51:32 +0000

Last week, XML turned 10. Hurray!
Incredible that it's just 10 years ago.

Crunching my memory, I think the first time I came across XML was somewhere in the end of 1998, when I was working on a Microsoft technology based CMS. Since people have been harassing me with this horrendous

Arje Cahn (Hippo): Fresh new hearing

Thu, 07 Feb 2008 16:01:10 +0000

They kicked me out of hospital last week.

Exactly ten years after what was supposed to be my last operation, my left ear started troubling me again. I had no other choice than to undergo some major surgery to stabilize the inflammation and to hopefully get some of my old hearing back.

Not a lot of people actually know this, but I'm almost deaf on one ear. Sitting on my left side in a crowded bar is a good guarantee that I won't be able to have any conversation with you. That's why you can see me switching chairs all the time for apparently no reason - it's not because I'm superstitious or something - I just want to be able to hear people.

But now this is all supposed to get soo much better...!

When I woke up from anaesthetics, the doctors (all three of them) were jumping up and down next to my bed like little children. Surgery went much quicker then they had expected, and they had had so much fun playing around with chunks of Titanium in my head, neurological sensors to monitor my facial nerves and so on. Oh big joy. But I can tell you - nothing feels better than seeing happy doctors when you wake up after long hours of surgery!

I'm taking it easy now - trying to recover and let the new ear heal. So bear with me if I'm not responding to your email quick enough.

For those of you who hungry for bloodshed and gore pictures - here's what my head looked like last week :-)

Enjoy,

Arjé

Arje Cahn (Hippo): Information patterns: Classification follows context

Mon, 31 Dec 2007 08:36:45 +0000

I was at the Amsterdam Zoo, a place that I go to quite frequently to wander around and feel simple and taken care of amidst a bunch of animals sitting properly organized behind their name tags. No surprises in this place. A zoo breathes a fath

Arje Cahn (Hippo): Apache Wicket Meetup

Mon, 19 Nov 2007 22:13:50 +0000

Small-scale meetups are good for attracting new people to the Apache community. So after the 6-years-in-a-row (and still running!) Cocoon GetTogether series, we're now running a brand new meetup for the Apache Wicket community. I kind of promised that I would

Arje Cahn (Hippo): Investing in open source

Thu, 11 Oct 2007 16:01:49 +0000

I felt sad for Lars - one of my Cocoon buddies - when he told me that his company lost its primary investor. They're now forced to close

Arje Cahn (Hippo): Cocoon GetTogether 2007: When in Rome....

Fri, 14 Sep 2007 14:01:15 +0000

After two years of backing the Cocoon GetTogether in Amsterdam, that cold rainy place in Northern Europe, I'm more than happy to let Lady Coco go to her new foster parents. The Cocoon community is moving back to its Mediterranean roots: Rome!

For the sixth time (it's becoming a serious tradition by now) I and the other Hippo brains will be there. And even if you have only the slightest interest in Apache Cocoon, you should be there, too!

Since I like the Cocoon GT so much, and want everyone to come on over, I'm hereby adding *all three* Cocoon GetTogether banners to my blog. So here you go.

;-)

See you all in Rome!

UPDATE: Obviously, the real reason for us coming to Italy is that some genius has translated Hippo CMS into Italian now. Nice job, Marco :-)

Arje Cahn (Hippo): Developers update: Defining facets in Hippo Repository 2.0

Tue, 11 Sep 2007 09:30:14 +0000

By (not) organizing the hierarchy of the content repository upfront, but by allowing it to grow dynamically based on meta data, I hope we can adhere to David Neuscheler's Rule #1, which was i

Arje Cahn (Hippo): Hippo is hiring... Java pros!

Fri, 24 Aug 2007 16:01:40 +0000

Hippo is looking for kick ass Java developers to join our product development team. If you happen to know anyone that would fit the profile, I'd really appreciate it if you could get us in touch..

BTW, we're also looking for consultants, web developers and open source community builders.. In short, we need lots of people :-)

Job Title: Senior Java Developers (product development)

Hippo is looking for experienced Java programmers who would like to work in a dynamic and open environment that emphasizes individual initiative and is deeply involved in the Apache open source community.

We're expanding our Java development teams, and are looking for developers to work on our CMS, Portal and Repository products.

Profile:

* Academic qualification in IT
* Relevant work experience
* Good knowledge of Java
* Experience in developing server applications
* Affinity with open source, Apache in particular

Knowledge of the following items is desirable:

* Apache Cocoon, Jackrabbit or Jetspeed
* Content management systems
* Portal development

Hippo is the developer of the open source enterprise content management system Hippo ECM, a native XML content management platform, and Hippo Portal, an open source portal container.

The level of knowledge within Hippo is high, oriented specifically towards XML and Java. Staff are encouraged to investigate new technologies. In particular, emerging technologies from within the open source community and the W3C are followed closely. Where possible, Hippo participates in open source projects. Researching and developing new applications before the market is even demanding them, is a challenge we face every day.

Hippo develops software for a market that is changing on a daily basis. It is therefore important that we respond quickly to new developments, but all the while keeping an eye on the continuity of the existing products. As well as creativity, all staff are therefore expected to have a well-developed feeling for their own responsibility.

The company’s distinguishing characteristics are the short communication lines, a customer-friendly attitude and the use of the newest technologies, with personal creativity and an eye for detail being highly valued.

For more information, visit our website:
* www.hippo.nl

Or visit our community site:
* www.hippocms.org

Got questions? Don't hesitate to mail me directly at arje (@) apache dot org.